@esportsplus/reactivity 0.8.0 → 0.9.0

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 './system.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 './system.js';
 export * from './types.js';

package/build/reactive/array.js

@@ -1,5 +1,5 @@
 import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { computed, dispose, isComputed, read } from '../signal.js';
+import { computed, dispose, isComputed, read } from '../system.js';
 import object from './object.js';
 import { Disposable } from './disposable.js';
 class ReactiveArray extends Disposable {

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';
+import { read, root, signal } from '../system.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,13 @@
 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 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 {
     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,16 @@
-import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import { isArray, isAsyncFunction, isObject } from '@esportsplus/utilities';
 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 (isObject(input)) {
+        return object(input);
     }
-    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/build/reactive/object.js

@@ -1,8 +1,8 @@
 import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf } from '@esportsplus/utilities';
 import array from './array.js';
-import { computed, dispose, read, signal } from '../signal.js';
+import { computed, dispose, read, signal } from '../system.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/system.d.ts

@@ -0,0 +1,15 @@
+import { Computed, Signal } from './types.js';
+declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
+declare const dispose: <T>(computed: Computed<T>) => void;
+declare const effect: <T>(fn: Computed<T>["fn"]) => void;
+declare const isComputed: (value: unknown) => value is Computed<unknown>;
+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;
+declare const signal: {
+    <T>(value: T): Signal<T>;
+    set<T>(signal: Signal<T>, value: T): void;
+};
+declare const stabilize: () => void;
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, stabilize };

package/build/system.js

