use-typed-reducer 3.3.0-2 → 3.3.0

package/dist/index.d.ts

@@ -1,39 +1,38 @@
-import { MutableRefObject } from "react";
-type PromiseBox<T> = T | Promise<T>;
-type VoidFn<Fn extends (...any: any[]) => any> = ReturnType<Fn> extends Promise<any> ? (...a: Parameters<Fn>) => Promise<void> : (...a: Parameters<Fn>) => void;
-type Action<State> = (...args: any) => PromiseBox<(state: State) => State>;
-export type Dispatch<State, Fns extends {
-    [key in keyof Fns]: Action<State>;
-}> = {
-    [R in keyof Fns]: (...args: any[]) => PromiseBox<(state: State) => State>;
-};
-type MapReducers<State extends {}, Reducers extends Dispatch<State, Reducers>> = {
-    [R in keyof Reducers]: VoidFn<Reducers[R]>;
-};
-type ReducerArgs<State extends {}, Props extends object> = {
-    state: () => State;
-    props: () => Props;
-    initialState: State;
-};
-type FnMap<State> = {
-    [k: string]: (...args: any[]) => PromiseBox<Partial<State>>;
-};
-type MappedReducers<State extends {}, Fns extends FnMap<State>> = {
-    [F in keyof Fns]: (...args: Parameters<Fns[F]>) => PromiseBox<Partial<State>>;
-};
-type MapReducerReturn<State extends {}, Fns extends FnMap<State>> = {
-    [F in keyof Fns]: VoidFn<Fns[F]>;
-};
-type UseReducerReduce<State extends object, Props extends object> = (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>;
-type UseReducer<Selector, State extends {}, Props extends {}, Reducers extends UseReducerReduce<State, Props>> = readonly [state: Selector, dispatchers: MapReducerReturn<State, ReturnType<Reducers>>];
-type ReducerMiddleware<State extends object, Props extends object, Reducers extends (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>> = Array<(state: State, key: keyof ReturnType<Reducers>) => State>;
-type Callback<T> = T | ((prev: T) => T);
-export declare const useTypedReducer: <State extends {}, Reducers extends Dispatch<State, Reducers>>(initialState: State, reducers: Reducers) => [state: State, dispatch: MapReducers<State, Reducers>];
-export declare const useMutable: <T extends {}>(state: T) => MutableRefObject<T>;
-export declare const dispatchCallback: <Prev extends unknown, T extends Callback<Prev>>(prev: Prev, setter: T) => any;
-export type DispatchCallback<T extends any> = Callback<T>;
-export declare const useReducer: <State extends {}, Reducers extends UseReducerReduce<State, Props>, Props extends object, Middlewares extends ReducerMiddleware<State, Props, Reducers>>(initialState: State, reducer: Reducers, props?: Props | undefined, middlewares?: Middlewares | undefined) => UseReducer<State, State, Props, Reducers>;
-export declare const createReducer: <State extends {} = {}, Props extends object = {}>() => <Reducer extends (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>>(reducer: Reducer) => Reducer;
-export declare const createGlobalReducer: <State extends {}, Reducers extends UseReducerReduce<State, Props>, Props extends object, Middlewares extends ReducerMiddleware<State, Props, Reducers>>(initialState: State, reducer: Reducers, props?: Props | undefined, middlewares?: Middlewares | undefined) => <Selector extends (state: State) => any>(selector?: Selector | undefined) => UseReducer<Selector extends (state: State) => State ? State : ReturnType<Selector>, State, Props, Reducers>;
-export default useTypedReducer;
-//# sourceMappingURL=index.d.ts.map
+import { MutableRefObject } from "react";
+declare type PromiseBox<T> = T | Promise<T>;
+declare type VoidFn<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) => PromiseBox<(state: State) => State>;
+export declare type Dispatch<State, Fns extends {
+    [key in keyof Fns]: Action<State>;
+}> = {
+    [R in keyof Fns]: (...args: any[]) => PromiseBox<(state: State) => State>;
+};
+declare type MapReducers<State extends {}, Reducers extends Dispatch<State, Reducers>> = {
+    [R in keyof Reducers]: VoidFn<Reducers[R]>;
+};
+declare type ReducerArgs<State extends {}, Props extends object> = {
+    state: () => State;
+    props: () => Props;
+    initialState: State;
+};
+declare type FnMap<State> = {
+    [k: string]: (...args: any[]) => PromiseBox<Partial<State>>;
+};
+declare type MappedReducers<State extends {}, Fns extends FnMap<State>> = {
+    [F in keyof Fns]: (...args: Parameters<Fns[F]>) => PromiseBox<Partial<State>>;
+};
+declare type MapReducerReturn<State extends {}, Fns extends FnMap<State>> = {
+    [F in keyof Fns]: VoidFn<Fns[F]>;
+};
+declare type UseReducerReduce<State extends object, Props extends object> = (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>;
+declare type UseReducer<Selector, State extends {}, Props extends {}, Reducers extends UseReducerReduce<State, Props>> = readonly [state: Selector, dispatchers: MapReducerReturn<State, ReturnType<Reducers>>];
+declare type ReducerMiddleware<State extends object, Props extends object, Reducers extends (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>> = Array<(state: State, key: keyof ReturnType<Reducers>) => State>;
+declare type Callback<T> = T | ((prev: T) => T);
+export declare const useTypedReducer: <State extends {}, Reducers extends Dispatch<State, Reducers>>(initialState: State, reducers: Reducers) => [state: State, dispatch: MapReducers<State, Reducers>];
+export declare const useMutable: <T extends {}>(state: T) => MutableRefObject<T>;
+export declare const dispatchCallback: <Prev extends unknown, T extends Callback<Prev>>(prev: Prev, setter: T) => any;
+export declare type DispatchCallback<T extends any> = Callback<T>;
+export declare const useReducer: <State extends {}, Reducers extends UseReducerReduce<State, Props>, Props extends object, Middlewares extends ReducerMiddleware<State, Props, Reducers>>(initialState: State, reducer: Reducers, props?: Props | undefined, middlewares?: Middlewares | undefined) => UseReducer<State, State, Props, Reducers>;
+export declare const createReducer: <State extends {} = {}, Props extends object = {}>() => <Reducer extends (args: ReducerArgs<State, Props>) => MappedReducers<State, FnMap<State>>>(reducer: Reducer) => Reducer;
+export declare const createGlobalReducer: <State extends {}, Reducers extends UseReducerReduce<State, Props>, Props extends object, Middlewares extends ReducerMiddleware<State, Props, Reducers>>(initialState: State, reducer: Reducers, props?: Props | undefined, middlewares?: Middlewares | undefined) => <Selector extends (state: State) => any>(selector?: Selector | undefined) => UseReducer<Selector extends (state: State) => State ? State : ReturnType<Selector>, State, Props, Reducers>;
+export default useTypedReducer;

package/dist/index.es.js

@@ -0,0 +1,380 @@
+import react, { useState, useMemo, useRef, useEffect } from 'react';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p="function"===typeof Object.is?Object.is:n,q=react.useSyncExternalStore,r=react.useRef,t=react.useEffect,u=react.useMemo,v=react.useDebugValue;
+var useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f;}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return [function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);
+t(function(){f.hasValue=!0;f.value=d;},[d]);v(d);return d};
+
+var useSyncExternalStoreWithSelector_production_min = {
+	useSyncExternalStoreWithSelector: useSyncExternalStoreWithSelector
+};
+
+var useSyncExternalStoreWithSelector_development = createCommonjsModule(function (module, exports) {
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = react;
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+var useSyncExternalStore = React.useSyncExternalStore;
+
+// for CommonJS interop.
+
+var useRef = React.useRef,
+    useEffect = React.useEffect,
+    useMemo = React.useMemo,
+    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.
+
+function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+  // Use this to track the rendered snapshot.
+  var instRef = useRef(null);
+  var inst;
+
+  if (instRef.current === null) {
+    inst = {
+      hasValue: false,
+      value: null
+    };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+
+  var _useMemo = useMemo(function () {
+    // Track the memoized state using closure variables that are local to this
+    // memoized instance of a getSnapshot function. Intentionally not using a
+    // useRef hook, because that state would be shared across all concurrent
+    // copies of the hook/component.
+    var hasMemo = false;
+    var memoizedSnapshot;
+    var memoizedSelection;
+
+    var memoizedSelector = function (nextSnapshot) {
+      if (!hasMemo) {
+        // The first time the hook is called, there is no memoized result.
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+
+        var _nextSelection = selector(nextSnapshot);
+
+        if (isEqual !== undefined) {
+          // Even if the selector has changed, the currently rendered selection
+          // may be equal to the new selection. We should attempt to reuse the
+          // current value if possible, to preserve downstream memoizations.
+          if (inst.hasValue) {
+            var currentSelection = inst.value;
+
+            if (isEqual(currentSelection, _nextSelection)) {
+              memoizedSelection = currentSelection;
+              return currentSelection;
+            }
+          }
+        }
+
+        memoizedSelection = _nextSelection;
+        return _nextSelection;
+      } // We may be able to reuse the previous invocation's result.
+
+
+      // We may be able to reuse the previous invocation's result.
+      var prevSnapshot = memoizedSnapshot;
+      var prevSelection = memoizedSelection;
+
+      if (objectIs(prevSnapshot, nextSnapshot)) {
+        // The snapshot is the same as last time. Reuse the previous selection.
+        return prevSelection;
+      } // The snapshot has changed, so we need to compute a new selection.
+
+
+      // The snapshot has changed, so we need to compute a new selection.
+      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+
+      // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {
+        return prevSelection;
+      }
+
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    }; // Assigning this to a constant so that Flow knows it can't change.
+
+
+    // Assigning this to a constant so that Flow knows it can't change.
+    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
+
+    var getSnapshotWithSelector = function () {
+      return memoizedSelector(getSnapshot());
+    };
+
+    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {
+      return memoizedSelector(maybeGetServerSnapshot());
+    };
+    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+  }, [getSnapshot, getServerSnapshot, selector, isEqual]),
+      getSelection = _useMemo[0],
+      getServerSelection = _useMemo[1];
+
+  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+  useEffect(function () {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [value]);
+  useDebugValue(value);
+  return value;
+}
+
+exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
+});
+var useSyncExternalStoreWithSelector_development_1 = useSyncExternalStoreWithSelector_development.useSyncExternalStoreWithSelector;
+
+var withSelector = createCommonjsModule(function (module) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = useSyncExternalStoreWithSelector_production_min;
+} else {
+  module.exports = useSyncExternalStoreWithSelector_development;
+}
+});
+
+var entries = function (t) { return Object.entries(t); };
+var isPromise = function (promise) { return promise instanceof Promise; };
+var useTypedReducer = function (initialState, reducers) {
+    var _a = __read(useState(initialState), 2), state = _a[0], setState = _a[1];
+    var dispatches = useMemo(function () {
+        return entries(reducers).reduce(function (acc, _a) {
+            var _b;
+            var _c = __read(_a, 2), name = _c[0], dispatch = _c[1];
+            return (__assign(__assign({}, acc), (_b = {}, _b[name] = function () {
+                var params = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    params[_i] = arguments[_i];
+                }
+                return __awaiter(void 0, void 0, void 0, function () {
+                    var dispatcher;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, dispatch.apply(void 0, __spread(params))];
+                            case 1:
+                                dispatcher = _a.sent();
+                                return [2 /*return*/, setState(function (previousState) { return dispatcher(previousState); })];
+                        }
+                    });
+                });
+            }, _b)));
+        }, reducers);
+    }, [reducers]);
+    return [state, dispatches];
+};
+var useMutable = function (state) {
+    var mutable = useRef(state !== null && state !== void 0 ? state : {});
+    useEffect(function () { return void (mutable.current = state); }, [state]);
+    return mutable;
+};
+var dispatchCallback = function (prev, setter) {
+    return typeof setter === "function" ? setter(prev) : setter;
+};
+var reduceMiddleware = function (state, prev, middleware, key) { return middleware.reduce(function (acc, fn) { return fn(acc, key); }, __assign(__assign({}, prev), state)); };
+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({
+            state: function () { return mutableState.current; },
+            props: function () { return mutableProps.current; },
+            initialState: savedInitialState.current
+        });
+        return entries(reducers).reduce(function (acc, _a) {
+            var _b;
+            var _c = __read(_a, 2), name = _c[0], dispatch = _c[1];
+            return (__assign(__assign({}, acc), (_b = {}, _b[name] = function () {
+                var params = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    params[_i] = arguments[_i];
+                }
+                var result = dispatch.apply(void 0, __spread(params));
+                var set = function (newState) {
+                    return setState(function (prev) { return reduceMiddleware(newState, prev, middleware.current, name); });
+                };
+                return isPromise(result) ? void result.then(set) : set(result);
+            }, _b)));
+        }, {});
+    }, [mutableProps, mutableReducer, mutableState]);
+    return [state, dispatchers];
+};
+var createReducer = function () {
+    return function (reducer) {
+        return reducer;
+    };
+};
+var createGlobalReducer = function (initialState, reducer, props, middlewares) {
+    var state = initialState;
+    var getSnapshot = function () { return state; };
+    var listeners = new Set();
+    var addListener = function (listener) {
+        listeners.add(listener);
+        return function () { return listeners.delete(listener); };
+    };
+    var setState = function (callback) {
+        var previousState = __assign({}, state);
+        var newState = callback(state);
+        state = newState;
+        listeners.forEach(function (exec) { return exec(newState, previousState); });
+    };
+    var getProps = function () { return props || {}; };
+    var args = { state: getSnapshot, props: getProps, initialState: initialState };
+    var middlewareList = middlewares || [];
+    var dispatchers = entries(reducer(args)).reduce(function (acc, _a) {
+        var _b;
+        var _c = __read(_a, 2), name = _c[0], fn = _c[1];
+        return (__assign(__assign({}, acc), (_b = {}, _b[name] = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var result = fn.apply(void 0, __spread(args));
+            var set = function (newState) {
+                return setState(function (prev) { return reduceMiddleware(newState, prev, middlewareList, name); });
+            };
+            return isPromise(result) ? result.then(set) : set(result);
+        }, _b)));
+    }, {});
+    var defaultSelector = function (state) { return state; };
+    return function useStore(selector) {
+        var state = withSelector.useSyncExternalStoreWithSelector(addListener, getSnapshot, getSnapshot, selector || defaultSelector, Object.is);
+        return [state, dispatchers];
+    };
+};
+
+export default useTypedReducer;
+export { createGlobalReducer, createReducer, dispatchCallback, useMutable, useReducer, useTypedReducer };