@esportsplus/reactivity 0.12.2 → 0.12.4

package/build/constants.d.ts

@@ -11,4 +11,5 @@ declare const STATE_CHECK: number;
 declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
-export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+declare const STATE_NOTIFY_MASK: number;
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STATE_NOTIFY_MASK, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/constants.js

@@ -11,4 +11,5 @@ const STATE_CHECK = 1 << 0;
 const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
-export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STATE_NOTIFY_MASK, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/reactive/array.d.ts

@@ -57,7 +57,6 @@ declare class ReactiveArray<T> {
     splice(start: number, deleteCount?: number, ...input: T[]): Item<T>[];
     unshift(...input: T[]): number;
 }
-declare const isReactiveArray: (value: any) => value is ReactiveArray<any>;
-export default function array<T>(input: T[]): API<T>;
-export { isReactiveArray };
+declare const _default: <T>(input: T[]) => API<T>;
+export default _default;
 export type { API as ReactiveArray };

package/build/reactive/array.js

@@ -63,7 +63,7 @@ class ReactiveArray {
         }
     }
     map(fn, i, n) {
-        let { data, proxy } = this, values = [];
+        let { data, proxy } = this;
         if (i === undefined) {
             i = 0;
         }
@@ -71,9 +71,10 @@ class ReactiveArray {
             n = data.length;
         }
         n = Math.min(n, data.length);
+        let values = new Array(n - i);
         for (; i < n; i++) {
             let item = data[i];
-            values.push(fn.call(proxy, (isComputed(item) ? item.value : item), i));
+            values[i] = fn.call(proxy, (isComputed(item) ? item.value : item), i);
         }
         return values;
     }
@@ -86,14 +87,18 @@ class ReactiveArray {
             if (listeners === undefined) {
                 this.listeners[event] = [listener];
             }
-            else if (listeners.indexOf(listener) === -1) {
-                let i = listeners.indexOf(null);
-                if (i === -1) {
-                    listeners.push(listener);
-                }
-                else {
-                    listeners[i] = listener;
+            else {
+                let hole = listeners.length;
+                for (let i = 0, n = hole; i < n; i++) {
+                    let l = listeners[i];
+                    if (l === listener) {
+                        return;
+                    }
+                    else if (l === null && hole === n) {
+                        hole = i;
+                    }
                 }
+                listeners[hole] = listener;
             }
         }
     }
@@ -153,25 +158,22 @@ class ReactiveArray {
     }
 }
 function factory(input) {
-    let items = [];
-    for (let i = 0, n = input.length; i < n; i++) {
+    let n = input.length, output = new Array(n);
+    for (let i = 0; i < n; i++) {
         let value = input[i];
         if (isFunction(value)) {
-            items[i] = computed(value);
+            output[i] = computed(value);
         }
         else if (isObject(value)) {
-            items[i] = object(value);
+            output[i] = object(value);
         }
         else {
-            items[i] = value;
+            output[i] = value;
         }
     }
-    return items;
+    return output;
 }
-const isReactiveArray = (value) => {
-    return isObject(value) && REACTIVE_ARRAY in value;
-};
-export default function array(input) {
+export default (input) => {
     let proxy = new Proxy({}, {
         get(_, key) {
             if (isNumber(key)) {
@@ -192,13 +194,12 @@ export default function array(input) {
                 return true;
             }
             else if (key === 'length') {
-                return array.length = value;
+                array.length = value;
+                return true;
             }
             return false;
         }
     }), wrapped = factory(input);
     let array = new ReactiveArray(wrapped, proxy);
     return proxy;
-}
-;
-export { isReactiveArray };
+};

package/build/reactive/object.d.ts

@@ -6,10 +6,12 @@ type API<T extends Record<PropertyKey, unknown>> = Prettify<{
 }> & ReactiveObject<T>;
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT]: boolean;
+    private disposers;
     constructor(data: T);
     dispose(): void;
 }
 declare const isReactiveObject: (value: any) => value is ReactiveObject<any>;
-export default function object<T extends Record<PropertyKey, unknown>>(input: T): ReactiveObject<T>;
+declare const _default: <T extends Record<PropertyKey, unknown>>(input: T) => API<T>;
+export default _default;
 export { isReactiveObject };
 export type { API as ReactiveObject };

package/build/reactive/object.js

