acknowledge the subduxes actions

src/Updux.js

@@ -13,7 +13,11 @@ export class Updux {
         this.#config = config;
         this.#localInitial = config.initial ?? {};
         this.#subduxes = config.subduxes ?? {};
-        this.#actions = config.actions ?? {};
+
+        this.#actions = R.mergeAll([
+            config.actions ?? {},
+            ...Object.values(this.#subduxes).map(R.prop('actions')),
+        ]);
     }
 
     get actions() {
@@ -35,7 +39,7 @@ export class Updux {
     }
 
     get upreducer() {
-        return (action) => state => {
+        return (action) => (state) => {
             const mutation = this.#mutations[action.type];
 
             if (mutation) {

src/actions.js

@@ -1,8 +1,4 @@
-export function action(
+export function action(type, payloadFunction, transformer) {
-    type,
-    payloadFunction,
-    transformer,
-) {
     let generator = function (...payloadArg) {
         const result = { type };
 

src/actions.test.js

@@ -15,23 +15,39 @@ test('basic action', () => {
     });
 });
 
-test( "Updux config accepts actions", () => {
+test('Updux config accepts actions', () => {
     const foo = new Updux({
         actions: {
             one: action('one', (x) => ({ x })),
-             two: action('two', x => x),
+            two: action('two', (x) => x),
-        }
+        },
     });
 
     expect(Object.keys(foo.actions)).toHaveLength(2);
 
     expect(foo.actions.one).toBeTypeOf('function');
-    expect( foo.actions.one("potato") ).toEqual({
+    expect(foo.actions.one('potato')).toEqual({
         type: 'one',
         payload: {
-            x: 'potato'
+            x: 'potato',
-        }
+        },
+    });
 });
 
-} )
+test('subduxes actions', () => {
+    const foo = new Updux({
+        actions: {
+            foo: null,
+        },
+        subduxes: {
+            beta: {
+                actions: {
+                    bar: null,
+                },
+            },
+        },
+    });
 
+    expect(foo.actions).toHaveProperty('foo');
+    expect(foo.actions).toHaveProperty('bar');
+});

src/buildUpreducer.js

@@ -5,7 +5,7 @@ export function buildUpreducer(
     initial,
     mutations,
     subduxes = {},
-    wrapper = undefined
+    wrapper = undefined,
 ) {
     const subReducers =
         Object.keys(subduxes).length > 0
@@ -23,11 +23,11 @@ export function buildUpreducer(
                 newState = u.updateIn(
                     '*',
                     subduxes['*'].upreducer(action),
-                    newState
+                    newState,
                 );
             } else {
                 const update = mapValues(subReducers, (upReducer) =>
-                    upReducer(action)
+                    upReducer(action),
                 );
 
                 newState = u(update, newState);

src/mutations.test.js

@@ -9,22 +9,22 @@ import { Updux } from './Updux.js';
 test('set a mutation', () => {
     const dux = new Updux({
         initial: {
-            x: "potato",
+            x: 'potato',
         },
         actions: {
             foo: action('foo', (x) => ({ x })),
             bar: action('bar'),
-        }
+        },
     });
 
-    dux.setMutation( dux.actions.foo, (payload,action) => u({
+    dux.setMutation(dux.actions.foo, (payload, action) =>
-        x: payload.x + action.type
+        u({
-    }) );
+            x: payload.x + action.type,
+        }),
+    );
 
-    const result = dux.reducer(undefined,dux.actions.foo("hello "));
+    const result = dux.reducer(undefined, dux.actions.foo('hello '));
     expect(result).toEqual({
-        x: "hello foo"
+        x: 'hello foo',
-    })
+    });
-
-
 });