redux-astroglide 0.1.21 → 0.1.22

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+
+### Bug Fixes
+
+### Features

package/dist/index.es.js

@@ -3892,6 +3892,8 @@ var configure = function configure(_ref) {
       name: name,
       initialState: initialState
     })]), [shorthandParams ? astroglideConfigOverrides : initialState]);
+
+    // @ts-ignore - params is dynamically constructed based on shorthand vs normal call
     return createAutomatedSlice.apply(void 0, _toConsumableArray(params));
   };
   return {

package/dist/index.js

@@ -3896,6 +3896,8 @@ var configure = function configure(_ref) {
       name: name,
       initialState: initialState
     })]), [shorthandParams ? astroglideConfigOverrides : initialState]);
+
+    // @ts-ignore - params is dynamically constructed based on shorthand vs normal call
     return createAutomatedSlice.apply(void 0, _toConsumableArray(params));
   };
   return {

package/dist/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-redux')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react-redux'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}, global.reactRedux));
-})(this, (function (exports, reactRedux) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}));
+})(this, (function (exports) { 'use strict';
 
   function _arrayLikeToArray(r, a) {
     (null == a || a > r.length) && (a = r.length);
@@ -5625,23 +5625,6 @@
   var upperFirst = createCaseFirst('toUpperCase');
   var upperFirst_1 = upperFirst;
 
-  const callbackObj = {
-    onAddMiddleware: () => {
-      throw Error("You can't inject middleware until after the store has been initialized.");
-    }
-  };
-  const injectMiddleware = middleware => {
-    callbackObj.onAddMiddleware(middleware);
-  };
-  const injectableMiddleware = store => _next => {
-    let next = _next;
-    callbackObj.onAddMiddleware = middleware => {
-      const currentNextFn = next;
-      next = compose(middleware(store))(currentNextFn); // wrap the previous `next` function with this new one, a la redux
-    };
-    return action => next(action);
-  };
-
   var react = {exports: {}};
 
   var react_production_min = {};
@@ -8417,11 +8400,378 @@
     }
   })(react);
 
+  var withSelector = {exports: {}};
+
+  var useSyncExternalStoreWithSelector_production = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-with-selector.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredUseSyncExternalStoreWithSelector_production;
+  function requireUseSyncExternalStoreWithSelector_production() {
+    if (hasRequiredUseSyncExternalStoreWithSelector_production) return useSyncExternalStoreWithSelector_production;
+    hasRequiredUseSyncExternalStoreWithSelector_production = 1;
+    var React = react.exports;
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is,
+      useSyncExternalStore = React.useSyncExternalStore,
+      useRef = React.useRef,
+      useEffect = React.useEffect,
+      useMemo = React.useMemo,
+      useDebugValue = React.useDebugValue;
+    useSyncExternalStoreWithSelector_production.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef(null);
+      if (null === instRef.current) {
+        var inst = {
+          hasValue: !1,
+          value: null
+        };
+        instRef.current = inst;
+      } else inst = instRef.current;
+      instRef = useMemo(function () {
+        function memoizedSelector(nextSnapshot) {
+          if (!hasMemo) {
+            hasMemo = !0;
+            memoizedSnapshot = nextSnapshot;
+            nextSnapshot = selector(nextSnapshot);
+            if (void 0 !== isEqual && inst.hasValue) {
+              var currentSelection = inst.value;
+              if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+            }
+            return memoizedSelection = nextSnapshot;
+          }
+          currentSelection = memoizedSelection;
+          if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+          var nextSelection = selector(nextSnapshot);
+          if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+          memoizedSnapshot = nextSnapshot;
+          return memoizedSelection = nextSelection;
+        }
+        var hasMemo = !1,
+          memoizedSnapshot,
+          memoizedSelection,
+          maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+        return [function () {
+          return memoizedSelector(getSnapshot());
+        }, null === maybeGetServerSnapshot ? void 0 : function () {
+          return memoizedSelector(maybeGetServerSnapshot());
+        }];
+      }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect(function () {
+        inst.hasValue = !0;
+        inst.value = value;
+      }, [value]);
+      useDebugValue(value);
+      return value;
+    };
+    return useSyncExternalStoreWithSelector_production;
+  }
+
+  var useSyncExternalStoreWithSelector_development = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-with-selector.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredUseSyncExternalStoreWithSelector_development;
+  function requireUseSyncExternalStoreWithSelector_development() {
+    if (hasRequiredUseSyncExternalStoreWithSelector_development) return useSyncExternalStoreWithSelector_development;
+    hasRequiredUseSyncExternalStoreWithSelector_development = 1;
+    "production" !== process.env.NODE_ENV && function () {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React = react.exports,
+        objectIs = "function" === typeof Object.is ? Object.is : is,
+        useSyncExternalStore = React.useSyncExternalStore,
+        useRef = React.useRef,
+        useEffect = React.useEffect,
+        useMemo = React.useMemo,
+        useDebugValue = React.useDebugValue;
+      useSyncExternalStoreWithSelector_development.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        if (null === instRef.current) {
+          var inst = {
+            hasValue: !1,
+            value: null
+          };
+          instRef.current = inst;
+        } else inst = instRef.current;
+        instRef = useMemo(function () {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = !0;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = !1,
+            memoizedSnapshot,
+            memoizedSelection,
+            maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [function () {
+            return memoizedSelector(getSnapshot());
+          }, null === maybeGetServerSnapshot ? void 0 : function () {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }];
+        }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+        var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+        useEffect(function () {
+          inst.hasValue = !0;
+          inst.value = value;
+        }, [value]);
+        useDebugValue(value);
+        return value;
+      };
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+    return useSyncExternalStoreWithSelector_development;
+  }
+
+  (function (module) {
+
+    if (process.env.NODE_ENV === 'production') {
+      module.exports = requireUseSyncExternalStoreWithSelector_production();
+    } else {
+      module.exports = requireUseSyncExternalStoreWithSelector_development();
+    }
+  })(withSelector);
+
+  // src/utils/react.ts
+
+  // src/utils/shallowEqual.ts
+  function is(x, y) {
+    if (x === y) {
+      return x !== 0 || y !== 0 || 1 / x === 1 / y;
+    } else {
+      return x !== x && y !== y;
+    }
+  }
+  function shallowEqual(objA, objB) {
+    if (is(objA, objB)) return true;
+    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+      return false;
+    }
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) return false;
+    for (let i = 0; i < keysA.length; i++) {
+      if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // src/components/Context.ts
+  var ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`);
+  var gT = typeof globalThis !== "undefined" ? globalThis : (
+    /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+    {}
+  );
+  function getContext() {
+    if (!react.exports.createContext) return {};
+    const contextMap = gT[ContextKey] ??= /* @__PURE__ */ new Map();
+    let realContext = contextMap.get(react.exports.createContext);
+    if (!realContext) {
+      realContext = react.exports.createContext(
+        null
+      );
+      if (process.env.NODE_ENV !== "production") {
+        realContext.displayName = "ReactRedux";
+      }
+      contextMap.set(react.exports.createContext, realContext);
+    }
+    return realContext;
+  }
+  var ReactReduxContext = /* @__PURE__ */ getContext();
+
+  // src/hooks/useReduxContext.ts
+  function createReduxContextHook(context = ReactReduxContext) {
+    return function useReduxContext2() {
+      const contextValue = react.exports.useContext(context);
+      if (process.env.NODE_ENV !== "production" && !contextValue) {
+        throw new Error(
+          "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+        );
+      }
+      return contextValue;
+    };
+  }
+  var useReduxContext = /* @__PURE__ */ createReduxContextHook();
+
+  // src/hooks/useStore.ts
+  function createStoreHook(context = ReactReduxContext) {
+    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
+      // @ts-ignore
+      createReduxContextHook(context)
+    );
+    const useStore2 = () => {
+      const { store } = useReduxContext2();
+      return store;
+    };
+    Object.assign(useStore2, {
+      withTypes: () => useStore2
+    });
+    return useStore2;
+  }
+  var useStore = /* @__PURE__ */ createStoreHook();
+
+  // src/hooks/useDispatch.ts
+  function createDispatchHook(context = ReactReduxContext) {
+    const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
+    const useDispatch2 = () => {
+      const store = useStore2();
+      return store.dispatch;
+    };
+    Object.assign(useDispatch2, {
+      withTypes: () => useDispatch2
+    });
+    return useDispatch2;
+  }
+  var useDispatch = /* @__PURE__ */ createDispatchHook();
+  var refEquality = (a, b) => a === b;
+  function createSelectorHook$1(context = ReactReduxContext) {
+    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
+    const useSelector2 = (selector, equalityFnOrOptions = {}) => {
+      const { equalityFn = refEquality } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
+      if (process.env.NODE_ENV !== "production") {
+        if (!selector) {
+          throw new Error(`You must pass a selector to useSelector`);
+        }
+        if (typeof selector !== "function") {
+          throw new Error(`You must pass a function as a selector to useSelector`);
+        }
+        if (typeof equalityFn !== "function") {
+          throw new Error(
+            `You must pass a function as an equality function to useSelector`
+          );
+        }
+      }
+      const reduxContext = useReduxContext2();
+      const { store, subscription, getServerState } = reduxContext;
+      const firstRun = react.exports.useRef(true);
+      const wrappedSelector = react.exports.useCallback(
+        {
+          [selector.name](state) {
+            const selected = selector(state);
+            if (process.env.NODE_ENV !== "production") {
+              const { devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? {} : equalityFnOrOptions;
+              const { identityFunctionCheck, stabilityCheck } = reduxContext;
+              const {
+                identityFunctionCheck: finalIdentityFunctionCheck,
+                stabilityCheck: finalStabilityCheck
+              } = {
+                stabilityCheck,
+                identityFunctionCheck,
+                ...devModeChecks
+              };
+              if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
+                const toCompare = selector(state);
+                if (!equalityFn(selected, toCompare)) {
+                  let stack = void 0;
+                  try {
+                    throw new Error();
+                  } catch (e) {
+                    ({ stack } = e);
+                  }
+                  console.warn(
+                    "Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization",
+                    {
+                      state,
+                      selected,
+                      selected2: toCompare,
+                      stack
+                    }
+                  );
+                }
+              }
+              if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) {
+                if (selected === state) {
+                  let stack = void 0;
+                  try {
+                    throw new Error();
+                  } catch (e) {
+                    ({ stack } = e);
+                  }
+                  console.warn(
+                    "Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.",
+                    { stack }
+                  );
+                }
+              }
+              if (firstRun.current) firstRun.current = false;
+            }
+            return selected;
+          }
+        }[selector.name],
+        [selector]
+      );
+      const selectedState = withSelector.exports.useSyncExternalStoreWithSelector(
+        subscription.addNestedSub,
+        store.getState,
+        getServerState || store.getState,
+        wrappedSelector,
+        equalityFn
+      );
+      react.exports.useDebugValue(selectedState);
+      return selectedState;
+    };
+    Object.assign(useSelector2, {
+      withTypes: () => useSelector2
+    });
+    return useSelector2;
+  }
+  var useSelector = /* @__PURE__ */ createSelectorHook$1();
+
+  const callbackObj = {
+    onAddMiddleware: () => {
+      throw Error("You can't inject middleware until after the store has been initialized.");
+    }
+  };
+  const injectMiddleware = middleware => {
+    callbackObj.onAddMiddleware(middleware);
+  };
+  const injectableMiddleware = store => _next => {
+    let next = _next;
+    callbackObj.onAddMiddleware = middleware => {
+      const currentNextFn = next;
+      next = compose(middleware(store))(currentNextFn); // wrap the previous `next` function with this new one, a la redux
+    };
+    return action => next(action);
+  };
+
   var useAction = function useAction(action, deps) {
     return useActions([action], deps)[0];
   };
   var useActions = function useActions(actions, deps) {
-    var dispatch = reactRedux.useDispatch();
+    var dispatch = useDispatch();
     return react.exports.useMemo(function () {
       if (Array.isArray(actions)) {
         return actions.map(function (a) {
@@ -8553,12 +8903,12 @@
 
   var makeSelectorHook = function makeSelectorHook(selector) {
     return function () {
-      return reactRedux.useSelector(selector, reactRedux.shallowEqual);
+      return useSelector(selector, shallowEqual);
     };
   };
   var createSelectorUpdateHook = function createSelectorUpdateHook(selector, action) {
     return function () {
-      return [reactRedux.useSelector(selector), useAction(action, undefined)];
+      return [useSelector(selector), useAction(action, undefined)];
     };
   };
   var createSelectorHook = function createSelectorHook() {
@@ -8626,7 +8976,7 @@
         var setterCb = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (value) {
           return value;
         };
-        return [reactRedux.useSelector(selector), useAction(function (value) {
+        return [useSelector(selector), useAction(function (value) {
           return updateAction(setterCb(value));
         }, undefined)];
       };
@@ -8782,7 +9132,7 @@
 
       /* eslint-disable react-hooks/rules-of-hooks */
       hooks[domainHookKey] = function () {
-        return [reactRedux.useSelector(selectDomain), useAction(slice.actions[sliceSetterKey], undefined).apply(void 0, _toConsumableArray(getParams())),
+        return [useSelector(selectDomain), useAction(slice.actions[sliceSetterKey], undefined).apply(void 0, _toConsumableArray(getParams())),
         // prop updater
         useAction(slice.actions.__override__slice__caution, undefined) // state overwriter
         ];
@@ -8810,6 +9160,8 @@
         name: name,
         initialState: initialState
       })]), [shorthandParams ? astroglideConfigOverrides : initialState]);
+
+      // @ts-ignore - params is dynamically constructed based on shorthand vs normal call
       return createAutomatedSlice.apply(void 0, _toConsumableArray(params));
     };
     return {