cross-state 0.6.7 → 0.6.9

package/dist/cjs/hash.cjs

@@ -0,0 +1,712 @@
+"use strict";
+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 = [];
+  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;
+      let next;
+      while (next = q.shift()) {
+        try {
+          let result = next.action();
+          if (result instanceof Promise) {
+            result = await result;
+          }
+          next.resolve(result);
+        } catch (error) {
+          next.reject(error);
+        }
+      }
+      active = false;
+      notify();
+    }
+  };
+  return Object.assign(
+    (action, ref) => {
+      return new Promise((resolve, reject) => {
+        q.push({ action, resolve, reject, ref });
+        run();
+      });
+    },
+    {
+      clear() {
+        q.length = 0;
+      },
+      whenDone() {
+        if (!active) {
+          return Promise.resolve();
+        }
+        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 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,
+        (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(function_(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 checkAll = () => {
+      if (!checks.every((check) => check())) {
+        cancel();
+        onInvalidate == null ? void 0 : onInvalidate();
+      }
+    };
+    const invalidateDependencies = () => {
+      for (const dep of deps.values()) {
+        dep.invalidate();
+      }
+    };
+    const use = (store, { disableProxy } = {}) => {
+      if (isCancled) {
+        return store.get();
+      }
+      let value = store.get();
+      let equals = (newValue) => {
+        return newValue === value;
+      };
+      if (!disableProxy) {
+        [value, equals] = trackingProxy(value);
+      }
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store.sub(checkAll, { 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(() => equals(store.get()));
+      deps.set(store, dep);
+      return value;
+    };
+    const updateValue = (update) => q(async () => {
+      if (isCancled) {
+        return;
+      }
+      if (update instanceof Function) {
+        try {
+          update = update(getValue == null ? void 0 : 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, updateValue, updateError });
+    } catch (error) {
+      setError == null ? void 0 : setError(error);
+    }
+    this.current = { cancel, check: checkAll, invalidateDependencies };
+  }
+  stop() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.cancel();
+  }
+  check() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.check();
+  }
+  invalidateDependencies() {
+    var _a;
+    (_a = this.current) == null ? void 0 : _a.invalidateDependencies();
+  }
+}
+class Callable extends Function {
+  constructor(_call) {
+    super("...args", "return this._call(...args)");
+    this._call = _call;
+    return this.bind(this);
+  }
+}
+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);
+    }
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      timeoutStarted = void 0;
+      action(...args);
+    }, deadline - now);
+  };
+}
+const defaultEquals = (a, b) => a === b;
+function forwardError(error) {
+  setTimeout(() => {
+    throw error;
+  });
+}
+function flatClone(object) {
+  if (object instanceof Map) {
+    return new Map(object);
+  }
+  if (object instanceof Set) {
+    return new Set(object);
+  }
+  if (Array.isArray(object)) {
+    return [...object];
+  }
+  if (object instanceof Object) {
+    return { ...object };
+  }
+  return object;
+}
+function castArrayPath(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  if (path === "") {
+    return [];
+  }
+  return path.split(".");
+}
+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 (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;
+  }
+  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}`);
+    }
+    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;
+  }
+  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) {
+    return (x) => x;
+  }
+  if (selector instanceof Function) {
+    return selector;
+  }
+  return (x) => get(x, selector);
+}
+const createArrayAction = (prop) => function arrayAction(...args) {
+  const newArray = this.get().slice();
+  const result = newArray[prop](...args);
+  this.set(newArray);
+  return result;
+};
+const arrayMethods = {
+  splice: /* @__PURE__ */ createArrayAction("splice"),
+  push: /* @__PURE__ */ createArrayAction("push"),
+  pop: /* @__PURE__ */ createArrayAction("pop"),
+  shift: /* @__PURE__ */ createArrayAction("shift"),
+  unshift: /* @__PURE__ */ createArrayAction("unshift"),
+  reverse: /* @__PURE__ */ createArrayAction("reverse"),
+  sort: /* @__PURE__ */ createArrayAction("sort")
+};
+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.set(copy);
+  },
+  clear() {
+    this.set({});
+  }
+};
+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.set(newMap);
+    return result;
+  },
+  clear() {
+    this.set(/* @__PURE__ */ new Map());
+  }
+};
+const setMethods = {
+  add(value) {
+    const newSet = new Set(this.get());
+    newSet.add(value);
+    this.set(newSet);
+  },
+  delete(value) {
+    const newSet = new Set(this.get());
+    newSet.delete(value);
+    this.set(newSet);
+  },
+  clear() {
+    this.set(/* @__PURE__ */ new Set());
+  }
+};
+function throttle(action, duration) {
+  const ms = calcDuration(duration);
+  let t = 0;
+  let timeout;
+  return (...args) => {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    const dt = t + ms - Date.now();
+    if (dt <= 0) {
+      action(...args);
+      t = Date.now();
+      return;
+    }
+    timeout = setTimeout(() => {
+      action(...args);
+      t = Date.now();
+    }, dt);
+  };
+}
+const noop = () => void 0;
+class Store extends Callable {
+  constructor(getter, options = {}, derivedFrom, _call = () => void 0) {
+    super(_call);
+    this.getter = getter;
+    this.options = options;
+    this.derivedFrom = derivedFrom;
+    this._call = _call;
+    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)
+    });
+    this.get = this.get.bind(this);
+    this.set = this.set.bind(this);
+    this.sub = this.sub.bind(this);
+    this.once = this.once.bind(this);
+    this.map = this.map.bind(this);
+    this.addEffect = this.addEffect.bind(this);
+    this.isActive = this.isActive.bind(this);
+    if (!(getter instanceof Function)) {
+      this._value = { v: getter };
+    }
+  }
+  get() {
+    this.calculationHelper.check();
+    if (!this._value) {
+      this.calculationHelper.execute();
+      return this.get();
+    }
+    return this._value.v;
+  }
+  set(...args) {
+    const path = args.length > 1 ? args[0] : [];
+    let update = args.length > 1 ? args[1] : args[0];
+    if (update instanceof Function) {
+      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);
+    }
+    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) {
+    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) => {
+      if (!this._value) {
+        return;
+      }
+      const value = this._value.v;
+      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, throttleOption);
+    } else if (debounceOption) {
+      innerListener = debounce(innerListener, debounceOption);
+    }
+    this.listeners.set(innerListener, !passive);
+    if (!passive) {
+      this.onSubscribe();
+    }
+    if (runNow && !hasRun) {
+      innerListener(true);
+    }
+    return () => {
+      this.listeners.delete(innerListener);
+      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.derivedFrom ? this.derivedFrom.store : this,
+      selectors: this.derivedFrom ? [...this.derivedFrom.selectors, _selector] : [_selector]
+    };
+    return new Store(
+      ({ use }) => {
+        return selector(use(this, options));
+      },
+      this.options,
+      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.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();
+      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. */
+  isActive() {
+    return [...this.listeners.values()].some(Boolean);
+  }
+  onSubscribe() {
+    if ([...this.listeners.values()].filter(Boolean).length > 1)
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      this.effects.set(effect, {
+        handle: handle ?? effect() ?? noop,
+        retain,
+        timeout: void 0
+      });
+    }
+  }
+  onUnsubscribe() {
+    if ([...this.listeners.values()].some(Boolean))
+      return;
+    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
+      if (!retain) {
+        handle == null ? void 0 : handle();
+      }
+      if (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 = n;
+    const snapshot = [...this.listeners.keys()];
+    for (const listener of snapshot) {
+      listener();
+      if (n !== this.notifyId)
+        break;
+    }
+  }
+}
+const defaultOptions = {};
+function create(initialState, options) {
+  const store = new Store(initialState, options);
+  if (initialState instanceof Function) {
+    return store;
+  }
+  let methods = options == null ? void 0 : options.methods;
+  if (initialState instanceof Map) {
+    methods = { ...mapMethods, ...methods };
+  } else if (initialState instanceof Set) {
+    methods = { ...setMethods, ...methods };
+  } else if (Array.isArray(initialState)) {
+    methods = { ...arrayMethods, ...methods };
+  } else if (initialState instanceof Object) {
+    methods = { ...recordMethods, ...methods };
+  }
+  const boundMethods = Object.fromEntries(
+    Object.entries(methods ?? {}).filter(([name]) => !(name in store)).map(([name, action]) => [name, action.bind(store)])
+  );
+  return Object.assign(store, boundMethods);
+}
+const createStore = /* @__PURE__ */ Object.assign(create, { defaultOptions });
+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 (Array.isArray(value)) {
+    return `[${value.map(hash).join(",")}]`;
+  }
+  if (value instanceof Object) {
+    return `o[${Object.entries(value).map(hash).sort().join(",")}]`;
+  }
+  return JSON.stringify(value);
+}
+exports.Store = Store;
+exports.arrayMethods = arrayMethods;
+exports.calcDuration = calcDuration;
+exports.createStore = createStore;
+exports.hash = hash;
+exports.makeSelector = makeSelector;
+exports.mapMethods = mapMethods;
+exports.recordMethods = recordMethods;
+exports.setMethods = setMethods;
+exports.trackingProxy = trackingProxy;
+//# sourceMappingURL=hash.cjs.map