@fluixi/reactive 1.0.0-alpha.100

package/dist/lib/signal/cached-resource.cjs

@@ -0,0 +1,726 @@
+/*! @fluixi/reactive v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/signal/cached-resource.ts
+var cached_resource_exports = {};
+__export(cached_resource_exports, {
+  cachedResource: () => cachedResource,
+  clearCachedResources: () => clearCachedResources,
+  createResourceCache: () => createResourceCache
+});
+module.exports = __toCommonJS(cached_resource_exports);
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+var currentScope;
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin, scope: report.scope ?? currentScope } : { ...report, scope: report.scope ?? currentScope }
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/signal/graph/core.ts
+var CLEAN = 0;
+var CHECK = 1;
+var DIRTY = 2;
+var Source = class {
+  constructor() {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    this.watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    this.version = 0;
+  }
+  /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+  updateIfNecessary() {
+  }
+  /** Link the current consumer (if any) as an observer of this node. */
+  track() {
+    if (G.untracked) return;
+    const consumer = G.consumer;
+    if (!consumer) return;
+    (this.observers ??= /* @__PURE__ */ new Set()).add(consumer);
+    (consumer.sources ??= /* @__PURE__ */ new Set()).add(this);
+  }
+};
+var State = class extends Source {
+  constructor(value, options) {
+    super();
+    this._value = value;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    this.track();
+    return this._value;
+  }
+  set(next) {
+    if (this._equals(this._value, next)) return;
+    this._value = next;
+    this.version++;
+    reportReactiveWrite(this, G.consumer);
+    if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+    notifyWatchers(this);
+  }
+  /** Read without subscribing (peek). */
+  peek() {
+    return this._value;
+  }
+};
+var Computed = class extends Source {
+  constructor(fn, options) {
+    super();
+    this._threw = false;
+    this._initialized = false;
+    this.state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    this.sources = null;
+    this._fn = fn;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    if (G.consumer === this) {
+      throw new Error("Signal.Computed cannot read itself");
+    }
+    this.track();
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+  /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+  updateIfNecessary() {
+    if (this.state === CHECK) {
+      if (this.sources) {
+        for (const s of this.sources) {
+          s.updateIfNecessary();
+          if (this.state === DIRTY) break;
+        }
+      }
+    }
+    if (this.state === DIRTY || !this._initialized) this.recompute();
+    this.state = CLEAN;
+  }
+  recompute() {
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources.clear();
+    }
+    const prevConsumer = G.consumer;
+    const prevUntracked = G.untracked;
+    const watched = enterReactiveRun(this);
+    G.consumer = this;
+    G.untracked = false;
+    let next;
+    let threw = false;
+    let err;
+    try {
+      next = this._fn();
+    } catch (e) {
+      threw = true;
+      err = e;
+      next = this._value;
+    } finally {
+      G.consumer = prevConsumer;
+      G.untracked = prevUntracked;
+      if (watched) exitReactiveRun();
+    }
+    const changed = !this._initialized || this._threw !== threw || (threw ? err !== this._error : !this._equals(this._value, next));
+    this._initialized = true;
+    this._threw = threw;
+    this._error = err;
+    this._value = next;
+    reportReactiveRun(this);
+    if (changed) {
+      this.version++;
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      notifyWatchers(this);
+    }
+  }
+  /**
+   * Push a maybe-dirty mark. A direct observer of a changed node gets DIRTY; its
+   * own observers get CHECK (recurse), stopping where already marked, so the
+   * push is O(newly-dirtied) and never recomputes.
+   */
+  markDirty(level) {
+    if (this.state >= level) return;
+    const wasClean = this.state === CLEAN;
+    this.state = level;
+    if (wasClean) {
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      notifyWatchers(this);
+    }
+  }
+  peek() {
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+};
+function notifyWatchers(node) {
+  if (!node.watchers) return;
+  for (const w of [...node.watchers]) w._notify(node);
+}
+var Watcher = class {
+  constructor(notify) {
+    this._watched = /* @__PURE__ */ new Set();
+    this._pending = /* @__PURE__ */ new Set();
+    this._notifyFn = notify;
+  }
+  watch(...nodes) {
+    for (const n of nodes) {
+      this._watched.add(n);
+      (n.watchers ??= /* @__PURE__ */ new Set()).add(this);
+    }
+  }
+  unwatch(...nodes) {
+    for (const n of nodes) {
+      this._watched.delete(n);
+      n.watchers?.delete(this);
+      this._pending.delete(n);
+    }
+  }
+  /** Watched nodes that may have changed since the last getPending(). */
+  getPending() {
+    const out = [...this._pending];
+    this._pending.clear();
+    return out;
+  }
+  /** @internal, a watched node became non-clean. Edge-triggered: notify once. */
+  _notify(node) {
+    if (!this._watched.has(node) || this._pending.has(node)) return;
+    const wasEmpty = this._pending.size === 0;
+    this._pending.add(node);
+    if (wasEmpty) this._notifyFn();
+  }
+};
+function untrack(fn) {
+  if (G.untracked) return fn();
+  G.untracked = true;
+  try {
+    return fn();
+  } finally {
+    G.untracked = false;
+  }
+}
+
+// src/lib/signal/graph/runtime.ts
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function runWithOwner(owner, fn) {
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function onCleanup(fn) {
+  if (!G.owner) return;
+  if (G.owner.disposed) {
+    fn();
+    return;
+  }
+  (G.owner.cleanups ??= []).push(fn);
+}
+function disposeOwner(owner, final = true) {
+  if (owner.disposed) return;
+  if (owner.owned) {
+    for (let i = owner.owned.length - 1; i >= 0; i--) disposeOwner(owner.owned[i]);
+    owner.owned = null;
+  }
+  if (owner.cleanups) {
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) owner.cleanups[i]();
+    owner.cleanups = null;
+  }
+  if (final) owner.disposed = true;
+}
+function setScheduler(fn) {
+  G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
+}
+function enqueue(e) {
+  if (e.queued) return;
+  e.queued = true;
+  G.queue.push(e);
+  if (!G.scheduled && G.batchDepth === 0) {
+    G.scheduled = true;
+    G.hostSchedule(flushSync);
+  }
+}
+function flushSync() {
+  G.scheduled = false;
+  if (G.flushing) return;
+  G.flushing = true;
+  let guard = 0;
+  let failed = false;
+  let first;
+  try {
+    while (G.queue.length) {
+      if (++guard > 1e5) throw new Error("[fluixi] effect flush did not settle (cycle?)");
+      const batchOf = G.queue;
+      G.queue = [];
+      for (const e of batchOf) {
+        e.queued = false;
+        if (e.disposed) continue;
+        try {
+          e.run();
+        } catch (error) {
+          if (!failed) {
+            failed = true;
+            first = error;
+          }
+        }
+      }
+    }
+  } finally {
+    G.flushing = false;
+  }
+  if (failed) throw first;
+}
+function afterWrite() {
+  if (G.batchDepth === 0) flushSync();
+}
+function batch(fn) {
+  G.batchDepth++;
+  try {
+    return fn();
+  } finally {
+    if (--G.batchDepth === 0) flushSync();
+  }
+}
+var EffectNode = class {
+  constructor(fn, report = false, name) {
+    this.queued = false;
+    this.disposed = false;
+    this.owner = makeOwner(G.owner);
+    if (G.owner) (G.owner.cleanups ??= []).push(() => this.dispose());
+    this.computed = new Computed(() => {
+      disposeOwner(this.owner, false);
+      runWithOwner(this.owner, () => {
+        const r = fn();
+        if (typeof r === "function") (this.owner.cleanups ??= []).push(r);
+      });
+    });
+    reportReactiveNode({ kind: "effect", node: this.computed, handle: this, internal: !report, ...name ? { name } : {} });
+    this.watcher = new Watcher(() => enqueue(this));
+    this.run();
+    this.watcher.watch(this.computed);
+  }
+  run() {
+    if (this.disposed) return;
+    this.watcher.getPending();
+    try {
+      this.computed.get();
+    } catch (e) {
+      if (e && typeof e.then === "function" && G.onSuspend) {
+        G.onSuspend(e, this.owner);
+        return;
+      }
+      if (G.onError && G.onError(e, this.owner)) return;
+      throw e;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    reportReactiveDispose(this.computed);
+    this.watcher.unwatch(this.computed);
+    disposeOwner(this.owner);
+  }
+};
+function effect(fn, report = false, name) {
+  const node = new EffectNode(fn, report, name);
+  return () => node.dispose();
+}
+
+// src/lib/signal/graph/compat.ts
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+var $NODE = /* @__PURE__ */ Symbol.for("signal-node");
+function createSignal(value, options) {
+  const state = new State(value, { equals: options?.equals });
+  const read = (() => state.get());
+  const write = ((next) => {
+    const v = typeof next === "function" ? next(state.peek()) : next;
+    state.set(v);
+    afterWrite();
+    return v;
+  });
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $NODE, {
+    value: {
+      get value() {
+        return state.peek();
+      },
+      get version() {
+        return state.version;
+      }
+    },
+    enumerable: false
+  });
+  reportReactiveNode({
+    kind: "signal",
+    node: state,
+    handle: read,
+    name: options?.name,
+    set: write
+  });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(state));
+  return [read, write];
+}
+function createEffect(fn, value, options) {
+  let prev = value;
+  return effect(() => {
+    const r = fn(prev);
+    prev = r;
+  }, true, options?.name);
+}
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/lib/signal/graph/ssr-hooks.ts
+var _resourceTracker = null;
+function trackResourcePromise(p) {
+  if (_resourceTracker) _resourceTracker(p);
+}
+var _serverDataGetter = null;
+function getServerData(id) {
+  return _serverDataGetter ? _serverDataGetter(id) : void 0;
+}
+var _resourceIdSource = null;
+function nextResourceId() {
+  return _resourceIdSource ? _resourceIdSource() : void 0;
+}
+var _resourceDataSink = null;
+function reportResourceData(id, value) {
+  if (_resourceDataSink) _resourceDataSink(id, value);
+}
+function createResourceCache() {
+  const entries = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set: (key, entry) => void entries.set(key, entry),
+    delete: (key) => void entries.delete(key),
+    keys: () => entries.keys(),
+    clear: () => {
+      entries.clear();
+      inflight.clear();
+    },
+    inflight
+  };
+}
+var _cacheScope = null;
+var _pageCache;
+function currentResourceCache() {
+  const scoped = _cacheScope?.();
+  if (scoped) return scoped;
+  if (typeof window === "undefined") return createResourceCache();
+  return _pageCache ??= createResourceCache();
+}
+
+// src/lib/signal/cached-resource.ts
+var _autoId = 0;
+var $SIGNAL2 = /* @__PURE__ */ Symbol.for("signal");
+var $RESOURCE = /* @__PURE__ */ Symbol.for("resource");
+function cachedResource(sourceOrFetcher, fetcherOrOptions, opts = {}) {
+  let sourceFn;
+  let fetchFn;
+  let options;
+  if (typeof fetcherOrOptions === "function") {
+    sourceFn = sourceOrFetcher;
+    fetchFn = fetcherOrOptions;
+    options = opts;
+  } else {
+    sourceFn = () => true;
+    fetchFn = sourceOrFetcher;
+    options = fetcherOrOptions ?? opts;
+  }
+  const {
+    ttl = Infinity,
+    name = `_auto_${_autoId++}`,
+    staleWhileRevalidate = true
+  } = options;
+  const ns = name;
+  const cache = options.cache ?? currentResourceCache();
+  const inflight = cache.inflight;
+  const ssrId = options.transport === false ? void 0 : nextResourceId();
+  const seed = ssrId !== void 0 ? getServerData(ssrId) : void 0;
+  const deps = options.deps ?? [];
+  const depValues = () => deps.map((dep) => dep());
+  const buildKey = (key, values = untrack2(depValues)) => `${ns}:${JSON.stringify(key)}` + (deps.length ? `:${JSON.stringify(values)}` : "");
+  const isFresh = (entry) => ttl === Infinity || Date.now() - entry.timestamp <= ttl;
+  const [value, setValue] = createSignal(void 0, { equals: false });
+  const [resourceState, setResourceState] = createSignal("unresolved", { equals: false });
+  const [resourceError, setResourceError] = createSignal(void 0, { equals: false });
+  const [pendingP, setPendingP] = createSignal(void 0, { equals: false });
+  const [isStale, setIsStale] = createSignal(false);
+  const [tick, setTick] = createSignal(0, { equals: false });
+  const UNSET = /* @__PURE__ */ Symbol("unset");
+  let prevKey = UNSET;
+  let flagRefetch = false;
+  let flagInvalidate = false;
+  function doFetch(key, ck, background, isCancelled) {
+    const running2 = inflight.get(ck);
+    if (running2) {
+      running2.then(
+        (v) => {
+          if (!isCancelled()) settle(v, background);
+        },
+        (e) => {
+          if (!isCancelled() && !background) fail(e);
+        }
+      );
+      if (!background) {
+        trackResourcePromise(running2);
+        setPendingP(running2);
+      }
+      return;
+    }
+    const promise = Promise.resolve(fetchFn(key)).then(
+      (v) => {
+        cache.set(ck, { value: v, timestamp: Date.now() });
+        inflight.delete(ck);
+        return v;
+      },
+      (e) => {
+        inflight.delete(ck);
+        throw e;
+      }
+    );
+    inflight.set(ck, promise);
+    if (!background) {
+      trackResourcePromise(promise);
+      setPendingP(promise);
+    }
+    promise.then(
+      (v) => {
+        if (!isCancelled()) settle(v, background);
+      },
+      (e) => {
+        if (!isCancelled() && !background) fail(e);
+      }
+    );
+  }
+  function settle(v, _background) {
+    if (ssrId !== void 0) reportResourceData(ssrId, v);
+    batch2(() => {
+      setValue(() => v);
+      setResourceState("ready");
+      setIsStale(false);
+      setPendingP(void 0);
+      setResourceError(void 0);
+    });
+  }
+  function fail(e) {
+    batch2(() => {
+      setResourceError(e);
+      setResourceState("errored");
+      setPendingP(void 0);
+    });
+  }
+  createEffect(() => {
+    const key = sourceFn();
+    const values = depValues();
+    tick();
+    if (key === false || key === null || key === void 0) {
+      prevKey = UNSET;
+      batch2(() => {
+        setResourceState("unresolved");
+        setPendingP(void 0);
+        setResourceError(void 0);
+      });
+      return;
+    }
+    const doRefetch = flagRefetch;
+    const doInvalidate = flagInvalidate;
+    flagRefetch = false;
+    flagInvalidate = false;
+    const ck = buildKey(key, values);
+    if (seed && prevKey === UNSET && !cache.get(ck)) cache.set(ck, { value: seed.value, timestamp: Date.now() });
+    if (doInvalidate) cache.delete(ck);
+    const keyChanged = prevKey === UNSET || key !== prevKey;
+    prevKey = key;
+    let cancelled = false;
+    onCleanup(() => {
+      cancelled = true;
+    });
+    const cached = cache.get(ck);
+    if (cached && isFresh(cached) && !doRefetch && !doInvalidate) {
+      if (ssrId !== void 0) reportResourceData(ssrId, cached.value);
+      const cur2 = untrack2(resourceState);
+      if (cur2 !== "ready" || untrack2(value) !== cached.value) {
+        batch2(() => {
+          setValue(() => cached.value);
+          setResourceState("ready");
+          setIsStale(false);
+          setResourceError(void 0);
+        });
+      }
+      return;
+    }
+    if (cached && staleWhileRevalidate && !doInvalidate) {
+      batch2(() => {
+        setValue(() => cached.value);
+        setResourceState("ready");
+        setIsStale(true);
+        setResourceError(void 0);
+        setPendingP(void 0);
+      });
+      doFetch(key, ck, true, () => cancelled);
+      return;
+    }
+    const cur = untrack2(resourceState);
+    const isReload = cur === "ready" || cur === "refreshing";
+    batch2(() => {
+      setResourceState(isReload ? "refreshing" : "pending");
+      setResourceError(void 0);
+      setIsStale(false);
+    });
+    doFetch(key, ck, false, () => cancelled);
+  });
+  const resource = (() => {
+    const e = resourceError();
+    if (e) throw e;
+    const s = resourceState();
+    if (s === "pending") {
+      const p = pendingP();
+      if (p) throw p;
+    }
+    return value();
+  });
+  Object.defineProperty(resource, $RESOURCE, { value: true, enumerable: true });
+  Object.defineProperty(resource, $SIGNAL2, { value: true, enumerable: true });
+  Object.defineProperties(resource, {
+    state: { get: resourceState },
+    loading: { get: () => {
+      const s = resourceState();
+      return s === "pending" || s === "refreshing";
+    } },
+    error: { get: resourceError },
+    latest: { get: value },
+    stale: { get: isStale }
+  });
+  const refetch = () => {
+    flagRefetch = true;
+    setTick((v) => v + 1);
+  };
+  const invalidate = () => {
+    const key = untrack2(sourceFn);
+    if (key !== null && key !== void 0 && key !== false) {
+      cache.delete(buildKey(key));
+    }
+    flagInvalidate = true;
+    setTick((v) => v + 1);
+  };
+  return Object.assign(resource, { mutate: setValue, refetch, invalidate });
+}
+function clearCachedResources(name, cache = currentResourceCache()) {
+  if (name === void 0) return cache.clear();
+  const prefix = `${name}:`;
+  for (const key of [...cache.keys()]) if (key.startsWith(prefix)) cache.delete(key);
+}