cross-state 0.6.0

package/dist/cjs/react.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.cjs","sources":["../../src/react/storeScope.tsx","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.min.js","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/with-selector.js","../../src/react/useStore.ts","../../src/react/useProp.ts"],"sourcesContent":["import type { Store } from '@core/store';\nimport { store } from '@core/store';\nimport type { StoreScope } from '@core/storeScope';\nimport type { Context, ReactNode } from 'react';\nimport { createContext, useContext, useMemo } from 'react';\n\nexport type StoreScopeProps<T> = { scope: StoreScope<T>; store?: Store<T>; children?: ReactNode };\n\nexport const contextMap = new WeakMap<StoreScope<any>, Context<Store<any>>>();\n\nexport function getStoreScopeContext<T>(scope: StoreScope<T>): Context<Store<T>> {\n  let context = contextMap.get(scope);\n\n  if (!context) {\n    context = createContext<Store<T>>(store(scope.defaultValue));\n    contextMap.set(scope, context);\n  }\n\n  return context;\n}\n\nexport function StoreScopeProvider<T>({ scope, store: inputStore, children }: StoreScopeProps<T>) {\n  const context = getStoreScopeContext(scope);\n  const currentStore = useMemo(() => inputStore ?? store(scope.defaultValue), [scope, inputStore]);\n\n  return <context.Provider value={currentStore}>{children}</context.Provider>;\n}\n\nexport function useStoreScope<T>(scope: StoreScope<T>): Store<T> {\n  const context = getStoreScopeContext(scope);\n  return useContext(context);\n}\n","/**\n * @license React\n * use-sync-external-store-with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var g=require(\"react\");function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p=\"function\"===typeof Object.is?Object.is:n,q=g.useSyncExternalStore,r=g.useRef,t=g.useEffect,u=g.useMemo,v=g.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);\nt(function(){f.hasValue=!0;f.value=d},[d]);v(d);return d};\n","/**\n * @license React\n * use-sync-external-store-with-selector.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n  (function() {\n\n          'use strict';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===\n    'function'\n) {\n  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());\n}\n          var React = require('react');\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare\n  ;\n}\n\nvar objectIs = typeof Object.is === 'function' ? Object.is : is;\n\nvar useSyncExternalStore = React.useSyncExternalStore;\n\n// for CommonJS interop.\n\nvar useRef = React.useRef,\n    useEffect = React.useEffect,\n    useMemo = React.useMemo,\n    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.\n\nfunction useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {\n  // Use this to track the rendered snapshot.\n  var instRef = useRef(null);\n  var inst;\n\n  if (instRef.current === null) {\n    inst = {\n      hasValue: false,\n      value: null\n    };\n    instRef.current = inst;\n  } else {\n    inst = instRef.current;\n  }\n\n  var _useMemo = useMemo(function () {\n    // Track the memoized state using closure variables that are local to this\n    // memoized instance of a getSnapshot function. Intentionally not using a\n    // useRef hook, because that state would be shared across all concurrent\n    // copies of the hook/component.\n    var hasMemo = false;\n    var memoizedSnapshot;\n    var memoizedSelection;\n\n    var memoizedSelector = function (nextSnapshot) {\n      if (!hasMemo) {\n        // The first time the hook is called, there is no memoized result.\n        hasMemo = true;\n        memoizedSnapshot = nextSnapshot;\n\n        var _nextSelection = selector(nextSnapshot);\n\n        if (isEqual !== undefined) {\n          // Even if the selector has changed, the currently rendered selection\n          // may be equal to the new selection. We should attempt to reuse the\n          // current value if possible, to preserve downstream memoizations.\n          if (inst.hasValue) {\n            var currentSelection = inst.value;\n\n            if (isEqual(currentSelection, _nextSelection)) {\n              memoizedSelection = currentSelection;\n              return currentSelection;\n            }\n          }\n        }\n\n        memoizedSelection = _nextSelection;\n        return _nextSelection;\n      } // We may be able to reuse the previous invocation's result.\n\n\n      // We may be able to reuse the previous invocation's result.\n      var prevSnapshot = memoizedSnapshot;\n      var prevSelection = memoizedSelection;\n\n      if (objectIs(prevSnapshot, nextSnapshot)) {\n        // The snapshot is the same as last time. Reuse the previous selection.\n        return prevSelection;\n      } // The snapshot has changed, so we need to compute a new selection.\n\n\n      // The snapshot has changed, so we need to compute a new selection.\n      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data\n      // has changed. If it hasn't, return the previous selection. That signals\n      // to React that the selections are conceptually equal, and we can bail\n      // out of rendering.\n\n      // If a custom isEqual function is provided, use that to check if the data\n      // has changed. If it hasn't, return the previous selection. That signals\n      // to React that the selections are conceptually equal, and we can bail\n      // out of rendering.\n      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {\n        return prevSelection;\n      }\n\n      memoizedSnapshot = nextSnapshot;\n      memoizedSelection = nextSelection;\n      return nextSelection;\n    }; // Assigning this to a constant so that Flow knows it can't change.\n\n\n    // Assigning this to a constant so that Flow knows it can't change.\n    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;\n\n    var getSnapshotWithSelector = function () {\n      return memoizedSelector(getSnapshot());\n    };\n\n    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {\n      return memoizedSelector(maybeGetServerSnapshot());\n    };\n    return [getSnapshotWithSelector, getServerSnapshotWithSelector];\n  }, [getSnapshot, getServerSnapshot, selector, isEqual]),\n      getSelection = _useMemo[0],\n      getServerSelection = _useMemo[1];\n\n  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);\n  useEffect(function () {\n    inst.hasValue = true;\n    inst.value = value;\n  }, [value]);\n  useDebugValue(value);\n  return value;\n}\n\nexports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;\n          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===\n    'function'\n) {\n  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());\n}\n        \n  })();\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.production.min.js');\n} else {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.development.js');\n}\n","import type { SubscribeOptions } from '@core/commonTypes';\nimport type { Store } from '@core/store';\nimport { hash } from '@lib/hash';\nimport { trackingProxy } from '@lib/trackingProxy';\nimport { useCallback, useDebugValue, useLayoutEffect, useRef } from 'react';\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';\n\nexport type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;\n\nexport function useStore<T>(store: Store<T>, options?: UseStoreOptions): T {\n  const lastEqualsRef = useRef<(newValue: T) => boolean>();\n\n  const subOptions = { ...options, runNow: false, equals: undefined };\n\n  const subscribe = useCallback(\n    (listener: () => void) => {\n      return store.sub(listener, subOptions);\n    },\n    [store, hash(subOptions)]\n  );\n\n  const value = useSyncExternalStoreWithSelector(\n    //\n    subscribe,\n    store.get,\n    undefined,\n    (x) => x,\n    options?.equals ?? ((_v, newValue) => lastEqualsRef.current?.(newValue) ?? false)\n  );\n  const [proxiedValue, equals] = trackingProxy(value);\n\n  useLayoutEffect(() => {\n    lastEqualsRef.current = equals;\n  });\n\n  useDebugValue(value);\n  return proxiedValue;\n}\n","import type { Store } from '@core/store';\nimport type { UpdateFn } from '@core/commonTypes';\nimport type { UseStoreOptions } from './useStore';\nimport { useStore } from './useStore';\n\nexport function useProp<T>(store: Store<T>, options?: UseStoreOptions): [value: T, setValue: UpdateFn<T>] {\n  const value = useStore(store, options);\n\n  return [value, store.update];\n}\n"],"names":["createContext","store","useMemo","useContext","a","c","d","b","e","module","require$$0","require$$1","useRef","useCallback","hash","useSyncExternalStoreWithSelector","trackingProxy","useLayoutEffect","useDebugValue"],"mappings":"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"}

package/dist/es/hash.mjs

@@ -0,0 +1,633 @@
+function queue() {
+  const q = [];
+  let promise, resolve;
+  let active = false;
+  const run = async () => {
+    if (!active) {
+      active = true;
+      let next;
+      while (next = q.shift()) {
+        try {
+          let result = next.action();
+          if (result instanceof Promise) {
+            result = await result;
+          }
+          next.resolve(result);
+        } catch (e) {
+          next.reject(e);
+        }
+      }
+      active = false;
+      resolve == null ? void 0 : resolve();
+    }
+  };
+  return Object.assign(
+    (action) => {
+      return new Promise((resolve2, reject) => {
+        q.push({ action, resolve: resolve2, reject });
+        run();
+      });
+    },
+    {
+      clear() {
+        q.length = 0;
+        resolve == null ? void 0 : resolve();
+      },
+      get whenDone() {
+        if (!promise) {
+          promise = new Promise((r) => {
+            resolve = () => {
+              promise = void 0;
+              resolve = void 0;
+              r();
+            };
+          });
+        }
+        return promise;
+      }
+    }
+  );
+}
+const ProxyKeys = ["get", "getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys"];
+const isPlainObject = (value) => typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+function trackingProxy(value) {
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return [value, (other) => other === value];
+  }
+  const deps = new Array();
+  const proxy = new Proxy(
+    value,
+    Object.fromEntries(
+      ProxyKeys.map((key) => [
+        key,
+        (value2, ...args) => {
+          const fn = Reflect[key];
+          const [proxiedValue, equals] = trackingProxy(fn(value2, ...args));
+          deps.push((otherValue) => {
+            if (!isPlainObject(otherValue) && !Array.isArray(otherValue)) {
+              return false;
+            }
+            return equals(fn(otherValue, ...args));
+          });
+          return proxiedValue;
+        }
+      ])
+    )
+  );
+  return [proxy, (other) => !!other && deps.every((equals) => equals(other))];
+}
+class CalculationHelper {
+  constructor(options) {
+    this.options = options;
+    options.addEffect(() => {
+      if (this.current) {
+        this.current.check();
+      } else {
+        this.execute();
+      }
+    });
+  }
+  execute() {
+    this.stop();
+    const { calculate, addEffect, getValue, setValue, setError, onInvalidate } = this.options;
+    const checks = new Array();
+    const deps = /* @__PURE__ */ new Map();
+    const q = queue();
+    let isActive = false;
+    let isCancled = false;
+    const cancelEffect = addEffect(() => {
+      isActive = true;
+      for (const dep of deps.values()) {
+        dep.on();
+      }
+      return () => {
+        isActive = false;
+        for (const dep of deps.values()) {
+          dep.off();
+        }
+      };
+    });
+    const cancel = () => {
+      isCancled = true;
+      cancelSubscription == null ? void 0 : cancelSubscription();
+      cancelEffect();
+      delete this.current;
+    };
+    const check = () => {
+      if (!checks.every((check2) => check2())) {
+        cancel();
+        onInvalidate == null ? void 0 : onInvalidate();
+      }
+    };
+    const use = (store2, { disableProxy } = {}) => {
+      if (isCancled) {
+        return store2.get();
+      }
+      let value = store2.get();
+      let equals = (newValue) => {
+        return newValue === value;
+      };
+      if (!disableProxy) {
+        [value, equals] = trackingProxy(value);
+      }
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store2.sub(check, { runNow: false });
+        },
+        off() {
+          sub == null ? void 0 : sub();
+          sub = void 0;
+        }
+      };
+      if (isActive) {
+        dep.on();
+      }
+      checks.push(() => equals(store2.get()));
+      deps.set(store2, dep);
+      return value;
+    };
+    const useFetch = (store2) => {
+      if (isCancled) {
+        return store2.fetch();
+      }
+      const value = store2.fetch();
+      const ref = store2.get().ref;
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store2.sub(check, { runNow: false });
+        },
+        off() {
+          sub == null ? void 0 : sub();
+          sub = void 0;
+        }
+      };
+      if (isActive) {
+        dep.on();
+      }
+      checks.push(() => {
+        return store2.get().ref === ref;
+      });
+      deps.set(store2, dep);
+      return value;
+    };
+    const updateValue = (update) => q(async () => {
+      if (isCancled) {
+        return;
+      }
+      if (update instanceof Function) {
+        try {
+          update = update(getValue());
+        } catch (error) {
+          setError == null ? void 0 : setError(error);
+          return;
+        }
+      }
+      if (update instanceof Promise) {
+        try {
+          update = await update;
+        } catch (error) {
+          if (!isCancled) {
+            setError == null ? void 0 : setError(error);
+          }
+          return;
+        }
+      }
+      if (!isCancled) {
+        setValue == null ? void 0 : setValue(update);
+      }
+    });
+    const updateError = (error) => q(() => {
+      if (!isCancled) {
+        setError == null ? void 0 : setError(error);
+      }
+    });
+    let cancelSubscription;
+    try {
+      cancelSubscription = calculate({ use, useFetch, updateValue, updateError });
+    } catch (error) {
+      setError == null ? void 0 : setError(error);
+    }
+    this.current = { cancel, check };
+  }
+  stop() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.cancel();
+  }
+  check() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.check();
+  }
+}
+function get(obj, path) {
+  if (path === "") {
+    return obj;
+  }
+  if (!(obj instanceof Object)) {
+    throw new Error(`Could not get ${path} of ${obj}`);
+  }
+  const index = path.indexOf(".");
+  if (index >= 0) {
+    const key = path.slice(0, index);
+    const rest = path.slice(index + 1);
+    const subObj = obj[key];
+    if (!subObj) {
+      return void 0;
+    }
+    return get(subObj, rest);
+  }
+  return obj[path];
+}
+function set(obj, path, value, rootPath = path) {
+  if (path === "") {
+    return value;
+  }
+  if (!(obj instanceof Object)) {
+    throw new Error(`Could not set ${path} of ${obj}`);
+  }
+  const index = path.indexOf(".");
+  let key, update;
+  if (index >= 0) {
+    key = path.slice(0, index);
+    const rest = path.slice(index + 1);
+    const subObj = obj[key];
+    if (!subObj) {
+      const prefix = rootPath.slice(0, -rest.length - 1);
+      throw Error(`Cannot set ${rootPath} because ${prefix} is ${subObj}`);
+    }
+    update = set(subObj, rest, value, rootPath);
+  } else {
+    key = path;
+    update = value instanceof Function ? value(obj[key]) : value;
+  }
+  if (Array.isArray(obj)) {
+    const copy = Array.from(obj);
+    copy[key] = update;
+    return copy;
+  }
+  return {
+    ...obj,
+    [key]: update
+  };
+}
+function makeSelector(selector) {
+  if (!selector) {
+    return (x) => x;
+  }
+  if (selector instanceof Function) {
+    return selector;
+  }
+  return (x) => get(x, selector);
+}
+const getAllProperties = (object) => {
+  const properties = /* @__PURE__ */ new Set();
+  do {
+    for (const key of Reflect.ownKeys(object)) {
+      properties.add([object, key]);
+    }
+  } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+  return properties;
+};
+function bind(self) {
+  for (const [object, key] of getAllProperties(self.constructor.prototype)) {
+    if (key === "constructor") {
+      continue;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      self[key] = self[key].bind(self);
+    }
+  }
+}
+const calcDuration = (t) => {
+  if (typeof t === "number")
+    return t;
+  return (t.milliseconds ?? 0) + (t.seconds ?? 0) * 1e3 + (t.minutes ?? 0) * 60 * 1e3 + (t.hours ?? 0) * 60 * 60 * 1e3 + (t.days ?? 0) * 24 * 60 * 60 * 1e3;
+};
+const defaultEquals = (a, b) => a === b;
+const simpleShallowEquals = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((value, i) => value === b[i]);
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    if (a === null || b === null) {
+      return false;
+    }
+    const e1 = Object.entries(a);
+    const e2 = Object.entries(b);
+    return e1.length === e2.length && e1.every(([key, value]) => value === b[key]);
+  }
+  return false;
+};
+function forwardError(error) {
+  setTimeout(() => {
+    throw error;
+  });
+}
+const arrMod = (prop) => function(...args) {
+  const newArr = this.get().slice();
+  const result = newArr[prop](...args);
+  this.update(newArr);
+  return result;
+};
+const arrayActions = {
+  splice: arrMod("splice"),
+  push: arrMod("push"),
+  pop: arrMod("pop"),
+  shift: arrMod("shift"),
+  unshift: arrMod("unshift"),
+  reverse: arrMod("reverse"),
+  sort: arrMod("sort")
+};
+const recordActions = {
+  set(key, value) {
+    if (value instanceof Function) {
+      value = value(this.get()[key]);
+    }
+    this.update({ ...this.get(), [key]: value });
+    return this;
+  },
+  delete(key) {
+    const copy = { ...this.get() };
+    delete copy[key];
+    this.update(copy);
+  },
+  clear() {
+    this.update({});
+  }
+};
+const mapActions = {
+  set(key, value) {
+    const newMap = new Map(this.get());
+    newMap.set(key, value);
+    this.update(newMap);
+    return this;
+  },
+  delete(key) {
+    const newMap = new Map(this.get());
+    const result = newMap.delete(key);
+    this.update(newMap);
+    return result;
+  },
+  clear() {
+    this.update(/* @__PURE__ */ new Map());
+  }
+};
+const setActions = {
+  add(value) {
+    const newSet = new Set(this.get());
+    newSet.add(value);
+    this.update(newSet);
+  },
+  delete(value) {
+    const newSet = new Set(this.get());
+    newSet.delete(value);
+    this.update(newSet);
+  },
+  clear() {
+    this.update(/* @__PURE__ */ new Set());
+  }
+};
+function throttle(fn, ms) {
+  let t = 0;
+  let timeout;
+  return (...args) => {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    const dt = t + ms - Date.now();
+    if (dt <= 0) {
+      fn(...args);
+      t = Date.now();
+      return;
+    }
+    timeout = setTimeout(() => {
+      fn(...args);
+      t = Date.now();
+    }, dt);
+  };
+}
+const noop = () => void 0;
+class Store {
+  constructor(initialValue, options = {}) {
+    this.initialValue = initialValue;
+    this.options = options;
+    this.value = this.initialValue;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.effects = /* @__PURE__ */ new Map();
+    this.notifyId = {};
+    bind(this);
+  }
+  get() {
+    return this.value;
+  }
+  update(update) {
+    if (update instanceof Function) {
+      update = update(this.get());
+    }
+    this.value = update;
+    this.notify();
+  }
+  sub(listener, options) {
+    const { runNow = true, throttle: throttleOption, equals = defaultEquals } = options ?? {};
+    let compareToValue = this.get();
+    let previousValue;
+    let hasRun = false;
+    let innerListener = (force) => {
+      const value = this.get();
+      if (!force && equals(value, compareToValue)) {
+        return;
+      }
+      compareToValue = value;
+      const _previousValue = previousValue;
+      previousValue = value;
+      hasRun = true;
+      try {
+        listener(value, _previousValue);
+      } catch (error) {
+        forwardError(error);
+      }
+    };
+    if (throttleOption) {
+      innerListener = throttle(innerListener, calcDuration(throttleOption));
+    }
+    this.listeners.add(innerListener);
+    this.onSubscribe();
+    if (runNow && !hasRun) {
+      innerListener(true);
+    }
+    return () => {
+      this.listeners.delete(innerListener);
+      this.onUnsubscribe();
+    };
+  }
+  map(_selector, options) {
+    const selector = makeSelector(_selector);
+    const derivedFrom = { store: this, selectors: [_selector] };
+    return new DerivedStore(({ use }) => {
+      return selector(use(this, options));
+    }, derivedFrom);
+  }
+  addEffect(effect, retain) {
+    this.effects.set(effect, {
+      handle: this.listeners.size > 0 ? effect() ?? noop : void 0,
+      retain: retain !== void 0 ? calcDuration(retain) : void 0
+    });
+    return () => {
+      const { handle, timeout } = this.effects.get(effect) ?? {};
+      handle == null ? void 0 : handle();
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.delete(effect);
+    };
+  }
+  get isActive() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+    if (this.listeners.size > 1)
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.set(effect, {
+        handle: handle ?? effect() ?? noop,
+        retain,
+        timeout: void 0
+      });
+    }
+  }
+  onUnsubscribe() {
+    if (this.listeners.size > 0)
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      !retain && (handle == null ? void 0 : handle());
+      timeout !== void 0 && clearTimeout(timeout);
+      this.effects.set(effect, {
+        handle: retain ? handle : void 0,
+        retain,
+        timeout: retain && handle ? setTimeout(handle, retain) : void 0
+      });
+    }
+  }
+  notify() {
+    const n = this.notifyId = {};
+    for (const listener of [...this.listeners]) {
+      listener();
+      if (n !== this.notifyId)
+        break;
+    }
+  }
+}
+const defaultOptions = {};
+function _store(initialState, options) {
+  if (initialState instanceof Function) {
+    return new DerivedStore(initialState);
+  }
+  let methods = options == null ? void 0 : options.methods;
+  if (initialState instanceof Map) {
+    methods = { ...mapActions, ...methods };
+  } else if (initialState instanceof Set) {
+    methods = { ...setActions, ...methods };
+  } else if (Array.isArray(initialState)) {
+    methods = { ...arrayActions, ...methods };
+  } else if (initialState instanceof Object) {
+    methods = { ...recordActions, ...methods };
+  }
+  const store2 = new Store(initialState, options);
+  const boundActions = Object.fromEntries(
+    Object.entries(methods ?? {}).filter(([name]) => !(name in store2)).map(([name, fn]) => [name, fn.bind(store2)])
+  );
+  return Object.assign(store2, boundActions);
+}
+const store = Object.assign(_store, { defaultOptions });
+class DerivedStore extends Store {
+  constructor(calculate, derivedFrom) {
+    super(void 0);
+    this.calculate = calculate;
+    this.derivedFrom = derivedFrom;
+    this.calculationHelper = new CalculationHelper({
+      calculate: ({ use }) => {
+        const value = this.calculate.apply({ use }, [{ use }]);
+        this.valid = true;
+        super.update(value);
+      },
+      addEffect: this.addEffect,
+      getValue: () => this.value,
+      onInvalidate: this.invalidate
+    });
+    this.valid = false;
+  }
+  get() {
+    if (!this.valid) {
+      this.calculationHelper.execute();
+    }
+    return super.get();
+  }
+  update(update) {
+    if (this.derivedFrom && this.derivedFrom.selectors.every((selector) => typeof selector === "string")) {
+      const path = this.derivedFrom.selectors.join(".");
+      if (update instanceof Function) {
+        const before = get(this.derivedFrom.store, path);
+        update = update(before);
+      }
+      this.derivedFrom.store.update((before) => set(before, path, update));
+    } else {
+      throw new Error("Can only updated computed stores that are derived from other stores using string selectors");
+    }
+  }
+  map(_selector) {
+    const selector = makeSelector(_selector);
+    const derivedFrom = this.derivedFrom ?? { store: this, selectors: [] };
+    const newDerivedFrom = { ...derivedFrom, selectors: derivedFrom.selectors.concat(_selector) };
+    return new DerivedStore(({ use }) => {
+      return selector(use(this));
+    }, newDerivedFrom);
+  }
+  invalidate() {
+    this.valid = false;
+    if (this.isActive) {
+      this.calculationHelper.execute();
+    }
+  }
+}
+function _derivedStore(calculate) {
+  return new DerivedStore(calculate);
+}
+const derivedStore = Object.assign(_derivedStore, {});
+function hash(value) {
+  if (value instanceof Set) {
+    return `s[${[...value].map(hash).sort().join(",")}]`;
+  }
+  if (value instanceof Map) {
+    return `m[${[...value.entries()].map(hash).sort().join(",")}]`;
+  }
+  if (value instanceof Array) {
+    return `[${value.map(hash).join(",")}]`;
+  }
+  if (value instanceof Object) {
+    return `o[${Object.entries(value).map(hash).sort().join(",")}]`;
+  }
+  return JSON.stringify(value);
+}
+export {
+  CalculationHelper as C,
+  Store as S,
+  arrayActions as a,
+  mapActions as b,
+  calcDuration as c,
+  defaultEquals as d,
+  setActions as e,
+  derivedStore as f,
+  store as g,
+  hash as h,
+  makeSelector as m,
+  recordActions as r,
+  simpleShallowEquals as s,
+  trackingProxy as t
+};
+//# sourceMappingURL=hash.mjs.map