@esportsplus/reactivity 0.15.0 → 0.16.1

package/build/reactive/index.js

@@ -3,20 +3,24 @@ import { onCleanup, root } from '../system.js';
 import array from './array.js';
 import object from './object.js';
 export default (input) => {
-    let value;
-    return root(() => {
+    let dispose = false, value = root(() => {
+        let response;
         if (isArray(input)) {
-            value = array(input);
+            response = array(input);
         }
         else if (isObject(input)) {
-            value = object(input);
+            response = object(input);
         }
-        if (value) {
+        if (response) {
             if (root.disposables) {
-                onCleanup(() => value.dispose());
+                dispose = true;
             }
-            return value;
+            return response;
         }
         throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
     });
+    if (dispose) {
+        onCleanup(() => value.dispose());
+    }
+    return value;
 };

package/build/system.d.ts

@@ -7,7 +7,7 @@ declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
 declare const root: {
-    <T>(fn: () => T): T;
+    <T>(fn: (dispose?: VoidFunction) => T): T;
     disposables: number;
 };
 declare const set: <T>(signal: Signal<T>, value: T) => void;

package/build/system.js

@@ -1,6 +1,6 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { COMPUTED, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
-let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, microtask = queueMicrotask, notified = false, observer = null, stabilizer = STABILIZER_IDLE, version = 0;
+let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, microtask = queueMicrotask, notified = false, observer = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0;
 function cleanup(computed) {
     if (!computed.cleanup) {
         return;
@@ -262,6 +262,9 @@ const computed = (fn) => {
     else {
         recompute(self, false);
         root.disposables++;
+        if (scope) {
+            onCleanup(() => dispose(self));
+        }
     }
     return self;
 };
@@ -289,18 +292,19 @@ const isSignal = (value) => {
     return isObject(value) && SIGNAL in value;
 };
 const onCleanup = (fn) => {
-    if (!observer) {
+    let parent = observer || scope;
+    if (!parent) {
         return fn;
     }
-    let cleanup = observer.cleanup;
+    let cleanup = parent.cleanup;
     if (!cleanup) {
-        observer.cleanup = fn;
+        parent.cleanup = fn;
     }
     else if (isArray(cleanup)) {
         cleanup.push(fn);
     }
     else {
-        observer.cleanup = [cleanup, fn];
+        parent.cleanup = [cleanup, fn];
     }
     return fn;
 };
@@ -328,12 +332,23 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let d = root.disposables, o = observer;
+    let c, d = root.disposables, o = observer, s = scope, self = null, tracking = fn.length, value;
     observer = null;
     root.disposables = 0;
-    let value = fn();
+    if (tracking) {
+        scope = self = { cleanup: null };
+        value = fn(c = () => dispose(self));
+    }
+    else {
+        scope = null;
+        value = fn();
+    }
     observer = o;
     root.disposables = d;
+    scope = s;
+    if (c) {
+        onCleanup(c);
+    }
     return value;
 };
 root.disposables = 0;

package/package.json

@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/index.ts

@@ -20,24 +20,31 @@ type Input<T> =
 
 
 export default <T>(input: Input<T>): API<T> => {
-    let value: API<T> | undefined;
-
-    return root(() => {
-        if (isArray(input)) {
-            value = array(input) as API<T>;
-        }
-        else if (isObject(input)) {
-            value = object(input) as API<T>;
-        }
-
-        if (value) {
-            if (root.disposables) {
-                onCleanup(() => value!.dispose());
+    let dispose = false,
+        value = root(() => {
+            let response: API<T> | undefined;
+
+            if (isArray(input)) {
+                response = array(input) as API<T>;
+            }
+            else if (isObject(input)) {
+                response = object(input) as API<T>;
+            }
+
+            if (response) {
+                if (root.disposables) {
+                    dispose = true;
+                }
+
+                return response;
             }
 
-            return value;
-        }
+            throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+        });
+
+    if (dispose) {
+        onCleanup(() => value.dispose());
+    }
 
-        throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
-    });
+    return value;
 };

package/src/system.ts

@@ -14,6 +14,7 @@ let depth = 0,
     microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
+    scope: Computed<unknown> | null = null,
     stabilizer = STABILIZER_IDLE,
     version = 0;
 
@@ -370,6 +371,10 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     else {
         recompute(self, false);
         root.disposables++;
+
+        if (scope) {
+            onCleanup(() => dispose(self));
+        }
     }
 
     return self;
@@ -408,20 +413,22 @@ const isSignal = (value: unknown): value is Signal<unknown> => {
 };
 
 const onCleanup = (fn: VoidFunction): typeof fn => {
-    if (!observer) {
+    let parent = observer || scope;
+
+    if (!parent) {
         return fn;
     }
 
-    let cleanup = observer.cleanup;
+    let cleanup = parent.cleanup;
 
     if (!cleanup) {
-        observer.cleanup = fn;
+        parent.cleanup = fn;
     }
     else if (isArray(cleanup)) {
         cleanup.push(fn);
     }
     else {
-        observer.cleanup = [cleanup, fn];
+        parent.cleanup = [cleanup, fn];
     }
 
     return fn;
@@ -457,17 +464,34 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
     return node.value;
 };
 
-const root = <T>(fn: () => T) => {
-    let d = root.disposables,
-        o = observer;
+const root = <T>(fn: (dispose?: VoidFunction) => T) => {
+    let c,
+        d = root.disposables,
+        o = observer,
+        s = scope,
+        self: Computed<unknown> | null = null,
+        tracking = fn.length,
+        value: T;
 
     observer = null;
     root.disposables = 0;
 
-    let value = fn();
+    if (tracking) {
+        scope = self = { cleanup: null } as Computed<unknown>;
+        value = fn( c = () => dispose(self!) );
+    }
+    else {
+        scope = null;
+        value = fn();
+    }
 
     observer = o;
     root.disposables = d;
+    scope = s;
+
+    if (c) {
+        onCleanup(c);
+    }
 
     return value;
 };