@@ -1,71 +1,71 @@
 import { defineProperty, isArray, isFunction, isObject, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, isComputed, read, root, set, signal } from '../system.js';
+import { computed, dispose, effect, read, root, set, signal } from '../system.js';
 import { REACTIVE_OBJECT } from '../constants.js';
-import array, { isReactiveArray } from './array.js';
+import array from './array.js';
 class ReactiveObject {
     [REACTIVE_OBJECT] = true;
+    disposers = null;
     constructor(data) {
-        for (let key in data) {
-            let value = data[key];
+        let keys = Object.keys(data);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let key = keys[i], value = data[key];
             if (isArray(value)) {
-                let a = array(value);
+                let node = array(value);
+                (this.disposers ??= []).push(() => node.dispose());
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        return a;
-                    }
+                    value: node
                 });
             }
             else if (isFunction(value)) {
-                let c;
+                let node;
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        if (c === undefined) {
+                    get: () => {
+                        if (node === undefined) {
                             root(() => {
-                                c = computed(value);
-                                if (isPromise(c.value)) {
-                                    let factory = c, version = 0;
-                                    c = signal(undefined);
-                                    effect(() => {
+                                node = computed(value);
+                                if (isPromise(node.value)) {
+                                    let factory = node, version = 0;
+                                    node = signal(undefined);
+                                    (this.disposers ??= []).push(effect(() => {
                                         let id = ++version;
-                                        read(factory).then((value) => {
+                                        read(factory).then((v) => {
                                             if (id !== version) {
                                                 return;
                                             }
-                                            set(c, value);
+                                            set(node, v);
                                         });
-                                    });
+                                    }));
+                                }
+                                else {
+                                    (this.disposers ??= []).push(() => dispose(node));
                                 }
                             });
                         }
-                        return read(c);
+                        return read(node);
                     }
                 });
             }
             else {
-                let s = signal(value);
+                let node = signal(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(s);
+                        return read(node);
                     },
                     set(v) {
-                        set(s, v);
+                        set(node, v);
                     }
                 });
             }
         }
     }
     dispose() {
-        let value;
-        for (let key in this) {
-            value = this[key];
-            if (isReactiveArray(value) || isReactiveObject(value)) {
-                value.dispose();
-            }
-            else if (isComputed(value)) {
-                dispose(value);
+        let disposers = this.disposers;
+        if (disposers) {
+            for (let i = 0, n = disposers.length; i < n; i++) {
+                disposers[i]();
             }
         }
     }
@@ -73,8 +73,7 @@ class ReactiveObject {
 const isReactiveObject = (value) => {
     return isObject(value) && REACTIVE_OBJECT in value;
 };
-export default function object(input) {
+export default (input) => {
     return new ReactiveObject(input);
-}
-;
+};
 export { isReactiveObject };

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_RECOMPUTING } from './constants.js';
-let depth = 0, heap = new Array(2048), index = 0, length = 0, microtask = queueMicrotask, notified = false, observer = null, stabilizer = STABILIZER_IDLE, version = 0;
+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;
 function cleanup(computed) {
     if (!computed.cleanup) {
         return;
@@ -55,10 +55,10 @@ function insertIntoHeap(computed) {
         computed.prevHeap = tail;
         heapAtHeight.prevHeap = computed;
     }
-    if (height > length) {
-        length = height;
+    if (height > heap_n) {
+        heap_n = height;
         if (height >= heap.length) {
-            heap.length = Math.round(heap.length * 1.5);
+            heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
 }
@@ -106,7 +106,7 @@ function link(dep, sub) {
 }
 function notify(computed, newState = STATE_DIRTY) {
     let state = computed.state;
-    if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
+    if ((state & STATE_NOTIFY_MASK) >= newState) {
         return;
     }
     computed.state = state | newState;
@@ -122,7 +122,9 @@ function recompute(computed, del) {
         computed.nextHeap = undefined;
         computed.prevHeap = computed;
     }
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
     let o = observer, ok = true, value;
     observer = computed;
     computed.depsTail = null;
@@ -175,15 +177,18 @@ function stabilize() {
     let o = observer;
     observer = null;
     stabilizer = STABILIZER_RUNNING;
-    for (index = 0; index <= length; index++) {
-        let computed = heap[index];
-        heap[index] = undefined;
+    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+        let computed = heap[heap_i];
+        heap[heap_i] = undefined;
         while (computed !== undefined) {
             let next = computed.nextHeap;
             recompute(computed, false);
             computed = next;
         }
     }
+    while (heap_n > 0 && heap[heap_n] === undefined) {
+        heap_n--;
+    }
     observer = o;
     if (stabilizer === STABILIZER_RESCHEDULE) {
         microtask(stabilize);
@@ -193,7 +198,7 @@ function stabilize() {
     }
 }
 function unlink(link) {
-    let { dep, nextDep, nextSub, prevSub } = link;
+    let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
     if (nextSub !== null) {
         nextSub.prevSub = prevSub;
     }
@@ -267,7 +272,9 @@ const dispose = (computed) => {
         dep = unlink(dep);
     }
     computed.deps = null;
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
 };
 const effect = (fn) => {
     let c = computed(fn);
@@ -285,14 +292,15 @@ const onCleanup = (fn) => {
     if (!observer) {
         return fn;
     }
-    if (!observer.cleanup) {
+    let cleanup = observer.cleanup;
+    if (!cleanup) {
         observer.cleanup = fn;
     }
-    else if (isArray(observer.cleanup)) {
-        observer.cleanup.push(fn);
+    else if (isArray(cleanup)) {
+        cleanup.push(fn);
     }
     else {
-        observer.cleanup = [observer.cleanup, fn];
+        observer.cleanup = [cleanup, fn];
     }
     return fn;
 };
@@ -304,11 +312,10 @@ const read = (node) => {
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
-            if (height >= index ||
-                node.state & (STATE_DIRTY | STATE_CHECK)) {
+            if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
                 if (!notified) {
                     notified = true;
-                    for (let i = 0; i <= length; i++) {
+                    for (let i = 0; i <= heap_n; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
                             notify(computed);
                         }

package/package.json

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

package/src/constants.ts

@@ -26,6 +26,8 @@ const STATE_RECOMPUTING = 1 << 2;
 
 const STATE_IN_HEAP = 1 << 3;
 
+const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
+
 
 export {
     COMPUTED,
@@ -33,6 +35,7 @@ export {
     REACTIVE_OBJECT,
     SIGNAL,
     STABILIZER_IDLE,
+    STATE_NOTIFY_MASK,
     STABILIZER_RESCHEDULE,
     STABILIZER_RUNNING,
     STABILIZER_SCHEDULED,

package/src/reactive/array.ts

@@ -53,7 +53,9 @@ class ReactiveArray<T> {
     disposables: number = 0;
 
     private data: Item<T>[];
+
     private listeners: Record<string, (Listener<any> | null)[]> | null = null;
+
     private proxy: API<T>;
 
 
@@ -134,8 +136,7 @@ class ReactiveArray<T> {
         i?: number,
         n?: number
     ) {
-        let { data, proxy } = this,
-            values: R[] = [];
+        let { data, proxy } = this;
 
         if (i === undefined) {
             i = 0;
@@ -147,15 +148,15 @@ class ReactiveArray<T> {
 
         n = Math.min(n, data.length);
 
+        let values: R[] = new Array(n - i);
+
         for (; i < n; i++) {
             let item = data[i];
 
-            values.push(
-                fn.call(
-                    proxy,
-                    (isComputed(item) ? item.value : item) as Value<T>,
-                    i
-                )
+            values[i] = fn.call(
+                proxy,
+                (isComputed(item) ? item.value : item) as Value<T>,
+                i
             );
         }
 
@@ -172,15 +173,21 @@ class ReactiveArray<T> {
             if (listeners === undefined) {
                 this.listeners[event] = [listener];
             }
-            else if (listeners.indexOf(listener) === -1) {
-                let i = listeners.indexOf(null);
+            else {
+                let hole = listeners.length;
 
-                if (i === -1) {
-                    listeners.push(listener);
-                }
-                else {
-                    listeners[i] = listener;
+                for (let i = 0, n = hole; i < n; i++) {
+                    let l = listeners[i];
+
+                    if (l === listener) {
+                        return;
+                    }
+                    else if (l === null && hole === n) {
+                        hole = i;
+                    }
                 }
+
+                listeners[hole] = listener;
             }
         }
     }
@@ -269,32 +276,28 @@ class ReactiveArray<T> {
 
 
 function factory<T>(input: T[]) {
-    let items: Item<T>[] = [];
+    let n = input.length,
+        output: Item<T>[] = new Array(n);
 
-    for (let i = 0, n = input.length; i < n; i++) {
+    for (let i = 0; i < n; i++) {
         let value = input[i];
 
         if (isFunction(value)) {
-            items[i] = computed(value as Computed<T>['fn']);
+            output[i] = computed(value as Computed<T>['fn']);
         }
         else if (isObject(value)) {
-            items[i] = object(value) as Item<T>;
+            output[i] = object(value) as Item<T>;
         }
         else {
-            items[i] = value;
+            output[i] = value;
         }
     }
 
-    return items;
+    return output;
 }
 
 
-const isReactiveArray = (value: any): value is ReactiveArray<any> => {
-    return isObject(value) && REACTIVE_ARRAY in value;
-};
-
-
-export default function array<T>(input: T[]) {
+export default <T>(input: T[]) => {
     let proxy = new Proxy({}, {
             get(_: any, key: any) {
                 if (isNumber(key)) {
@@ -318,7 +321,8 @@ export default function array<T>(input: T[]) {
                     return true;
                 }
                 else if (key === 'length') {
-                    return array.length = value;
+                    array.length = value;
+                    return true;
                 }
 
                 return false;
@@ -330,5 +334,4 @@ export default function array<T>(input: T[]) {
 
     return proxy;
 };
-export { isReactiveArray };
 export type { API as ReactiveArray };

package/src/reactive/object.ts

@@ -1,8 +1,8 @@
 import { defineProperty, isArray, isFunction, isObject, isPromise, Prettify } from '@esportsplus/utilities';
-import { computed, dispose, effect, isComputed, read, root, set, signal } from '~/system';
+import { computed, dispose, effect, read, root, set, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
 import { REACTIVE_OBJECT } from '~/constants';
-import array, { isReactiveArray } from './array';
+import array from './array';
 
 
 type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
@@ -12,65 +12,76 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT] = true;
 
 
+    private disposers: VoidFunction[] | null = null;
+
+
     constructor(data: T) {
-        for (let key in data) {
-            let value = data[key];
+        let keys = Object.keys(data);
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let key = keys[i],
+                value = data[key];
 
             if (isArray(value)) {
-                let a = array(value);
+                let node = array(value);
+
+                (this.disposers ??= []).push( () => node.dispose() );
 
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        return a;
-                    }
+                    value: node
                 });
             }
             else if (isFunction(value)) {
-                let c: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
+                let node: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
 
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        if (c === undefined) {
+                    get: () => {
+                        if (node === undefined) {
                             root(() => {
-                                c = computed(value as Computed<T[typeof key]>['fn']);
+                                node = computed(value as Computed<T[typeof key]>['fn']);
 
-                                if (isPromise(c.value)) {
-                                    let factory = c,
+                                if (isPromise(node.value)) {
+                                    let factory = node,
                                         version = 0;
 
-                                    c = signal(undefined);
+                                    node = signal<T[typeof key] | undefined>(undefined);
 
-                                    effect(() => {
-                                        let id = ++version;
+                                    (this.disposers ??= []).push(
+                                        effect(() => {
+                                            let id = ++version;
 
-                                        (read(factory) as Promise<T[typeof key]>).then((value) => {
-                                            if (id !== version) {
-                                                return;
-                                            }
+                                            (read(factory) as Promise<T[typeof key]>).then((v) => {
+                                                if (id !== version) {
+                                                    return;
+                                                }
 
-                                            set(c as Signal<typeof value>, value);
-                                        });
-                                    });
+                                                set(node as Signal<typeof v>, v);
+                                            });
+                                        })
+                                    )
+                                }
+                                else {
+                                    (this.disposers ??= []).push(() => dispose(node as Computed<T[typeof key]>));
                                 }
                             });
                         }
 
-                        return read(c!);
+                        return read(node!);
                     }
                 });
             }
             else {
-                let s = signal(value);
+                let node = signal(value);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(s);
+                        return read(node);
                     },
                     set(v: typeof value) {
-                        set(s, v);
+                        set(node, v);
                     }
                 });
             }
@@ -79,16 +90,11 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
 
 
     dispose() {
-        let value;
+        let disposers = this.disposers;
 
-        for (let key in this) {
-            value = this[key];
-
-            if (isReactiveArray(value) || isReactiveObject(value)) {
-                value.dispose();
-            }
-            else if (isComputed(value)) {
-                dispose(value);
+        if (disposers) {
+            for (let i = 0, n = disposers.length; i < n; i++) {
+                disposers[i]();
             }
         }
     }
@@ -100,8 +106,8 @@ const isReactiveObject = (value: any): value is ReactiveObject<any> => {
 };
 
 
-export default function object<T extends Record<PropertyKey, unknown>>(input: T) {
-    return new ReactiveObject<T>(input);
+export default <T extends Record<PropertyKey, unknown>>(input: T) => {
+    return new ReactiveObject<T>(input) as API<T>;
 };
 export { isReactiveObject };
 export type { API as ReactiveObject };

package/src/system.ts

@@ -2,15 +2,15 @@ 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_RECOMPUTING
+    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, Link, Signal } from './types';
 
 
 let depth = 0,
-    heap: (Computed<unknown> | undefined)[] = new Array(2048),
-    index = 0,
-    length = 0,
+    heap: (Computed<unknown> | undefined)[] = new Array(64),
+    heap_i = 0,
+    heap_n = 0,
     microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
@@ -93,12 +93,12 @@ function insertIntoHeap<T>(computed: Computed<T>) {
         heapAtHeight.prevHeap = computed;
     }
 
-    if (height > length) {
-        length = height;
+    if (height > heap_n) {
+        heap_n = height;
 
         // Simple auto adjust to avoid manual management within apps.
         if (height >= heap.length) {
-            heap.length = Math.round(heap.length * 1.5);
+            heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
 }
@@ -163,7 +163,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
 function notify<T>(computed: Computed<T>, newState = STATE_DIRTY) {
     let state = computed.state;
 
-    if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
+    if ((state & STATE_NOTIFY_MASK) >= newState) {
         return;
     }
 
@@ -183,7 +183,9 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
         computed.prevHeap = computed;
     }
 
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
 
     let o = observer,
         ok = true,
@@ -258,10 +260,10 @@ function stabilize() {
     observer = null;
     stabilizer = STABILIZER_RUNNING;
 
-    for (index = 0; index <= length; index++) {
-        let computed = heap[index];
+    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+        let computed = heap[heap_i];
 
-        heap[index] = undefined;
+        heap[heap_i] = undefined;
 
         while (computed !== undefined) {
             let next = computed.nextHeap;
@@ -272,6 +274,10 @@ function stabilize() {
         }
     }
 
+    while (heap_n > 0 && heap[heap_n] === undefined) {
+        heap_n--;
+    }
+
     observer = o;
 
     if (stabilizer === STABILIZER_RESCHEDULE) {
@@ -284,7 +290,10 @@ function stabilize() {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlink(link: Link): Link | null {
-    let { dep, nextDep, nextSub, prevSub } = link;
+    let dep = link.dep,
+        nextDep = link.nextDep,
+        nextSub = link.nextSub,
+        prevSub = link.prevSub;
 
     if (nextSub !== null) {
         nextSub.prevSub = prevSub;
@@ -377,7 +386,9 @@ const dispose = <T>(computed: Computed<T>) => {
 
     computed.deps = null;
 
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
 };
 
 const effect = <T>(fn: Computed<T>['fn']) => {
@@ -401,14 +412,16 @@ const onCleanup = (fn: VoidFunction): typeof fn => {
         return fn;
     }
 
-    if (!observer.cleanup) {
+    let cleanup = observer.cleanup;
+
+    if (!cleanup) {
         observer.cleanup = fn;
     }
-    else if (isArray(observer.cleanup)) {
-        observer.cleanup.push(fn);
+    else if (isArray(cleanup)) {
+        cleanup.push(fn);
     }
     else {
-        observer.cleanup = [observer.cleanup, fn];
+        observer.cleanup = [cleanup, fn];
     }
 
     return fn;
@@ -425,14 +438,11 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
                 observer.height = height + 1;
             }
 
-            if (
-                height >= index ||
-                node.state & (STATE_DIRTY | STATE_CHECK)
-            ) {
+            if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
                 if (!notified) {
                     notified = true;
 
-                    for (let i = 0; i <= length; i++) {
+                    for (let i = 0; i <= heap_n; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
                             notify(computed);
                         }