cross-state 0.53.3 → 0.54.0

package/dist/cjs/store.cjs

@@ -1,829 +0,0 @@
-'use strict';
-
-const propAccess = require('./propAccess.cjs');
-
-const marker = Symbol("autobind");
-const autobind = (_class) => {
-  for (const key of Reflect.ownKeys(_class.prototype)) {
-    if (key === "constructor") {
-      continue;
-    }
-    const descriptor = Reflect.getOwnPropertyDescriptor(_class.prototype, key);
-    let method = descriptor?.get?.() ?? descriptor?.value;
-    let isBinding = false;
-    if (typeof method !== "function" || method[marker]) {
-      continue;
-    }
-    Reflect.defineProperty(_class.prototype, key, {
-      configurable: true,
-      get() {
-        if (isBinding || this === _class.prototype || Object.prototype.hasOwnProperty.call(this, key) || typeof method !== "function") {
-          return method;
-        }
-        const boundMethod = (...args) => Reflect.apply(method, this, args);
-        boundMethod[marker] = true;
-        isBinding = true;
-        Object.defineProperty(this, key, {
-          configurable: true,
-          get() {
-            return boundMethod;
-          }
-        });
-        isBinding = false;
-        return boundMethod;
-      },
-      set(v) {
-        method = v;
-      }
-    });
-  }
-  return _class;
-};
-
-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;
-}
-
-class Deferred extends Promise {
-  constructor() {
-    Object.defineProperty(Deferred, Symbol.species, {
-      value: Promise
-    });
-    const that = {};
-    super((resolve, reject) => {
-      Object.assign(that, { resolve, reject });
-    });
-    this.resolve = () => undefined;
-    this.reject = () => undefined;
-    Object.assign(this, that);
-  }
-}
-
-function isPromise(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-
-class PromiseWithState extends Promise {
-  constructor(value, state = { status: "pending" }) {
-    super((resolve) => resolve(value));
-    this.state = state;
-    Object.defineProperty(PromiseWithState, Symbol.species, {
-      value: Promise
-    });
-    if (isPromise(value)) {
-      value.then((value2) => {
-        this.state = { status: "value", value: value2 };
-      }).catch((error) => {
-        this.state = { status: "error", error };
-      });
-    } else {
-      this.state = { status: "value", value };
-    }
-  }
-  static resolve(value) {
-    return new PromiseWithState(value);
-  }
-  static reject(error) {
-    return new PromiseWithState(Promise.reject(error), { status: "error", error });
-  }
-}
-
-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 (isPromise(result)) {
-            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 !== undefined);
-      }
-    }
-  );
-}
-
-function calculatedValue(store, notify) {
-  let active = false;
-  const deps = new Array();
-  let value;
-  const whenConnected = new Deferred();
-  const whenExecuted = new Deferred();
-  const ac = new AbortController();
-  let connection;
-  const q = queue();
-  q(() => whenExecuted);
-  const cancelEffect = store.addEffect(() => {
-    if (connection) {
-      store.invalidate();
-      return;
-    }
-    active = true;
-    for (const dep of deps) {
-      dep.on();
-    }
-    return () => {
-      active = false;
-      for (const dep of deps) {
-        dep.off();
-      }
-      if (connection) {
-        connection.active = false;
-        connection.cancel?.();
-        q.clear();
-        if ("state" in store) {
-          store.state.set((state) => ({
-            ...state,
-            isConnected: false,
-            isStale: true
-          }));
-        }
-      }
-    };
-  });
-  function use(dep) {
-    const value2 = dep.get();
-    let cancel;
-    const on = () => {
-      cancel ||= dep.subscribe(() => store.invalidate(), { runNow: false });
-    };
-    const off = () => {
-      cancel?.();
-      cancel = undefined;
-    };
-    deps.push({ store: dep, value: value2, on, off });
-    if (active) {
-      on();
-    }
-    return value2;
-  }
-  async function connect(createConnection) {
-    if (!active) {
-      connection = { active: false };
-      return;
-    }
-    const actions = {
-      set(_value) {
-        q(() => {
-          if (!connection?.active) {
-            return;
-          }
-          value = _value;
-          notify();
-        });
-      },
-      updateValue(update) {
-        q(async () => {
-          if (!connection?.active) {
-            return;
-          }
-          if (update instanceof Function) {
-            const currentValue = await value;
-            if (!connection?.active) {
-              return;
-            }
-            try {
-              update = update(currentValue);
-            } catch (error) {
-              value = PromiseWithState.reject(error);
-              notify();
-              connection.active = false;
-              connection.cancel?.();
-              return;
-            }
-          }
-          value = PromiseWithState.resolve(update);
-          notify();
-        });
-      },
-      updateError(error) {
-        q(() => {
-          if (!connection?.active) {
-            return;
-          }
-          connection.active = false;
-          connection.cancel?.();
-          if ("state" in store) {
-            store.state.set({
-              status: "error",
-              error,
-              isConnected: false,
-              isUpdating: false,
-              isStale: false
-            });
-          }
-          value = PromiseWithState.reject(error);
-          notify();
-        });
-      },
-      updateIsConnected(isConnected) {
-        if (isConnected) {
-          whenConnected.resolve();
-        }
-        q(() => {
-          if (!connection?.active) {
-            return;
-          }
-          if ("state" in store) {
-            store.state.set("isConnected", isConnected);
-          }
-        });
-      },
-      close() {
-        if (connection?.active) {
-          store.invalidate();
-        }
-      }
-    };
-    connection = { active: true };
-    let _cancel = createConnection(actions);
-    connection.cancel = () => {
-      _cancel?.();
-      _cancel = undefined;
-    };
-    if (!connection.active) {
-      connection.cancel();
-    }
-    return whenConnected;
-  }
-  if (store.getter instanceof Function) {
-    try {
-      value = store.getter({ signal: ac.signal, use, connect });
-    } catch (error) {
-      value = PromiseWithState.reject(error);
-      if (connection) {
-        connection.active = false;
-        connection.cancel?.();
-        q.clear();
-      }
-    }
-  } else {
-    value = store.getter;
-  }
-  if (isPromise(value)) {
-    value.finally(() => whenExecuted.resolve()).catch(() => undefined);
-  } else {
-    whenExecuted.resolve();
-  }
-  function check() {
-    for (const dep of deps) {
-      if (!propAccess.deepEqual(dep.store.get(), dep.value)) {
-        store.invalidate();
-        return;
-      }
-    }
-  }
-  function stop() {
-    cancelEffect();
-    whenExecuted.resolve();
-    whenConnected.resolve();
-    ac.abort();
-    if (connection) {
-      connection.active = false;
-      connection.cancel?.();
-      q.clear();
-    }
-  }
-  function invalidateDependencies(recursive) {
-    for (const dep of deps) {
-      dep.store.invalidate(recursive);
-    }
-  }
-  return {
-    get value() {
-      return value;
-    },
-    check,
-    stop,
-    invalidateDependencies
-  };
-}
-function staticValue(value) {
-  return {
-    value,
-    check: () => undefined,
-    stop: () => undefined,
-    invalidateDependencies: () => undefined
-  };
-}
-
-function makeSelector(selector) {
-  if (!selector) {
-    return (x) => x;
-  }
-  if (selector instanceof Function) {
-    return selector;
-  }
-  return (x) => propAccess.get(x, selector);
-}
-
-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 !== undefined ? calcDuration(options.maxWait) : undefined;
-  let run;
-  let timeout;
-  let timeoutStarted;
-  function flush() {
-    if (timeout !== undefined) {
-      clearTimeout(timeout);
-    }
-    run?.();
-  }
-  function cancel() {
-    if (timeout !== undefined) {
-      clearTimeout(timeout);
-    }
-    run = undefined;
-    timeout = undefined;
-    timeoutStarted = undefined;
-  }
-  function isScheduled() {
-    return timeout !== undefined;
-  }
-  function debounce2(...args) {
-    const now = Date.now();
-    timeoutStarted ??= now;
-    const deadline = Math.min(
-      //
-      now + wait,
-      timeoutStarted + (maxWait ?? Number.POSITIVE_INFINITY)
-    );
-    if (timeout !== undefined) {
-      clearTimeout(timeout);
-    }
-    run = () => {
-      run = undefined;
-      timeout = undefined;
-      timeoutStarted = undefined;
-      action(...args);
-    };
-    timeout = setTimeout(run, deadline - now);
-  }
-  return Object.assign(debounce2, { flush, cancel, isScheduled });
-}
-
-function disposable(dispose) {
-  return Object.assign(
-    dispose,
-    Symbol.dispose ? { [Symbol.dispose]: dispose } : {}
-  );
-}
-
-function forwardError(error) {
-  setTimeout(() => {
-    throw error;
-  });
-}
-
-class PromiseCancelError extends Error {
-  constructor() {
-    super("cancelled");
-  }
-}
-class PromiseWithCancel extends Promise {
-  constructor(executor) {
-    autobind(PromiseWithCancel);
-    const abortController = new AbortController();
-    super((resolve, reject) => {
-      executor(resolve, reject, abortController.signal);
-      abortController.signal.addEventListener("abort", () => {
-        reject(abortController.signal.reason);
-      });
-    });
-    this.abortController = abortController;
-  }
-  cancel(reason = new PromiseCancelError()) {
-    this.abortController.abort(reason);
-  }
-}
-
-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 !== undefined) {
-      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 undefined;
-}
-class Store {
-  constructor(getter, options = {}, derivedFrom) {
-    this.getter = getter;
-    this.options = options;
-    this.derivedFrom = derivedFrom;
-    this.listeners = /* @__PURE__ */ new Map();
-    this.effects = /* @__PURE__ */ new Map();
-    this.notifyId = {};
-    autobind(Store);
-    if (typeof getter !== "function") {
-      this.calculatedValue = this.defaultValue = staticValue(getter);
-    }
-    for (const hook of Store.hooks ?? []) {
-      hook.apply(this, [this]);
-    }
-    if (options.effect instanceof Function) {
-      this.addEffect(options.effect);
-    } else if (options.effect) {
-      this.addEffect(options.effect.effect, options.effect.retain);
-    }
-  }
-  static addHook(hook) {
-    this.hooks ??= /* @__PURE__ */ new Set();
-    this.hooks.add(hook);
-    return disposable(() => this.hooks?.delete(hook));
-  }
-  get() {
-    this.calculatedValue?.check();
-    if (!this.calculatedValue) {
-      this.calculatedValue = calculatedValue(this, this.notify);
-    }
-    return this.calculatedValue.value;
-  }
-  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 = propAccess.get(before, path);
-      const valueAfter = update(valueBefore);
-      update = propAccess.set(before, path, valueAfter);
-    } else if (path.length > 0) {
-      update = propAccess.set(this.get(), path, update);
-    }
-    if (this.derivedFrom) {
-      this.derivedFrom.updater(update);
-      return;
-    }
-    this.calculatedValue?.stop();
-    this.calculatedValue = staticValue(update);
-    this.notify();
-  }
-  invalidate(recursive) {
-    if (recursive) {
-      this.calculatedValue?.invalidateDependencies(recursive);
-    }
-    this.calculatedValue?.stop();
-    this.calculatedValue = this.defaultValue;
-    this.notify();
-  }
-  subscribe(listener, options) {
-    const {
-      passive,
-      runNow = true,
-      throttle: throttleOption,
-      debounce: debounceOption,
-      equals = this.options.equals ?? propAccess.deepEqual
-    } = options ?? {};
-    let isSetup = false;
-    let previousValue;
-    let innerListener = () => {
-      if (!isSetup) {
-        return;
-      }
-      const value = passive ? this.calculatedValue : { value: this.get() };
-      if (!value) {
-        return;
-      }
-      if (previousValue && equals(value.value, previousValue.value)) {
-        return;
-      }
-      const _previousValue = previousValue?.value;
-      previousValue = this.calculatedValue && { value: this.calculatedValue?.value };
-      try {
-        listener.apply({ cancel }, [value.value, _previousValue]);
-      } catch (error) {
-        forwardError(error);
-      }
-    };
-    if (throttleOption) {
-      innerListener = throttle(innerListener, throttleOption);
-    } else if (debounceOption) {
-      innerListener = debounce(innerListener, debounceOption);
-    }
-    this.listeners.set(innerListener, !passive);
-    const cancel = () => {
-      if (this.listeners.delete(innerListener) && !passive) {
-        this.onUnsubscribe();
-      }
-    };
-    if (!passive) {
-      this.onSubscribe();
-    }
-    isSetup = true;
-    if (runNow) {
-      innerListener();
-      if (!throttleOption && typeof debounceOption === "object" && "waitOnRunNow" in debounceOption && debounceOption.waitOnRunNow === false && "flush" in innerListener) {
-        innerListener.flush();
-      }
-    } else {
-      previousValue = passive ? this.calculatedValue && { value: this.calculatedValue.value } : { value: this.get() };
-    }
-    return disposable(cancel);
-  }
-  once(...args) {
-    const condition = args[0] instanceof Function ? args[0] : Boolean;
-    const options = args[0] instanceof Function ? args[1] : args[0];
-    return new PromiseWithCancel((resolve, reject, signal) => {
-      let stopped = false;
-      let timer;
-      const cancel = this.subscribe(
-        (value) => {
-          if (stopped || !condition(value)) {
-            return;
-          }
-          resolve(value);
-          stopped = true;
-          if (timer) {
-            clearTimeout(timer);
-          }
-          setTimeout(() => cancel());
-        },
-        {
-          runNow: !!condition
-        }
-      );
-      if (stopped) {
-        return;
-      }
-      signal.addEventListener("abort", cancel);
-      options?.signal?.addEventListener("abort", () => {
-        cancel();
-        reject(options.signal?.reason ?? new Error("cancelled"));
-      });
-      if (options?.timeout !== undefined) {
-        timer = setTimeout(() => {
-          cancel();
-          reject(new Error("timeout"));
-        }, calcDuration(options.timeout));
-      }
-    });
-  }
-  map(_selector, ...args) {
-    const updater = _selector instanceof Function ? args[0] : (value) => (state) => propAccess.set(state, _selector, value);
-    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 update 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));
-      },
-      undefined,
-      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.options.retain) {
-    this.effects.set(effect, {
-      handle: this.isActive() ? effect.apply(this, [this]) ?? noop : undefined,
-      retain: retain !== undefined ? calcDuration(retain) : undefined
-    });
-    return disposable(() => {
-      const { handle, timeout } = this.effects.get(effect) ?? {};
-      handle?.();
-      if (timeout !== undefined) {
-        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 !== undefined) {
-        clearTimeout(timeout);
-      }
-      this.effects.set(effect, {
-        handle: handle ?? effect.apply(this, [this]) ?? noop,
-        retain,
-        timeout: undefined
-      });
-    }
-  }
-  onUnsubscribe() {
-    if ([...this.listeners.values()].some(Boolean)) return;
-    for (const [effect, { handle, retain, timeout }] of this.effects.entries()) {
-      if (!retain) {
-        handle?.();
-        if (timeout !== undefined) {
-          clearTimeout(timeout);
-        }
-        this.effects.set(effect, {
-          handle: undefined,
-          retain,
-          timeout: undefined
-        });
-        continue;
-      }
-      const newTimeout = timeout ?? (handle ? setTimeout(() => {
-        handle();
-        this.effects.set(effect, {
-          handle: undefined,
-          retain,
-          timeout: undefined
-        });
-      }, retain) : undefined);
-      this.effects.set(effect, {
-        handle,
-        retain,
-        timeout: newTimeout
-      });
-    }
-  }
-  notify() {
-    const n = {};
-    this.notifyId = n;
-    const snapshot = [...this.listeners.keys()];
-    for (const listener of snapshot) {
-      listener();
-      if (n !== this.notifyId) break;
-    }
-  }
-}
-function create(initialState, options) {
-  options = { ...createStore.defaultOptions, ...options };
-  const store = new Store(initialState, options);
-  if (initialState instanceof Function) {
-    return store;
-  }
-  let methods = 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 (propAccess.isObject(initialState)) {
-    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: {
-    equals: propAccess.deepEqual
-  }
-});
-
-exports.PromiseWithState = PromiseWithState;
-exports.Store = Store;
-exports.arrayMethods = arrayMethods;
-exports.autobind = autobind;
-exports.calcDuration = calcDuration;
-exports.calculatedValue = calculatedValue;
-exports.createStore = createStore;
-exports.debounce = debounce;
-exports.disposable = disposable;
-exports.isPromise = isPromise;
-exports.makeSelector = makeSelector;
-exports.mapMethods = mapMethods;
-exports.queue = queue;
-exports.recordMethods = recordMethods;
-exports.setMethods = setMethods;
-exports.throttle = throttle;
-//# sourceMappingURL=store.cjs.map