Taskfile.yaml

@@ -19,7 +19,6 @@ tasks:
             - checks
         cmds:
             - npm version prerelease
-            - git push --tags
             - npm pack --pack-destination releases
             - { task: 'release:gitea' }
 

src/Updux.ts

@@ -81,9 +81,6 @@ export default class Updux<D extends DuxConfig> {
     /** @internal */
     #inheritedReducer: (state: DuxState<D> | undefined, action: AnyAction) => DuxState<D>;
 
-    /** @internal */
-    #selectors = {};
-
     constructor(private readonly duxConfig: D) {
         if (duxConfig.subduxes)
             this.#subduxes = D.map(duxConfig.subduxes, (s) =>
@@ -97,8 +94,6 @@ export default class Updux<D extends DuxConfig> {
         this.#reactions = (duxConfig.reactions as any) ?? [];
 
         this.#actions = buildActions(duxConfig.actions, this.#subduxes) as any;
-
-        this.#selectors = duxConfig.selectors ?? {};
     }
 
 
@@ -171,17 +166,6 @@ export default class Updux<D extends DuxConfig> {
             throw new Error(`redefining action ${type}`);
     }
 
-    addSelector<R, N extends string>(name: N, selector: (state: DuxState<D>) => R) {
-        this.#selectors = {
-            ...this.#selectors,
-            [name]: selector,
-        }
-
-        return this as any as Updux<D & {
-            selectors: Record<N, (state: DuxState<D>) => R>
-        }>;
-    }
-
     addMutation<A extends keyof DuxActions<D>>(
         actionType: A,
         mutation: Mutation<
@@ -256,7 +240,7 @@ export default class Updux<D extends DuxConfig> {
 
     get selectors(): DuxSelectors<D> {
         return this.#memoBuildSelectors(
-            this.#selectors,
+            this.duxConfig.selectors,
             this.#subduxes,
         ) as any;
     }

src/actions.test.ts

@@ -1,7 +1,4 @@
-import {
+import { ActionCreatorWithPreparedPayload } from '@reduxjs/toolkit';
-    ActionCreator,
-    ActionCreatorWithPreparedPayload,
-} from '@reduxjs/toolkit';
 import { buildActions, createAction, withPayload } from './actions.js';
 import Updux from './index.js';
 
@@ -45,8 +42,7 @@ test('withPayload, just the type', () => {
 test('buildActions', () => {
     const actions = buildActions(
         {
-            one: createAction('one'),
+            one: createAction('one'), two: (x: string) => x,
-            two: (x: string) => x,
             withoutValue: null,
         },
         { a: { actions: buildActions({ three: () => 3 }) } },
@@ -91,15 +87,15 @@ describe('Updux interactions', () => {
         subduxes: {
             subdux1: new Updux({
                 actions: {
-                    fromSubdux: (x: string) => x,
+                    fromSubdux: (x: string) => x
-                },
+                }
             }),
             subdux2: {
                 actions: {
-                    ohmy: () => { },
+                    ohmy: () => { }
-                },
+                }
-            },
+            }
-        },
+        }
     });
 
     test('actions getter', () => {
@@ -107,18 +103,11 @@ describe('Updux interactions', () => {
     });
 
     expectTypeOf(dux.actions.withNull).toMatchTypeOf<
-        ActionCreator<'withNull'>
+        ActionCreatorWithPreparedPayload<any, null, 'withNull'>>();
-    >();
-
-    expect(dux.actions.withNull()).toMatchObject({
-        type: 'withNull',
-    });
 
     expectTypeOf(dux.actions).toMatchTypeOf<Record<string, any>>();
     expectTypeOf(dux.actions?.add).not.toEqualTypeOf<any>();
 
-    expect(dux.actions.fromSubdux('payload')).toEqual({
+    expect(dux.actions.fromSubdux('payload')).toEqual({ type: 'fromSubdux', payload: 'payload' });
-        type: 'fromSubdux',
+
-        payload: 'payload',
-    });
 });

src/selectors.test.ts

@@ -19,8 +19,8 @@ describe('basic selectors', () => {
                     getY: ({ y }: { y: number }) => y,
                     getYPlus:
                         ({ y }) =>
-                            (incr: number) =>
+                        (incr: number) =>
-                                (y + incr) as number,
+                            (y + incr) as number,
                 },
             }),
             // cause the type to fail
@@ -51,17 +51,4 @@ describe('basic selectors', () => {
         expect(store.getState.getY()).toBe(2);
         expect(store.getState.getYPlus(3)).toBe(5);
     });
-
-    test('addSelector', () => {
-        const dux = new Updux({ initialState: 13 }).addSelector(
-            'plusHundred',
-            (state) => state + 100,
-        );
-
-        expectTypeOf(dux.selectors.plusHundred).toMatchTypeOf<
-            (state: number) => number
-        >();
-
-        expect(dux.selectors.plusHundred(7)).toBe(107);
-    });
 });

src/types.ts

@@ -45,16 +45,11 @@ type SubduxesActions<D> = D extends {
     ? UnionToIntersection<DuxActions<UpduxConfig<S[keyof S]>>>
     : unknown;
 
-type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type ResolveAction<K extends string, A> = A extends Function & { type: string }
-type IsAny<T> = IfAny<T, true, never>;
-
-type ResolveAction<K extends string, A> = true extends IsAny<A>
-    ? ActionCreator<A>
-    : A extends Function & { type: string }
     ? A
     : A extends (...args: infer PARAMS) => infer R
     ? ActionCreatorWithPreparedPayload<PARAMS, R, K, never, never>
-    : ActionCreator<A>;
+    : A;
 
 type ResolveActions<A> = A extends { [key: string]: any }
     ? {