@fluixi/reactive 1.0.0-alpha.100

package/dist/lib/signal/graph/core.cjs

@@ -0,0 +1,295 @@
+/*! @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/graph/core.ts
+var core_exports = {};
+__export(core_exports, {
+  Computed: () => Computed,
+  State: () => State,
+  Watcher: () => Watcher,
+  currentComputed: () => currentComputed,
+  hasSinks: () => hasSinks,
+  untrack: () => untrack
+});
+module.exports = __toCommonJS(core_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 = [];
+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);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+
+// 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;
+  }
+}
+function currentComputed() {
+  return G.consumer;
+}
+function hasSinks(node) {
+  return !!(node.observers && node.observers.size) || !!(node.watchers && node.watchers.size);
+}

package/dist/lib/signal/graph/core.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The TC39-shaped reactive graph core.
+ *
+ * `State`, `Computed` and `Watcher` own the dependency graph and nothing else:
+ * values, versions, source and observer edges, the lazy state machine, and
+ * glitch-free pull evaluation. Ownership, scheduling, effects, suspense and
+ * resources all live in `runtime.ts`, with the `create*` surface over them in
+ * `compat.ts`.
+ *
+ * `../signal.ts` also implements a graph and is not the one that runs. It is
+ * archive, reachable only through the `@fluixi/reactive/signal-legacy` entry, and
+ * editing it changes nothing here. Its `Computation` and `signalObservers` are the
+ * earlier spelling of what `Computed` and `Source.observers` do below, which is
+ * the only reason to open it.
+ *
+ * The scheme is push the dirt, pull the value, as in Reactively, SolidJS and the
+ * TC39 polyfill. A write pushes a maybe-dirty mark down to observers without
+ * recomputing anything. A read pulls: upstream settles lazily and only what
+ * actually changed recomputes, gated on equality. A read outside a tracking scope
+ * subscribes to nothing.
+ */
+declare const CLEAN = 0;
+declare const CHECK = 1;
+declare const DIRTY = 2;
+type NodeState = typeof CLEAN | typeof CHECK | typeof DIRTY;
+/** A thing that can be depended upon: holds observers + a monotonic version. */
+declare abstract class Source {
+    /** Computeds, and watched leaves, that read this node. */
+    observers: Set<Computed<any>> | null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    watchers: Set<Watcher> | null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    version: number;
+    /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+    updateIfNecessary(): void;
+    /** Link the current consumer (if any) as an observer of this node. */
+    protected track(): void;
+}
+export declare class State<T> extends Source {
+    private _value;
+    private readonly _equals;
+    constructor(value: T, options?: {
+        equals?: ((a: T, b: T) => boolean) | false;
+    });
+    get(): T;
+    set(next: T): void;
+    /** Read without subscribing (peek). */
+    peek(): T;
+}
+export declare class Computed<T> extends Source {
+    private _value;
+    private _error;
+    private _threw;
+    private _initialized;
+    state: NodeState;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    sources: Set<Source> | null;
+    private readonly _fn;
+    private readonly _equals;
+    constructor(fn: () => T, options?: {
+        equals?: ((a: T, b: T) => boolean) | false;
+    });
+    get(): T;
+    /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+    updateIfNecessary(): void;
+    private recompute;
+    /**
+     * 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: NodeState): void;
+    peek(): T;
+}
+/**
+ * Signal.subtle.Watcher, the only eager observation primitive. Its callback fires
+ * when a watched signal MAY have changed; the callback must not read or write
+ * signals. Effects are built on this and a scheduler, in `runtime.ts`.
+ */
+export declare class Watcher {
+    private readonly _notifyFn;
+    private readonly _watched;
+    private _pending;
+    constructor(notify: () => void);
+    watch(...nodes: Source[]): void;
+    unwatch(...nodes: Source[]): void;
+    /** Watched nodes that may have changed since the last getPending(). */
+    getPending(): Source[];
+    /** @internal, a watched node became non-clean. Edge-triggered: notify once. */
+    _notify(node: Source): void;
+}
+/** Signal.subtle.untrack: run `fn` without subscribing the current consumer. */
+export declare function untrack<T>(fn: () => T): T;
+/** Signal.subtle.currentComputed, the computed currently evaluating, or null. */
+export declare function currentComputed(): Computed<unknown> | null;
+/** Whether a node currently has observers/watchers (Signal.subtle.hasSinks). */
+export declare function hasSinks(node: Source): boolean;
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/lib/signal/graph/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/lib/signal/graph/core.ts"],"names":[],"mappings":"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"}

package/dist/lib/signal/graph/core.js

@@ -0,0 +1,268 @@
+/**
+ * The TC39-shaped reactive graph core.
+ *
+ * `State`, `Computed` and `Watcher` own the dependency graph and nothing else:
+ * values, versions, source and observer edges, the lazy state machine, and
+ * glitch-free pull evaluation. Ownership, scheduling, effects, suspense and
+ * resources all live in `runtime.ts`, with the `create*` surface over them in
+ * `compat.ts`.
+ *
+ * `../signal.ts` also implements a graph and is not the one that runs. It is
+ * archive, reachable only through the `@fluixi/reactive/signal-legacy` entry, and
+ * editing it changes nothing here. Its `Computation` and `signalObservers` are the
+ * earlier spelling of what `Computed` and `Source.observers` do below, which is
+ * the only reason to open it.
+ *
+ * The scheme is push the dirt, pull the value, as in Reactively, SolidJS and the
+ * TC39 polyfill. A write pushes a maybe-dirty mark down to observers without
+ * recomputing anything. A read pulls: upstream settles lazily and only what
+ * actually changed recomputes, gated on equality. A read outside a tracking scope
+ * subscribes to nothing.
+ */
+import { G } from './state.js';
+import { enterReactiveRun, exitReactiveRun, reportReactiveRun, reportReactiveWrite } from './observe.js';
+// CLEAN, the cached value is current. CHECK, a source may have changed, so verify on
+// read. DIRTY, recompute without checking.
+// CHECK is what keeps a diamond from recomputing twice: a write marks direct observers
+// DIRTY and everything downstream of them CHECK, so a transitive reader asks its
+// sources whether their versions moved before it runs its own function.
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+// The current consumer + untrack flag live on the shared globalThis-backed state (G)
+// so duplicate module copies share one graph. `consumer`/`untracked` proxy them.
+/** A thing that can be depended upon: holds observers + a monotonic version. */
+class Source {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    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 ??= new Set()).add(consumer);
+        (consumer.sources ??= new Set()).add(this);
+    }
+}
+export class State extends Source {
+    _value;
+    _equals;
+    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++;
+        // Who wrote it: once a write has propagated, nothing else records what caused it.
+        reportReactiveWrite(this, G.consumer);
+        // Push: direct observers go DIRTY, their transitive observers CHECK.
+        // Snapshot first. The scheduler is synchronous, so an effect can re-run part way
+        // through this loop, and re-running re-subscribes it, which mutates `observers`.
+        // Iterating the live Set would then reach the re-added node again, and again.
+        if (this.observers)
+            for (const o of [...this.observers])
+                o.markDirty(DIRTY);
+        notifyWatchers(this);
+    }
+    /** Read without subscribing (peek). */
+    peek() {
+        return this._value;
+    }
+}
+export class Computed extends Source {
+    _value;
+    _error;
+    _threw = false;
+    _initialized = false;
+    state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    sources = null;
+    _fn;
+    _equals;
+    constructor(fn, options) {
+        super();
+        this._fn = fn;
+        this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+    }
+    get() {
+        // Cycle guard: a computed reading itself.
+        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) {
+            // Pull each source; if one recomputes to a new value it will have flipped
+            // us to DIRTY (markDirty), so stop early.
+            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() {
+        // Drop old edges (we re-collect during the run).
+        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++;
+            // Our value moved -> observers that were merely CHECK must now recompute.
+            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);
+}
+/**
+ * Signal.subtle.Watcher, the only eager observation primitive. Its callback fires
+ * when a watched signal MAY have changed; the callback must not read or write
+ * signals. Effects are built on this and a scheduler, in `runtime.ts`.
+ */
+export class Watcher {
+    _notifyFn;
+    _watched = new Set();
+    _pending = new Set();
+    constructor(notify) {
+        this._notifyFn = notify;
+    }
+    watch(...nodes) {
+        for (const n of nodes) {
+            this._watched.add(n);
+            (n.watchers ??= 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();
+    }
+}
+/** Signal.subtle.untrack: run `fn` without subscribing the current consumer. */
+export function untrack(fn) {
+    if (G.untracked)
+        return fn();
+    G.untracked = true;
+    try {
+        return fn();
+    }
+    finally {
+        G.untracked = false;
+    }
+}
+/** Signal.subtle.currentComputed, the computed currently evaluating, or null. */
+export function currentComputed() {
+    return G.consumer;
+}
+/** Whether a node currently has observers/watchers (Signal.subtle.hasSinks). */
+export function hasSinks(node) {
+    return !!(node.observers && node.observers.size) || !!(node.watchers && node.watchers.size);
+}