@praxisjs/core 1.7.0 → 1.8.1

package/src/signal/effect.ts

@@ -1,9 +1,42 @@
 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);
+}
+
+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 {
@@ -37,6 +70,7 @@ export function effect(fn: () => Cleanup) {
 
   function run(): void {
     if (stopped) return;
+    cleanupEffectDeps(run);
     cleanup?.();
     const prev = activeEffect;
     activeEffect = run;
@@ -50,7 +84,9 @@ export function effect(fn: () => Cleanup) {
   run();
 
   return function stop(): void {
+    if (stopped) return;
     stopped = true;
+    cleanupEffectDeps(run);
     cleanup?.();
     cleanup = undefined;
   };

package/src/signal/index.ts

@@ -1,7 +1,7 @@
 export { batch } from "./batch";
 export { peek } from "./peek";
 export { signal } from "./signal";
-export { computed } from "./computed";
+export { computed, writableComputed } from "./computed";
 export { type PersistedSignalOptions, persistedSignal } from "./persisted";
 export { type SyncedSignal, syncedSignal } from "./synced";
 export { effect, untrack } from "./effect";

package/src/signal/signal.ts

@@ -1,11 +1,17 @@
 import type { Signal } from "@praxisjs/shared";
 
 import { isBatching, enqueueEffect } from "./batch";
-import { activeEffect, type Effect } from "./effect";
+import {
+  activeEffect,
+  recordDependency,
+  type Effect,
+  type SubList,
+  type SubscriberHolder,
+} from "./effect";
 
-export type SubList = Effect | Effect[] | null;
+export type { SubList } from "./effect";
 
-export function addSub(holder: { subs: SubList }, eff: Effect): void {
+export function addSub(holder: SubscriberHolder, eff: Effect): void {
   const subs = holder.subs;
   if (subs === null) {
     holder.subs = eff;
@@ -14,9 +20,10 @@ export function addSub(holder: { subs: SubList }, eff: Effect): void {
   } else {
     if (!subs.includes(eff)) subs.push(eff);
   }
+  recordDependency(eff, holder);
 }
 
-export function removeSub(holder: { subs: SubList }, eff: Effect): void {
+export function removeSub(holder: SubscriberHolder, eff: Effect): void {
   const subs = holder.subs;
   if (subs === null) return;
   if (typeof subs === "function") {
@@ -24,6 +31,7 @@ export function removeSub(holder: { subs: SubList }, eff: Effect): void {
   } else {
     const idx = subs.indexOf(eff);
     if (idx >= 0) subs.splice(idx, 1);
+    if (subs.length === 0) holder.subs = null;
   }
 }
 
@@ -32,13 +40,14 @@ export function notifySubs(subs: Exclude<SubList, null>, batching: boolean): voi
     if (batching) enqueueEffect(subs); else subs();
     return;
   }
+  const snapshot = [...subs];
   if (batching) {
-    for (const sub of subs) enqueueEffect(sub);
+    for (const sub of snapshot) enqueueEffect(sub);
     return;
   }
   let lastError: unknown;
   let hasError = false;
-  for (const sub of subs) {
+  for (const sub of snapshot) {
     try {
       sub();
     } catch (e) {