@praxisjs/core 1.5.0 → 1.7.0

package/src/signal/computed.ts

@@ -1,69 +1,72 @@
 import type { Computed } from "@praxisjs/shared";
 
 import { activeEffect, runEffect, type Effect } from "./effect";
+import { addSub, removeSub, notifySubs, type SubList } from "./signal";
 
 type ComputedRecompute = Effect & { __isComputedRecompute: true };
 
-export function computed<T>(computeFn: () => T): Computed<T> {
-  let cachedValue: T;
+function isComputedRecompute(eff: Effect): boolean {
+  return (eff as Partial<ComputedRecompute>).__isComputedRecompute === true;
+}
+
+export function computed<T>(getter: () => T): Computed<T> {
+  let cachedValue: T | undefined;
   let dirty = true;
-  const subscribers = new Set<Effect>();
+
+  const computedHolder = { subs: null as SubList };
+  const leafHolder = { subs: null as SubList };
   let scheduled = false;
 
-  const recompute: ComputedRecompute = Object.assign(
-    () => {
+  let recompute: ComputedRecompute | null = null;
+
+  function getRecompute(): ComputedRecompute {
+    if (recompute !== null) return recompute;
+    recompute = function markDirty(): void {
+      if (dirty) return;
       dirty = true;
-      for (const sub of [...subscribers]) {
-        if ((sub as Partial<ComputedRecompute>).__isComputedRecompute) {
-          sub(); // propagate dirty synchronously through computed chain
-        }
-      }
-      if (!scheduled) {
+      if (computedHolder.subs !== null) notifySubs(computedHolder.subs, false);
+      if (leafHolder.subs !== null && !scheduled) {
         scheduled = true;
         queueMicrotask(() => {
           scheduled = false;
-          for (const sub of [...subscribers]) {
-            if (!(sub as Partial<ComputedRecompute>).__isComputedRecompute) {
-              sub(); // notify leaf effects (DOM, @Watch, subscribe)
-            }
-          }
+          if (leafHolder.subs !== null) notifySubs(leafHolder.subs, false);
         });
       }
-    },
-    { __isComputedRecompute: true as const },
-  );
+    } as ComputedRecompute;
+    recompute.__isComputedRecompute = true;
+    return recompute;
+  }
 
-  function read() {
-    if (activeEffect) {
-      subscribers.add(activeEffect);
+  function read(): T {
+    if (activeEffect !== null) {
+      if (isComputedRecompute(activeEffect)) {
+        addSub(computedHolder, activeEffect);
+      } else {
+        addSub(leafHolder, activeEffect);
+      }
     }
-
     if (dirty) {
       const prevEffect = activeEffect;
-      runEffect(recompute);
+      runEffect(getRecompute());
       try {
-        cachedValue = computeFn();
+        cachedValue = getter();
         dirty = false;
       } finally {
         runEffect(prevEffect);
       }
     }
-
-    return cachedValue;
+    return cachedValue as T;
   }
 
-  function subscribe(fn: (value: T) => void) {
-    const wrappedEffect = () => {
-      fn(read());
-    };
-    subscribers.add(wrappedEffect);
-    wrappedEffect();
-    return () => subscribers.delete(wrappedEffect);
-  }
+  const c = read as Computed<T>;
 
-  const computedSignal = read as Computed<T>;
-  computedSignal.subscribe = subscribe;
-  computedSignal.__isComputed = true;
+  c.subscribe = (fn: (value: T) => void) => {
+    const wrapped: Effect = () => { fn(read()); };
+    addSub(leafHolder, wrapped);
+    wrapped();
+    return () => { removeSub(leafHolder, wrapped); };
+  };
 
-  return computedSignal;
+  c.__isComputed = true;
+  return c;
 }

package/src/signal/effect.ts

@@ -4,14 +4,13 @@ export let activeEffect: Effect | null = null;
 const effectStack: Effect[] = [];
 
 export function track(effect: Effect) {
-  const subscriber = effect;
-  effectStack.push(subscriber);
-  activeEffect = subscriber;
+  effectStack.push(effect);
+  activeEffect = effect;
   try {
-    subscriber();
+    effect();
   } finally {
     effectStack.pop();
-    activeEffect = effectStack[effectStack.length - 1] || null;
+    activeEffect = effectStack[effectStack.length - 1] ?? null;
   }
 }
 
@@ -36,21 +35,21 @@ export function effect(fn: () => Cleanup) {
   let cleanup: Cleanup;
   let stopped = false;
 
-  const wrappedEffect = () => {
+  function run(): void {
     if (stopped) return;
     cleanup?.();
-    const prevEffect = activeEffect;
-    activeEffect = wrappedEffect;
+    const prev = activeEffect;
+    activeEffect = run;
     try {
       cleanup = fn();
     } finally {
-      activeEffect = prevEffect;
+      activeEffect = prev;
     }
-  };
+  }
 
-  wrappedEffect();
+  run();
 
-  return () => {
+  return function stop(): void {
     stopped = true;
     cleanup?.();
     cleanup = undefined;

package/src/signal/signal.ts

@@ -3,53 +3,78 @@ import type { Signal } from "@praxisjs/shared";
 import { isBatching, enqueueEffect } from "./batch";
 import { activeEffect, type Effect } from "./effect";
 
+export type SubList = Effect | Effect[] | null;
+
+export function addSub(holder: { subs: SubList }, eff: Effect): void {
+  const subs = holder.subs;
+  if (subs === null) {
+    holder.subs = eff;
+  } else if (typeof subs === "function") {
+    if (subs !== eff) holder.subs = [subs, eff];
+  } else {
+    if (!subs.includes(eff)) subs.push(eff);
+  }
+}
+
+export function removeSub(holder: { subs: SubList }, eff: Effect): void {
+  const subs = holder.subs;
+  if (subs === null) return;
+  if (typeof subs === "function") {
+    if (subs === eff) holder.subs = null;
+  } else {
+    const idx = subs.indexOf(eff);
+    if (idx >= 0) subs.splice(idx, 1);
+  }
+}
+
+export function notifySubs(subs: Exclude<SubList, null>, batching: boolean): void {
+  if (typeof subs === "function") {
+    if (batching) enqueueEffect(subs); else subs();
+    return;
+  }
+  if (batching) {
+    for (const sub of subs) enqueueEffect(sub);
+    return;
+  }
+  let lastError: unknown;
+  let hasError = false;
+  for (const sub of subs) {
+    try {
+      sub();
+    } catch (e) {
+      lastError = e;
+      hasError = true;
+    }
+  }
+  if (hasError) throw lastError;
+}
+
 export function signal<T>(initialValue: T): Signal<T> {
   let value = initialValue;
-  const subscribers = new Set<Effect>();
+  const holder = { subs: null as SubList };
 
-  function read() {
-    if (activeEffect) {
-      subscribers.add(activeEffect);
-    }
+  function read(): T {
+    if (activeEffect !== null) addSub(holder, activeEffect);
     return value;
   }
 
-  function set(newValue: T) {
+  const s = read as Signal<T>;
+
+  s.set = (newValue: T) => {
     if (Object.is(value, newValue)) return;
     value = newValue;
-    if (isBatching()) {
-      [...subscribers].forEach((sub) => { enqueueEffect(sub); });
-      return;
-    }
-    const errors: unknown[] = [];
-    [...subscribers].forEach((sub) => {
-      try {
-        sub();
-      } catch (e) {
-        errors.push(e);
-      }
-    });
-    if (errors.length > 0) throw errors[errors.length - 1];
-  }
+    if (holder.subs !== null) notifySubs(holder.subs, isBatching());
+  };
 
-  function update(fn: (prev: T) => T) {
-    set(fn(value));
-  }
+  s.update = (fn: (prev: T) => T) => { s.set(fn(value)); };
 
-  function subscribe(fn: (value: T) => void) {
-    const wrapped = () => {
-      fn(value);
-    };
-    subscribers.add(wrapped);
+  s.subscribe = (fn: (value: T) => void) => {
+    const wrapped: Effect = () => { fn(value); };
+    addSub(holder, wrapped);
     wrapped();
-    return () => subscribers.delete(wrapped);
-  }
-
-  const signal = read as Signal<T>;
-  signal.set = set;
-  signal.update = update;
-  signal.subscribe = subscribe;
-  signal.__isSignal = true;
+    return () => { removeSub(holder, wrapped); };
+  };
 
-  return signal;
+  s.__isSignal = true;
+  return s;
 }