cross-state 0.6.10 → 0.7.1

package/dist/es/store.mjs

@@ -0,0 +1,799 @@
+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);
+      }
+    }
+  );
+}
+function defaultEqual(a, b) {
+  return a === b;
+}
+function shallowEqual(a, b) {
+  return internalEqual(defaultEqual)(a, b);
+}
+function deepEqual(a, b) {
+  return internalEqual(deepEqual)(a, b);
+}
+const internalEqual = (comp) => (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return a !== a && b !== b;
+  }
+  if (a.constructor !== b.constructor) {
+    return false;
+  }
+  if (a.constructor === Object) {
+    const entries1 = Object.entries(a);
+    const entries2 = Object.entries(b);
+    return entries1.length === entries2.length && entries1.every(([key, value]) => comp(value, b[key]));
+  }
+  if (Array.isArray(a)) {
+    return a.length === b.length && a.every((value, i) => comp(value, b[i]));
+  }
+  if (a instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof Map) {
+    return a.size === b.size && [...a.entries()].every(([key, value]) => comp(value, b.get(key)));
+  }
+  if (a instanceof Set) {
+    return a.size === b.size && [...a.values()].every((value) => b.has(value));
+  }
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(a)) {
+    if (a.byteLength !== b.byteLength) {
+      return false;
+    }
+    const a_ = new Int8Array(a.buffer);
+    const b_ = new Int8Array(b.buffer);
+    return a_.every((value, i) => value === b_[i]);
+  }
+  return false;
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+function trackingProxy(value, equals = deepEqual) {
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return [value, (other) => equals(value, other)];
+  }
+  const deps = new Array();
+  function trackComplexProp(function_, ...args) {
+    const [proxiedValue, equals2] = trackingProxy(function_(value, ...args));
+    deps.push((otherValue) => {
+      if (!isPlainObject(otherValue) && !Array.isArray(otherValue)) {
+        return false;
+      }
+      return equals2(function_(otherValue, ...args));
+    });
+    return proxiedValue;
+  }
+  function trackSimpleProp(function_, ...args) {
+    const calculatedValue = function_(value, ...args);
+    deps.push((otherValue) => {
+      return function_(otherValue, ...args) === calculatedValue;
+    });
+    return calculatedValue;
+  }
+  const proxy = new Proxy(value, {
+    get(target, p, receiver) {
+      const { writable, configurable } = Object.getOwnPropertyDescriptor(target, p) ?? {};
+      if (writable === false && configurable === false) {
+        return target[p];
+      }
+      return trackComplexProp(Reflect.get, p, receiver);
+    },
+    getOwnPropertyDescriptor(target, p) {
+      const { writable, configurable } = Object.getOwnPropertyDescriptor(target, p) ?? {};
+      if (writable === false && configurable === false) {
+        return Reflect.getOwnPropertyDescriptor(target, p);
+      }
+      return trackComplexProp(Reflect.getOwnPropertyDescriptor, p);
+    },
+    ownKeys() {
+      return trackComplexProp(Reflect.ownKeys);
+    },
+    getPrototypeOf() {
+      return trackSimpleProp(Reflect.getPrototypeOf);
+    },
+    has(_target, p) {
+      return trackSimpleProp(Reflect.has, p);
+    },
+    isExtensible() {
+      return trackSimpleProp(Reflect.isExtensible);
+    }
+  });
+  return [proxy, (other) => !!other && deps.every((equals2) => equals2(other))];
+}
+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, onValue, onError, onConnectionState, 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();
+        }
+        if (cancelSubscription) {
+          cancelSubscription();
+          cancelSubscription = void 0;
+          cancel();
+          onInvalidate == null ? void 0 : onInvalidate();
+        }
+      };
+    });
+    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 deepEqual(newValue, value);
+      };
+      if (!disableProxy) {
+        [value, equals] = trackingProxy(value);
+      }
+      const check = () => equals(store.get());
+      let sub;
+      const dep = {
+        on() {
+          this.off();
+          sub = store.subscribe(
+            () => {
+              if (sub && !check()) {
+                cancel();
+                onInvalidate == null ? void 0 : onInvalidate();
+              }
+            },
+            { 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(check);
+      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) {
+          onError == null ? void 0 : onError(error);
+          return;
+        }
+      }
+      if (update instanceof Promise) {
+        try {
+          update = await update;
+        } catch (error) {
+          if (!isCancled) {
+            onError == null ? void 0 : onError(error);
+          }
+          return;
+        }
+      }
+      if (!isCancled) {
+        onValue == null ? void 0 : onValue(update);
+      }
+    });
+    const updateError = (error) => q(() => {
+      if (!isCancled) {
+        onError == null ? void 0 : onError(error);
+      }
+    });
+    const updateConnectionState = (state) => q(() => {
+      if (!isCancled) {
+        onConnectionState == null ? void 0 : onConnectionState(state);
+      }
+    });
+    let cancelSubscription;
+    try {
+      cancelSubscription = calculate({ use, updateValue, updateError, updateConnectionState });
+    } catch (error) {
+      onError == null ? void 0 : onError(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();
+  }
+  checkOrExecute() {
+    if (this.current) {
+      this.check();
+    } else {
+      this.execute();
+    }
+  }
+  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 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 || object === void 0) {
+    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: (helpers) => {
+        if (this.getter instanceof Function) {
+          const value = this.getter.apply(helpers, [helpers]);
+          this._value = { v: value };
+          this.notify();
+        }
+      },
+      addEffect: (effect) => this.addEffect(effect, this.options.retain),
+      getValue: () => {
+        var _a;
+        return (_a = this._value) == null ? void 0 : _a.v;
+      },
+      onInvalidate: () => this.reset()
+    });
+    this.get = this.get.bind(this);
+    this.set = this.set.bind(this);
+    this.subscribe = this.subscribe.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.updater(update);
+      return;
+    }
+    this._value = { v: update };
+    this.notify();
+  }
+  reset() {
+    this._value = void 0;
+    if (this.isActive()) {
+      this.calculationHelper.execute();
+    }
+  }
+  subscribe(listener, options) {
+    var _a;
+    const {
+      passive,
+      runNow = true,
+      throttle: throttleOption,
+      debounce: debounceOption,
+      equals = deepEqual
+    } = 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.subscribe(
+        (value) => {
+          if (stopped || condition && !condition(value)) {
+            return;
+          }
+          resolve(value);
+          stopped = true;
+          setTimeout(() => cancel());
+        },
+        {
+          runNow: !!condition
+        }
+      );
+    });
+  }
+  map(_selector, ...args) {
+    const updater = _selector instanceof Function ? args[0] : (value) => (state) => set(state, _selector, value);
+    const options = _selector instanceof Function ? args[1] : args[0];
+    const selector = makeSelector(_selector);
+    const derivedFrom = {
+      store: this.derivedFrom ? this.derivedFrom.store : this,
+      selectors: this.derivedFrom ? [...this.derivedFrom.selectors, _selector] : [_selector],
+      updater: (value) => {
+        if (!updater) {
+          throw new TypeError(
+            "Can only updated computed stores that either are derived from other stores using string selectors or have an updater function."
+          );
+        }
+        let update = updater(value);
+        if (update instanceof Function) {
+          update = update(this.get());
+        }
+        if (this.derivedFrom) {
+          this.derivedFrom.updater(update);
+        } else {
+          this.set(update);
+        }
+      }
+    };
+    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 });
+export {
+  Store as S,
+  calcDuration as a,
+  castArrayPath as b,
+  createStore as c,
+  set as d,
+  arrayMethods as e,
+  setMethods as f,
+  get as g,
+  debounce as h,
+  makeSelector as i,
+  trackingProxy as j,
+  mapMethods as m,
+  queue as q,
+  recordMethods as r,
+  shallowEqual as s,
+  throttle as t
+};
+//# sourceMappingURL=store.mjs.map