cross-state 0.19.3 → 0.21.0

package/dist/cjs/scope.cjs

@@ -1,30 +1,583 @@
 "use strict";
+const require$$0 = require("react");
 const store = require("./store.cjs");
-function hash(value) {
-  if (value instanceof Set) {
-    return `s[${[...value].map(hash).sort().join(",")}]`;
+const jsxRuntime = require("react/jsx-runtime");
+const hash = require("./hash.cjs");
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production_min;
+function requireUseSyncExternalStoreShim_production_min() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min)
+    return useSyncExternalStoreShim_production_min;
+  hasRequiredUseSyncExternalStoreShim_production_min = 1;
+  var e = require$$0;
+  function h(a, b) {
+    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
   }
-  if (value instanceof Map) {
-    return `m[${[...value.entries()].map(hash).sort().join(",")}]`;
+  var k = "function" === typeof Object.is ? Object.is : h, l = e.useState, m = e.useEffect, n = e.useLayoutEffect, p = e.useDebugValue;
+  function q(a, b) {
+    var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
+    n(function() {
+      c.value = d;
+      c.getSnapshot = b;
+      r(c) && g({ inst: c });
+    }, [a, d, b]);
+    m(function() {
+      r(c) && g({ inst: c });
+      return a(function() {
+        r(c) && g({ inst: c });
+      });
+    }, [a]);
+    p(d);
+    return d;
   }
-  if (Array.isArray(value)) {
-    return `[${value.map(hash).join(",")}]`;
+  function r(a) {
+    var b = a.getSnapshot;
+    a = a.value;
+    try {
+      var d = b();
+      return !k(a, d);
+    } catch (f) {
+      return true;
+    }
   }
-  if (value instanceof Object) {
-    return `o[${Object.entries(value).map(hash).sort().join(",")}]`;
+  function t(a, b) {
+    return b();
   }
-  return JSON.stringify(value);
+  var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
+  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
+  return useSyncExternalStoreShim_production_min;
 }
-class Scope {
-  constructor(defaultValue) {
-    this.defaultValue = defaultValue;
-    store.autobind(Scope);
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development)
+    return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0;
+      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format, args);
+          }
+        }
+      }
+      function printWarning(level, format, args) {
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== "") {
+            format += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      function is(x, y) {
+        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false;
+      function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React.startTransition !== void 0) {
+              didWarnOld18Alpha = true;
+              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+            }
+          }
+        }
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error("The result of getSnapshot should be cached to avoid an infinite loop");
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        }
+        var _useState = useState({
+          inst: {
+            value,
+            getSnapshot
+          }
+        }), inst = _useState[0].inst, forceUpdate = _useState[1];
+        useLayoutEffect(function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+        }, [subscribe, value, getSnapshot]);
+        useEffect(function() {
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+          var handleStoreChange = function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          };
+          return subscribe(handleStoreChange);
+        }, [subscribe]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error2) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+      var isServerEnvironment = !canUseDOM;
+      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+      var useSyncExternalStore$2 = React.useSyncExternalStore !== void 0 ? React.useSyncExternalStore : shim2;
+      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
   }
+  return useSyncExternalStoreShim_development;
 }
