feat: add effects method of Builder

Author: megazazik

README.md

@@ -113,6 +113,44 @@ export const parentModel = build()
 
 Then every time you dispatch `Child1.increment` the `Child2.decrement` actoin will be dispatched and handled too and vice versa.
 
+### Dispatching no object action
+If you need to dispatch actions which are not simple objects, for example, functions with using redux-think, you can use the `effects` and `effect` methods of a Builder.
+```js
+import { build } from 'encaps';
+
+export const model = build()
+	.initState(() => ({value: true}))
+	.handlers({
+		set: (state, {payload}) => ({...state, value: payload})
+	})
+	.affect(
+		'thunk1',
+		(actions) => () => (dispatch) => {
+			...
+			/** some async code */
+			...
+			dispatch(actions.set(false))
+		}
+	)
+	.affects({
+		thunk2: (actions) => () => (dispatch) => {
+			...
+			/** some async code */
+			...
+			dispatch(actions.set(true))
+		},
+		thunk3: (actions) => (payload) => (dispatch) => {
+			...
+			/** some async code */
+			...
+			dispatch(actions.set(payload))
+		},
+	})
+	
+dispatch(model.actions.thunk3(false));
+```
+An effect is a function which receives actions of the current builder. It should return an action creator. And this action creator can return a function, a promise or something else.
+
 ### Dynamic list of children
 
 #### Array of children
@@ -172,7 +210,7 @@ map.reducer(initState, map.actions.add('Child1'));
 ```
 
 ## API
-The main idea of this package it to build independent modeles that consists of action creators and a reducer.
+The main idea of this package it to build independent modeles which consists of action creators and a reducer.
 
 ```typescript
 interface Model {
@@ -185,7 +223,7 @@ interface Model {
 }
 ```
 
-The `actions` field of model is a map that contains of functions which get payload and return action. Action creators can be nested.
+The `actions` field of model is a map which contains of functions which get payload and return action. Action creators can be nested.
 
 ```typescript
 interface ActionCreators {
@@ -211,7 +249,7 @@ The `build` function returns a `Builder` object.
 ```typescript
 interface Builder {
 	/**
-	 * You can set function that create initial state
+	 * You can set function which create initial state
 	 * This function gets state created by previous initState function (it can be used then you extends existing model).
 	 * @returns new Builder
 	 */
@@ -250,9 +288,29 @@ interface Builder {
 	 * @returns new Builder
 	 */
 	subActions(
-		/** map of functions that create additional actions */
+		/** map of functions which create additional actions */
 		wrapers: {[K: string]: (action, actions) => Action}
 	): Builder;
+
+	/**
+	 * adds action creator which can return something different from simple object
+	 * @returns new builder
+	 */
+	effect(
+		/** action key */
+		key: K,
+		/**  */
+		effect: (actions) => (...args) => any
+	): Builder;
+
+	/**
+	 * adds action creators which can return something different from simple object
+	 * @returns new builder
+	 */
+	effects(
+		/** map of affects */
+		effects: {[K: string]: (actions) => (...args) => any}
+	): Builder;
 }
 ```
 

dist/controller.d.ts

@@ -97,6 +97,15 @@ export interface IBuilder<Actions extends IActionCreators = {}, State = {}> exte
     effect: (actions: Actions) => (...args: P) => A): IBuilder<Actions & {
         [F in K]: (...args: P) => A;
     }, State>;
+    /**
+     * Позволяет создавать любые действия, не только простые объекты
+     * @returns новый строитель
+     */
+    effects<EF extends Dictionary<(actions: Actions) => (...args: any[]) => any>>(
+    /** ассоциативный массив дочерних моделей */
+    effects: EF): IBuilder<Actions & {
+        [C in keyof EF]: ReturnType<EF[C]>;
+    }, State>;
 }
 export declare function getSubActions(action: IAction<any>): IAction<any>[];
 export declare const unwrapAction: (action: IAction<any>) => {

dist/controller.js

@@ -11,6 +11,7 @@ var Builder = /** @class */ (function () {
     function Builder(_model) {
         this._model = _model;
     }
+    /** @deprecated Will be removed in the next version. Use initState instead. */
     Builder.prototype.setInitState = function (f) {
         if (console && typeof console.warn === 'function') {
             console.warn('"setInitState" method is deprecated and will be removed in the next version. Use "initState" instead.');
@@ -85,6 +86,16 @@ var Builder = /** @class */ (function () {
         var _a;
         return new Builder(tslib_1.__assign({}, this.model, { actions: tslib_1.__assign({}, this.model.actions, (_a = {}, _a[key] = createEffect(effect, function () { return _this.model.actions; }), _a)) }));
     };
+    /**
+     * Позволяет создавать любые действия, не только простые объекты
+     * @returns новый строитель
+     */
+    Builder.prototype.effects = function (
+    /** ассоциативный массив дочерних моделей */
+    effects) {
+        /** @todo оптимизировать */
+        return Object.keys(effects).reduce(function (newBuilder, key) { return newBuilder.effect(key, effects[key]); }, this);
+    };
     Object.defineProperty(Builder.prototype, "model", {
         get: function () {
             return tslib_1.__assign({}, this._model);

src/controller.ts

@@ -121,6 +121,18 @@ export interface IBuilder<
 		/** Функция, которая создает действия не в виде простых объектов */
 		effect: (actions: Actions) => (...args: P) => A
 	): IBuilder<Actions & {[F in K]: (...args: P) => A}, State>;
+
+	/**
+	 * Позволяет создавать любые действия, не только простые объекты
+	 * @returns новый строитель
+	 */
+	effects<EF extends Dictionary<(actions: Actions) => (...args: any[]) => any>>(
+		/** ассоциативный массив дочерних моделей */
+		effects: EF
+	): IBuilder<
+		Actions & {[C in keyof EF]: ReturnType<EF[C]>},
+		State
+	>;
 }
 
 /**
@@ -245,6 +257,24 @@ class Builder<
 		});
 	}
 
+	/**
+	 * Позволяет создавать любые действия, не только простые объекты
+	 * @returns новый строитель
+	 */
+	effects<EF extends Dictionary<(actions: Actions) => (...args: any[]) => any>>(
+		/** ассоциативный массив дочерних моделей */
+		effects: EF
+	): IBuilder<
+		Actions & {[C in keyof EF]: ReturnType<EF[C]>},
+		State
+	> {
+		/** @todo оптимизировать */
+		return Object.keys(effects).reduce(
+			(newBuilder, key) => newBuilder.effect(key, effects[key]),
+			this as any
+		);
+	}
+
 	get model(): IModel<Actions, State> {
 		return {...this._model};
 	}

test/controller.spec.ts

@@ -637,6 +637,30 @@ test('simple effects', (t) => {
 	t.end();
 });
 
+test('simple multiple effects', (t) => {
+	const model = build()
+		.initState((state) => ({...state, value: 0}))
+		.handlers({
+			simpleAction: (state, action: IAction<number>) => ({...state, value: action.payload})
+		})
+		.effects({
+			ef1: (actions) => (payload: number) => () => actions.simpleAction(payload * 2),
+			ef2: (actions) => (payload: number) => () => actions.simpleAction(payload / 2),
+		});
+	
+	t.deepEqual(
+		model.actions.ef1(10)(),
+		{type: 'simpleAction', payload: 20}
+	);
+
+	t.deepEqual(
+		model.actions.ef2(10)(),
+		{type: 'simpleAction', payload: 5}
+	);
+
+	t.end();
+});
+
 test('children effects', (t) => {
 	const grandChild = build()
 		.initState((state) => ({...state, value: 0}))