@praxisjs/core 2.1.0 → 2.3.0

package/src/signal/batch.ts

@@ -1,25 +1,11 @@
-import type { Effect } from "./effect";
+import { endBatch, startBatch } from "./graph";
 
-const batchEffects: Effect[] = [];
-let batchDepth = 0;
-
-export function isBatching(): boolean {
-  return batchDepth > 0;
-}
-
-export function enqueueEffect(effect: Effect): void {
-  if (!batchEffects.includes(effect)) batchEffects.push(effect);
-}
-
-export function batch(fn: () => void) {
-  batchDepth++;
+/** Runs `fn` and defers every effect it invalidates until it returns, so each runs once. */
+export function batch(fn: () => void): void {
+  startBatch();
   try {
     fn();
   } finally {
-    if (--batchDepth === 0) {
-      const n = batchEffects.length;
-      for (let i = 0; i < n; i++) batchEffects[i]();
-      batchEffects.length = 0;
-    }
+    endBatch();
   }
 }

package/src/signal/computed.ts

@@ -1,72 +1,29 @@
 import type { Computed, WritableComputed } from "@praxisjs/shared";
 
-import { activeEffect, cleanupEffectDeps, runEffect, type Effect, type SubList } from "./effect";
-import { addSub, removeSub, notifySubs } from "./signal";
-
-type ComputedRecompute = Effect & { __isComputedRecompute: true };
-
-function isComputedRecompute(eff: Effect): boolean {
-  return (eff as Partial<ComputedRecompute>).__isComputedRecompute === true;
-}
+import { untrack } from "./effect";
+import { ComputedNode, createEffect, DIRTY, disposeEffect, readComputed, unlinkDeps } from "./graph";
 
 export function computed<T>(getter: () => T): Computed<T> {
-  let cachedValue: T | undefined;
-  let dirty = true;
-
-  const computedHolder = { subs: null as SubList };
-  const leafHolder = { subs: null as SubList };
-  let scheduled = false;
-
-  let recompute: ComputedRecompute | null = null;
-
-  function getRecompute(): ComputedRecompute {
-    if (recompute !== null) return recompute;
-    recompute = function markDirty(): void {
-      if (dirty) return;
-      dirty = true;
-      if (computedHolder.subs !== null) notifySubs(computedHolder.subs, false);
-      if (leafHolder.subs !== null && !scheduled) {
-        scheduled = true;
-        queueMicrotask(() => {
-          scheduled = false;
-          if (leafHolder.subs !== null) notifySubs(leafHolder.subs, false);
-        });
-      }
-    } as ComputedRecompute;
-    recompute.__isComputedRecompute = true;
-    return recompute;
-  }
-
-  function read(): T {
-    if (activeEffect !== null) {
-      if (isComputedRecompute(activeEffect)) {
-        addSub(computedHolder, activeEffect);
-      } else {
-        addSub(leafHolder, activeEffect);
-      }
-    }
-    if (dirty) {
-      const prevEffect = activeEffect;
-      const recomputeEffect = getRecompute();
-      cleanupEffectDeps(recomputeEffect);
-      runEffect(recomputeEffect);
-      try {
-        cachedValue = getter();
-        dirty = false;
-      } finally {
-        runEffect(prevEffect);
-      }
-    }
-    return cachedValue as T;
-  }
-
-  const c = read as Computed<T>;
+  const node = new ComputedNode(getter);
+
+  const c = (() => readComputed(node)) as Computed<T> & { dispose(): void };
+
+  // Drops this computed's subscriptions to its sources so an unreachable one (e.g. an evicted
+  // @Memo entry) isn't kept alive by the signals it read. Does nothing while anything still
+  // depends on it: detaching then would leave those dependents silently stale.
+  c.dispose = () => {
+    if (node.subs !== undefined) return;
+    unlinkDeps(node);
+    node.flags |= DIRTY;
+    node.value = undefined;
+  };
 
   c.subscribe = (fn: (value: T) => void) => {
-    const wrapped: Effect = () => { fn(read()); };
-    addSub(leafHolder, wrapped);
-    wrapped();
-    return () => { removeSub(leafHolder, wrapped); };
+    const sub = createEffect(() => {
+      const value = readComputed(node);
+      untrack(() => { fn(value); });
+    });
+    return () => { disposeEffect(sub); };
   };
 
   c.__isComputed = true;

package/src/signal/effect.ts

@@ -1,93 +1,22 @@
-export type Effect = () => void;
-export type SubList = Effect | Effect[] | null;
-export interface SubscriberHolder {
-  subs: SubList;
-}
-
-type TrackedEffect = Effect & { __deps?: Set<SubscriberHolder> };
-
-export let activeEffect: Effect | null = null;
-const effectStack: Effect[] = [];
-
-function removeTrackedSub(holder: SubscriberHolder, eff: Effect): void {
-  const subs = holder.subs;
-  if (subs === null) return;
-  if (typeof subs === "function") {
-    if (subs === eff) holder.subs = null;
-    return;
-  }
-  const idx = subs.indexOf(eff);
-  if (idx >= 0) subs.splice(idx, 1);
-  if (subs.length === 0) holder.subs = null;
-}
-
-export function recordDependency(eff: Effect, holder: SubscriberHolder): void {
-  const tracked = eff as TrackedEffect;
-  tracked.__deps ??= new Set();
-  tracked.__deps.add(holder);
-}
+import { activeSub, createEffect, disposeEffect, setActiveSub, type EffectCleanup } from "./graph";
 
-export function cleanupEffectDeps(eff: Effect): void {
-  const tracked = eff as TrackedEffect;
-  const deps = tracked.__deps;
-  if (!deps) return;
-  for (const holder of deps) removeTrackedSub(holder, eff);
-  deps.clear();
-}
-
-export function track(effect: Effect) {
-  cleanupEffectDeps(effect);
-  effectStack.push(effect);
-  activeEffect = effect;
-  try {
-    effect();
-  } finally {
-    effectStack.pop();
-    activeEffect = effectStack[effectStack.length - 1] ?? null;
-  }
-}
-
-export function runEffect(effect: Effect | null) {
-  activeEffect = effect;
-}
+export type Effect = () => void;
 
 export function untrack<T>(fn: () => T): T {
-  const prev = activeEffect;
-  activeEffect = null;
+  if (activeSub === undefined) return fn();
+  const prev = setActiveSub(undefined);
   try {
     return fn();
   } finally {
-    activeEffect = prev;
+    setActiveSub(prev);
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-type Cleanup = (() => void) | void;
-
-export function effect(fn: () => Cleanup) {
-  let cleanup: Cleanup;
-  let stopped = false;
-
-  function run(): void {
-    if (stopped) return;
-    cleanupEffectDeps(run);
-    cleanup?.();
-    const prev = activeEffect;
-    activeEffect = run;
-    try {
-      cleanup = fn();
-    } finally {
-      activeEffect = prev;
-    }
-  }
-
-  run();
-
-  return function stop(): void {
-    if (stopped) return;
-    stopped = true;
-    cleanupEffectDeps(run);
-    cleanup?.();
-    cleanup = undefined;
-  };
+/**
+ * Runs `fn` now and again whenever a signal or computed it read changes. A returned function is
+ * called before each re-run and on stop. Returns the stop function.
+ */
+export function effect(fn: () => EffectCleanup): () => void {
+  const node = createEffect(fn);
+  return () => { disposeEffect(node); };
 }