cross-state 0.6.10 → 0.7.1

package/dist/cjs/index.cjs

@@ -1,295 +1,81 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const hash = require("./hash.cjs");
-class ResourceGroup {
-  constructor(name) {
-    this.name = name;
-    this.refMap = /* @__PURE__ */ new WeakMap();
-    this.refSet = /* @__PURE__ */ new Set();
-    this.add = this.add.bind(this);
-    this.delete = this.delete.bind(this);
-    this.invalidateAll = this.invalidateAll.bind(this);
-    this.clearAll = this.clearAll.bind(this);
-  }
-  add(resource) {
-    const ref = new WeakRef(resource);
-    this.refMap.set(resource, ref);
-    this.refSet.add(ref);
-  }
-  delete(resource) {
-    const ref = this.refMap.get(resource);
-    if (ref) {
-      this.refMap.delete(resource);
-      this.refSet.delete(ref);
-    }
-  }
-  invalidateAll() {
-    for (const ref of this.refSet) {
-      const resource = ref.deref();
-      if (resource) {
-        resource.invalidate();
-      } else {
-        this.refSet.delete(ref);
-      }
-    }
-  }
-  clearAll() {
-    for (const ref of this.refSet) {
-      const resource = ref.deref();
-      if (resource) {
-        resource.clear();
-      } else {
-        this.refSet.delete(ref);
-      }
-    }
-  }
-}
-const allResources = /* @__PURE__ */ new ResourceGroup();
-function createResourceGroup(name) {
-  return new ResourceGroup(name);
-}
-class InstanceCache {
-  constructor(factory, cacheTime) {
-    this.factory = factory;
-    this.cacheTime = cacheTime;
-    this.cache = /* @__PURE__ */ new Map();
-    this.interval = this.cacheTime ? setInterval(() => this.cleanup(), Math.max(this.cacheTime / 10, 1)) : void 0;
-  }
-  cleanup() {
-    var _a;
-    const cutoff = this.now() - (this.cacheTime ?? 0);
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.ref && entry.t <= cutoff) {
-        delete entry.ref;
-      }
-      if (!entry.ref && !((_a = entry.weakRef) == null ? void 0 : _a.deref())) {
-        this.cache.delete(key);
-      }
-    }
-  }
-  get(...args) {
-    var _a;
-    const key = hash.hash(args);
-    let entry = this.cache.get(key);
-    let value = (entry == null ? void 0 : entry.ref) ?? ((_a = entry == null ? void 0 : entry.weakRef) == null ? void 0 : _a.deref());
-    if (!entry || !value) {
-      value = this.factory(...args);
-      entry = {
-        t: this.now(),
-        ref: value,
-        weakRef: new WeakRef(value)
-      };
-      this.cache.set(key, entry);
-    } else {
-      entry.t = this.now();
-      entry.ref ?? (entry.ref = value);
-    }
-    return value;
-  }
-  values() {
-    return [...this.cache.values()].map((entry) => {
-      var _a;
-      return entry.ref ?? ((_a = entry.weakRef) == null ? void 0 : _a.deref());
-    }).filter((value) => !!value);
-  }
-  stop() {
-    if (this.interval) {
-      clearInterval(this.interval);
-    }
-  }
-  stats() {
-    return {
-      count: this.cache.size,
-      withRef: [...this.cache.values()].filter((x) => !!x.ref).length,
-      withWeakRef: [...this.cache.values()].filter((x) => {
-        var _a;
-        return !!((_a = x.weakRef) == null ? void 0 : _a.deref());
-      }).length
-    };
-  }
-  now() {
-    return performance.now();
-  }
-}
-class Cache extends hash.Store {
-  constructor(getter, options = {}, derivedFromCache, _call) {
-    super(getter, options, void 0, _call);
+const store = require("./store.cjs");
+const scope = require("./scope.cjs");
+require("./hash.cjs");
+class SubstriptionCache extends store.Store {
+  constructor(connectFunction, options = {}, derivedFromSubscriptionCache, _call) {
+    super(void 0, options, void 0, _call);
+    this.connectFunction = connectFunction;
     this.options = options;
-    this.derivedFromCache = derivedFromCache;
-    this.state = hash.createStore({
-      status: "pending",
-      isStale: true,
-      isUpdating: false
+    this.derivedFromSubscriptionCache = derivedFromSubscriptionCache;
+    this.state = store.createStore({
+      connectionState: "closed",
+      error: void 0
     });
-    this.invalidate = this.invalidate.bind(this);
-    this.clear = this.clear.bind(this);
-    this.mapValue = this.mapValue.bind(this);
-    this.watchPromise();
-    this.watchFocus();
-  }
-  get({ update = "whenStale", backgroundUpdate = false } = {}) {
-    var _a;
-    const promise = (_a = this._value) == null ? void 0 : _a.v;
-    const stalePromise = this.stalePromise;
-    if (update === "whenMissing" && !promise && !stalePromise || update === "whenStale" && !promise || update === "force") {
-      this.calculationHelper.execute();
-      if (!promise && !stalePromise || !backgroundUpdate) {
-        return super.get();
+    this.calculationHelper.options = {
+      ...this.calculationHelper.options,
+      calculate: (helpers) => {
+        let result = connectFunction.apply(helpers);
+        if (result instanceof Function && result.length > 0) {
+          result = result(helpers);
+        }
+        return result;
+      },
+      onValue: (value) => {
+        this.set(value);
+      },
+      onError: (error) => {
+        this.state.set("error", error);
+      },
+      onConnectionState: (state) => {
+        this.state.set("connectionState", state);
+      },
+      onInvalidate: () => {
+        this.invalidate();
       }
-    }
-    if (!promise || stalePromise && backgroundUpdate) {
-      return stalePromise;
-    }
-    return promise;
+    };
   }
   invalidate({ invalidateDependencies = true } = {}) {
-    var _a;
-    const { clearOnInvalidate: clearOnInvalidation = defaultOptions.clearOnInvalidate } = this.options;
-    if (clearOnInvalidation) {
+    const { clearOnInvalidate = defaultOptions.clearOnInvalidate } = this.options;
+    if (clearOnInvalidate) {
       return this.clear({ invalidateDependencies });
     }
     if (invalidateDependencies) {
       this.calculationHelper.invalidateDependencies();
     }
-    const { status, isStale, isUpdating } = this.state.get();
-    if (status !== "pending" && !isStale && !isUpdating) {
-      this.stalePromise = (_a = this._value) == null ? void 0 : _a.v;
+    this.calculationHelper.stop();
+    if (this.isActive()) {
+      this.calculationHelper.execute();
     }
-    this.state.set((state) => ({
-      ...state,
-      isStale: true,
-      isUpdating: false
-    }));
-    super.reset();
   }
   clear({ invalidateDependencies = true } = {}) {
     if (invalidateDependencies) {
       this.calculationHelper.invalidateDependencies();
     }
-    this.state.set({
-      status: "pending",
-      isStale: true,
-      isUpdating: false
-    });
-    delete this.stalePromise;
-    super.reset();
-  }
-  mapValue(_selector) {
-    const selector = hash.makeSelector(_selector);
-    const derivedFromCache = {
-      cache: this.derivedFromCache ? this.derivedFromCache.cache : this,
-      selectors: this.derivedFromCache ? [...this.derivedFromCache.selectors, _selector] : [_selector]
-    };
-    const that = this;
-    return new Cache(
-      async function() {
-        const value = await this.use(that);
-        return selector(value);
-      },
-      {},
-      derivedFromCache
-    );
-  }
-  watchPromise() {
-    this.sub(
-      async (promise) => {
-        var _a, _b;
-        this.state.set((state) => ({
-          ...state,
-          isUpdating: true
-        }));
-        this.setTimers();
-        try {
-          const value = await promise;
-          if (promise !== ((_a = this._value) == null ? void 0 : _a.v)) {
-            return;
-          }
-          this.state.set({
-            status: "value",
-            value,
-            isStale: false,
-            isUpdating: false
-          });
-          delete this.stalePromise;
-          this.setTimers();
-        } catch (error) {
-          if (promise !== ((_b = this._value) == null ? void 0 : _b.v)) {
-            return;
-          }
-          this.state.set({
-            status: "error",
-            error,
-            isStale: false,
-            isUpdating: false
-          });
-          delete this.stalePromise;
-          this.setTimers();
-        }
-      },
-      { passive: true }
-    );
-  }
-  setTimers() {
-    if (this.invalidationTimer) {
-      clearTimeout(this.invalidationTimer);
-    }
-    this.invalidationTimer = void 0;
-    const state = this.state.get();
-    let { invalidateAfter = defaultOptions.invalidateAfter } = this.options;
-    const ref = new WeakRef(this);
-    if (state.status === "pending") {
-      return;
-    }
-    if (invalidateAfter instanceof Function) {
-      invalidateAfter = invalidateAfter(state);
-    }
-    if (invalidateAfter !== null && invalidateAfter !== void 0) {
-      this.invalidationTimer = setTimeout(
-        () => {
-          var _a;
-          return (_a = ref == null ? void 0 : ref.deref()) == null ? void 0 : _a.invalidate();
-        },
-        hash.calcDuration(invalidateAfter)
-      );
-    }
-  }
-  watchFocus() {
-    const { invalidateOnWindowFocus = defaultOptions.invalidateOnWindowFocus } = this.options;
-    if (!invalidateOnWindowFocus || typeof document === "undefined" || typeof document.addEventListener === "undefined") {
-      return;
+    this.calculationHelper.stop();
+    if (this.isActive()) {
+      this.calculationHelper.execute();
     }
-    const ref = new WeakRef(this);
-    const onFocus = () => {
-      const that = ref == null ? void 0 : ref.deref();
-      if (!that) {
-        document.removeEventListener("visibilitychange", onFocus);
-        return;
-      }
-      if (!document.hidden) {
-        that.invalidate();
-      }
-    };
-    document.addEventListener("visibilitychange", onFocus);
   }
 }
 const defaultOptions = {
-  invalidateOnWindowFocus: true,
-  invalidateOnActivation: true,
-  clearUnusedAfter: { days: 1 }
+  clearUnusedAfter: { days: 1 },
+  retain: { seconds: 1 }
 };
 function create(cacheFunction, options) {
   const { clearUnusedAfter = defaultOptions.clearUnusedAfter, resourceGroup } = options ?? {};
   let baseInstance;
-  const instanceCache = new InstanceCache(
+  const instanceCache = new scope.InstanceCache(
     (...args) => {
       if (args.length === 0 && baseInstance) {
         return baseInstance;
       }
-      return new Cache(function() {
+      return new SubstriptionCache(function() {
         return cacheFunction.apply(this, args);
       }, options);
     },
-    clearUnusedAfter ? hash.calcDuration(clearUnusedAfter) : void 0
+    clearUnusedAfter ? store.calcDuration(clearUnusedAfter) : void 0
   );
   const get = (...args) => {
     return instanceCache.get(...args);
@@ -304,12 +90,8 @@ function create(cacheFunction, options) {
       instance.clear();
     }
   };
-  const groups = Array.isArray(resourceGroup) ? resourceGroup : resourceGroup ? [resourceGroup] : [];
-  for (const group of groups.concat(allResources)) {
-    group.add({ invalidate: invalidateAll, clear: clearAll });
-  }
   baseInstance = Object.assign(
-    new Cache(
+    new SubstriptionCache(
       function() {
         return cacheFunction.apply(this);
       },
@@ -322,23 +104,350 @@ function create(cacheFunction, options) {
       clearAll
     }
   );
+  const groups = Array.isArray(resourceGroup) ? resourceGroup : resourceGroup ? [resourceGroup] : [];
+  for (const group of groups.concat(scope.allResources)) {
+    group.add(baseInstance);
+  }
   get(...[]);
   return baseInstance;
 }
-const createCache = /* @__PURE__ */ Object.assign(create, {
+const createSubscriptionCache = /* @__PURE__ */ Object.assign(create, {
   defaultOptions
 });
-exports.Store = hash.Store;
-exports.arrayMethods = hash.arrayMethods;
-exports.calcDuration = hash.calcDuration;
-exports.createStore = hash.createStore;
-exports.mapMethods = hash.mapMethods;
-exports.recordMethods = hash.recordMethods;
-exports.setMethods = hash.setMethods;
-exports.Cache = Cache;
-exports.InstanceCache = InstanceCache;
-exports.ResourceGroup = ResourceGroup;
-exports.allResources = allResources;
-exports.createCache = createCache;
-exports.createResourceGroup = createResourceGroup;
+class UrlStore extends store.Store {
+  constructor(options) {
+    super(() => {
+      const url = new URL(window.location.href);
+      const parameters = new URLSearchParams(url[options.type].slice(1));
+      const urlValue = parameters.get(options.key);
+      const deserialize = options.deserialize ?? defaultDeserializer;
+      return urlValue !== null ? deserialize(urlValue) : options.defaultValue;
+    });
+    this.options = options;
+    this.serializedDefaultValue = this.options.serialize(this.options.defaultValue);
+    this.addEffect(() => this.watchUrl());
+  }
+  set(...args) {
+    super.set.apply(this, args);
+    this.updateUrl(super.get());
+  }
+  watchUrl() {
+    const originalPushState = window.history.pushState;
+    const originalReplaceState = window.history.replaceState;
+    window.history.pushState = (...args) => {
+      originalPushState.apply(window.history, args);
+      this.reset();
+    };
+    window.history.replaceState = (...args) => {
+      originalReplaceState.apply(window.history, args);
+      this.reset();
+    };
+    return () => {
+      window.history.pushState = originalPushState;
+      window.history.replaceState = originalReplaceState;
+    };
+  }
+  updateUrl(value) {
+    var _a, _b;
+    const url = new URL(window.location.href);
+    const parameters = new URLSearchParams(url[this.options.type].slice(1));
+    const serializedValue = value !== void 0 ? this.options.serialize(value) : void 0;
+    if (serializedValue === void 0 || serializedValue === this.serializedDefaultValue) {
+      parameters.delete(this.options.key);
+    } else {
+      parameters.set(this.options.key, serializedValue);
+    }
+    url[this.options.type] = parameters.toString();
+    window.history.replaceState(null, "", url.toString());
+    (_b = (_a = this.options).onCommit) == null ? void 0 : _b.call(_a, value);
+  }
+}
+function defaultDeserializer(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value, (_k, v) => {
+      if (typeof v === "object" && v !== null && "__set" in v) {
+        return new Set(v.__set);
+      }
+      if (typeof v === "object" && v !== null && "__map" in v) {
+        return new Map(v.__map);
+      }
+      return v;
+    });
+  } catch {
+    return void 0;
+  }
+}
+function defaultSerializer(value) {
+  return JSON.stringify(value, (_k, v) => {
+    if (v instanceof Set) {
+      return { __set: Array.from(v) };
+    }
+    if (v instanceof Map) {
+      return { __map: Array.from(v) };
+    }
+    return v;
+  });
+}
+function createUrlStore(options) {
+  return new UrlStore({
+    ...options,
+    type: options.type ?? "search",
+    serialize: options.serialize ?? defaultSerializer,
+    deserialize: options.deserialize ?? defaultDeserializer,
+    defaultValue: options.defaultValue ?? void 0
+  });
+}
+function findOrDefault(array, predicate, defaultValue) {
+  const index = array.findIndex(predicate);
+  if (index >= 0) {
+    return array[index];
+  }
+  const value = defaultValue instanceof Function ? defaultValue() : defaultValue;
+  array.push(value);
+  return value;
+}
+const isAncestor = (ancestor, path) => {
+  return ancestor.length <= path.length && ancestor.every((v, i) => v === "*" || path[i] === "*" || v === path[i]);
+};
+function maybeAsync(value, action) {
+  if (value instanceof Promise) {
+    return value.then(action);
+  }
+  return action(value);
+}
+function maybeAsyncArray(values) {
+  const run = (remainingValues, results) => {
+    const [first, ...rest] = remainingValues;
+    if (!first) {
+      return results;
+    }
+    return maybeAsync(first(), (result) => run(rest, results.concat(result)));
+  };
+  return run(values, []);
+}
+function normalizeStorage(storage) {
+  return {
+    getItem: storage.getItem.bind(storage),
+    setItem: storage.setItem.bind(storage),
+    removeItem: storage.removeItem.bind(storage),
+    keys() {
+      if ("keys" in storage) {
+        return storage.keys();
+      }
+      return maybeAsync(
+        storage.length instanceof Function ? storage.length() : storage.length,
+        (length) => {
+          const keyPromises = maybeAsyncArray(
+            Array.from({ length }, (_, index) => () => storage.key(index))
+          );
+          return maybeAsync(
+            keyPromises,
+            (keys) => keys.filter((key) => typeof key === "string")
+          );
+        }
+      );
+    }
+  };
+}
+function diff(a, b) {
+  const result = [..._diff(a, b)];
+  const patches = result.map(([patch]) => patch);
+  const reversePatches = result.map(([, reversePatch]) => reversePatch);
+  return [patches, reversePatches];
+}
+function* _diff(a, b, prefix = []) {
+  if (a === b) {
+    return;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    return yield* mapDiff(a, b, prefix);
+  }
+  if (a instanceof Set && b instanceof Set) {
+    a = [...a];
+    b = [...b];
+  }
+  if (a instanceof Object && b instanceof Object && Array.isArray(a) === Array.isArray(b)) {
+    return yield* objectDiff(a, b, prefix);
+  }
+  yield [
+    { op: "replace", path: prefix, value: b },
+    { op: "replace", path: prefix, value: a }
+  ];
+}
+function* mapDiff(a, b, prefix) {
+  for (const [key, value] of a) {
+    if (!b.has(key)) {
+      yield [
+        { op: "remove", path: [...prefix, key] },
+        { op: "add", path: [...prefix, key], value }
+      ];
+    } else {
+      yield* _diff(value, b.get(key), [...prefix, key]);
+    }
+  }
+  for (const [key, value] of b) {
+    if (!a.has(key)) {
+      yield [
+        { op: "add", path: [...prefix, key], value },
+        { op: "remove", path: [...prefix, key] }
+      ];
+    }
+  }
+}
+function* objectDiff(a, b, prefix) {
+  const castKey = (key) => Array.isArray(a) ? Number(key) : key;
+  for (const [key, value] of Object.entries(a)) {
+    if (!(key in b)) {
+      yield [
+        { op: "remove", path: [...prefix, castKey(key)] },
+        { op: "add", path: [...prefix, castKey(key)], value }
+      ];
+    } else {
+      yield* _diff(value, b[key], [...prefix, castKey(key)]);
+    }
+  }
+  for (const [key, value] of Object.entries(b)) {
+    if (!(key in a)) {
+      yield [
+        { op: "add", path: [...prefix, castKey(key)], value },
+        { op: "remove", path: [...prefix, castKey(key)] }
+      ];
+    }
+  }
+}
+class Persist {
+  constructor(store$1, options) {
+    this.store = store$1;
+    this.options = options;
+    this.queue = store.queue();
+    this.handles = /* @__PURE__ */ new Set();
+    this.stopped = false;
+    this.storage = normalizeStorage(options.storage);
+    this.channel = new BroadcastChannel(`cross-state-persist_${options.id}`);
+    this.paths = (options.paths ?? []).map(
+      (p) => typeof p === "string" || Array.isArray(p) ? {
+        path: store.castArrayPath(p)
+      } : {
+        path: store.castArrayPath(p.path),
+        throttleMs: p.throttleMs
+      }
+    ).sort((a, b) => b.path.length - a.path.length);
+    if (this.paths.length === 0) {
+      this.paths.push({ path: ["*"] });
+    }
+    this.watchStore();
+    this.watchStorage();
+  }
+  watchStore() {
+    let committed = this.store.get();
+    const cancel = this.store.subscribe(
+      (value) => {
+        const [patches] = diff(committed, value);
+        committed = value;
+        for (const patch of patches) {
+          if (this.updateInProgress && store.shallowEqual(this.updateInProgress[0], patch.path) && this.updateInProgress[1] === (patch.op === "remove" ? void 0 : patch.value)) {
+            continue;
+          }
+          const ancestor = this.paths.find((p) => isAncestor(p.path, patch.path));
+          if (!ancestor) {
+            continue;
+          }
+          const pathToSave = patch.path.slice(0, ancestor.path.length);
+          this.queue(() => this.save(pathToSave), pathToSave);
+        }
+      },
+      { runNow: false }
+    );
+    this.handles.add(cancel);
+  }
+  async watchStorage() {
+    let keys = this.storage.keys();
+    if (keys instanceof Promise) {
+      keys = await keys;
+    }
+    if (this.stopped) {
+      return;
+    }
+    for (const key of keys) {
+      const path = JSON.parse(key);
+      this.queue(() => this.load(path));
+    }
+    const listener = (event) => {
+      this.queue(() => this.load(event.data));
+    };
+    this.channel.addEventListener("message", listener);
+    this.handles.add(() => this.channel.removeEventListener("message", listener));
+  }
+  load(path) {
+    const matchingPath = this.paths.find(
+      (p) => p.path.length === path.length && isAncestor(p.path, path)
+    );
+    if (!matchingPath) {
+      return;
+    }
+    const key = JSON.stringify(path);
+    return maybeAsync(this.storage.getItem(key), (value) => {
+      if (this.stopped || !value) {
+        return;
+      }
+      const inSaveQueue = this.queue.getRefs().find((ref) => isAncestor(ref, path) || isAncestor(path, ref));
+      if (inSaveQueue) {
+        return;
+      }
+      const parsedValue = value === "undefined" ? void 0 : JSON.parse(value);
+      this.updateInProgress = [path, parsedValue];
+      this.store.set((state) => store.set(state, path, parsedValue));
+      this.updateInProgress = void 0;
+    });
+  }
+  save(path) {
+    const key = JSON.stringify(path);
+    const value = store.get(this.store.get(), path);
+    const serializedValue = value === void 0 ? "undefined" : JSON.stringify(value);
+    return maybeAsync(this.storage.setItem(key, serializedValue), () => {
+      this.channel.postMessage(path);
+      return maybeAsync(this.storage.keys(), (keys) => {
+        const toRemove = keys.filter((k) => {
+          const parsedKey = JSON.parse(k);
+          return parsedKey.length > path.length && isAncestor(path, parsedKey);
+        });
+        return maybeAsyncArray(toRemove.map((k) => () => this.storage.removeItem(k)));
+      });
+    });
+  }
+  async stop() {
+    this.stopped = true;
+    for (const handle of this.handles) {
+      handle();
+    }
+    await this.queue.whenDone();
+    this.channel.close();
+  }
+}
+function persist(store2, options) {
+  return new Persist(store2, options);
+}
+exports.Store = store.Store;
+exports.arrayMethods = store.arrayMethods;
+exports.calcDuration = store.calcDuration;
+exports.createStore = store.createStore;
+exports.mapMethods = store.mapMethods;
+exports.recordMethods = store.recordMethods;
+exports.setMethods = store.setMethods;
+exports.Cache = scope.Cache;
+exports.InstanceCache = scope.InstanceCache;
+exports.ResourceGroup = scope.ResourceGroup;
+exports.Scope = scope.Scope;
+exports.allResources = scope.allResources;
+exports.createCache = scope.createCache;
+exports.createResourceGroup = scope.createResourceGroup;
+exports.createScope = scope.createScope;
+exports.SubstriptionCache = SubstriptionCache;
+exports.createSubscriptionCache = createSubscriptionCache;
+exports.createUrlStore = createUrlStore;
+exports.findOrDefault = findOrDefault;
+exports.persist = persist;
 //# sourceMappingURL=index.cjs.map