@esportsplus/reactivity 0.4.8 → 0.6.0

package/build/signal.d.ts

@@ -1,31 +1,15 @@
-import { Computed, Changed, Effect, Event, Function, Listener, NeverAsync, Options, Root, Scheduler, Signal, State, Type } from './types.js';
-declare class Reactive<T> {
-    changed: Changed | null;
-    fn: Computed<T>['fn'] | Effect['fn'] | null;
-    listeners: Record<Event, (Listener<any> | null)[]> | null;
-    observers: Reactive<any>[] | null;
-    root: Root | null;
-    scheduler: Scheduler | null;
-    sources: Reactive<any>[] | null;
-    state: State;
-    task: Function | null;
-    tracking: boolean | null;
-    type: Type;
-    value: T;
-    constructor(state: State, type: Type, value: T);
-    dispatch<D>(event: Event, data?: D): void;
-    dispose(): void;
-    get(): T;
-    on<T>(event: Event, listener: Listener<T>): void;
-    once<T>(event: Event, listener: Listener<T>): void;
-    set(value: T): T;
-}
-declare const computed: <T>(fn: Computed<T>["fn"], options?: Options) => Computed<T>;
-declare const dispose: <T extends {
-    dispose: VoidFunction;
-}>(dispose?: T[] | T | null) => T | T[] | null | undefined;
-declare const effect: (fn: Effect["fn"]) => Effect;
-declare const root: <T>(fn: NeverAsync<(instance: Root) => T>, scheduler?: Scheduler) => T;
-declare const signal: <T>(value: T, options?: Options) => Signal<T>;
-export { computed, dispose, effect, root, signal };
-export { Reactive };
+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 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 root: <T>(fn: () => T) => T;
+declare const signal: {
+    <T>(value: T): Signal<T>;
+    set<T>(el: Signal<T>, v: T): void;
+};
+declare const stabilize: () => void;
+export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };

package/build/signal.js

