use-typed-reducer 3.2.2 → 3.2.3

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import { MutableRefObject } from "react";
 declare type VoidableFn<Fn extends (...any: any[]) => any> = ReturnType<Fn> extends Promise<any> ? (...a: Parameters<Fn>) => Promise<void> : (...a: Parameters<Fn>) => void;
 declare type Action<State> = (...args: any) => Promise<(state: State) => State> | ((state: State) => State);
 declare type Actions<Actions, State> = {
@@ -15,11 +15,14 @@ declare type FnMap<State> = {
     [k: string]: (...args: any[]) => Partial<State> | Promise<Partial<State>>;
 };
 declare type MappedReducers<State extends {}, Fns extends FnMap<State>> = {
-    [F in keyof Fns]: (...args: Parameters<Fns[F]>) => State | Promise<State> | Partial<State> | Promise<Partial<State>>;
+    [F in keyof Fns]: (...args: Parameters<Fns[F]>) => Promise<Partial<State>> | Partial<State>;
 };
 declare type MapReducerReturn<State extends {}, Fns extends FnMap<State>> = {
     [F in keyof Fns]: VoidableFn<Fns[F]>;
 };
-export declare const useMutable: <T extends {}>(state: T) => import("react").MutableRefObject<T>;
-export declare const useReducer: <State extends {}, Reducers extends (getState: () => State, getProps: () => Props) => MappedReducers<State, FnMap<State>>, Props extends {}>(initialState: State, reducer: Reducers, props?: Props | undefined) => [state: State, dispatchers: MapReducerReturn<State, ReturnType<Reducers>>];
+export declare const useMutable: <T extends {}>(state: T) => MutableRefObject<T>;
+export declare const dispatchCallback: <Prev extends unknown, T extends Prev | ((prev: Prev) => Prev)>(prev: Prev, setter: T) => any;
+export declare type DispatchCallback<T extends any> = T | ((prev: T) => T);
+export declare const useReducer: <State extends {}, Reducers extends (getState: () => State, getProps: () => Props, initialState: State) => MappedReducers<State, FnMap<State>>, Props extends {}, Middlewares extends ((state: State, key: keyof ReturnType<Reducers>) => State)[]>(initialState: State, reducer: Reducers, props?: Props | undefined, middlewares?: Middlewares | undefined) => readonly [state: State, dispatchers: MapReducerReturn<State, ReturnType<Reducers>>];
+export declare const createReducer: <State extends {} = {}, Props extends {} = {}>() => <Reducer extends (getState: () => State, getProps: () => Props, initialState: State) => MappedReducers<State, FnMap<State>>>(reducer: Reducer) => Reducer;
 export default useTypedReducer;

package/dist/index.es.js

@@ -121,13 +121,18 @@ var useMutable = function (state) {
     useEffect(function () { return void (mutable.current = state); }, [state]);
     return mutable;
 };
-var useReducer = function (initialState, reducer, props) {
+var dispatchCallback = function (prev, setter) {
+    return typeof setter === "function" ? setter(prev) : setter;
+};
+var useReducer = function (initialState, reducer, props, middlewares) {
     var _a = __read(useState(function () { return initialState; }), 2), state = _a[0], setState = _a[1];
     var mutableState = useMutable(state);
     var mutableProps = useMutable(props !== null && props !== void 0 ? props : {});
     var mutableReducer = useMutable(reducer);
+    var middleware = useMutable(middlewares !== null && middlewares !== void 0 ? middlewares : []);
+    var savedInitialState = useRef(initialState);
     var dispatchers = useMemo(function () {
-        var reducers = mutableReducer.current(function () { return mutableState.current; }, function () { var _a; return (_a = mutableProps.current) !== null && _a !== void 0 ? _a : {}; });
+        var reducers = mutableReducer.current(function () { return mutableState.current; }, function () { var _a; return (_a = mutableProps.current) !== null && _a !== void 0 ? _a : {}; }, savedInitialState.current);
         return entries(reducers).reduce(function (acc, _a) {
             var _b;
             var _c = __read(_a, 2), name = _c[0], dispatch = _c[1];
@@ -136,15 +141,26 @@ var useReducer = function (initialState, reducer, props) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     params[_i] = arguments[_i];
                 }
-                var newState = dispatch.apply(void 0, __spread(params));
-                return newState instanceof Promise
-                    ? void newState.then(function (state) { return void setState(function (prev) { return (__assign(__assign({}, prev), state)); }); })
-                    : setState(function (prev) { return (__assign(__assign({}, prev), newState)); });
+                var st = dispatch.apply(void 0, __spread(params));
+                return st instanceof Promise
+                    ? void st.then(function (state) {
+                        return setState(function (prev) {
+                            return middleware.current.reduce(function (acc, fn) { return fn(acc, name); }, __assign(__assign({}, prev), { state: state }));
+                        });
+                    })
+                    : setState(function (prev) {
+                        return middleware.current.reduce(function (acc, fn) { return fn(acc, name); }, __assign(__assign({}, prev), st));
+                    });
             }, _b)));
-        }, reducers);
-    }, []);
+        }, {});
+    }, [mutableProps, mutableReducer, mutableState]);
     return [state, dispatchers];
