@yiin/reactive-proxy-state 1.0.14 → 1.0.16

package/dist/index.js

@@ -410,6 +410,18 @@ function cleanupEffect(effect) {
     effect.dependencies.clear();
   }
 }
+function runCleanupFunctions(effect) {
+  if (effect.cleanupFns && effect.cleanupFns.length > 0) {
+    effect.cleanupFns.forEach((cleanupFn) => {
+      try {
+        cleanupFn();
+      } catch (error) {
+        console.error("Error in effect cleanup function:", error);
+      }
+    });
+    effect.cleanupFns = [];
+  }
+}
 function track(target, key) {
   if (!activeEffect || !activeEffect.active)
     return;
@@ -501,18 +513,20 @@ function trigger(target, key) {
 function watchEffect(effectCallback, options = {}) {
   const run = () => {
     if (!effectFn.active) {
-      try {
-        return effectCallback();
-      } catch (e) {
-        console.error("error in stopped watchEffect callback:", e);
-        return;
-      }
+      throw new Error("Trying to run a stopped effect");
     }
     const previousEffect = activeEffect;
     try {
+      runCleanupFunctions(effectFn);
       cleanupEffect(effectFn);
       setActiveEffect(effectFn);
-      return effectCallback();
+      const onCleanup = (cleanupFn) => {
+        if (!effectFn.cleanupFns) {
+          effectFn.cleanupFns = [];
+        }
+        effectFn.cleanupFns.push(cleanupFn);
+      };
+      return effectCallback(onCleanup);
     } finally {
       setActiveEffect(previousEffect);
     }
@@ -522,13 +536,15 @@ function watchEffect(effectCallback, options = {}) {
     dependencies: new Set,
     options,
     active: true,
-    _rawCallback: effectCallback
+    _rawCallback: effectCallback,
+    cleanupFns: []
   };
   if (!options.lazy) {
     effectFn.run();
   }
   const stopHandle = () => {
     if (effectFn.active) {
+      runCleanupFunctions(effectFn);
       cleanupEffect(effectFn);
       effectFn.active = false;
       queuedEffects.delete(effectFn);
@@ -1454,6 +1470,7 @@ export {
   setPathConcat,
   setInPathCache,
   setActiveEffect,
+  runCleanupFunctions,
   ref,
   reactive,
   pathConcatCache,

package/dist/watch-effect.d.ts

@@ -1,4 +1,4 @@
-type EffectCallback<T = any> = () => T;
+type EffectCallback<T = any> = (onCleanup: (cleanupFn: () => void) => void) => T;
 type Scheduler = (job: () => void) => void;
 export interface WatchEffectStopHandle<T = any> {
     (): void;
@@ -11,6 +11,7 @@ export interface TrackedEffect<T = any> {
     active?: boolean;
     _rawCallback: EffectCallback<T>;
     triggerDepth?: number;
+    cleanupFns?: (() => void)[];
 }
 export declare let activeEffect: TrackedEffect<any> | null;
 export declare function setActiveEffect(effect: TrackedEffect<any> | null): void;
@@ -19,6 +20,11 @@ export declare function setActiveEffect(effect: TrackedEffect<any> | null): void
  * this is crucial to prevent memory leaks and unnecessary updates when an effect is stopped or re-run.
  */
 export declare function cleanupEffect(effect: TrackedEffect<any>): void;
+/**
+ * runs all cleanup functions registered for an effect and clears them.
+ * called before re-running an effect or when stopping it.
+ */
+export declare function runCleanupFunctions(effect: TrackedEffect<any>): void;
 /**
  * establishes a dependency between the currently active effect and a specific object property.
  * called by proxy getters or ref getters.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yiin/reactive-proxy-state",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "author": "Yiin <stanislovas@yiin.lt>",
   "repository": {
     "type": "git",