cross-state 0.26.0 → 0.27.1

package/dist/cjs/scope2.cjs

@@ -1,392 +1,613 @@
 "use strict";
 const store = require("./store.cjs");
+const require$$0 = require("react");
+const jsxRuntime = require("react/jsx-runtime");
 const hash = require("./hash.cjs");
-class ResourceGroup {
-  constructor(name) {
-    this.name = name;
-    this.refMap = /* @__PURE__ */ new WeakMap();
-    this.refSet = /* @__PURE__ */ new Set();
-    store.autobind(ResourceGroup);
-  }
-  add(resource) {
-    const ref = new WeakRef(resource);
-    this.refMap.set(resource, ref);
-    this.refSet.add(ref);
-  }
-  delete(resource) {
-    const ref = this.refMap.get(resource);
-    if (ref) {
-      this.refMap.delete(resource);
-      this.refSet.delete(ref);
-    }
+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)];
   }
-  invalidateAll() {
-    for (const ref of this.refSet) {
-      const resource = ref.deref();
-      if (resource) {
-        resource.invalidateAll();
-      } else {
-        this.refSet.delete(ref);
+  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;
   }
-  clearAll() {
-    for (const ref of this.refSet) {
-      const resource = ref.deref();
-      if (resource) {
-        resource.clearAll();
-      } else {
-        this.refSet.delete(ref);
+  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);
     }
-  }
-}
-const allResources = /* @__PURE__ */ new ResourceGroup();
-function createResourceGroup(name) {
-  return new ResourceGroup(name);
+  });
+  return [
+    proxy,
+    (other) => !!other && deps.every((equals2) => equals2(other)),
+    () => {
+      revoked = true;
+      revokations.forEach((revoke) => revoke());
+    }
+  ];
 }
-class InstanceCache {
-  constructor(factory, cacheTime) {
-    this.factory = factory;
-    this.cacheTime = cacheTime;
-    this.cache = /* @__PURE__ */ new Map();
-    this.interval = this.cacheTime ? setInterval(() => this.cleanup(), Math.max(this.cacheTime / 10, 1)) : void 0;
-  }
-  cleanup() {
-    var _a;
-    const cutoff = this.now() - (this.cacheTime ?? 0);
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.ref && entry.t <= cutoff) {
-        delete entry.ref;
+var withSelector = { exports: {} };
+var withSelector_development = {};
+var shim = { exports: {} };
+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());
       }
-      if (!entry.ref && !((_a = entry.weakRef) == null ? void 0 : _a.deref())) {
-        this.cache.delete(key);
+      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());
+      }
+    })();
   }
-  get(...args) {
-    var _a;
-    const key = hash.hash(args);
-    let entry = this.cache.get(key);
-    let value = (entry == null ? void 0 : entry.ref) ?? ((_a = entry == null ? void 0 : entry.weakRef) == null ? void 0 : _a.deref());
-    if (!entry || !value) {
-      value = this.factory(...args);
-      entry = {
-        t: this.now(),
-        ref: value,
-        weakRef: new WeakRef(value)
-      };
-      this.cache.set(key, entry);
-    } else {
-      entry.t = this.now();
-      entry.ref ?? (entry.ref = value);
-    }
-    return value;
+  return useSyncExternalStoreShim_development;
+}
+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;
   }
-  values() {
-    return [...this.cache.values()].map((entry) => {
-      var _a;
-      return entry.ref ?? ((_a = entry.weakRef) == null ? void 0 : _a.deref());
-    }).filter((value) => !!value);
+  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;
   }
