cross-state 0.26.0 → 0.27.1

package/dist/es/scope.mjs

@@ -1,614 +1,393 @@
-import { d as deepEqual, m as makeSelector, c as createStore } from "./store.mjs";
-import require$$0, { useRef, useMemo, useCallback, useLayoutEffect, useDebugValue, useEffect, useContext, createContext } from "react";
-import { jsx } from "react/jsx-runtime";
+import { a as autobind, S as Store, c as createStore, b as calcDuration, m as makeSelector } from "./store.mjs";
 import { h as hash } from "./hash.mjs";
-const unwrapProxySymbol = /* @__PURE__ */ Symbol("unwrapProxy");
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
-}
-function trackingProxy(value, equals = deepEqual) {
-  if (!isPlainObject(value) && !Array.isArray(value)) {
-    return [value, (other) => equals(value, other)];
+class ResourceGroup {
+  constructor(name) {
+    this.name = name;
+    this.refMap = /* @__PURE__ */ new WeakMap();
+    this.refSet = /* @__PURE__ */ new Set();
+    autobind(ResourceGroup);
   }
-  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;
+  add(resource) {
+    const ref = new WeakRef(resource);
+    this.refMap.set(resource, ref);
+    this.refSet.add(ref);
   }
-  function trackSimpleProp(function_, ...args) {
-    const calculatedValue = function_(value, ...args);
-    deps.push((otherValue) => {
-      return function_(otherValue, ...args) === calculatedValue;
-    });
-    return calculatedValue;
+  delete(resource) {
+    const ref = this.refMap.get(resource);
+    if (ref) {
+      this.refMap.delete(resource);
+      this.refSet.delete(ref);
+    }
   }
-  const proxy = new Proxy(value, {
-    get(target, p, receiver) {
-      if (p === unwrapProxySymbol) {
-        return value;
+  invalidateAll() {
+    for (const ref of this.refSet) {
+      const resource = ref.deref();
+      if (resource) {
+        resource.invalidateAll();
+      } else {
+        this.refSet.delete(ref);
       }
-      if (revoked) {
-        return target[p];
+    }
+  }
+  clearAll() {
+    for (const ref of this.refSet) {
+      const resource = ref.deref();
+      if (resource) {
+        resource.clearAll();
+      } else {
+        this.refSet.delete(ref);
       }
-      const { writable, configurable } = Object.getOwnPropertyDescriptor(target, p) ?? {};
-      if (writable === false && configurable === false) {
-        return target[p];
+    }
+  }
+}
+const allResources = /* @__PURE__ */ new ResourceGroup();
+function createResourceGroup(name) {
+  return new ResourceGroup(name);
+}
+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;
       }
-      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);
+      if (!entry.ref && !((_a = entry.weakRef) == null ? void 0 : _a.deref())) {
+        this.cache.delete(key);
       }
-      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());
+  }
+  get(...args) {
+    var _a;
+    const key = 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);
     }
-  ];
-}
-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;
+    return 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;
+  values() {
+    return [...this.cache.values()].map((entry) => {
+      var _a;
+      return entry.ref ?? ((_a = entry.weakRef) == null ? void 0 : _a.deref());
+    }).filter((value) => !!value);
   }
-  function r(a) {
-    var b = a.getSnapshot;
-    a = a.value;
-    try {
-      var d = b();
-      return !k(a, d);
-    } catch (f) {
-      return true;
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
     }
   }
-  function t(a, b) {
-    return b();
+  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();
   }
-  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;
 }
-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);
-          }
+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 });
+  }
+}
+class Cache extends Store {
+  constructor(getter, options = {}, derivedFromCache, _call) {
+    super(
+      function() {
+        let result = getter.apply(this);
+        if (result instanceof Function) {
+          result = result(this);
         }
+        return result;
+      },
+      options,
+      void 0,
+      _call
+    );
+    this.options = options;
+    this.derivedFromCache = derivedFromCache;
+    this.state = createStore({
+      status: "pending",
+      isStale: true,
+      isUpdating: false
+    });
+    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();
       }
-      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);
+    }
+    if (!promise || stalePromise && backgroundUpdate) {
+      return stalePromise;
+    }
+    return promise;
+  }
+  updateValue(value) {
+    this.set(PromiseWithState.resolve(value));
+  }
+  updateError(error) {
+    this.set(PromiseWithState.reject(error));
+  }
+  invalidate({ invalidateDependencies = true } = {}) {
+    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 = 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
           });
