cross-state 0.6.3 → 0.6.6

package/dist/es/hash.mjs

@@ -1,7 +1,38 @@
+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;
+};
 function queue() {
   const q = [];
-  let promise, resolve;
+  const completionListeners = /* @__PURE__ */ new Set();
   let active = false;
+  const notify = () => {
+    for (const listener of completionListeners) {
+      listener();
+    }
+    completionListeners.clear();
+  };
   const run = async () => {
     if (!active) {
       active = true;
@@ -13,42 +44,50 @@ function queue() {
             result = await result;
           }
           next.resolve(result);
-        } catch (e) {
-          next.reject(e);
+        } catch (error) {
+          next.reject(error);
         }
       }
       active = false;
-      resolve == null ? void 0 : resolve();
+      notify();
     }
   };
   return Object.assign(
-    (action) => {
-      return new Promise((resolve2, reject) => {
-        q.push({ action, resolve: resolve2, reject });
+    (action, ref) => {
+      return new Promise((resolve, reject) => {
+        q.push({ action, resolve, reject, ref });
         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();
-            };
-          });
+      whenDone() {
+        if (!active) {
+          return Promise.resolve();
         }
-        return promise;
+        return new Promise((resolve) => {
+          completionListeners.add(resolve);
+        });
+      },
+      get size() {
+        return q.length;
+      },
+      getRefs() {
+        return q.map((item) => item.ref).filter((x) => x !== void 0);
       }
     }
   );
 }
-const ProxyKeys = ["get", "getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys"];
+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)) {
@@ -60,14 +99,14 @@ function trackingProxy(value) {
     Object.fromEntries(
       ProxyKeys.map((key) => [
         key,
-        (value2, ...args) => {
-          const fn = Reflect[key];
-          const [proxiedValue, equals] = trackingProxy(fn(value2, ...args));
+        (currentValue, ...args) => {
+          const function_ = Reflect[key];
+          const [proxiedValue, equals] = trackingProxy(function_(currentValue, ...args));
           deps.push((otherValue) => {
             if (!isPlainObject(otherValue) && !Array.isArray(otherValue)) {
               return false;
             }
-            return equals(fn(otherValue, ...args));
+            return equals(function_(otherValue, ...args));
           });
           return proxiedValue;
         }
@@ -113,17 +152,22 @@ class CalculationHelper {
       cancelEffect();
       delete this.current;
     };
-    const check = () => {
-      if (!checks.every((check2) => check2())) {
+    const checkAll = () => {
+      if (!checks.every((check) => check())) {
         cancel();
         onInvalidate == null ? void 0 : onInvalidate();
       }
     };
-    const use = (store2, { disableProxy } = {}) => {
+    const invalidateDependencies = () => {
+      for (const dep of deps.values()) {
+        dep.invalidate();
+      }
+    };
+    const use = (store, { disableProxy } = {}) => {
       if (isCancled) {
-        return store2.get();
+        return store.get();
       }
-      let value = store2.get();
+      let value = store.get();
       let equals = (newValue) => {
         return newValue === value;
       };
@@ -134,44 +178,23 @@ class CalculationHelper {
       const dep = {
         on() {
           this.off();
-          sub = store2.sub(check, { runNow: false });
+          sub = store.sub(checkAll, { 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;
+        invalidate() {
+          if ("invalidate" in store && store.invalidate instanceof Function) {
+            store.invalidate();
+          }
         }
       };
       if (isActive) {
         dep.on();
       }
-      checks.push(() => {
-        return store2.get().ref === ref;
-      });
-      deps.set(store2, dep);
+      checks.push(() => equals(store.get()));
+      deps.set(store, dep);
       return value;
     };
     const updateValue = (update) => q(async () => {
@@ -180,7 +203,7 @@ class CalculationHelper {
       }
       if (update instanceof Function) {
         try {
-          update = update(getValue());
+          update = update(getValue == null ? void 0 : getValue());
         } catch (error) {
           setError == null ? void 0 : setError(error);
           return;
@@ -207,11 +230,11 @@ class CalculationHelper {
     });
     let cancelSubscription;
     try {
-      cancelSubscription = calculate({ use, useFetch, updateValue, updateError });
+      cancelSubscription = calculate({ use, updateValue, updateError });
     } catch (error) {
       setError == null ? void 0 : setError(error);
     }
-    this.current = { cancel, check };
+    this.current = { cancel, check: checkAll, invalidateDependencies };
   }
   stop() {
     var _a;
@@ -221,105 +244,113 @@ class CalculationHelper {
     var _a;
     (_a = this.current) == null ? void 0 : _a.check();
   }
+  invalidateDependencies() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.invalidateDependencies();
+  }
 }
-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;
+function debounce(action, options) {
+  const wait = typeof options === "object" && "wait" in options ? calcDuration(options.wait) : calcDuration(options);
+  const maxWait = typeof options === "object" && "maxWait" in options && options.maxWait !== void 0 ? calcDuration(options.maxWait) : void 0;
+  let timeout;
+  let timeoutStarted;
+  return (...args) => {
+    const now = Date.now();
+    timeoutStarted ?? (timeoutStarted = now);
+    const deadline = Math.min(
+      //
+      now + wait,
+      timeoutStarted + (maxWait ?? Number.POSITIVE_INFINITY)
+    );
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
     }
-    return get(subObj, rest);
-  }
-  return obj[path];
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      timeoutStarted = void 0;
+      action(...args);
+    }, deadline - now);
+  };
 }
-function set(obj, path, value, rootPath = path) {
-  if (path === "") {
-    return value;
+const defaultEquals = (a, b) => a === b;
+function forwardError(error) {
+  setTimeout(() => {
+    throw error;
+  });
+}
+function flatClone(object) {
+  if (object instanceof Map) {
+    return new Map(object);
   }
-  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;
+  if (object instanceof Set) {
+    return new Set(object);
   }
-  return {
-    ...obj,
-    [key]: update
-  };
+  if (Array.isArray(object)) {
+    return [...object];
+  }
+  if (object instanceof Object) {
+    return { ...object };
+  }
+  return object;
 }
-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);
-    }
+function castArrayPath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (path === "") {
+    return [];
   }
+  return path.split(".");
 }
-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;
+function get(object, path) {
+  const _path = castArrayPath(path);
+  const [first, ...rest] = _path;
+  if (first === void 0 || !object) {
+    return object;
+  }
+  if (object instanceof Map) {
+    return get(object.get(first), rest);
+  }
+  if (object instanceof Set) {
+    return get(Array.from(object)[Number(first)], rest);
   }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((value, i) => value === b[i]);
+  if (object instanceof Object) {
+    return get(object[first], rest);
+  }
+  throw new Error(`Could not get ${path} of ${object}`);
+}
+function set(object, path, value, rootPath = path) {
+  const _path = castArrayPath(path);
+  const [first, ...rest] = _path;
+  if (first === void 0) {
+    return value;
   }
-  if (typeof a === "object" && typeof b === "object") {
-    if (a === null || b === null) {
-      return false;
+  const updateChild = (child) => {
+    if (!child && rest.length > 0) {
+      const _rootPath = castArrayPath(rootPath);
+      const prefix = _rootPath.slice(0, -rest.length);
+      throw new Error(`Cannot set ${rootPath} because ${prefix.join(".")} is ${child}`);
     }
-    const e1 = Object.entries(a);
-    const e2 = Object.entries(b);
-    return e1.length === e2.length && e1.every(([key, value]) => value === b[key]);
+    return set(child, rest, value, rootPath);
+  };
+  if (object instanceof Map) {
+    const copy = flatClone(object);
+    const child = copy.get(first);
+    copy.set(first, updateChild(child));
+    return copy;
   }
-  return false;
-};
-function forwardError(error) {
-  setTimeout(() => {
-    throw error;
-  });
+  if (object instanceof Set) {
+    const copy = [...object];
+    const child = copy[Number(first)];
+    copy[Number(first)] = updateChild(child);
+    return new Set(copy);
+  }
+  if (object instanceof Object) {
+    const copy = flatClone(object);
+    copy[first] = updateChild(copy[first]);
+    return copy;
+  }
+  throw new Error(`Could not set ${path} of ${object}`);
 }
 function makeSelector(selector) {
   if (!selector) {
@@ -330,74 +361,79 @@ function makeSelector(selector) {
   }
   return (x) => get(x, selector);
 }
-const arrMod = (prop) => function(...args) {
-  const newArr = this.get().slice();
-  const result = newArr[prop](...args);
-  this.update(newArr);
+const createArrayAction = (prop) => function arrayAction(...args) {
+  const newArray = this.get().slice();
+  const result = newArray[prop](...args);
+  this.set(newArray);
   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 arrayMethods = {
+  splice: createArrayAction("splice"),
+  push: createArrayAction("push"),
+  pop: createArrayAction("pop"),
+  shift: createArrayAction("shift"),
+  unshift: createArrayAction("unshift"),
+  reverse: createArrayAction("reverse"),
+  sort: createArrayAction("sort")
 };
-const recordActions = {
-  set(key, value) {
-    if (value instanceof Function) {
-      value = value(this.get()[key]);
-    }
-    this.update({ ...this.get(), [key]: value });
-    return this;
-  },
+const recordMethods = {
+  // set<T extends Record<any, any>, P extends Path<T>>(
+  //   this: Store<T>,
+  //   path: P,
+  //   value: Update<Value<T, P>>,
+  // ) {
+  //   if (value instanceof Function) {
+  //     value = value(get(this.get(), path));
+  //   }
+  //   this.set(set(this.get(), path, value));
+  //   return this;
+  // },
   delete(key) {
     const copy = { ...this.get() };
     delete copy[key];
-    this.update(copy);
+    this.set(copy);
   },
   clear() {
-    this.update({});
+    this.set({});
   }
 };
-const mapActions = {
-  set(key, value) {
-    if (value instanceof Function) {
-      value = value(this.get().get(key));
-    }
-    const newMap = new Map(this.get());
-    newMap.set(key, value);
-    this.update(newMap);
-    return this;
-  },
+const mapMethods = {
+  // set<K, V>(this: Store<Map<K, V>>, key: K, value: UpdateFrom<V, [V | undefined]>) {
+  //   if (value instanceof Function) {
+  //     value = value(this.get().get(key));
+  //   }
+  //   const newMap = new Map(this.get());
+  //   newMap.set(key, value);
+  //   this.set(newMap);
+  //   return this;
+  // },
   delete(key) {
     const newMap = new Map(this.get());
     const result = newMap.delete(key);
-    this.update(newMap);
+    this.set(newMap);
     return result;
   },
   clear() {
-    this.update(/* @__PURE__ */ new Map());
+    this.set(/* @__PURE__ */ new Map());
   }
 };
-const setActions = {
+const setMethods = {
   add(value) {
     const newSet = new Set(this.get());
     newSet.add(value);
-    this.update(newSet);
+    this.set(newSet);
   },
   delete(value) {
     const newSet = new Set(this.get());
     newSet.delete(value);
-    this.update(newSet);
+    this.set(newSet);
   },
   clear() {
-    this.update(/* @__PURE__ */ new Set());
+    this.set(/* @__PURE__ */ new Set());
   }
 };
-function throttle(fn, ms) {
+function throttle(action, duration) {
+  const ms = calcDuration(duration);
   let t = 0;
   let timeout;
   return (...args) => {
@@ -406,44 +442,96 @@ function throttle(fn, ms) {
     }
     const dt = t + ms - Date.now();
     if (dt <= 0) {
-      fn(...args);
+      action(...args);
       t = Date.now();
       return;
     }
     timeout = setTimeout(() => {
-      fn(...args);
+      action(...args);
       t = Date.now();
     }, dt);
   };
 }
 const noop = () => void 0;
 class Store {
-  constructor(initialValue, options = {}) {
-    this.initialValue = initialValue;
+  constructor(getter, options = {}, derivedFrom) {
+    this.getter = getter;
     this.options = options;
-    this.value = this.initialValue;
-    this.listeners = /* @__PURE__ */ new Set();
+    this.derivedFrom = derivedFrom;
+    this.listeners = /* @__PURE__ */ new Map();
     this.effects = /* @__PURE__ */ new Map();
     this.notifyId = {};
+    this.calculationHelper = new CalculationHelper({
+      calculate: ({ use }) => {
+        if (this.getter instanceof Function) {
+          const value = this.getter.apply({ use }, [{ use }]);
+          this._value = { v: value };
+          this.notify();
+        }
+      },
+      addEffect: this.addEffect.bind(this),
+      onInvalidate: this.reset.bind(this)
+    });
     bind(this);
+    if (!(getter instanceof Function)) {
+      this._value = { v: getter };
+    }
   }
   get() {
-    return this.value;
+    this.calculationHelper.check();
+    if (!this._value) {
+      this.calculationHelper.execute();
+      return this.get();
+    }
+    return this._value.v;
   }
-  update(update) {
+  set(...args) {
+    const path = args.length > 1 ? args[0] : [];
+    let update = args.length > 1 ? args[1] : args[0];
     if (update instanceof Function) {
-      update = update(this.get());
+      const before = this.get();
+      const valueBefore = get(before, path);
+      const valueAfter = update(valueBefore);
+      update = set(before, path, valueAfter);
+    } else if (path.length > 0) {
+      update = set(this.get(), path, update);
     }
-    this.value = update;
+    if (this.derivedFrom && this.derivedFrom.selectors.every((selector) => typeof selector === "string")) {
+      const derivationPath = this.derivedFrom.selectors.join(".");
+      this.derivedFrom.store.set((before) => set(before, derivationPath, update));
+      return;
+    }
+    if (this.derivedFrom) {
+      throw new TypeError(
+        "Can only updated computed stores that are derived from other stores using string selectors"
+      );
+    }
+    this._value = { v: update };
     this.notify();
   }
+  reset() {
+    this._value = void 0;
+    if (this.isActive) {
+      this.calculationHelper.execute();
+    }
+  }
   sub(listener, options) {
-    const { runNow = true, throttle: throttleOption, equals = defaultEquals } = options ?? {};
-    let compareToValue = this.get();
+    var _a;
+    const {
+      passive,
+      runNow = true,
+      throttle: throttleOption,
+      debounce: debounceOption,
+      equals = defaultEquals
+    } = options ?? {};
+    let compareToValue = (_a = this._value) == null ? void 0 : _a.v;
     let previousValue;
     let hasRun = false;
     let innerListener = (force) => {
-      const value = this.get();
+      if (!this._value) {
+        return;
+      }
+      const value = this._value.v;
       if (!force && equals(value, compareToValue)) {
         return;
       }
@@ -458,22 +546,49 @@ class Store {
       }
     };
     if (throttleOption) {
-      innerListener = throttle(innerListener, calcDuration(throttleOption));
+      innerListener = throttle(innerListener, throttleOption);
+    } else if (debounceOption) {
+      innerListener = debounce(innerListener, debounceOption);
+    }
+    this.listeners.set(innerListener, !passive);
+    if (!passive) {
+      this.onSubscribe();
     }
-    this.listeners.add(innerListener);
-    this.onSubscribe();
     if (runNow && !hasRun) {
       innerListener(true);
     }
     return () => {
       this.listeners.delete(innerListener);
-      this.onUnsubscribe();
+      if (!passive) {
+        this.onUnsubscribe();
+      }
     };
   }
+  once(condition = (value) => !!value) {
+    return new Promise((resolve) => {
+      let stopped = false;
+      const cancel = this.sub(
+        (value) => {
+          if (stopped || condition && !condition(value)) {
+            return;
+          }
+          resolve(value);
+          stopped = true;
+          setTimeout(() => cancel());
+        },
+        {
+          runNow: !!condition
+        }
+      );
+    });
+  }
   map(_selector, options) {
     const selector = makeSelector(_selector);
-    const derivedFrom = { store: this, selectors: [_selector] };
-    return new DerivedStore(
+    const derivedFrom = {
+      store: this.derivedFrom ? this.derivedFrom.store : this,
+      selectors: this.derivedFrom ? [...this.derivedFrom.selectors, _selector] : [_selector]
+    };
+    return new Store(
       ({ use }) => {
         return selector(use(this, options));
       },
@@ -481,26 +596,41 @@ class Store {
       derivedFrom
     );
   }
+  /** Add an effect that will be executed when the store becomes active, which means when it has at least one subscriber.
+   * @param effect
+   * If there is already a subscriber, the effect will be executed immediately.
+   * Otherweise it will be executed as soon as the first subscription is created.
+   * Every time all subscriptions are removed and the first is created again, the effect will be executed again.
+   * @param retain
+   * If provided, delay tearing down effects when the last subscriber is removed. This is useful if a short gap in subscriber coverage is supposed to be ignored. E.g. when switching pages, the old page might unsubscribe, while the new page subscribes immediately after.
+   * @returns
+   * The effect can return a teardown callback, which will be executed when the last subscription is removed and potentially the ratain time has passed.
+   */
   addEffect(effect, retain) {
     this.effects.set(effect, {
-      handle: this.listeners.size > 0 ? effect() ?? noop : void 0,
+      handle: this.isActive ? 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);
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
       this.effects.delete(effect);
     };
   }
+  /** Return whether the store is currently active, which means whether it has at least one subscriber. */
   get isActive() {
-    return this.listeners.size > 0;
+    return [...this.listeners.values()].some(Boolean);
   }
   onSubscribe() {
-    if (this.listeners.size > 1)
+    if ([...this.listeners.values()].filter(Boolean).length > 1)
       return;
     for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
-      timeout !== void 0 && clearTimeout(timeout);
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
       this.effects.set(effect, {
         handle: handle ?? effect() ?? noop,
         retain,
@@ -509,11 +639,15 @@ class Store {
     }
   }
   onUnsubscribe() {
-    if (this.listeners.size > 0)
+    if ([...this.listeners.values()].some(Boolean))
       return;
     for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
-      !retain && (handle == null ? void 0 : handle());
-      timeout !== void 0 && clearTimeout(timeout);
+      if (!retain) {
+        handle == null ? void 0 : handle();
+      }
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
       this.effects.set(effect, {
         handle: retain ? handle : void 0,
         retain,
@@ -522,8 +656,10 @@ class Store {
     }
   }
   notify() {
-    const n = this.notifyId = {};
-    for (const listener of [...this.listeners]) {
+    const n = {};
+    this.notifyId = n;
+    const snapshot = [...this.listeners.keys()];
+    for (const listener of snapshot) {
       listener();
       if (n !== this.notifyId)
         break;
@@ -531,75 +667,27 @@ class Store {
   }
 }
 const defaultOptions = {};
-function _store(initialState, options) {
+function create(initialState, options) {
+  const store = new Store(initialState, options);
   if (initialState instanceof Function) {
-    return derivedStore(initialState, options);
+    return store;
   }
   let methods = options == null ? void 0 : options.methods;
   if (initialState instanceof Map) {
-    methods = { ...mapActions, ...methods };
+    methods = { ...mapMethods, ...methods };
   } else if (initialState instanceof Set) {
-    methods = { ...setActions, ...methods };
+    methods = { ...setMethods, ...methods };
   } else if (Array.isArray(initialState)) {
-    methods = { ...arrayActions, ...methods };
+    methods = { ...arrayMethods, ...methods };
   } else if (initialState instanceof Object) {
-    methods = { ...recordActions, ...methods };
+    methods = { ...recordMethods, ...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)])
+  const boundMethods = Object.fromEntries(
+    Object.entries(methods ?? {}).filter(([name]) => !(name in store)).map(([name, action]) => [name, action.bind(store)])
   );
-  return Object.assign(store2, boundActions);
-}
-const store = Object.assign(_store, { defaultOptions });
-class DerivedStore extends Store {
-  constructor(calculate, options = {}, derivedFrom) {
-    super(void 0);
-    this.calculate = calculate;
-    this.options = options;
-    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() {
-    this.calculationHelper.check();
-    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 = this.get();
-        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");
-    }
-  }
-  invalidate() {
-    this.valid = false;
-    if (this.isActive) {
-      this.calculationHelper.execute();
-    }
-  }
-}
-function _derivedStore(calculate, options) {
-  return new DerivedStore(calculate, options);
+  return Object.assign(store, boundMethods);
 }
-const derivedStore = Object.assign(_derivedStore, {});
+const createStore = Object.assign(create, { defaultOptions });
 function hash(value) {
   if (value instanceof Set) {
     return `s[${[...value].map(hash).sort().join(",")}]`;
@@ -607,7 +695,7 @@ function hash(value) {
   if (value instanceof Map) {
     return `m[${[...value.entries()].map(hash).sort().join(",")}]`;
   }
-  if (value instanceof Array) {
+  if (Array.isArray(value)) {
     return `[${value.map(hash).join(",")}]`;
   }
   if (value instanceof Object) {
@@ -616,19 +704,16 @@ function hash(value) {
   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,
+  calcDuration as a,
+  bind as b,
+  createStore as c,
+  arrayMethods as d,
+  mapMethods as e,
   hash as h,
   makeSelector as m,
-  recordActions as r,
-  simpleShallowEquals as s,
+  recordMethods as r,
+  setMethods as s,
   trackingProxy as t
 };
 //# sourceMappingURL=hash.mjs.map