@@ -1,280 +1,318 @@
-import { isArray } from '@esportsplus/utilities';
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants.js';
-let index = 0, observer = null, observers = null, scope = null;
-class Reactive {
-    changed = null;
-    fn = null;
-    listeners = null;
-    observers = null;
-    root;
-    scheduler = null;
-    sources = null;
-    state;
-    task = null;
-    tracking = null;
-    type;
-    value;
-    constructor(state, type, value) {
-        let root = null;
-        if (type !== ROOT) {
-            if (scope !== null) {
-                root = scope;
-            }
-            else if (observer !== null) {
-                root = observer.root;
-            }
-            if (root == null) {
-                if (type === EFFECT) {
-                    throw new Error(`@esportsplus/reactivity: 'effect' cannot be created without a reactive root`);
-                }
-            }
-            else if (root.tracking) {
-                root.on('dispose', () => this.dispose());
-            }
-        }
-        this.root = root;
-        this.state = state;
-        this.type = type;
-        this.value = value;
+import { 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;
+function cleanup(node) {
+    if (!node.cleanup) {
+        return;
     }
-    dispatch(event, data) {
-        if (this.listeners === null || this.listeners[event] === undefined) {
-            return;
-        }
-        let listeners = this.listeners[event];
-        for (let i = 0, n = listeners.length; i < n; i++) {
-            let listener = listeners[i];
-            if (listener === null) {
-                continue;
-            }
-            try {
-                listener(data, this.value);
-                if (listener.once !== undefined) {
-                    listeners[i] = null;
-                }
-            }
-            catch {
-                listeners[i] = null;
-            }
+    if (isArray(node.cleanup)) {
+        for (let i = 0; i < node.cleanup.length; i++) {
+            node.cleanup[i]();
         }
     }
-    dispose() {
-        if (this.state === DISPOSED) {
-            return;
-        }
-        this.dispatch('cleanup', this);
-        this.dispatch('dispose', this);
-        removeSourceObservers(this, 0);
-        this.listeners = null;
-        this.observers = null;
-        this.sources = null;
-        this.state = DISPOSED;
-    }
-    get() {
-        if (this.state === DISPOSED) {
-            return this.value;
-        }
-        if (observer !== null) {
-            if (observers === null) {
-                if (observer.sources !== null && observer.sources[index] == this) {
-                    index++;
-                }
-                else {
-                    observers = [this];
-                }
-            }
-            else {
-                observers.push(this);
-            }
-        }
-        if (this.type === COMPUTED || this.type === EFFECT) {
-            sync(this);
-        }
-        return this.value;
+    else {
+        node.cleanup();
     }
-    on(event, listener) {
-        if (this.state === DIRTY) {
-            if (event !== 'cleanup') {
-                throw new Error(`@esportsplus/reactivity: events set within computed or effects must use the 'cleanup' event name`);
-            }
-            listener.once = true;
-        }
-        if (this.listeners === null) {
-            this.listeners = { [event]: [listener] };
+    node.cleanup = null;
+}
+function deleteFromHeap(n) {
+    let state = n.state;
+    if (!(state & STATE_IN_HEAP)) {
+        return;
+    }
+    n.state = state & ~STATE_IN_HEAP;
+    let height = n.height;
+    if (n.prevHeap === n) {
+        dirtyHeap[height] = undefined;
+    }
+    else {
+        let next = n.nextHeap, dhh = dirtyHeap[height], end = next ?? dhh;
+        if (n === dhh) {
+            dirtyHeap[height] = next;
         }
         else {
-            let listeners = this.listeners[event];
-            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;
-                }
-            }
+            n.prevHeap.nextHeap = next;
         }
+        end.prevHeap = n.prevHeap;
+    }
+    n.nextHeap = undefined;
+    n.prevHeap = n;
+}
+function insertIntoHeap(n) {
+    let state = n.state;
+    if (state & STATE_IN_HEAP) {
+        return;
     }
-    once(event, listener) {
-        listener.once = true;
-        this.on(event, listener);
+    n.state = state | STATE_IN_HEAP;
+    let height = n.height, heapAtHeight = dirtyHeap[height];
+    if (heapAtHeight === undefined) {
+        dirtyHeap[height] = n;
     }
-    set(value) {
-        if (this.type !== SIGNAL && observer !== this) {
-            throw new Error(`@esportsplus/reactivity: 'set' method is only available on signals`);
-        }
-        if (this.changed(this.value, value)) {
-            this.value = value;
-            notify(this.observers, DIRTY);
+    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;
         }
-        return this.value;
     }
 }
-function changed(a, b) {
-    return a !== b;
-}
-function notify(nodes, state) {
-    if (nodes === null) {
+function link(dep, sub) {
+    let prevDep = sub.depsTail;
+    if (prevDep !== null && prevDep.dep === dep) {
         return;
     }
-    for (let i = 0, n = nodes.length; i < n; i++) {
-        let node = nodes[i];
-        if (node.state < state) {
-            if (node.type === EFFECT && node.state === CLEAN) {
-                node.root.scheduler(node.task);
-            }
-            node.state = state;
-            notify(node.observers, CHECK);
+    let nextDep = null;
+    if (sub.state & STATE_RECOMPUTING) {
+        nextDep = prevDep !== null ? prevDep.nextDep : sub.deps;
+        if (nextDep !== null && nextDep.dep === dep) {
+            sub.depsTail = nextDep;
+            return;
         }
     }
+    let prevSub = dep.subsTail, newLink = sub.depsTail =
+        dep.subsTail = {
+            dep,
+            sub,
+            nextDep,
+            prevSub,
+            nextSub: null,
+        };
+    if (prevDep !== null) {
+        prevDep.nextDep = newLink;
+    }
+    else {
+        sub.deps = newLink;
+    }
+    if (prevSub !== null) {
+        prevSub.nextSub = newLink;
+    }
+    else {
+        dep.subs = newLink;
+    }
 }
-function removeSourceObservers(node, start) {
-    if (node.sources === null) {
+function markHeap() {
+    if (markedHeap) {
         return;
     }
-    for (let i = start, n = node.sources.length; i < n; i++) {
-        let observers = node.sources[i].observers;
-        if (observers === null) {
-            continue;
+    markedHeap = true;
+    for (let i = 0; i <= maxDirty; i++) {
+        for (let el = dirtyHeap[i]; el !== undefined; el = el.nextHeap) {
+            markNode(el);
         }
-        observers[observers.indexOf(node)] = observers[observers.length - 1];
-        observers.pop();
     }
 }
-function sync(node) {
-    if (node.state === CHECK && node.sources !== null) {
-        for (let i = 0, n = node.sources.length; i < n; i++) {
-            sync(node.sources[i]);
-            if (node.state === DIRTY) {
-                break;
+function markNode(el, newState = STATE_DIRTY) {
+    let state = el.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);
+    }
+}
+function recompute(el, del) {
+    if (del) {
+        deleteFromHeap(el);
+    }
+    else {
+        el.nextHeap = undefined;
+        el.prevHeap = el;
+    }
+    cleanup(el);
+    let o = observer, ok = true, value;
+    observer = el;
+    el.depsTail = null;
+    el.state = STATE_RECOMPUTING;
+    try {
+        value = el.fn(oncleanup);
+    }
+    catch (e) {
+        ok = false;
+    }
+    observer = o;
+    el.state = STATE_NONE;
+    let depsTail = el.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : el.deps;
+    if (toRemove !== null) {
+        do {
+            toRemove = unlink(toRemove);
+        } while (toRemove !== null);
+        if (depsTail !== null) {
+            depsTail.nextDep = null;
+        }
+        else {
+            el.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 (state & STATE_CHECK) {
+                o.state = state | STATE_DIRTY;
             }
+            insertIntoHeap(o);
         }
     }
-    if (node.state === DIRTY) {
-        update(node);
+}
+function unlink(link) {
+    let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
+    if (nextSub !== null) {
+        nextSub.prevSub = prevSub;
+    }
+    else {
+        dep.subsTail = prevSub;
+    }
+    if (prevSub !== null) {
+        prevSub.nextSub = nextSub;
     }
     else {
-        node.state = CLEAN;
+        dep.subs = nextSub;
+        if (nextSub === null && 'fn' in dep) {
+            dispose(dep);
+        }
     }
+    return nextDep;
 }
-function update(node) {
-    let i = index, o = observer, os = observers;
-    index = 0;
-    observer = node;
-    observers = null;
-    try {
-        node.dispatch('cleanup');
-        node.dispatch('update');
-        let value = node.fn.call(null, node);
-        if (observers) {
-            removeSourceObservers(node, index);
-            if (node.sources !== null && index > 0) {
-                node.sources.length = index + observers.length;
-                for (let i = 0, n = observers.length; i < n; i++) {
-                    node.sources[index + i] = observers[i];
-                }
-            }
-            else {
-                node.sources = observers;
+function update(el) {
+    if (el.state & STATE_CHECK) {
+        for (let d = el.deps; d; d = d.nextDep) {
+            let dep = d.dep;
+            if ('fn' in dep) {
+                update(dep);
             }
-            for (let i = index, n = node.sources.length; i < n; i++) {
-                let source = node.sources[i];
-                if (source.observers === null) {
-                    source.observers = [node];
-                }
-                else {
-                    source.observers.push(node);
-                }
+            if (el.state & STATE_DIRTY) {
+                break;
             }
         }
-        else if (node.sources !== null && index < node.sources.length) {
-            removeSourceObservers(node, index);
-            node.sources.length = index;
+    }
+    if (el.state & STATE_DIRTY) {
+        recompute(el, true);
+    }
+    el.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);
         }
-        if (node.type === COMPUTED) {
-            node.set(value);
+        else {
+            self.height = observer.height + 1;
+            insertIntoHeap(self);
         }
+        link(self, observer);
     }
-    finally {
-        index = i;
-        observer = o;
-        observers = os;
+    else {
+        recompute(self, false);
     }
-    node.state = CLEAN;
-}
-const computed = (fn, options) => {
-    let instance = new Reactive(DIRTY, COMPUTED, undefined);
-    instance.changed = options?.changed || changed;
-    instance.fn = fn;
-    return instance;
+    return self;
 };
-const dispose = (dispose) => {
-    if (dispose == null) {
+const dispose = (el) => {
+    deleteFromHeap(el);
+    let dep = el.deps;
+    while (dep !== null) {
+        dep = unlink(dep);
     }
-    else if (isArray(dispose)) {
-        for (let i = 0, n = dispose.length; i < n; i++) {
-            dispose[i].dispose();
-        }
+    el.deps = null;
+    cleanup(el);
+};
+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) => {
+    if (!observer) {
+        return fn;
+    }
+    let node = observer;
+    if (!node.cleanup) {
+        node.cleanup = fn;
+    }
+    else if (isArray(node.cleanup)) {
+        node.cleanup.push(fn);
     }
     else {
-        dispose.dispose();
+        node.cleanup = [node.cleanup, fn];
     }
-    return dispose;
-};
-const effect = (fn) => {
-    let instance = new Reactive(DIRTY, EFFECT, null);
-    instance.fn = fn;
-    instance.task = () => instance.get();
-    update(instance);
-    return instance;
+    return fn;
 };
-const root = (fn, scheduler) => {
-    let o = observer, s = scope;
-    if (scheduler === undefined) {
-        if (o?.type === EFFECT) {
-            scope = o.root;
-        }
-        if (scope === null) {
-            throw new Error('@esportsplus/reactivity: `root` cannot be created without a task scheduler');
+const read = (el) => {
+    if (observer) {
+        link(el, observer);
+        if ('fn' in el) {
+            let height = el.height;
+            if (height >= observer.height) {
+                observer.height = height + 1;
+            }
+            if (height >= minDirty ||
+                el.state & (STATE_DIRTY | STATE_CHECK)) {
+                markHeap();
+                update(el);
+            }
         }
-        scheduler = scope.scheduler;
     }
+    return el.value;
+};
+const root = (fn) => {
+    let o = observer;
     observer = null;
-    scope = new Reactive(CLEAN, ROOT, null);
-    scope.scheduler = scheduler;
-    scope.tracking = fn.length > 0;
-    let result = fn.call(null, scope);
+    let value = fn();
     observer = o;
-    scope = s;
-    return result;
+    return value;
+};
+const signal = (value) => {
+    return {
+        [REACTIVE]: true,
+        subs: null,
+        subsTail: null,
+        value,
+    };
 };
-const signal = (value, options) => {
-    let instance = new Reactive(CLEAN, SIGNAL, value);
-    instance.changed = options?.changed || changed;
-    return instance;
+signal.set = (el, v) => {
+    if (el.value === v) {
+        return;
+    }
+    el.value = v;
+    for (let link = el.subs; link !== null; link = link.nextSub) {
+        markedHeap = false;
+        insertIntoHeap(link.sub);
+    }
+};
+const stabilize = () => {
+    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;
+        }
+    }
 };
-export { computed, dispose, effect, root, signal };
-export { Reactive };
+export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };

package/build/types.d.ts

@@ -1,43 +1,33 @@
-import { Function, NeverAsync, Prettify } from '@esportsplus/utilities';
+import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
+import { oncleanup } from './signal.js';
 import { ReactiveArray } from './reactive/array.js';
 import { ReactiveObject } from './reactive/object.js';
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants.js';
-import { Reactive as ReactiveBase } from './signal.js';
-type Base<T> = Omit<ReactiveBase<T>, 'changed' | 'fn' | 'get' | 'scheduler' | 'set' | 'task' | 'tracking'>;
-type Changed = (a: unknown, b: unknown) => boolean;
-type Computed<T> = {
-    changed: Changed;
-    fn: NeverAsync<(instance: Computed<T>) => T>;
-    get(): T;
-} & Base<T>;
-type Effect = {
-    fn: NeverAsync<(instance: Effect) => void>;
-    root: Root;
-    task: Function;
-} & Omit<Base<void>, 'value'>;
-type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<T> ? ReactiveObject<T> : T extends Record<PropertyKey, unknown> ? {
+interface Computed<T> extends Signal<T> {
+    [REACTIVE]: true;
+    cleanup: VoidFunction | VoidFunction[] | null;
+    deps: Link | null;
+    depsTail: Link | null;
+    fn: (oc?: typeof oncleanup) => T;
+    height: number;
+    nextHeap: Computed<unknown> | undefined;
+    prevHeap: Computed<unknown>;
+    state: typeof STATE_CHECK | typeof STATE_DIRTY | typeof STATE_IN_HEAP | typeof STATE_NONE | typeof STATE_RECOMPUTING;
+}
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K];
 } : T;
-type Event = 'cleanup' | 'dispose' | 'update' | string;
-type Listener<D> = {
-    once?: boolean;
-    <V>(data: D, value: V): void;
-};
-type Options = {
-    changed?: Changed;
-};
+interface Link {
+    dep: Signal<unknown> | Computed<unknown>;
+    sub: Computed<unknown>;
+    nextDep: Link | null;
+    nextSub: Link | null;
+    prevSub: Link | null;
+}
 type Reactive<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : ReactiveArray<T>;
-type Root = {
-    scheduler: Scheduler;
-    tracking: boolean;
-    value: void;
-} & Omit<ReactiveBase<void>, 'root'>;
-type Scheduler = (fn: Function) => unknown;
 type Signal<T> = {
-    changed: Changed;
-    get(): T;
-    set(value: T): T;
-} & Base<T>;
-type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
-type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
-export type { Changed, Computed, Effect, Event, Function, Infer, Listener, NeverAsync, Options, Prettify, Reactive, ReactiveArray, ReactiveObject, Root, Scheduler, Signal, State, Type };
+    [REACTIVE]: true;
+    subs: Link | null;
+    subsTail: Link | null;
+    value: T;
+};
+export type { Computed, Infer, Link, Signal, Reactive, ReactiveArray, ReactiveObject };

package/build/types.js

@@ -1 +1 @@
-export {};
+import { REACTIVE } from './constants.js';