+};
+var createReducer = function () {
+    return function (reducer) {
+        return reducer;
+    };
 };
 
 export default useTypedReducer;
-export { useMutable, useReducer, useTypedReducer };
+export { createReducer, dispatchCallback, useMutable, useReducer, useTypedReducer };

package/dist/index.js

@@ -125,13 +125,18 @@ var useMutable = function (state) {
     react.useEffect(function () { return void (mutable.current = state); }, [state]);
     return mutable;
 };
-var useReducer = function (initialState, reducer, props) {
+var dispatchCallback = function (prev, setter) {
+    return typeof setter === "function" ? setter(prev) : setter;
+};
+var useReducer = function (initialState, reducer, props, middlewares) {
     var _a = __read(react.useState(function () { return initialState; }), 2), state = _a[0], setState = _a[1];
     var mutableState = useMutable(state);
     var mutableProps = useMutable(props !== null && props !== void 0 ? props : {});
     var mutableReducer = useMutable(reducer);
+    var middleware = useMutable(middlewares !== null && middlewares !== void 0 ? middlewares : []);
+    var savedInitialState = react.useRef(initialState);
     var dispatchers = react.useMemo(function () {
-        var reducers = mutableReducer.current(function () { return mutableState.current; }, function () { var _a; return (_a = mutableProps.current) !== null && _a !== void 0 ? _a : {}; });
+        var reducers = mutableReducer.current(function () { return mutableState.current; }, function () { var _a; return (_a = mutableProps.current) !== null && _a !== void 0 ? _a : {}; }, savedInitialState.current);
         return entries(reducers).reduce(function (acc, _a) {
             var _b;
             var _c = __read(_a, 2), name = _c[0], dispatch = _c[1];
@@ -140,17 +145,30 @@ var useReducer = function (initialState, reducer, props) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     params[_i] = arguments[_i];
                 }
-                var newState = dispatch.apply(void 0, __spread(params));
-                return newState instanceof Promise
-                    ? void newState.then(function (state) { return void setState(function (prev) { return (__assign(__assign({}, prev), state)); }); })
-                    : setState(function (prev) { return (__assign(__assign({}, prev), newState)); });
+                var st = dispatch.apply(void 0, __spread(params));
+                return st instanceof Promise
+                    ? void st.then(function (state) {
+                        return setState(function (prev) {
+                            return middleware.current.reduce(function (acc, fn) { return fn(acc, name); }, __assign(__assign({}, prev), { state: state }));
+                        });
+                    })
+                    : setState(function (prev) {
+                        return middleware.current.reduce(function (acc, fn) { return fn(acc, name); }, __assign(__assign({}, prev), st));
+                    });
             }, _b)));
-        }, reducers);
-    }, []);
+        }, {});
+    }, [mutableProps, mutableReducer, mutableState]);
     return [state, dispatchers];
+};
+var createReducer = function () {
+    return function (reducer) {
+        return reducer;
+    };
 };
 
+exports.createReducer = createReducer;
 exports.default = useTypedReducer;
+exports.dispatchCallback = dispatchCallback;
 exports.useMutable = useMutable;
 exports.useReducer = useReducer;
 exports.useTypedReducer = useTypedReducer;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "use-typed-reducer",
-    "version": "3.2.2",
+    "version": "3.2.3",
     "description": "use-reducer React hook alternative",
     "author": "g4rcez",
     "license": "MIT",