cross-state 0.6.10 → 0.7.2

package/dist/cjs/hash.cjs

@@ -1,677 +1,4 @@
 "use strict";
-function 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"
-];
-function isPlainObject(value) {
-  return 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);
-  };
-}
-function defaultEquals(a, b) {
-  return 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);
-}
-function createArrayAction(prop) {
-  return 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 = {
-  delete(key) {
-    const copy = { ...this.get() };
-    delete copy[key];
-    this.set(copy);
-  },
-  clear() {
-    this.set({});
-  }
-};
-const mapMethods = {
-  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);
-  };
-}
-function noop() {
-  return 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(",")}]`;
@@ -687,14 +14,5 @@ function hash(value) {
   }
   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