@@ -0,0 +1,345 @@
+import { defineProperty, isArray, isObject } from '@esportsplus/utilities';
+import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
+let depth = 0, heap = new Array(2000), index = 0, length = 0, notified = false, observer = null, scheduled = false, scheduler = null, version = 0;
+function cleanup(node) {
+    if (!node.cleanup) {
+        return;
+    }
+    let cleanup = node.cleanup;
+    if (isArray(cleanup)) {
+        for (let i = 0; i < cleanup.length; i++) {
+            cleanup[i]();
+        }
+    }
+    else {
+        cleanup();
+    }
+    node.cleanup = null;
+}
+function deleteFromHeap(computed) {
+    let state = computed.state;
+    if (!(state & STATE_IN_HEAP)) {
+        return;
+    }
+    computed.state = state & ~STATE_IN_HEAP;
+    let height = computed.height;
+    if (computed.prevHeap === computed) {
+        heap[height] = undefined;
+    }
+    else {
+        let next = computed.nextHeap, dhh = heap[height], end = next ?? dhh;
+        if (computed === dhh) {
+            heap[height] = next;
+        }
+        else {
+            computed.prevHeap.nextHeap = next;
+        }
+        end.prevHeap = computed.prevHeap;
+    }
+    computed.nextHeap = undefined;
+    computed.prevHeap = computed;
+}
+function insertIntoHeap(computed) {
+    let state = computed.state;
+    if (state & STATE_IN_HEAP) {
+        return;
+    }
+    computed.state = state | STATE_IN_HEAP;
+    let height = computed.height, heapAtHeight = heap[height];
+    if (heapAtHeight === undefined) {
+        heap[height] = computed;
+    }
+    else {
+        let tail = heapAtHeight.prevHeap;
+        tail.nextHeap = computed;
+        computed.prevHeap = tail;
+        heapAtHeight.prevHeap = computed;
+    }
+    if (height > length) {
+        length = height;
+        if (height >= heap.length) {
+            heap.length += 250;
+        }
+    }
+}
+function link(dep, sub) {
+    let prevDep = sub.depsTail;
+    if (prevDep !== null && prevDep.dep === dep) {
+        return;
+    }
+    let nextDep = null;
+    if (sub.state & STATE_RECOMPUTING) {
+        nextDep = prevDep !== null ? prevDep.nextDep : sub.deps;
+        if (nextDep !== null && nextDep.dep === dep) {
+            nextDep.version = version;
+            sub.depsTail = nextDep;
+            return;
+        }
+    }
+    let prevSub = dep.subsTail;
+    if (prevSub !== null &&
+        prevSub.version === version &&
+        prevSub.sub === sub) {
+        return;
+    }
+    let newLink = sub.depsTail =
+        dep.subsTail = {
+            dep,
+            sub,
+            nextDep,
+            prevSub,
+            nextSub: null,
+            version
+        };
+    if (prevDep !== null) {
+        prevDep.nextDep = newLink;
+    }
+    else {
+        sub.deps = newLink;
+    }
+    if (prevSub !== null) {
+        prevSub.nextSub = newLink;
+    }
+    else {
+        dep.subs = newLink;
+    }
+}
+function notify(computed, newState = STATE_DIRTY) {
+    let state = computed.state;
+    if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
+        return;
+    }
+    computed.state = state | newState;
+    for (let link = computed.subs; link !== null; link = link.nextSub) {
+        notify(link.sub, STATE_CHECK);
+    }
+}
+function recompute(computed, del) {
+    if (del) {
+        deleteFromHeap(computed);
+    }
+    else {
+        computed.nextHeap = undefined;
+        computed.prevHeap = computed;
+    }
+    cleanup(computed);
+    let o = observer, ok = true, value;
+    observer = computed;
+    computed.depsTail = null;
+    computed.state = STATE_RECOMPUTING;
+    depth++;
+    version++;
+    try {
+        value = computed.fn(onCleanup);
+    }
+    catch (e) {
+        ok = false;
+    }
+    observer = o;
+    computed.state = STATE_NONE;
+    let depsTail = computed.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
+    if (toRemove !== null) {
+        do {
+            toRemove = unlink(toRemove);
+        } while (toRemove !== null);
+        if (depsTail !== null) {
+            depsTail.nextDep = null;
+        }
+        else {
+            computed.deps = null;
+        }
+    }
+    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 (!--depth) {
+        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) {
+    let { dep, nextDep, nextSub, prevSub } = link;
+    if (nextSub !== null) {
+        nextSub.prevSub = prevSub;
+    }
+    else {
+        dep.subsTail = prevSub;
+    }
+    if (prevSub !== null) {
+        prevSub.nextSub = nextSub;
+    }
+    else {
+        dep.subs = nextSub;
+        if (nextSub === null && 'fn' in dep) {
+            dispose(dep);
+        }
+    }
+    return nextDep;
+}
+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 (computed.state & STATE_DIRTY) {
+                break;
+            }
+        }
+    }
+    if (computed.state & STATE_DIRTY) {
+        recompute(computed, true);
+    }
+    computed.state = STATE_NONE;
+}
+const computed = (fn) => {
+    let self = {
+        [REACTIVE]: true,
+        cleanup: null,
+        deps: null,
+        depsTail: null,
+        fn: fn,
+        height: 0,
+        nextHeap: undefined,
+        prevHeap: null,
+        state: STATE_NONE,
+        subs: null,
+        subsTail: null,
+        value: undefined,
+    };
+    self.prevHeap = self;
+    if (observer) {
+        if (observer.depsTail === null) {
+            self.height = observer.height;
+            recompute(self, false);
+        }
+        else {
+            self.height = observer.height + 1;
+            insertIntoHeap(self);
+        }
+        link(self, observer);
+    }
+    else {
+        recompute(self, false);
+    }
+    return self;
+};
+const dispose = (computed) => {
+    deleteFromHeap(computed);
+    let dep = computed.deps;
+    while (dep !== null) {
+        dep = unlink(dep);
+    }
+    computed.deps = null;
+    cleanup(computed);
+};
+const effect = (fn) => {
+    computed(fn);
+};
+const isComputed = (value) => {
+    return isObject(value) && REACTIVE in value && 'fn' in value;
+};
+const isSignal = (value) => {
+    return isObject(value) && REACTIVE in value && 'fn' in value === false;
+};
+const onCleanup = (fn) => {
+    if (!observer) {
+        return fn;
+    }
+    let node = observer;
+    if (!node.cleanup) {
+        node.cleanup = fn;
+    }
+    else if (isArray(node.cleanup)) {
+        node.cleanup.push(fn);
+    }
+    else {
+        node.cleanup = [node.cleanup, fn];
+    }
+    return fn;
+};
+const read = (node) => {
+    if (observer) {
+        link(node, observer);
+        if ('fn' in node) {
+            let height = node.height;
+            if (height >= observer.height) {
+                observer.height = height + 1;
+            }
+            if (height >= index ||
+                node.state & (STATE_DIRTY | STATE_CHECK)) {
+                if (!notified) {
+                    notified = true;
+                    for (let i = 0; i <= length; i++) {
+                        for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
+                            notify(computed);
+                        }
+                    }
+                }
+                update(node);
+            }
+        }
+    }
+    return node.value;
+};
+const root = (fn) => {
+    let o = observer;
+    observer = null;
+    let value = fn();
+    observer = o;
+    return value;
+};
+const signal = (value) => {
+    return {
+        [REACTIVE]: true,
+        subs: null,
+        subsTail: null,
+        value,
+    };
+};
+signal.set = (signal, value) => {
+    if (signal.value === value) {
+        return;
+    }
+    notified = false;
+    signal.value = value;
+    for (let link = signal.subs; link !== null; link = link.nextSub) {
+        insertIntoHeap(link.sub);
+    }
+};
+const stabilize = () => {
+    root(() => {
+        for (index = 0; index <= length; index++) {
+            let computed = heap[index];
+            heap[index] = undefined;
+            while (computed !== undefined) {
+                let next = computed.nextHeap;
+                recompute(computed, false);
+                computed = next;
+            }
+        }
+        scheduled = false;
+    });
+};
+defineProperty(stabilize, 'scheduler', {
+    get() {
+        return scheduler;
+    },
+    set(s) {
+        scheduler = s;
+    },
+});
+export { computed, dispose, effect, 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 './system.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>;
@@ -22,6 +22,7 @@ interface Link {
     nextDep: Link | null;
     nextSub: Link | null;
     prevSub: Link | null;
+    version: number;
 }
 type Reactive<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : ReactiveArray<T>;
 type Signal<T> = {

package/package.json

@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "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 './system';
 export * from './types';

package/src/reactive/array.ts

@@ -1,5 +1,5 @@
 import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { computed, dispose, isComputed, read } from '~/signal';
+import { computed, dispose, isComputed, read } from '~/system';
 import { Computed, Infer } from '~/types';
 import object, { ReactiveObject } from './object';
 import { Disposable } from './disposable';

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

@@ -1,12 +1,12 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { read, root, signal } from '~/signal';
+import { read, root, signal } from '~/system';
 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,19 +1,19 @@
-import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import { isArray, isAsyncFunction, isObject } from '@esportsplus/utilities';
 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>>>
+        ? ReturnType<typeof async<A, Promise<R>>>
         : 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 }
@@ -23,16 +23,16 @@ type Guard<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 (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

@@ -1,9 +1,9 @@
 import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, Prettify } from '@esportsplus/utilities';
 import array, { ReactiveArray } from './array';
-import { computed, dispose, read, signal } from '~/signal';
+import { computed, dispose, read, signal } from '~/system';
 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,