@nisli/core 0.43.0

package/dist/signal.js

@@ -0,0 +1,403 @@
+/**
+ * signal.ts — Reactive primitives: signal(), computed(), effect()
+ *
+ * Push-pull hybrid model:
+ * - Writes push "dirty" flags up the dependency graph
+ * - Reads pull fresh values lazily (computed only recalculates when read)
+ * - Multiple synchronous writes coalesce into one microtask flush
+ *
+ * Dependency tracking is automatic: reading a signal inside a computed
+ * or effect registers it as a dependency. Dependencies are re-tracked
+ * on every execution (dynamic/conditional tracking).
+ */
+// ── Late-bound context hook for auto-disposal ──────────────────────
+// Avoids circular dependency: context.ts imports nothing from signal.ts,
+// but signal.ts needs to check for component context to auto-dispose effects.
+// component.ts wires this up at import time via `setContextHook()`.
+let contextHook = null;
+/**
+ * Register the context hook. Called by component.ts at module init.
+ * The hook returns an `addDisposer` function if inside setup context, null otherwise.
+ */
+export function setContextHook(hook) {
+    contextHook = hook;
+}
+// ── Brand symbol for signal detection in templates ──────────────────
+export const SIGNAL_BRAND = Symbol.for('backlog.signal');
+// ── Internal tracking state ─────────────────────────────────────────
+/**
+ * The currently executing reactive context (computed or effect).
+ * When non-null, any signal read during execution is recorded as a dependency.
+ */
+let activeObserver = null;
+/**
+ * Global epoch counter. Incremented on every signal write.
+ * Used to determine if a computed needs recalculation: if a dependency's
+ * lastChanged > this computed's lastChecked, the computed is stale.
+ */
+let globalEpoch = 0;
+// ── Effect scheduling ────────────────────────────────────────────────
+const pendingEffects = new Set();
+let flushScheduled = false;
+function scheduleFlush() {
+    if (!flushScheduled) {
+        flushScheduled = true;
+        queueMicrotask(flushPendingEffects);
+    }
+}
+function flushPendingEffects() {
+    flushScheduled = false;
+    // Copy to avoid mutation during iteration
+    const effects = [...pendingEffects];
+    pendingEffects.clear();
+    for (const effect of effects) {
+        if (!effect.disposed) {
+            runEffect(effect);
+        }
+    }
+}
+// ── Dependency graph node types ─────────────────────────────────────
+var NodeState;
+(function (NodeState) {
+    NodeState[NodeState["Clean"] = 0] = "Clean";
+    NodeState[NodeState["MaybeDirty"] = 1] = "MaybeDirty";
+    NodeState[NodeState["Dirty"] = 2] = "Dirty";
+})(NodeState || (NodeState = {}));
+class SignalImpl {
+    [SIGNAL_BRAND] = true;
+    /** @internal */
+    _node;
+    constructor(initialValue) {
+        this._node = {
+            value: initialValue,
+            lastChanged: globalEpoch,
+            observers: new Set(),
+        };
+    }
+    get value() {
+        // Track dependency if inside a reactive context
+        if (activeObserver) {
+            activeObserver.sources.add(this._node);
+            this._node.observers.add(activeObserver);
+        }
+        return this._node.value;
+    }
+    set value(newValue) {
+        if (Object.is(this._node.value, newValue))
+            return;
+        this._node.value = newValue;
+        this._node.lastChanged = ++globalEpoch;
+        notifyObservers(this._node.observers);
+    }
+    subscribe(fn) {
+        // Immediately notify with current value
+        fn(this._node.value);
+        // Create a lightweight effect that calls fn
+        const dispose = effect(() => {
+            fn(this.value);
+        });
+        return dispose;
+    }
+}
+function notifyObservers(observers) {
+    for (const observer of observers) {
+        observer.notify();
+    }
+}
+class ComputedImpl {
+    [SIGNAL_BRAND] = true;
+    /** @internal */
+    _node;
+    compute;
+    state = NodeState.Dirty; // Start dirty so first read computes
+    sources = new Set();
+    computing = false;
+    constructor(fn) {
+        this.compute = fn;
+        this._node = {
+            value: undefined,
+            lastChanged: 0,
+            observers: new Set(),
+        };
+    }
+    get value() {
+        if (this.computing) {
+            throw new Error('Circular dependency detected in computed()');
+        }
+        // Track dependency if inside a reactive context
+        if (activeObserver) {
+            activeObserver.sources.add(this._node);
+            this._node.observers.add(activeObserver);
+        }
+        // Pull: recalculate if dirty
+        if (this.state !== NodeState.Clean) {
+            this.update();
+        }
+        return this._node.value;
+    }
+    update() {
+        // Unsubscribe from previous sources (for dynamic dependency tracking)
+        for (const source of this.sources) {
+            source.observers.delete(this);
+        }
+        this.sources.clear();
+        // Run compute with tracking
+        const prevObserver = activeObserver;
+        activeObserver = this;
+        this.computing = true;
+        try {
+            const newValue = this.compute();
+            if (!Object.is(this._node.value, newValue)) {
+                this._node.value = newValue;
+                this._node.lastChanged = ++globalEpoch;
+                // Notify downstream observers that our value changed
+                notifyObservers(this._node.observers);
+            }
+        }
+        finally {
+            this.computing = false;
+            activeObserver = prevObserver;
+        }
+        this.state = NodeState.Clean;
+    }
+    /** @internal — called by the ReactiveNode interface when a source changes */
+    notify() {
+        if (this.state === NodeState.Clean) {
+            this.state = NodeState.Dirty;
+            // Propagate dirty flags to downstream observers
+            // (they need to re-check if this computed's value actually changed)
+            notifyObservers(this._node.observers);
+        }
+    }
+    subscribe(fn) {
+        fn(this.value);
+        const dispose = effect(() => {
+            fn(this.value);
+        });
+        return dispose;
+    }
+    // ReactiveNode interface — used by dependency tracking
+    get sources_() {
+        return this.sources;
+    }
+}
+// Make ComputedImpl satisfy ReactiveNode for the dependency tracker
+Object.defineProperty(ComputedImpl.prototype, 'sources', {
+    enumerable: false,
+});
+// Bridge ComputedImpl to ReactiveNode — the observer interface.
+// We cast in notify() above; here we make the computed usable as a ReactiveNode
+// by defining the properties the tracker expects.
+const computedAsReactiveNode = (c) => ({
+    get state() { return c['state']; },
+    set state(v) { c['state'] = v; },
+    get sources() { return c['sources']; },
+    notify: () => c.notify(),
+});
+// ── Effect (side-effect, auto-tracks, auto-disposes) ────────────────
+/**
+ * Maximum consecutive re-runs within a time window before we assume an infinite loop.
+ * An effect that writes to a signal it reads will re-trigger itself
+ * on every flush. This guard prevents silent UI freezes.
+ * See ADR 0008 Gap 2 / ADR 0009.
+ */
+const MAX_EFFECT_RERUNS = 100;
+/**
+ * Time window (ms) for counting consecutive re-runs.
+ * If an effect runs MAX_EFFECT_RERUNS times within this window, it's a loop.
+ * Resets when the effect hasn't been re-triggered for longer than this window.
+ */
+const LOOP_WINDOW_MS = 2000;
+function createEffectNode(fn) {
+    return {
+        state: NodeState.Dirty,
+        fn,
+        cleanup: null,
+        disposed: false,
+        sources: new Set(),
+        disposers: [],
+        runCount: 0,
+        windowStart: 0,
+        notify() {
+            if (this.disposed)
+                return;
+            this.state = NodeState.Dirty;
+            pendingEffects.add(this);
+            scheduleFlush();
+        },
+    };
+}
+function runEffect(node) {
+    if (node.disposed)
+        return;
+    // Loop detection: count consecutive re-runs within a time window.
+    // If the effect runs MAX_EFFECT_RERUNS times within LOOP_WINDOW_MS,
+    // it's almost certainly a write-to-own-dependency loop. Dispose it.
+    const now = Date.now();
+    if (now - node.windowStart > LOOP_WINDOW_MS) {
+        // New window — reset counter
+        node.runCount = 0;
+        node.windowStart = now;
+    }
+    node.runCount++;
+    if (node.runCount > MAX_EFFECT_RERUNS) {
+        console.error(`Effect exceeded maximum re-run limit (${MAX_EFFECT_RERUNS}). ` +
+            `This usually means the effect writes to a signal it reads. ` +
+            `The effect has been disposed to prevent a UI freeze.`);
+        node.disposed = true;
+        // Unsubscribe from all sources to stop further notifications
+        for (const source of node.sources) {
+            source.observers.delete(node);
+        }
+        node.sources.clear();
+        pendingEffects.delete(node);
+        return;
+    }
+    // Run cleanup from previous execution
+    if (node.cleanup) {
+        try {
+            node.cleanup();
+        }
+        catch (_) { /* cleanup errors are swallowed */ }
+        node.cleanup = null;
+    }
+    // Unsubscribe from previous sources
+    for (const source of node.sources) {
+        source.observers.delete(node);
+    }
+    node.sources.clear();
+    // Run effect with tracking
+    const prevObserver = activeObserver;
+    activeObserver = node;
+    try {
+        const result = node.fn();
+        if (typeof result === 'function') {
+            node.cleanup = result;
+        }
+    }
+    catch (err) {
+        // Effect errors: log but don't crash the system.
+        // The effect is NOT disposed — it may succeed on next signal change.
+        console.error('Effect error:', err);
+    }
+    finally {
+        activeObserver = prevObserver;
+    }
+    node.state = NodeState.Clean;
+}
+// ── Public API ──────────────────────────────────────────────────────
+/**
+ * Create a writable reactive signal.
+ *
+ * ```ts
+ * const count = signal(0);
+ * count.value;     // read (auto-tracks in reactive contexts)
+ * count.value = 5; // write (notifies dependents)
+ * ```
+ */
+export function signal(initialValue) {
+    return new SignalImpl(initialValue);
+}
+/**
+ * Create a derived, lazy, cached computed signal.
+ * Re-evaluates only when dependencies change AND the value is read.
+ *
+ * ```ts
+ * const doubled = computed(() => count.value * 2);
+ * doubled.value; // lazy evaluation
+ * ```
+ */
+export function computed(fn) {
+    return new ComputedImpl(fn);
+}
+/**
+ * Create a side-effect that re-runs when its dependencies change.
+ * Returns a dispose function to stop the effect.
+ *
+ * The effect function may return a cleanup callback that runs
+ * before each re-execution and on disposal.
+ *
+ * ```ts
+ * const dispose = effect(() => {
+ *   console.log('count is', count.value);
+ *   return () => { // cleanup
+ *     console.log('cleaning up');
+ *   };
+ * });
+ * dispose(); // stop the effect
+ * ```
+ */
+export function effect(fn) {
+    const node = createEffectNode(fn);
+    // Run immediately to establish initial dependencies
+    runEffect(node);
+    const dispose = () => {
+        node.disposed = true;
+        // Run final cleanup
+        if (node.cleanup) {
+            try {
+                node.cleanup();
+            }
+            catch (_) { /* swallow */ }
+            node.cleanup = null;
+        }
+        // Unsubscribe from all sources
+        for (const source of node.sources) {
+            source.observers.delete(node);
+        }
+        node.sources.clear();
+        pendingEffects.delete(node);
+    };
+    // Auto-dispose when inside component setup context
+    if (contextHook) {
+        const addDisposer = contextHook();
+        if (addDisposer) {
+            addDisposer(dispose);
+        }
+    }
+    return dispose;
+}
+/**
+ * Check if a value is a signal (writable or computed).
+ * Used by the template engine to detect signals in expression slots.
+ */
+export function isSignal(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        SIGNAL_BRAND in value);
+}
+// ── Observer isolation ───────────────────────────────────────────────
+/**
+ * Run a function with activeObserver set to null, preventing any
+ * signal reads inside `fn` from being tracked by an outer effect.
+ *
+ * Used by component.ts to isolate connectedCallback: child component
+ * setup signal reads must not leak into a parent effect's dependency
+ * set. See ADR 0008 Gap 1.
+ */
+export function untrack(fn) {
+    const prev = activeObserver;
+    activeObserver = null;
+    try {
+        fn();
+    }
+    finally {
+        activeObserver = prev;
+    }
+}
+// ── Synchronous flush ───────────────────────────────────────────────
+/**
+ * Synchronously execute all pending effects.
+ *
+ * In normal usage, effects run automatically on the next microtask.
+ * Use flush() only when you need effects to have executed before
+ * the next line — e.g., imperative DOM measurement after state change.
+ *
+ * flush() is idempotent: calling it with no pending effects is a no-op.
+ */
+export function flush() {
+    flushPendingEffects();
+}
+/** Backward compat alias for tests. */
+export { flush as flushEffects };
+//# sourceMappingURL=signal.js.map