-          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, useEffect2 = React.useEffect, useLayoutEffect2 = React.useLayoutEffect, useDebugValue2 = 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.");
-            }
-          }
+          delete this.stalePromise;
+          this.setTimers();
+          return;
         }
-        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;
-            }
+        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;
           }
-        }
-        var _useState = useState({
-          inst: {
+          this.state.set({
+            status: "value",
             value,
-            getSnapshot
-          }
-        }), inst = _useState[0].inst, forceUpdate = _useState[1];
-        useLayoutEffect2(function() {
-          inst.value = value;
-          inst.getSnapshot = getSnapshot;
-          if (checkIfSnapshotChanged(inst)) {
-            forceUpdate({
-              inst
-            });
-          }
-        }, [subscribe, value, getSnapshot]);
-        useEffect2(function() {
-          if (checkIfSnapshotChanged(inst)) {
-            forceUpdate({
-              inst
-            });
+            isStale: false,
+            isUpdating: false
+          });
+          delete this.stalePromise;
+          this.setTimers();
+        } catch (error) {
+          if (promise !== ((_b = this._value) == null ? void 0 : _b.v)) {
+            return;
           }
-          var handleStoreChange = function() {
-            if (checkIfSnapshotChanged(inst)) {
-              forceUpdate({
-                inst
-              });
-            }
-          };
-          return subscribe(handleStoreChange);
-        }, [subscribe]);
-        useDebugValue2(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;
+          this.state.set({
+            status: "error",
+            error,
+            isStale: false,
+            isUpdating: false
+          });
+          delete this.stalePromise;
+          this.setTimers();
         }
-      }
-      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;
-}
-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();
+      },
+      { passive: true }
+    );
   }
-  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;
+  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();
+        },
+        calcDuration(invalidateAfter)
+      );
+    }
   }
-  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 useRef2 = React.useRef, useEffect2 = React.useEffect, useMemo2 = React.useMemo, useDebugValue2 = React.useDebugValue;
-      function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
-        var instRef = useRef2(null);
-        var inst;
-        if (instRef.current === null) {
-          inst = {
-            hasValue: false,
-            value: null
-          };
-          instRef.current = inst;
-        } else {
-          inst = instRef.current;
-        }
-        var _useMemo = useMemo2(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);
-        useEffect2(function() {
-          inst.hasValue = true;
-          inst.value = value;
-        }, [value]);
-        useDebugValue2(value);
-        return value;
+  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;
       }
-      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());
+      if (!document.hidden) {
+        that.invalidate();
       }
-    })();
+    };
+    document.addEventListener("visibilitychange", onFocus);
   }
-  return withSelector_development;
 }