-function createScope(defaultValue) {
-  return new Scope(defaultValue);
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim)
+    return shim.exports;
+  hasRequiredShim = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim.exports = requireUseSyncExternalStoreShim_production_min();
+  } else {
+    shim.exports = requireUseSyncExternalStoreShim_development();
+  }
+  return shim.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_production_min;
+function requireWithSelector_production_min() {
+  if (hasRequiredWithSelector_production_min)
+    return withSelector_production_min;
+  hasRequiredWithSelector_production_min = 1;
+  var h = require$$0, n = requireShim();
+  function p(a, b) {
+    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+  }
+  var q = "function" === typeof Object.is ? Object.is : p, r = n.useSyncExternalStore, t = h.useRef, u = h.useEffect, v = h.useMemo, w = h.useDebugValue;
+  withSelector_production_min.useSyncExternalStoreWithSelector = function(a, b, e, l, g) {
+    var c = t(null);
+    if (null === c.current) {
+      var f = { hasValue: false, value: null };
+      c.current = f;
+    } else
+      f = c.current;
+    c = v(function() {
+      function a2(a3) {
+        if (!c2) {
+          c2 = true;
+          d2 = a3;
+          a3 = l(a3);
+          if (void 0 !== g && f.hasValue) {
+            var b2 = f.value;
+            if (g(b2, a3))
+              return k = b2;
+          }
+          return k = a3;
+        }
+        b2 = k;
+        if (q(d2, a3))
+          return b2;
+        var e2 = l(a3);
+        if (void 0 !== g && g(b2, e2))
+          return b2;
+        d2 = a3;
+        return k = e2;
+      }
+      var c2 = false, d2, k, m = void 0 === e ? null : e;
+      return [function() {
+        return a2(b());
+      }, null === m ? void 0 : function() {
+        return a2(m());
+      }];
+    }, [b, e, l, g]);
+    var d = r(a, c[0], c[1]);
+    u(function() {
+      f.hasValue = true;
+      f.value = d;
+    }, [d]);
+    w(d);
+    return d;
+  };
+  return withSelector_production_min;
+}
+var withSelector_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_development;
+function requireWithSelector_development() {
+  if (hasRequiredWithSelector_development)
+    return withSelector_development;
+  hasRequiredWithSelector_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0;
+      var shim2 = requireShim();
+      function is(x, y) {
+        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useSyncExternalStore = shim2.useSyncExternalStore;
+      var useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+      function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        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() {
+          var hasMemo = false;
+          var memoizedSnapshot;
+          var memoizedSelection;
+          var memoizedSelector = function(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              var _nextSelection = selector(nextSnapshot);
+              if (isEqual !== void 0) {
+                if (inst.hasValue) {
+                  var currentSelection = inst.value;
+                  if (isEqual(currentSelection, _nextSelection)) {
+                    memoizedSelection = currentSelection;
+                    return currentSelection;
+                  }
+                }
+              }
+              memoizedSelection = _nextSelection;
+              return _nextSelection;
+            }
+            var prevSnapshot = memoizedSnapshot;
+            var prevSelection = memoizedSelection;
+            if (objectIs(prevSnapshot, nextSnapshot)) {
+              return prevSelection;
+            }
+            var nextSelection = selector(nextSnapshot);
+            if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
+              return prevSelection;
+            }
+            memoizedSnapshot = nextSnapshot;
+            memoizedSelection = nextSelection;
+            return nextSelection;
+          };
+          var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
+          var getSnapshotWithSelector = function() {
+            return memoizedSelector(getSnapshot());
+          };
+          var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : 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;
+      }
+      withSelector_development.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return withSelector_development;
+}
+if (process.env.NODE_ENV === "production") {
+  withSelector.exports = requireWithSelector_production_min();
+} else {
+  withSelector.exports = requireWithSelector_development();
+}
+var withSelectorExports = withSelector.exports;
+const unwrapProxySymbol = /* @__PURE__ */ Symbol("unwrapProxy");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+function trackingProxy(value, equals = store.deepEqual) {
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return [value, (other) => equals(value, other)];
+  }
+  value = value[unwrapProxySymbol] ?? value;
+  const deps = new Array();
+  const revokations = new Array();
+  let revoked = false;
+  function trackComplexProp(function_, ...args) {
+    const [proxiedValue, equals2, revoke] = trackingProxy(function_(value, ...args));
+    deps.push((otherValue) => {
+      if (!isPlainObject(otherValue) && !Array.isArray(otherValue)) {
+        return false;
+      }
+      return equals2(function_(otherValue, ...args));
+    });
+    if (revoke) {
+      revokations.push(revoke);
+    }
+    return proxiedValue;
+  }
+  function trackSimpleProp(function_, ...args) {
+    const calculatedValue = function_(value, ...args);
+    deps.push((otherValue) => {
+      return function_(otherValue, ...args) === calculatedValue;
+    });
+    return calculatedValue;
+  }
+  const proxy = new Proxy(value, {
+    get(target, p, receiver) {
+      if (p === unwrapProxySymbol) {
+        return value;
+      }
+      if (revoked) {
+        return target[p];
+      }
+      const { writable, configurable } = Object.getOwnPropertyDescriptor(target, p) ?? {};
+      if (writable === false && configurable === false) {
+        return target[p];
+      }
+      return trackComplexProp(Reflect.get, p, receiver);
+    },
+    getOwnPropertyDescriptor(target, p) {
+      const { writable, configurable } = Object.getOwnPropertyDescriptor(target, p) ?? {};
+      if (writable === false && configurable === false) {
+        return Reflect.getOwnPropertyDescriptor(target, p);
+      }
+      return trackComplexProp(Reflect.getOwnPropertyDescriptor, p);
+    },
+    ownKeys() {
+      return trackComplexProp(Reflect.ownKeys);
+    },
+    getPrototypeOf() {
+      return trackSimpleProp(Reflect.getPrototypeOf);
+    },
+    has(_target, p) {
+      return trackSimpleProp(Reflect.has, p);
+    },
+    isExtensible() {
+      return trackSimpleProp(Reflect.isExtensible);
+    }
+  });
+  return [
+    proxy,
+    (other) => !!other && deps.every((equals2) => equals2(other)),
+    () => {
+      revoked = true;
+      revokations.forEach((revoke) => revoke());
+    }
+  ];
+}
+function useStore(store$1, argument1, argument2) {
+  const selector = store.makeSelector(
+    typeof argument1 === "function" || typeof argument1 === "string" ? argument1 : void 0
+  );
+  const {
+    disableTrackingProxy = true,
+    equals = store.deepEqual,
+    ...options
+  } = typeof argument1 === "object" ? argument1 : argument2 ?? {};
+  const lastEqualsRef = require$$0.useRef();
+  const { rootStore, mappingSelector } = require$$0.useMemo(() => {
+    var _a;
+    const rootStore2 = ((_a = store$1.derivedFrom) == null ? void 0 : _a.store) ?? store$1;
+    let mappingSelector2 = (x) => x;
+    if (store$1.derivedFrom) {
+      mappingSelector2 = (value2) => {
+        for (const s of store$1.derivedFrom.selectors) {
+          value2 = store.makeSelector(s)(value2);
+        }
+        return value2;
+      };
+    }
+    return { rootStore: rootStore2, mappingSelector: mappingSelector2 };
+  }, [store$1]);
+  const subOptions = { ...options, runNow: false, passive: false };
+  const subscribe = require$$0.useCallback(
+    (listener) => {
+      return rootStore.subscribe(listener, subOptions);
+    },
+    [rootStore, hash.hash(subOptions)]
+  );
+  let value = withSelectorExports.useSyncExternalStoreWithSelector(
+    //
+    subscribe,
+    rootStore.get,
+    void 0,
+    (x) => selector(mappingSelector(x)),
+    (_v, newValue) => {
+      var _a;
+      return ((_a = lastEqualsRef.current) == null ? void 0 : _a.call(lastEqualsRef, newValue)) ?? false;
+    }
+  );
+  let lastEquals = (newValue) => equals(newValue, value);
+  let revoke;
+  if (!disableTrackingProxy) {
+    [value, lastEquals, revoke] = trackingProxy(value, equals);
+  }
+  require$$0.useLayoutEffect(() => {
+    lastEqualsRef.current = lastEquals;
+    revoke == null ? void 0 : revoke();
+  });
+  require$$0.useDebugValue(value);
+  return value;
+}
+function useProp(store2, argument1, argument2, argument3) {
+  const selector = typeof argument1 === "function" || typeof argument1 === "string" ? argument1 : void 0;
+  const updater = typeof argument2 === "function" ? argument2 : void 0;
+  const options = typeof argument1 === "object" ? argument1 : typeof argument2 === "object" ? argument2 : argument3;
+  if (selector) {
+    store2 = store2.map(selector, updater);
+  }
+  const value = useStore(store2, options);
+  return [value, store2.set];
+}
+const reactMethods = {
+  useStore(options) {
+    return useStore(this, options);
+  },
+  useProp(options) {
+    return useProp(this, options);
+  }
+};
+function useCache(cache, { passive, updateOnMount, ...options } = {}) {
+  const mappedState = require$$0.useMemo(() => {
+    var _a;
+    const rootCache = ((_a = cache.derivedFromCache) == null ? void 0 : _a.cache) ?? cache;
+    let selector = (x) => x;
+    if (cache.derivedFromCache) {
+      selector = (value) => {
+        for (const s of cache.derivedFromCache.selectors) {
+          value = store.makeSelector(s)(value);
+        }
+        return value;
+      };
+    }
+    return rootCache.state.map((state) => {
+      const value = state.status === "value" ? selector(state.value) : void 0;
+      return Object.assign(
+        [value, state.error, state.isUpdating, state.isStale],
+        { ...state, value }
+      );
+    });
+  }, [cache]);
+  require$$0.useEffect(() => !passive ? cache.subscribe(() => void 0) : void 0, [cache, passive]);
+  require$$0.useEffect(() => {
+    if (updateOnMount) {
+      cache.invalidate();
+    }
+  }, []);
+  return useStore(mappedState, options);
+}
+function getScopeContext(scope) {
+  scope.context ?? (scope.context = require$$0.createContext(store.createStore(scope.defaultValue)));
+  return scope.context;
+}
+function ScopeProvider({ scope, store: inputStore, children }) {
+  const context = getScopeContext(scope);
+  const currentStore = require$$0.useMemo(
+    () => inputStore ?? store.createStore(scope.defaultValue),
+    [scope, inputStore]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value: currentStore, children });
+}
+function useScope(scope) {
+  const context = getScopeContext(scope);
+  return require$$0.useContext(context);
+}
+function useScopeStore(scope, options) {
+  const store2 = useScope(scope);
+  return useStore(store2, options);
+}
+function useScopeProp(scope, options) {
+  const store2 = useScope(scope);
+  return useProp(store2, options);
 }
-exports.Scope = Scope;
-exports.createScope = createScope;
-exports.hash = hash;
+exports.ScopeProvider = ScopeProvider;
+exports.reactMethods = reactMethods;
+exports.useCache = useCache;
+exports.useProp = useProp;
+exports.useScope = useScope;
+exports.useScopeProp = useScopeProp;
+exports.useScopeStore = useScopeStore;
+exports.useStore = useStore;
 //# sourceMappingURL=scope.cjs.map