package/dist/signal.js.map

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

package/dist/template.d.ts

@@ -0,0 +1,49 @@
+/**
+ * template.ts — Tagged template engine with targeted DOM binding
+ *
+ * The html tagged template literal parses HTML with expression slots,
+ * creates bindings for signals, and produces a TemplateResult that
+ * can be mounted into the DOM with surgical updates.
+ *
+ * Two phases:
+ * 1. First render: parse template, clone, create bindings, mount
+ * 2. Updates: signal changes trigger individual binding updates (O(1))
+ */
+import { type ReadonlySignal } from './signal.js';
+export interface TemplateResult {
+    /** Mount this template into a host element */
+    mount(host: HTMLElement): void;
+    /** Dispose all bindings and effects */
+    dispose(): void;
+    /** Brand for type checking */
+    __templateResult: true;
+}
+/**
+ * Tagged template literal for creating reactive DOM templates.
+ *
+ * ```ts
+ * const name = signal('World');
+ * const greeting = html`<h1>Hello, ${name}!</h1>`;
+ * ```
+ *
+ * Signals in expression slots are detected automatically and
+ * create fine-grained bindings. When the signal changes, only
+ * the specific text node or attribute updates — no diffing needed.
+ */
+export declare function html(strings: TemplateStringsArray, ...values: unknown[]): TemplateResult;
+/**
+ * Reactive list rendering with keyed reconciliation.
+ *
+ * Renders a list of items from a signal, tracking each item by key.
+ * When the array changes, only affected DOM nodes are added, removed,
+ * or reordered — existing items update in-place via their signals.
+ *
+ * ```ts
+ * const tasks = signal([{ id: '1', title: 'A' }, { id: '2', title: 'B' }]);
+ * html`<ul>${each(tasks, t => t.id, (task, index) =>
+ *   html`<li>${computed(() => task.value.title)}</li>`
+ * )}</ul>`
+ * ```
+ */
+export declare function each<T>(items: ReadonlySignal<T[]>, keyFn: (item: T, index: number) => string | number, templateFn: (item: ReadonlySignal<T>, index: ReadonlySignal<number>) => TemplateResult): TemplateResult;
+export declare function when(condition: unknown, template: TemplateResult | (() => TemplateResult)): TemplateResult | ReadonlySignal<TemplateResult | null> | null;