@esportsplus/reactivity 0.8.0 → 0.8.1

package/build/index.d.ts

@@ -1,4 +1,3 @@
 export { default as reactive } from './reactive/index.js';
-export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
-export { default as scheduler } from './scheduler.js';
+export * from './signal.js';
 export * from './types.js';

package/build/index.js

@@ -1,4 +1,3 @@
 export { default as reactive } from './reactive/index.js';
-export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
-export { default as scheduler } from './scheduler.js';
+export * from './signal.js';
 export * from './types.js';

package/build/reactive/{promise.d.ts → async.d.ts}

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-declare class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+declare class ReactiveAsyncFunction<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
     private arguments;
     private okay;
     private response;
@@ -9,5 +9,5 @@ declare class ReactivePromise<A extends unknown[], R extends Promise<unknown>> e
     get input(): A | null;
     get ok(): boolean | null;
 }
-declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R) => ReactivePromise<A, R>;
+declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R) => ReactiveAsyncFunction<A, R>;
 export default _default;

package/build/reactive/{promise.js → async.js}

@@ -1,7 +1,7 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { read, root, signal } from '../signal.js';
 let { set } = signal;
-class ReactivePromise extends CustomFunction {
+class ReactiveAsyncFunction extends CustomFunction {
     arguments;
     okay;
     response;
@@ -44,5 +44,5 @@ class ReactivePromise extends CustomFunction {
     }
 }
 export default (fn) => {
-    return new ReactivePromise(fn);
+    return new ReactiveAsyncFunction(fn);
 };

package/build/reactive/index.d.ts

@@ -1,13 +1,14 @@
+import { Computed } from '../types.js';
 import array from './array.js';
+import async from './async.js';
 import object from './object.js';
-import promise from './promise.js';
-type API<T> = T extends (...args: infer A) => Promise<infer R> ? ReturnType<typeof promise<A, Promise<R>>> : T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
-type Guard<T> = T extends (...args: unknown[]) => Promise<unknown> ? T : T extends {
+type API<T> = T extends (...args: infer A) => Promise<infer R> ? ReturnType<typeof async<A, Promise<R>>> : T extends (...args: unknown[]) => unknown ? void : T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
+type Input<T> = T extends (...args: unknown[]) => Promise<unknown> ? T : T extends (...args: unknown[]) => unknown ? Computed<T>['fn'] : T extends {
     dispose: any;
 } | {
     signals: any;
 } ? {
     never: '[ dispose, signals ] are reserved keys';
 } : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
-declare const _default: <T>(data: Guard<T>) => API<T>;
+declare const _default: <T>(input: Input<T>) => API<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,16 +1,21 @@
-import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import { isArray, isAsyncFunction, isFunction, isObject } from '@esportsplus/utilities';
+import { computed } from '../signal.js';
 import array from './array.js';
+import async from './async.js';
 import object from './object.js';
-import promise from './promise.js';
-export default (data) => {
-    if (isArray(data)) {
-        return array(data);
+export default (input) => {
+    if (isArray(input)) {
+        return array(input);
     }
-    else if (isObject(data)) {
-        return object(data);
+    else if (isAsyncFunction(input)) {
+        return async(input);
     }
-    else if (isPromise(data)) {
-        return promise(data);
+    else if (isFunction(input)) {
+        computed(input);
+        return undefined;
     }
-    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
+    else if (isObject(input)) {
+        return object(input);
+    }
+    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
 };

package/build/reactive/object.js

@@ -2,7 +2,7 @@ import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf } fr
 import array from './array.js';
 import { computed, dispose, read, signal } from '../signal.js';
 import { Disposable } from './disposable.js';
-import promise from './promise.js';
+import async from './async.js';
 let { set } = signal;
 class ReactiveObject extends Disposable {
     disposable = {};
@@ -26,7 +26,7 @@ class ReactiveObject extends Disposable {
                 });
             }
             else if (isAsyncFunction(value)) {
-                let p = promise(value);
+                let p = async(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {

package/build/signal.d.ts

@@ -1,18 +1,14 @@
 import { Computed, Signal } from './types.js';
 declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
-declare const dispose: <T>(el: Computed<T>) => void;
+declare const dispose: <T>(computed: Computed<T>) => void;
 declare const isComputed: (value: unknown) => value is Computed<unknown>;
-declare const isReactive: (value: unknown) => value is Computed<unknown> | Signal<unknown>;
 declare const isSignal: (value: unknown) => value is Signal<unknown>;
-declare const oncleanup: (fn: VoidFunction) => typeof fn;
-declare const read: <T>(el: Signal<T> | Computed<T>) => T;
+declare const onCleanup: (fn: VoidFunction) => typeof fn;
+declare const read: <T>(node: Signal<T> | Computed<T>) => T;
 declare const root: <T>(fn: () => T) => T;
 declare const signal: {
     <T>(value: T): Signal<T>;
-    set<T>(el: Signal<T>, v: T): void;
+    set<T>(signal: Signal<T>, value: T): void;
 };
-declare const stabilize: {
-    (): void;
-    state: Signal<number>;
-};
-export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };
+declare const stabilize: () => void;
+export { computed, dispose, isComputed, isSignal, onCleanup, read, root, signal, stabilize };

package/build/signal.js

@@ -1,63 +1,64 @@
-import { isArray, isObject } from '@esportsplus/utilities';
+import { defineProperty, isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-let dirtyHeap = new Array(2000), maxDirty = 0, markedHeap = false, minDirty = 0, observer = null;
+let heap = new Array(2000), iHeap = 0, nHeap = 0, notifiedHeap = false, observer = null, scheduled = false, scheduler = null;
 function cleanup(node) {
     if (!node.cleanup) {
         return;
     }
-    if (isArray(node.cleanup)) {
-        for (let i = 0; i < node.cleanup.length; i++) {
-            node.cleanup[i]();
+    let cleanup = node.cleanup;
+    if (isArray(cleanup)) {
+        for (let i = 0; i < cleanup.length; i++) {
+            cleanup[i]();
         }
     }
     else {
-        node.cleanup();
+        cleanup();
     }
     node.cleanup = null;
 }
-function deleteFromHeap(n) {
-    let state = n.state;
+function deleteFromHeap(computed) {
+    let state = computed.state;
     if (!(state & STATE_IN_HEAP)) {
         return;
     }
-    n.state = state & ~STATE_IN_HEAP;
-    let height = n.height;
-    if (n.prevHeap === n) {
-        dirtyHeap[height] = undefined;
+    computed.state = state & ~STATE_IN_HEAP;
+    let height = computed.height;
+    if (computed.prevHeap === computed) {
+        heap[height] = undefined;
     }
     else {
-        let next = n.nextHeap, dhh = dirtyHeap[height], end = next ?? dhh;
-        if (n === dhh) {
-            dirtyHeap[height] = next;
+        let next = computed.nextHeap, dhh = heap[height], end = next ?? dhh;
+        if (computed === dhh) {
+            heap[height] = next;
         }
         else {
-            n.prevHeap.nextHeap = next;
+            computed.prevHeap.nextHeap = next;
         }
-        end.prevHeap = n.prevHeap;
+        end.prevHeap = computed.prevHeap;
     }
-    n.nextHeap = undefined;
-    n.prevHeap = n;
+    computed.nextHeap = undefined;
+    computed.prevHeap = computed;
 }
-function insertIntoHeap(n) {
-    let state = n.state;
+function insertIntoHeap(computed) {
+    let state = computed.state;
     if (state & STATE_IN_HEAP) {
         return;
     }
-    n.state = state | STATE_IN_HEAP;
-    let height = n.height, heapAtHeight = dirtyHeap[height];
+    computed.state = state | STATE_IN_HEAP;
+    let height = computed.height, heapAtHeight = heap[height];
     if (heapAtHeight === undefined) {
-        dirtyHeap[height] = n;
+        heap[height] = computed;
     }
     else {
         let tail = heapAtHeight.prevHeap;
-        tail.nextHeap = n;
-        n.prevHeap = tail;
-        heapAtHeight.prevHeap = n;
-    }
-    if (height > maxDirty) {
-        maxDirty = height;
-        if (height >= dirtyHeap.length) {
-            dirtyHeap.length += 250;
+        tail.nextHeap = computed;
+        computed.prevHeap = tail;
+        heapAtHeight.prevHeap = computed;
+    }
+    if (height > nHeap) {
+        nHeap = height;
+        if (height >= heap.length) {
+            heap.length += 250;
         }
     }
 }
@@ -95,49 +96,38 @@ function link(dep, sub) {
         dep.subs = newLink;
     }
 }
-function markHeap() {
-    if (markedHeap) {
-        return;
-    }
-    markedHeap = true;
-    for (let i = 0; i <= maxDirty; i++) {
-        for (let el = dirtyHeap[i]; el !== undefined; el = el.nextHeap) {
-            markNode(el);
-        }
-    }
-}
-function markNode(el, newState = STATE_DIRTY) {
-    let state = el.state;
+function notify(computed, newState = STATE_DIRTY) {
+    let state = computed.state;
     if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
         return;
     }
-    el.state = state | newState;
-    for (let link = el.subs; link !== null; link = link.nextSub) {
-        markNode(link.sub, STATE_CHECK);
+    computed.state = state | newState;
+    for (let link = computed.subs; link !== null; link = link.nextSub) {
+        notify(link.sub, STATE_CHECK);
     }
 }
-function recompute(el, del) {
+function recompute(computed, del) {
     if (del) {
-        deleteFromHeap(el);
+        deleteFromHeap(computed);
     }
     else {
-        el.nextHeap = undefined;
-        el.prevHeap = el;
+        computed.nextHeap = undefined;
+        computed.prevHeap = computed;
     }
-    cleanup(el);
+    cleanup(computed);
     let o = observer, ok = true, value;
-    observer = el;
-    el.depsTail = null;
-    el.state = STATE_RECOMPUTING;
+    observer = computed;
+    computed.depsTail = null;
+    computed.state = STATE_RECOMPUTING;
     try {
-        value = el.fn(oncleanup);
+        value = computed.fn(onCleanup);
     }
     catch (e) {
         ok = false;
     }
     observer = o;
-    el.state = STATE_NONE;
-    let depsTail = el.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : el.deps;
+    computed.state = STATE_NONE;
+    let depsTail = computed.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
     if (toRemove !== null) {
         do {
             toRemove = unlink(toRemove);
@@ -146,21 +136,25 @@ function recompute(el, del) {
             depsTail.nextDep = null;
         }
         else {
-            el.deps = null;
+            computed.deps = null;
         }
     }
-    if (ok && value !== el.value) {
-        el.value = value;
-        for (let s = el.subs; s !== null; s = s.nextSub) {
-            let o = s.sub, state = o.state;
+    if (ok && value !== computed.value) {
+        computed.value = value;
+        for (let c = computed.subs; c !== null; c = c.nextSub) {
+            let o = c.sub, state = o.state;
             if (state & STATE_CHECK) {
                 o.state = state | STATE_DIRTY;
             }
             insertIntoHeap(o);
         }
     }
-    if (stabilize.state.value === STATE_NONE) {
-        root(() => signal.set(stabilize.state, STATE_DIRTY));
+    if (!scheduled && scheduler) {
+        scheduled = true;
+        scheduler(stabilize);
+    }
+    else {
+        throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
     }
 }
 function unlink(link) {
@@ -182,22 +176,22 @@ function unlink(link) {
     }
     return nextDep;
 }
-function update(el) {
-    if (el.state & STATE_CHECK) {
-        for (let d = el.deps; d; d = d.nextDep) {
-            let dep = d.dep;
+function update(computed) {
+    if (computed.state & STATE_CHECK) {
+        for (let link = computed.deps; link; link = link.nextDep) {
+            let dep = link.dep;
             if ('fn' in dep) {
                 update(dep);
             }
-            if (el.state & STATE_DIRTY) {
+            if (computed.state & STATE_DIRTY) {
                 break;
             }
         }
     }
-    if (el.state & STATE_DIRTY) {
-        recompute(el, true);
+    if (computed.state & STATE_DIRTY) {
+        recompute(computed, true);
     }
-    el.state = STATE_NONE;
+    computed.state = STATE_NONE;
 }
 const computed = (fn) => {
     let self = {
@@ -231,25 +225,22 @@ const computed = (fn) => {
     }
     return self;
 };
-const dispose = (el) => {
-    deleteFromHeap(el);
-    let dep = el.deps;
+const dispose = (computed) => {
+    deleteFromHeap(computed);
+    let dep = computed.deps;
     while (dep !== null) {
         dep = unlink(dep);
     }
-    el.deps = null;
-    cleanup(el);
+    computed.deps = null;
+    cleanup(computed);
 };
 const isComputed = (value) => {
     return isObject(value) && REACTIVE in value && 'fn' in value;
 };
-const isReactive = (value) => {
-    return isObject(value) && REACTIVE in value;
-};
 const isSignal = (value) => {
     return isObject(value) && REACTIVE in value && 'fn' in value === false;
 };
-const oncleanup = (fn) => {
+const onCleanup = (fn) => {
     if (!observer) {
         return fn;
     }
@@ -265,22 +256,29 @@ const oncleanup = (fn) => {
     }
     return fn;
 };
-const read = (el) => {
+const read = (node) => {
     if (observer) {
-        link(el, observer);
-        if ('fn' in el) {
-            let height = el.height;
+        link(node, observer);
+        if ('fn' in node) {
+            let height = node.height;
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
-            if (height >= minDirty ||
-                el.state & (STATE_DIRTY | STATE_CHECK)) {
-                markHeap();
-                update(el);
+            if (height >= iHeap ||
+                node.state & (STATE_DIRTY | STATE_CHECK)) {
+                if (!notifiedHeap) {
+                    notifiedHeap = true;
+                    for (let i = 0; i <= nHeap; i++) {
+                        for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
+                            notify(computed);
+                        }
+                    }
+                }
+                update(node);
             }
         }
     }
-    return el.value;
+    return node.value;
 };
 const root = (fn) => {
     let o = observer;
@@ -297,29 +295,36 @@ const signal = (value) => {
         value,
     };
 };
-signal.set = (el, v) => {
-    if (el.value === v) {
+signal.set = (signal, value) => {
+    if (signal.value === value) {
         return;
     }
-    el.value = v;
-    for (let link = el.subs; link !== null; link = link.nextSub) {
-        markedHeap = false;
+    notifiedHeap = false;
+    signal.value = value;
+    for (let link = signal.subs; link !== null; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }
 };
 const stabilize = () => {
     root(() => {
-        for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
-            let el = dirtyHeap[minDirty];
-            dirtyHeap[minDirty] = undefined;
-            while (el !== undefined) {
-                let next = el.nextHeap;
-                recompute(el, false);
-                el = next;
+        for (iHeap = 0; iHeap <= nHeap; iHeap++) {
+            let computed = heap[iHeap];
+            heap[iHeap] = undefined;
+            while (computed !== undefined) {
+                let next = computed.nextHeap;
+                recompute(computed, false);
+                computed = next;
             }
         }
-        signal.set(stabilize.state, STATE_NONE);
+        scheduled = false;
     });
 };
-stabilize.state = signal(STATE_NONE);
-export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };
+defineProperty(stabilize, 'scheduler', {
+    get() {
+        return scheduler;
+    },
+    set(s) {
+        scheduler = s;
+    },
+});
+export { computed, dispose, isComputed, isSignal, onCleanup, read, root, signal, stabilize };

package/build/types.d.ts

@@ -1,5 +1,5 @@
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-import { oncleanup } from './signal.js';
+import { onCleanup } from './signal.js';
 import { ReactiveArray } from './reactive/array.js';
 import { ReactiveObject } from './reactive/object.js';
 interface Computed<T> extends Signal<T> {
@@ -7,7 +7,7 @@ interface Computed<T> extends Signal<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (oc?: typeof oncleanup) => T;
+    fn: (oc?: typeof onCleanup) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;

package/package.json

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

package/src/index.ts

@@ -1,4 +1,3 @@
 export { default as reactive } from './reactive';
-export { computed, dispose, oncleanup, root, signal, stabilize } from './signal';
-export { default as scheduler } from './scheduler';
+export * from './signal';
 export * from './types';

package/src/reactive/{promise.ts → async.ts}

@@ -6,7 +6,7 @@ import { Signal } from '~/types';
 let { set } = signal;
 
 
-class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+class ReactiveAsyncFunction<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
     private arguments: Signal<A | null>;
     private okay: Signal<boolean | null>;
     private response: Signal<Awaited<R> | null>;
@@ -63,5 +63,5 @@ class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends C
 
 
 export default <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R) => {
-    return new ReactivePromise(fn);
+    return new ReactiveAsyncFunction(fn);
 };

package/src/reactive/index.ts

@@ -1,38 +1,48 @@
-import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import { isArray, isAsyncFunction, isFunction, isObject } from '@esportsplus/utilities';
+import { computed } from '~/signal';
+import { Computed } from '~/types';
 import array from './array';
+import async from './async';
 import object from './object';
-import promise from './promise';
 
 
 type API<T> =
     T extends (...args: infer A) => Promise<infer R>
-        ? ReturnType<typeof promise<A, Promise<R>>>
-        : T extends Record<PropertyKey, unknown>
-            ? ReturnType<typeof object<T>>
-            : T extends unknown[]
-                ? ReturnType<typeof array<T>>
-                : never;
+        ? ReturnType<typeof async<A, Promise<R>>>
+        : T extends (...args: unknown[]) => unknown
+            ? void
+            : T extends Record<PropertyKey, unknown>
+                ? ReturnType<typeof object<T>>
+                : T extends unknown[]
+                    ? ReturnType<typeof array<T>>
+                    : never;
 
-type Guard<T> =
+type Input<T> =
     T extends (...args: unknown[]) => Promise<unknown>
         ? T
-        : T extends { dispose: any } | { signals: any }
-            ? { never: '[ dispose, signals ] are reserved keys' }
-            : T extends Record<PropertyKey, unknown> | unknown[]
-                ? T
-                : never;
+        : T extends (...args: unknown[]) => unknown
+            ? Computed<T>['fn']
+            : T extends { dispose: any } | { signals: any }
+                ? { never: '[ dispose, signals ] are reserved keys' }
+                : T extends Record<PropertyKey, unknown> | unknown[]
+                    ? T
+                    : never;
 
 
-export default <T>(data: Guard<T>): API<T> => {
-    if (isArray(data)) {
-        return array(data) as API<T>;
+export default <T>(input: Input<T>): API<T> => {
+    if (isArray(input)) {
+        return array(input) as API<T>;
     }
-    else if (isObject(data)) {
-        return object(data) as API<T>;
+    else if (isAsyncFunction(input)) {
+        return async(input) as API<T>;
     }
-    else if (isPromise(data)) {
-        return promise(data) as API<T>;
+    else if (isFunction(input)) {
+        computed(input as Computed<T>['fn']);
+        return undefined as API<T>;
+    }
+    else if (isObject(input)) {
+        return object(input) as API<T>;
     }
 
-    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
+    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
 };

package/src/reactive/object.ts

@@ -3,7 +3,7 @@ import array, { ReactiveArray } from './array';
 import { computed, dispose, read, signal } from '~/signal';
 import { Computed, Infer, Signal } from '~/types';
 import { Disposable } from './disposable';
-import promise from './promise';
+import async from './async';
 
 
 type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
@@ -45,7 +45,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
                 });
             }
             else if (isAsyncFunction(value)) {
-                let p = promise(value);
+                let p = async(value);
 
                 defineProperty(this, key, {
                     enumerable: true,

package/src/signal.ts

@@ -1,13 +1,15 @@
-import { isArray, isObject } from '@esportsplus/utilities';
+import { defineProperty, isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
 import { Computed, Link, Signal, } from './types';
 
 
-let dirtyHeap: (Computed<unknown> | undefined)[] = new Array(2000),
-    maxDirty = 0,
-    markedHeap = false,
-    minDirty = 0,
-    observer: Computed<unknown> | null = null;
+let heap: (Computed<unknown> | undefined)[] = new Array(2000),
+    iHeap = 0,
+    nHeap = 0,
+    notifiedHeap = false,
+    observer: Computed<unknown> | null = null,
+    scheduled = false,
+    scheduler: ((task: VoidFunction) => void) | null = null;
 
 
 function cleanup<T>(node: Computed<T>): void {
@@ -15,80 +17,82 @@ function cleanup<T>(node: Computed<T>): void {
         return;
     }
 
-    if (isArray(node.cleanup)) {
-        for (let i = 0; i < node.cleanup.length; i++) {
-            node.cleanup[i]();
+    let cleanup = node.cleanup;
+
+    if (isArray(cleanup)) {
+        for (let i = 0; i < cleanup.length; i++) {
+            cleanup[i]();
         }
     }
     else {
-        node.cleanup();
+        cleanup();
     }
 
     node.cleanup = null;
 }
 
-function deleteFromHeap<T>(n: Computed<T>) {
-    let state = n.state;
+function deleteFromHeap<T>(computed: Computed<T>) {
+    let state = computed.state;
 
     if (!(state & STATE_IN_HEAP)) {
         return;
     }
 
-    n.state = state & ~STATE_IN_HEAP;
+    computed.state = state & ~STATE_IN_HEAP;
 
-    let height = n.height;
+    let height = computed.height;
 
-    if (n.prevHeap === n) {
-        dirtyHeap[height] = undefined;
+    if (computed.prevHeap === computed) {
+        heap[height] = undefined;
     }
     else {
-        let next = n.nextHeap,
-            dhh = dirtyHeap[height]!,
+        let next = computed.nextHeap,
+            dhh = heap[height]!,
             end = next ?? dhh;
 
-        if (n === dhh) {
-            dirtyHeap[height] = next;
+        if (computed === dhh) {
+            heap[height] = next;
         }
         else {
-            n.prevHeap.nextHeap = next;
+            computed.prevHeap.nextHeap = next;
         }
 
-        end.prevHeap = n.prevHeap;
+        end.prevHeap = computed.prevHeap;
     }
 
-    n.nextHeap = undefined;
-    n.prevHeap = n;
+    computed.nextHeap = undefined;
+    computed.prevHeap = computed;
 }
 
-function insertIntoHeap<T>(n: Computed<T>) {
-    let state = n.state;
+function insertIntoHeap<T>(computed: Computed<T>) {
+    let state = computed.state;
 
     if (state & STATE_IN_HEAP) {
         return;
     }
 
-    n.state = state | STATE_IN_HEAP;
+    computed.state = state | STATE_IN_HEAP;
 
-    let height = n.height,
-        heapAtHeight = dirtyHeap[height];
+    let height = computed.height,
+        heapAtHeight = heap[height];
 
     if (heapAtHeight === undefined) {
-        dirtyHeap[height] = n;
+        heap[height] = computed;
     }
     else {
         let tail = heapAtHeight.prevHeap;
 
-        tail.nextHeap = n;
-        n.prevHeap = tail;
-        heapAtHeight.prevHeap = n;
+        tail.nextHeap = computed;
+        computed.prevHeap = tail;
+        heapAtHeight.prevHeap = computed;
     }
 
-    if (height > maxDirty) {
-        maxDirty = height;
+    if (height > nHeap) {
+        nHeap = height;
 
         // Simple auto adjust to avoid manual management within apps.
-        if (height >= dirtyHeap.length) {
-            dirtyHeap.length += 250;
+        if (height >= heap.length) {
+            heap.length += 250;
         }
     }
 }
@@ -138,65 +142,51 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
     }
 }
 
-function markHeap() {
-    if (markedHeap) {
-        return;
-    }
-
-    markedHeap = true;
-
-    for (let i = 0; i <= maxDirty; i++) {
-        for (let el = dirtyHeap[i]; el !== undefined; el = el.nextHeap) {
-            markNode(el);
-        }
-    }
-}
-
-function markNode<T>(el: Computed<T>, newState = STATE_DIRTY) {
-    let state = el.state;
+function notify<T>(computed: Computed<T>, newState = STATE_DIRTY) {
+    let state = computed.state;
 
     if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
         return;
     }
 
-    el.state = state | newState;
+    computed.state = state | newState;
 
-    for (let link = el.subs; link !== null; link = link.nextSub) {
-        markNode(link.sub, STATE_CHECK);
+    for (let link = computed.subs; link !== null; link = link.nextSub) {
+        notify(link.sub, STATE_CHECK);
     }
 }
 
-function recompute<T>(el: Computed<T>, del: boolean) {
+function recompute<T>(computed: Computed<T>, del: boolean) {
     if (del) {
-        deleteFromHeap(el);
+        deleteFromHeap(computed);
     }
     else {
-        el.nextHeap = undefined;
-        el.prevHeap = el;
+        computed.nextHeap = undefined;
+        computed.prevHeap = computed;
     }
 
-    cleanup(el);
+    cleanup(computed);
 
     let o = observer,
         ok = true,
         value;
 
-    observer = el;
-    el.depsTail = null;
-    el.state = STATE_RECOMPUTING;
+    observer = computed;
+    computed.depsTail = null;
+    computed.state = STATE_RECOMPUTING;
 
     try {
-        value = el.fn(oncleanup);
+        value = computed.fn(onCleanup);
     }
     catch (e) {
         ok = false;
     }
 
     observer = o;
-    el.state = STATE_NONE;
+    computed.state = STATE_NONE;
 
-    let depsTail = el.depsTail as Link | null,
-        toRemove = depsTail !== null ? depsTail.nextDep : el.deps;
+    let depsTail = computed.depsTail as Link | null,
+        toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
 
     if (toRemove !== null) {
         do {
@@ -208,15 +198,15 @@ function recompute<T>(el: Computed<T>, del: boolean) {
             depsTail.nextDep = null;
         }
         else {
-            el.deps = null;
+            computed.deps = null;
         }
     }
 
-    if (ok && value !== el.value) {
-        el.value = value as T;
+    if (ok && value !== computed.value) {
+        computed.value = value as T;
 
-        for (let s = el.subs; s !== null; s = s.nextSub) {
-            let o = s.sub,
+        for (let c = computed.subs; c !== null; c = c.nextSub) {
+            let o = c.sub,
                 state = o.state;
 
             if (state & STATE_CHECK) {
@@ -227,8 +217,12 @@ function recompute<T>(el: Computed<T>, del: boolean) {
         }
     }
 
-    if (stabilize.state.value === STATE_NONE) {
-        root(() => signal.set(stabilize.state, STATE_DIRTY));
+    if (!scheduled && scheduler) {
+        scheduled = true;
+        scheduler(stabilize);
+    }
+    else {
+        throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
     }
 }
 
@@ -260,26 +254,26 @@ function unlink(link: Link): Link | null {
     return nextDep;
 }
 
-function update<T>(el: Computed<T>): void {
-    if (el.state & STATE_CHECK) {
-        for (let d = el.deps; d; d = d.nextDep) {
-            let dep = d.dep;
+function update<T>(computed: Computed<T>): void {
+    if (computed.state & STATE_CHECK) {
+        for (let link = computed.deps; link; link = link.nextDep) {
+            let dep = link.dep;
 
             if ('fn' in dep) {
                 update(dep);
             }
 
-            if (el.state & STATE_DIRTY) {
+            if (computed.state & STATE_DIRTY) {
                 break;
             }
         }
     }
 
-    if (el.state & STATE_DIRTY) {
-        recompute(el, true);
+    if (computed.state & STATE_DIRTY) {
+        recompute(computed, true);
     }
 
-    el.state = STATE_NONE;
+    computed.state = STATE_NONE;
 }
 
 
@@ -320,33 +314,29 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     return self;
 };
 
-const dispose = <T>(el: Computed<T>) => {
-    deleteFromHeap(el);
+const dispose = <T>(computed: Computed<T>) => {
+    deleteFromHeap(computed);
 
-    let dep = el.deps;
+    let dep = computed.deps;
 
     while (dep !== null) {
         dep = unlink(dep);
     }
 
-    el.deps = null;
+    computed.deps = null;
 
-    cleanup(el);
-}
+    cleanup(computed);
+};
 
 const isComputed = (value: unknown): value is Computed<unknown> => {
     return isObject(value) && REACTIVE in value && 'fn' in value;
 };
 
-const isReactive = (value: unknown): value is Computed<unknown> | Signal<unknown> => {
-    return isObject(value) && REACTIVE in value;
-};
-
 const isSignal = (value: unknown): value is Signal<unknown> => {
     return isObject(value) && REACTIVE in value && 'fn' in value === false;
 };
 
-const oncleanup = (fn: VoidFunction): typeof fn => {
+const onCleanup = (fn: VoidFunction): typeof fn => {
     if (!observer) {
         return fn;
     }
@@ -366,28 +356,37 @@ const oncleanup = (fn: VoidFunction): typeof fn => {
     return fn;
 };
 
-const read = <T>(el: Signal<T> | Computed<T>): T => {
+const read = <T>(node: Signal<T> | Computed<T>): T => {
     if (observer) {
-        link(el, observer);
+        link(node, observer);
 
-        if ('fn' in el) {
-            let height = el.height;
+        if ('fn' in node) {
+            let height = node.height;
 
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
 
             if (
-                height >= minDirty ||
-                el.state & (STATE_DIRTY | STATE_CHECK)
+                height >= iHeap ||
+                node.state & (STATE_DIRTY | STATE_CHECK)
             ) {
-                markHeap();
-                update(el);
+                if (!notifiedHeap) {
+                    notifiedHeap = true;
+
+                    for (let i = 0; i <= nHeap; i++) {
+                        for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
+                            notify(computed);
+                        }
+                    }
+                }
+
+                update(node);
             }
         }
     }
 
-    return el.value;
+    return node.value;
 };
 
 const root = <T>(fn: () => T) => {
@@ -411,47 +410,54 @@ const signal = <T>(value: T): Signal<T> => {
     };
 };
 
-signal.set = <T>(el: Signal<T>, v: T) => {
-    if (el.value === v) {
+signal.set = <T>(signal: Signal<T>, value: T) => {
+    if (signal.value === value) {
         return;
     }
 
-    el.value = v;
+    notifiedHeap = false;
+    signal.value = value;
 
-    for (let link = el.subs; link !== null; link = link.nextSub) {
-        markedHeap = false;
+    for (let link = signal.subs; link !== null; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }
 };
 
 const stabilize = () => {
     root(() => {
-        for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
-            let el = dirtyHeap[minDirty];
+        for (iHeap = 0; iHeap <= nHeap; iHeap++) {
+            let computed = heap[iHeap];
 
-            dirtyHeap[minDirty] = undefined;
+            heap[iHeap] = undefined;
 
-            while (el !== undefined) {
-                let next = el.nextHeap;
+            while (computed !== undefined) {
+                let next = computed.nextHeap;
 
-                recompute(el, false);
+                recompute(computed, false);
 
-                el = next;
+                computed = next;
             }
         }
 
-        signal.set(stabilize.state, STATE_NONE);
+        scheduled = false;
     });
 };
 
-stabilize.state = signal(STATE_NONE);
+defineProperty(stabilize, 'scheduler', {
+    get() {
+        return scheduler;
+    },
+    set(s: typeof scheduler) {
+        scheduler = s;
+    },
+});
 
 
 export {
     computed,
     dispose,
-    isComputed, isReactive, isSignal,
-    oncleanup,
+    isComputed, isSignal,
+    onCleanup,
     read, root,
     signal, stabilize
 };

package/src/types.ts

@@ -1,5 +1,5 @@
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
-import { oncleanup } from './signal';
+import { onCleanup } from './signal';
 import { ReactiveArray } from './reactive/array';
 import { ReactiveObject } from './reactive/object';
 
@@ -9,7 +9,7 @@ interface Computed<T> extends Signal<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (oc?: typeof oncleanup) => T;
+    fn: (oc?: typeof onCleanup) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;

package/build/scheduler.d.ts

@@ -1,4 +0,0 @@
-declare const scheduler: (schedule: (task: VoidFunction) => void) => void;
-declare const state: import("./types.js").Signal<number>;
-export default scheduler;
-export { state };

package/build/scheduler.js

@@ -1,17 +0,0 @@
-import { STATE_DIRTY, STATE_NONE } from './constants.js';
-import { computed, dispose, read, signal, stabilize } from './signal.js';
-let c = null;
-const scheduler = (schedule) => {
-    if (c) {
-        dispose(c);
-    }
-    c = computed(() => {
-        if (read(state) !== STATE_DIRTY) {
-            return;
-        }
-        schedule(stabilize);
-    });
-};
-const state = signal(STATE_NONE);
-export default scheduler;
-export { state };

package/src/scheduler.ts

@@ -1,27 +0,0 @@
-import { STATE_DIRTY, STATE_NONE } from './constants';
-import { computed, dispose, read, signal, stabilize } from './signal';
-import { Computed } from './types';
-
-
-let c: Computed<void> | null = null;
-
-
-const scheduler = (schedule: (task: VoidFunction) => void) => {
-    if (c) {
-        dispose(c);
-    }
-
-    c = computed(() => {
-        if (read(state) !== STATE_DIRTY) {
-            return;
-        }
-
-        schedule(stabilize);
-    });
-};
-
-const state = signal(STATE_NONE);
-
-
-export default scheduler;
-export { state };