cross-state 0.33.2 → 0.33.5

package/dist/es/store.mjs

@@ -44,55 +44,20 @@ function calcDuration(t) {
     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 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)));
+class Deferred extends Promise {
+  constructor() {
+    const that = {};
+    super((resolve, reject) => {
+      Object.assign(that, { resolve, reject });
+    });
+    this.resolve = () => void 0;
+    this.reject = () => void 0;
+    Object.assign(this, that);
   }
-  if (a instanceof Set) {
-    return a.size === b.size && [...a.values()].every((value) => b.has(value));
+  static get [Symbol.species]() {
+    return Promise;
   }
-  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 queue() {
   const q = [];
   const completionListeners = /* @__PURE__ */ new Set();
@@ -150,219 +115,214 @@ function queue() {
     }
   );
 }
-class CalculationHelper {
-  constructor(options) {
-    this.options = options;
-    options.addEffect(() => {
-      if (this.current) {
-        this.current.check();
-      } else {
-        this.execute();
-      }
+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;
+};
+class PromiseWithState extends Promise {
+  constructor(value, state = { status: "pending" }) {
+    super((resolve) => resolve(value));
+    this.state = state;
+    value.then((value2) => {
+      this.state = { status: "value", value: value2 };
+    }).catch((error) => {
+      this.state = { status: "error", error };
     });
   }
-  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();
-        }
-      };
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  static resolve(value) {
+    return new PromiseWithState(Promise.resolve(value), {
+      status: "value",
+      value
     });
-    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();
+  }
+  static reject(error) {
+    return new PromiseWithState(Promise.reject(error), { status: "error", error });
+  }
+}
+function calculatedValue(store, notify) {
+  let active = false;
+  const deps = new Array();
+  let value;
+  const whenConnected = new Deferred();
+  const whenExecuted = new Deferred();
+  let cancelConnection;
+  const q = queue();
+  q(() => whenExecuted);
+  const cancelEffect = store.addEffect(() => {
+    if (cancelConnection) {
+      store.invalidate();
+      return;
+    }
+    active = true;
+    for (const dep of deps) {
+      dep.on();
+    }
+    return () => {
+      active = false;
+      for (const dep of deps) {
+        dep.off();
       }
-    };
-    const invalidateDependencies = () => {
-      for (const dep of deps.values()) {
-        dep.invalidate();
+      cancelConnection == null ? void 0 : cancelConnection();
+      if ("state" in store) {
+        store.state.set("isConnected", false);
       }
     };
-    const use = (store) => {
-      if (isCancled) {
-        return store.get();
-      }
-      const value = store.get();
-      const equals = (newValue) => {
-        return deepEqual(newValue, 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;
+  });
+  function use(dep) {
+    const value2 = dep.get();
+    let cancel;
+    const on = () => {
+      cancel || (cancel = dep.subscribe(() => store.invalidate(), { runNow: false }));
     };
-    const updateValue = (update) => q(async () => {
-      if (isCancled) {
-        return;
-      }
-      if (update instanceof Function) {
-        try {
-          update = update(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);
+    const off = () => {
+      cancel == null ? void 0 : cancel();
+      cancel = void 0;
+    };
+    deps.push({ store: dep, value: value2, on, off });
+    if (active) {
+      on();
+    }
+    return value2;
+  }
+  async function connect(connection) {
+    if (!active) {
+      return;
+    }
+    const actions = {
+      set(value2) {
+        q(() => {
+          store.set(value2);
+        });
+      },
+      updateValue(update) {
+        q(async () => {
+          if (update instanceof Function) {
+            update = update(await value);
+          }
+          if (update instanceof Promise) {
+            update = await update;
           }
-          return;
+          value = PromiseWithState.resolve(update);
+          notify();
+        });
+      },
+      updateError(error) {
+        q(() => {
+          store.set(Promise.reject(error));
+        });
+      },
+      updateIsConnected(isConnected) {
+        if (isConnected) {
+          whenConnected.resolve();
         }
+        q(() => {
+          if ("state" in store) {
+            store.state.set("isConnected", isConnected);
+          }
+        });
+      },
+      close() {
+        store.invalidate();
       }
-      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 };
+    };
+    cancelConnection = connection(actions);
+    return whenConnected;
   }
-  stop() {
-    var _a;
-    (_a = this.current) == null ? void 0 : _a.cancel();
+  value = store.getter instanceof Function ? store.getter({ use, connect }) : store.getter;
+  if (value instanceof Promise) {
+    value.finally(() => whenExecuted.resolve()).catch(() => void 0);
   }
-  check() {
-    var _a;
-    (_a = this.current) == null ? void 0 : _a.check();
-  }
-  checkOrExecute() {
-    if (this.current) {
-      this.check();
-    } else {
-      this.execute();
+  function check() {
+    if (active) {
+      return;
     }
-  }
-  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 run;
-  let timeout;
-  let timeoutStarted;
-  function flush() {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
+    for (const dep of deps) {
+      if (!deepEqual(dep.store.get(), dep.value)) {
+        store.invalidate();
+        return;
+      }
     }
-    run == null ? void 0 : run();
   }
-  function cancel() {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
+  function stop() {
+    cancelEffect();
+    cancelConnection == null ? void 0 : cancelConnection();
+    if (cancelConnection) {
+      whenConnected.reject();
+      whenExecuted.reject();
+    } else {
+      whenConnected.resolve();
+      whenExecuted.resolve();
     }
-    run = void 0;
-    timeout = void 0;
-    timeoutStarted = void 0;
   }
-  function isScheduled() {
-    return timeout !== void 0;
-  }
-  function debounce2(...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);
+  function invalidateDependencies(recursive) {
+    for (const dep of deps) {
+      dep.store.invalidate(recursive);
     }
-    run = () => {
-      run = void 0;
-      timeout = void 0;
-      timeoutStarted = void 0;
-      action(...args);
-    };
-    timeout = setTimeout(run, deadline - now);
   }
-  return Object.assign(debounce2, { flush, cancel, isScheduled });
+  return {
+    get value() {
+      return value;
+    },
+    check,
+    stop,
+    invalidateDependencies
+  };
 }
-function forwardError(error) {
-  setTimeout(() => {
-    throw error;
-  });
+function staticValue(value) {
+  return {
+    value,
+    check: () => void 0,
+    stop: () => void 0,
+    invalidateDependencies: () => void 0
+  };
 }
 function flatClone(object) {
   if (object instanceof Map) {
@@ -468,6 +428,83 @@ function makeSelector(selector) {
   }
   return (x) => get(x, selector);
 }
+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 run;
+  let timeout;
+  let timeoutStarted;
+  function flush() {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    run == null ? void 0 : run();
+  }
+  function cancel() {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    run = void 0;
+    timeout = void 0;
+    timeoutStarted = void 0;
+  }
+  function isScheduled() {
+    return timeout !== void 0;
+  }
+  function debounce2(...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);
+    }
+    run = () => {
+      run = void 0;
+      timeout = void 0;
+      timeoutStarted = void 0;
+      action(...args);
+    };
+    timeout = setTimeout(run, deadline - now);
+  }
+  return Object.assign(debounce2, { flush, cancel, isScheduled });
+}
+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", (e) => {
+        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();
@@ -541,26 +578,11 @@ function throttle(action, duration) {
     }, dt);
   };
 }
-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", (e) => {
-        reject(abortController.signal.reason);
-      });
-    });
-    this.abortController = abortController;
-  }
-  cancel(reason = new PromiseCancelError()) {
-    this.abortController.abort(reason);
-  }
+function disposable(dispose) {
+  return Object.assign(
+    dispose,
+    Symbol.dispose ? { [Symbol.dispose]: dispose } : {}
+  );
 }
 function noop() {
   return void 0;
@@ -575,35 +597,18 @@ class Store extends Callable {
     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()
-    });
     autobind(Store);
-    if (!(getter instanceof Function)) {
-      this._value = { v: getter };
-    }
   }
   get() {
-    this.calculationHelper.check();
-    if (!this._value) {
-      this.calculationHelper.execute();
-      return this.get();
+    var _a;
+    (_a = this.calculatedValue) == null ? void 0 : _a.check();
+    if (!this.calculatedValue) {
+      this.calculatedValue = calculatedValue(this, this.notify);
     }
-    return this._value.v;
+    return this.calculatedValue.value;
   }
   set(...args) {
+    var _a;
     const path = args.length > 1 ? args[0] : [];
     let update = args.length > 1 ? args[1] : args[0];
     if (update instanceof Function) {
@@ -618,17 +623,20 @@ class Store extends Callable {
       this.derivedFrom.updater(update);
       return;
     }
-    this._value = { v: update };
+    (_a = this.calculatedValue) == null ? void 0 : _a.stop();
+    this.calculatedValue = staticValue(update);
     this.notify();
   }
-  reset() {
-    this._value = void 0;
-    if (this.isActive()) {
-      this.calculationHelper.execute();
+  invalidate(recursive) {
+    var _a, _b;
+    if (recursive) {
+      (_a = this.calculatedValue) == null ? void 0 : _a.invalidateDependencies(recursive);
     }
+    (_b = this.calculatedValue) == null ? void 0 : _b.stop();
+    this.calculatedValue = void 0;
+    this.notify();
   }
   subscribe(listener, options) {
-    var _a;
     const {
       passive,
       runNow = true,
@@ -636,22 +644,20 @@ class Store extends Callable {
       debounce: debounceOption,
       equals = deepEqual
     } = options ?? {};
-    let compareToValue = (_a = this._value) == null ? void 0 : _a.v;
     let previousValue;
-    let isInitializing = true;
-    let innerListener = (force) => {
-      if (!this._value) {
+    let innerListener = () => {
+      var _a;
+      const value = passive ? this.calculatedValue : { value: this.get() };
+      if (!value) {
         return;
       }
-      const value = this._value.v;
-      if (!force && (isInitializing || equals(value, compareToValue))) {
+      if (previousValue && equals(value.value, previousValue.value)) {
         return;
       }
-      compareToValue = value;
-      const _previousValue = previousValue;
-      previousValue = value;
+      const _previousValue = previousValue == null ? void 0 : previousValue.value;
+      previousValue = this.calculatedValue && { value: (_a = this.calculatedValue) == null ? void 0 : _a.value };
       try {
-        listener(value, _previousValue);
+        listener(value.value, _previousValue);
       } catch (error) {
         forwardError(error);
       }
@@ -666,15 +672,16 @@ class Store extends Callable {
       this.onSubscribe();
     }
     if (runNow) {
-      innerListener(true);
+      innerListener();
+    } else {
+      previousValue = passive ? this.calculatedValue && { value: this.calculatedValue.value } : { value: this.get() };
     }
-    isInitializing = false;
-    return () => {
+    return disposable(() => {
       this.listeners.delete(innerListener);
       if (!passive) {
         this.onUnsubscribe();
       }
-    };
+    });
   }
   once(...args) {
     const condition = args[0] instanceof Function ? args[0] : Boolean;
@@ -755,7 +762,7 @@ class Store extends Callable {
    * @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) {
+  addEffect(effect, retain = this.options.retain) {
     this.effects.set(effect, {
       handle: this.isActive() ? effect() ?? noop : void 0,
       retain: retain !== void 0 ? calcDuration(retain) : void 0
@@ -829,8 +836,8 @@ class Store extends Callable {
     }
   }
 }
-const defaultOptions = {};
 function create(initialState, options) {
+  options = { ...createStore.defaultOptions, ...options };
   const store = new Store(initialState, options);
   if (initialState instanceof Function) {
     return store;
@@ -850,23 +857,29 @@ function create(initialState, options) {
   );
   return Object.assign(store, boundMethods);
 }
-const createStore = /* @__PURE__ */ Object.assign(create, { defaultOptions });
+const createStore = /* @__PURE__ */ Object.assign(create, {
+  defaultOptions: {
+    retain: { seconds: 1 }
+  }
+});
 export {
+  PromiseWithState as P,
   Store as S,
   autobind as a,
-  calcDuration as b,
+  calculatedValue as b,
   createStore as c,
-  deepEqual as d,
-  castArrayPath as e,
-  shallowEqual as f,
-  get as g,
-  arrayMethods as h,
-  mapMethods as i,
-  recordMethods as j,
-  setMethods as k,
-  debounce as l,
+  calcDuration as d,
+  deepEqual as e,
+  castArrayPath as f,
+  shallowEqual as g,
+  get as h,
+  arrayMethods as i,
+  mapMethods as j,
+  recordMethods as k,
+  setMethods as l,
   makeSelector as m,
-  join as n,
+  debounce as n,
+  join as o,
   queue as q,
   remove as r,
   set as s,