-  stop() {
-    if (this.interval) {
-      clearInterval(this.interval);
+  function r(a) {
+    var b = a.getSnapshot;
+    a = a.value;
+    try {
+      var d = b();
+      return !k(a, d);
+    } catch (f) {
+      return true;
     }
   }
-  stats() {
-    return {
-      count: this.cache.size,
-      withRef: [...this.cache.values()].filter((x) => !!x.ref).length,
-      withWeakRef: [...this.cache.values()].filter((x) => {
-        var _a;
-        return !!((_a = x.weakRef) == null ? void 0 : _a.deref());
-      }).length
-    };
-  }
-  now() {
-    return performance.now();
+  function t(a, b) {
+    return b();
   }
+  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 PromiseWithState extends Promise {
-  constructor(value, state = { status: "pending" }) {
-    super((resolve) => resolve(value));
-    this.state = state;
-    value.then((value2) => {
-      this.state = { status: "value", value: value2 };
-    }).catch((error) => {
-      this.state = { status: "error", error };
-    });
-  }
-  static resolve(value) {
-    return new PromiseWithState(Promise.resolve(value), {
-      status: "value",
-      value
-    });
-  }
-  static reject(error) {
-    return new PromiseWithState(Promise.reject(error), { status: "error", error });
+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;
 }
-class Cache extends store.Store {
-  constructor(getter, options = {}, derivedFromCache, _call) {
-    super(
-      function() {
-        let result = getter.apply(this);
-        if (result instanceof Function) {
-          result = result(this);
+/**
+ * @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;
         }
-        return result;
-      },
-      options,
-      void 0,
-      _call
-    );
-    this.options = options;
-    this.derivedFromCache = derivedFromCache;
-    this.state = store.createStore({
-      status: "pending",
-      isStale: true,
-      isUpdating: false
-    });
-    store.autobind(Cache);
-    this.calculationHelper.options.onInvalidate = () => this.invalidate({ invalidateDependencies: false });
-    this.watchPromise();
-    this.watchFocus();
-  }
-  get({ update = "whenStale", backgroundUpdate = false } = {}) {
-    var _a;
-    const promise = (_a = this._value) == null ? void 0 : _a.v;
-    const stalePromise = this.stalePromise;
-    if (update === "whenMissing" && !promise && !stalePromise || update === "whenStale" && !promise || update === "force") {
-      this.calculationHelper.execute();
-      if (!promise && !stalePromise || !backgroundUpdate) {
-        return super.get();
+        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;
       }
-    }
-    if (!promise || stalePromise && backgroundUpdate) {
-      return stalePromise;
-    }
-    return promise;
-  }
-  updateValue(value) {
-    this.set(PromiseWithState.resolve(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());
+      }
+    })();
   }
-  updateError(error) {
-    this.set(PromiseWithState.reject(error));
+  return withSelector_development;
+}
+var withSelector_production_min = {};
+/**
+ * @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;
   }
-  invalidate({ invalidateDependencies = true } = {}) {
+  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;
+}
+if (process.env.NODE_ENV === "production") {
+  withSelector.exports = requireWithSelector_production_min();
+} else {
+  withSelector.exports = requireWithSelector_development();
+}
+var withSelectorExports = withSelector.exports;
+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,
+    withViewTransition,
+    ...options
+  } = typeof argument1 === "object" ? argument1 : argument2 ?? {};
+  const lastEqualsRef = require$$0.useRef();
+  const { rootStore, mappingSelector } = require$$0.useMemo(() => {
     var _a;
-    const { clearOnInvalidate = createCache.defaultOptions.clearOnInvalidate } = this.options;
-    if (clearOnInvalidate) {
-      return this.clear({ invalidateDependencies });
-    }
-    if (invalidateDependencies) {
-      this.calculationHelper.invalidateDependencies();
-    }
-    const { status, isStale, isUpdating } = this.state.get();
-    if (status !== "pending" && !isStale && !isUpdating) {
-      this.stalePromise = (_a = this._value) == null ? void 0 : _a.v;
-    }
-    this.state.set((state) => ({
-      ...state,
-      isStale: true,
-      isUpdating: false
-    }));
-    this.calculationHelper.stop();
-    super.reset();
-  }
-  clear({ invalidateDependencies = true } = {}) {
-    if (invalidateDependencies) {
-      this.calculationHelper.invalidateDependencies();
-    }
-    this.state.set({
-      status: "pending",
-      isStale: true,
-      isUpdating: false
-    });
-    delete this.stalePromise;
-    this.calculationHelper.stop();
-    super.reset();
-  }
-  mapValue(_selector) {
-    const selector = store.makeSelector(_selector);
-    const derivedFromCache = {
-      cache: this.derivedFromCache ? this.derivedFromCache.cache : this,
-      selectors: this.derivedFromCache ? [...this.derivedFromCache.selectors, _selector] : [_selector]
-    };
-    const that = this;
-    return new Cache(
-      async function() {
-        const value = await this.use(that);
-        return selector(value);
-      },
-      {},
-      derivedFromCache
-    );
-  }
-  watchPromise() {
-    this.subscribe(
-      async (promise) => {
-        var _a, _b;
-        if (promise instanceof PromiseWithState) {
-          this.state.set({
-            ...promise.state,
-            isStale: false,
-            isUpdating: false
-          });
-          delete this.stalePromise;
-          this.setTimers();
-          return;
+    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);
         }
-        this.state.set((state) => ({
-          ...state,
-          isUpdating: true
-        }));
-        this.setTimers();
-        try {
-          const value = await promise;
-          if (promise !== ((_a = this._value) == null ? void 0 : _a.v)) {
+        return value2;
+      };
+    }
+    return { rootStore: rootStore2, mappingSelector: mappingSelector2 };
+  }, [store$1]);
+  const subOptions = { ...options, runNow: false, passive: false };
+  const subscribe = require$$0.useCallback(
+    (listener) => {
+      let _listener = listener;
+      if (withViewTransition && document.startViewTransition) {
+        let lastObservedValue;
+        _listener = (value2) => {
+          const observedValue = withViewTransition instanceof Function ? withViewTransition(value2) : value2;
+          if (equals(lastObservedValue, observedValue)) {
+            listener();
             return;
           }
-          this.state.set({
-            status: "value",
-            value,
-            isStale: false,
-            isUpdating: false
+          lastObservedValue = observedValue;
+          let hasChanges = false;
+          const mutationObserver = new MutationObserver(() => {
+            hasChanges = true;
+            mutationObserver.disconnect();
           });
-          delete this.stalePromise;
-          this.setTimers();
-        } catch (error) {
-          if (promise !== ((_b = this._value) == null ? void 0 : _b.v)) {
-            return;
-          }
-          this.state.set({
-            status: "error",
-            error,
-            isStale: false,
-            isUpdating: false
+          mutationObserver.observe(document.body, { childList: true, subtree: true });
+          document.startViewTransition(() => {
+            listener();
+            if (!hasChanges) {
+              throw new Error("no change");
+            }
           });
-          delete this.stalePromise;
-          this.setTimers();
-        }
-      },
-      { passive: true }
-    );
-  }
-  setTimers() {
-    if (this.invalidationTimer) {
-      clearTimeout(this.invalidationTimer);
-    }
-    this.invalidationTimer = void 0;
-    const state = this.state.get();
-    let { invalidateAfter = createCache.defaultOptions.invalidateAfter } = this.options;
-    const ref = new WeakRef(this);
-    if (state.status === "pending") {
-      return;
-    }
-    if (invalidateAfter instanceof Function) {
-      invalidateAfter = invalidateAfter(state);
-    }
-    if (invalidateAfter !== null && invalidateAfter !== void 0) {
-      this.invalidationTimer = setTimeout(
-        () => {
-          var _a;
-          return (_a = ref == null ? void 0 : ref.deref()) == null ? void 0 : _a.invalidate();
-        },
-        store.calcDuration(invalidateAfter)
-      );
-    }
-  }
-  watchFocus() {
-    const { invalidateOnWindowFocus = createCache.defaultOptions.invalidateOnWindowFocus } = this.options;
-    if (!invalidateOnWindowFocus || typeof document === "undefined" || typeof document.addEventListener === "undefined") {
-      return;
-    }
-    const ref = new WeakRef(this);
-    const onFocus = () => {
-      const that = ref == null ? void 0 : ref.deref();
-      if (!that) {
-        document.removeEventListener("visibilitychange", onFocus);
-        return;
-      }
-      if (!document.hidden) {
-        that.invalidate();
-      }
-    };
-    document.addEventListener("visibilitychange", onFocus);
-  }
-}
-function create(cacheFunction, options) {
-  const { clearUnusedAfter = createCache.defaultOptions.clearUnusedAfter, resourceGroup } = options ?? {};
-  let baseInstance;
-  const instanceCache = new InstanceCache(
-    (...args) => {
-      if (args.length === 0 && baseInstance) {
-        return baseInstance;
+        };
       }
-      return new Cache(function() {
-        return cacheFunction.apply(this, args);
-      }, options);
+      return rootStore.subscribe(_listener, subOptions);
     },
-    clearUnusedAfter ? store.calcDuration(clearUnusedAfter) : void 0
+    [rootStore, hash.hash(subOptions)]
   );
-  const get = (...args) => {
-    return instanceCache.get(...args);
-  };
-  const invalidateAll = () => {
-    for (const instance of instanceCache.values()) {
-      instance.invalidate();
-    }
-  };
-  const clearAll = () => {
-    for (const instance of instanceCache.values()) {
-      instance.clear();
-    }
-  };
-  baseInstance = Object.assign(
-    new Cache(
-      function() {
-        return cacheFunction.apply(this);
-      },
-      options,
-      void 0,
-      get
-    ),
-    {
-      invalidateAll,
-      clearAll
+  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;
     }
   );
-  const groups = Array.isArray(resourceGroup) ? resourceGroup : resourceGroup ? [resourceGroup] : [];
-  for (const group of groups.concat(allResources)) {
-    group.add(baseInstance);
+  let lastEquals = (newValue) => equals(newValue, value);
+  let revoke;
+  if (!disableTrackingProxy) {
+    [value, lastEquals, revoke] = trackingProxy(value, equals);
   }
-  get(...[]);
-  return baseInstance;
+  require$$0.useLayoutEffect(() => {
+    lastEqualsRef.current = lastEquals;
+    revoke == null ? void 0 : revoke();
+  });
+  require$$0.useDebugValue(value);
+  return value;
 }
-const createCache = /* @__PURE__ */ Object.assign(create, {
-  defaultOptions: {
-    invalidateOnWindowFocus: true,
-    invalidateOnActivation: true,
-    clearUnusedAfter: { days: 1 }
+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);
   }
-});
-class Scope {
-  constructor(defaultValue) {
-    this.defaultValue = defaultValue;
-    store.autobind(Scope);
+  const value = useStore(store2, options);
+  return [value, store2.set];
+}
+function boundUseStore(...args) {
+  return useStore(this, ...args);
+}
+function boundUseProp(...args) {
+  return useProp(this, ...args);
+}
+const reactMethods = {
+  useStore: boundUseStore,
+  useProp: boundUseProp
+};
+function useCache(cache, { passive, updateOnMount, withViewTransition, ...options } = {}) {
+  if (withViewTransition === true) {
+    withViewTransition = (state) => state.value;
   }
+  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, withViewTransition });
+}
+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 createScope(defaultValue) {
-  return new Scope(defaultValue);
+function useScopeProp(scope, options) {
+  const store2 = useScope(scope);
+  return useProp(store2, options);
 }
-exports.Cache = Cache;
-exports.InstanceCache = InstanceCache;
-exports.ResourceGroup = ResourceGroup;
-exports.Scope = Scope;
-exports.allResources = allResources;
-exports.createCache = createCache;
-exports.createResourceGroup = createResourceGroup;
-exports.createScope = createScope;
+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=scope2.cjs.map