@esportsplus/reactivity 0.14.3 → 0.16.0

package/build/reactive/array.d.ts

@@ -4,7 +4,7 @@ type ReactiveArray<T extends unknown[]> = Prettify<Infer<T> & {
     clear: () => void;
     dispose: () => void;
     dispatch: <K extends keyof Events<T[number]>, V>(event: K, value?: V) => void;
-    map: <R>(fn: (this: ReactiveArray<T>, value: T[number], i: number) => R, i?: number, n?: number) => R[];
+    map: <R>(fn: (this: ReactiveArray<T>, value: T[number], i: number) => R) => R[];
     on: <K extends keyof Events<T[number]>>(event: K, listener: Listener<Events<T[number]>[K]>) => void;
     once: <K extends keyof Events<T[number]>>(event: K, listener: Listener<Events<T[number]>[K]>) => void;
 }>;
@@ -60,7 +60,7 @@ declare const _default: <T>(data: T[]) => {
         clear: () => void;
         dispose: () => void;
         dispatch: <K extends keyof Events<T_1[number]>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
         on: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
         once: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
     };
@@ -77,7 +77,7 @@ declare const _default: <T>(data: T[]) => {
     };
     some: (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any) => boolean;
     forEach: (callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => void, thisArg?: any) => void;
-    map: (<U>(callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => U, thisArg?: any) => U[]) & (<R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[]);
+    map: (<U>(callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => U, thisArg?: any) => U[]) & (<R>(fn: (this: any, value: T, i: number) => R) => R[]);
     filter: {
         <S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): S[];
         (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): Infer<T>[];
@@ -101,7 +101,7 @@ declare const _default: <T>(data: T[]) => {
         clear: () => void;
         dispose: () => void;
         dispatch: <K extends keyof Events<T_1[number]>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
         on: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
         once: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
     };
@@ -109,7 +109,7 @@ declare const _default: <T>(data: T[]) => {
         clear: () => void;
         dispose: () => void;
         dispatch: <K extends keyof Events<T_1[number]>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
         on: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
         once: <K extends keyof Events<T_1[number]>>(event: K, listener: Listener<Events<T>[K]>) => void;
     };

package/build/reactive/array.js

@@ -37,16 +37,9 @@ function dispose(data) {
         cleanup(item);
     }
 }
-function map(data, proxy, fn, i, n) {
-    if (i === undefined) {
-        i = 0;
-    }
-    if (n === undefined) {
-        n = data.length;
-    }
-    n = Math.min(n, data.length);
-    let values = new Array(n - i);
-    for (; i < n; i++) {
+function map(data, proxy, fn) {
+    let n = data.length, values = new Array(n);
+    for (let i = 0; i < n; i++) {
         values[i] = fn.call(proxy, data[i], i);
     }
     return values;
@@ -170,8 +163,8 @@ export default (data) => {
             dispose(data);
             return proxy;
         },
-        map: (fn, i, n) => {
-            return map(data, proxy, fn, i, n);
+        map: (fn) => {
+            return map(data, proxy, fn);
         },
         on: (event, listener) => {
             on(listeners, event, listener);

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,14 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let d = root.disposables, o = observer;
+    let d = root.disposables, o = observer, s = scope, self = null, tracking = fn.length;
     observer = null;
     root.disposables = 0;
-    let value = fn();
+    scope = tracking ? (self = { cleanup: null }) : null;
+    let value = fn(tracking ? () => dispose(self) : undefined);
     observer = o;
     root.disposables = d;
+    scope = s;
     return value;
 };
 root.disposables = 0;

package/package.json

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

package/src/reactive/array.ts

@@ -9,7 +9,7 @@ type ReactiveArray<T extends unknown[]> = Prettify<
         clear: () => void;
         dispose: () => void;
         dispatch: <K extends keyof Events<T[number]>, V>(event: K, value?: V) => void;
-        map: <R>(fn: (this: ReactiveArray<T>, value: T[number], i: number) => R, i?: number, n?: number) => R[];
+        map: <R>(fn: (this: ReactiveArray<T>, value: T[number], i: number) => R) => R[];
         on: <K extends keyof Events<T[number]>>(event: K, listener: Listener<Events<T[number]>[K]>) => void;
         once: <K extends keyof Events<T[number]>>(event: K, listener: Listener<Events<T[number]>[K]>) => void;
     }
@@ -99,23 +99,12 @@ function dispose<T>(data: T[]) {
 function map<T, R>(
     data: T[],
     proxy: ReactiveArray<typeof data>,
-    fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R,
-    i?: number,
-    n?: number
+    fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R
 ) {
-    if (i === undefined) {
-        i = 0;
-    }
-
-    if (n === undefined) {
-        n = data.length;
-    }
-
-    n = Math.min(n, data.length);
-
-    let values: R[] = new Array(n - i);
+    let n = data.length,
+        values: R[] = new Array(n);
 
-    for (; i < n; i++) {
+    for (let i = 0; i < n; i++) {
         values[i] = fn.call(proxy, data[i], i);
     }
 
@@ -270,12 +259,8 @@ export default <T>(data: T[]) => {
                 dispose(data);
                 return proxy;
             },
-            map: <R>(
-                fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R,
-                i?: number,
-                n?: number
-            ) => {
-                return map(data, proxy, fn, i, n);
+            map: <R>(fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R) => {
+                return map(data, proxy, fn);
             },
             on: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => {
                 on(listeners, event, listener);

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,22 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
     return node.value;
 };
 
-const root = <T>(fn: () => T) => {
+const root = <T>(fn: (dispose?: VoidFunction) => T) => {
     let d = root.disposables,
-        o = observer;
+        o = observer,
+        s = scope,
+        self: Computed<unknown> | null = null,
+        tracking = fn.length;
 
     observer = null;
     root.disposables = 0;
+    scope = tracking ? (self = { cleanup: null } as Computed<unknown>) : null;
 
-    let value = fn();
+    let value = fn( tracking ? () => dispose(self!) : undefined);
 
     observer = o;
     root.disposables = d;
+    scope = s;
 
     return value;
 };