-if (process.env.NODE_ENV === "production") {
-  withSelector.exports = requireWithSelector_production_min();
-} else {
-  withSelector.exports = requireWithSelector_development();
-}
-var withSelectorExports = withSelector.exports;
-function useStore(store, argument1, argument2) {
-  const selector = makeSelector(
-    typeof argument1 === "function" || typeof argument1 === "string" ? argument1 : void 0
-  );
-  const {
-    disableTrackingProxy = true,
-    equals = deepEqual,
-    withViewTransition,
-    ...options
-  } = typeof argument1 === "object" ? argument1 : argument2 ?? {};
-  const lastEqualsRef = useRef();
-  const { rootStore, mappingSelector } = useMemo(() => {
-    var _a;
-    const rootStore2 = ((_a = store.derivedFrom) == null ? void 0 : _a.store) ?? store;
-    let mappingSelector2 = (x) => x;
-    if (store.derivedFrom) {
-      mappingSelector2 = (value2) => {
-        for (const s of store.derivedFrom.selectors) {
-          value2 = makeSelector(s)(value2);
-        }
-        return value2;
-      };
-    }
-    return { rootStore: rootStore2, mappingSelector: mappingSelector2 };
-  }, [store]);
-  const subOptions = { ...options, runNow: false, passive: false };
-  const subscribe = 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;
-          }
-          lastObservedValue = observedValue;
-          let hasChanges = false;
-          const mutationObserver = new MutationObserver(() => {
-            hasChanges = true;
-            mutationObserver.disconnect();
-          });
-          mutationObserver.observe(document.body, { childList: true, subtree: true });
-          document.startViewTransition(() => {
-            listener();
-            if (!hasChanges) {
-              throw new Error("no change");
-            }
-          });
-        };
+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 rootStore.subscribe(_listener, subOptions);
+      return new Cache(function() {
+        return cacheFunction.apply(this, args);
+      }, options);
     },
-    [rootStore, hash(subOptions)]
+    clearUnusedAfter ? calcDuration(clearUnusedAfter) : void 0
   );
-  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 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 lastEquals = (newValue) => equals(newValue, value);
-  let revoke;
-  if (!disableTrackingProxy) {
-    [value, lastEquals, revoke] = trackingProxy(value, equals);
+  const groups = Array.isArray(resourceGroup) ? resourceGroup : resourceGroup ? [resourceGroup] : [];
+  for (const group of groups.concat(allResources)) {
+    group.add(baseInstance);
   }
-  useLayoutEffect(() => {
-    lastEqualsRef.current = lastEquals;
-    revoke == null ? void 0 : revoke();
-  });
-  useDebugValue(value);
-  return value;
+  get(...[]);
+  return baseInstance;
 }
-function useProp(store, 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) {
-    store = store.map(selector, updater);
+const createCache = /* @__PURE__ */ Object.assign(create, {
+  defaultOptions: {
+    invalidateOnWindowFocus: true,
+    invalidateOnActivation: true,
+    clearUnusedAfter: { days: 1 }
   }
-  const value = useStore(store, options);
-  return [value, store.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;
+});
+class Scope {
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+    autobind(Scope);
   }
-  const mappedState = 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 = 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]);
-  useEffect(() => !passive ? cache.subscribe(() => void 0) : void 0, [cache, passive]);
-  useEffect(() => {
-    if (updateOnMount) {
-      cache.invalidate();
-    }
-  }, []);
-  return useStore(mappedState, { ...options, withViewTransition });
-}
-function getScopeContext(scope) {
-  scope.context ?? (scope.context = createContext(createStore(scope.defaultValue)));
-  return scope.context;
-}
-function ScopeProvider({ scope, store: inputStore, children }) {
-  const context = getScopeContext(scope);
-  const currentStore = useMemo(
-    () => inputStore ?? createStore(scope.defaultValue),
-    [scope, inputStore]
-  );
-  return /* @__PURE__ */ jsx(context.Provider, { value: currentStore, children });
-}
-function useScope(scope) {
-  const context = getScopeContext(scope);
-  return useContext(context);
-}
-function useScopeStore(scope, options) {
-  const store = useScope(scope);
-  return useStore(store, options);
 }
-function useScopeProp(scope, options) {
-  const store = useScope(scope);
-  return useProp(store, options);
+function createScope(defaultValue) {
+  return new Scope(defaultValue);
 }
 export {
-  ScopeProvider as S,
-  useScope as a,
-  useScopeStore as b,
-  useScopeProp as c,
-  useStore as d,
-  useProp as e,
-  reactMethods as r,
-  useCache as u
+  Cache as C,
+  InstanceCache as I,
+  ResourceGroup as R,
+  Scope as S,
+  allResources as a,
+  createResourceGroup as b,
+  createCache as c,
+  createScope as d
 };
 //# sourceMappingURL=scope.mjs.map