@esportsplus/reactivity 0.12.3 → 0.13.0

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

@@ -1,64 +1,7 @@
-import { REACTIVE_ARRAY } from '../constants.js';
-import { Computed, Infer } from '../types.js';
-import { ReactiveObject } from './object.js';
-type API<T> = Infer<T>[] & ReactiveArray<T>;
-type Events<T> = {
-    pop: {
-        item: Item<T>;
-    };
-    push: {
-        items: Item<T>[];
-    };
-    reverse: undefined;
-    set: {
-        index: number;
-        item: Item<T>;
-    };
-    shift: {
-        item: Item<T>;
-    };
-    sort: undefined;
-    splice: {
-        deleteCount: number;
-        items: Item<T>[];
-        start: number;
-    };
-    unshift: {
-        items: Item<T>[];
-    };
+import { Infer } from '../types.js';
+type API<T> = Infer<T[]> & {
+    clear: () => void;
+    dispose: () => void;
 };
-type Item<T> = T | Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
-type Listener<V> = {
-    once?: boolean;
-    (value: V): void;
-};
-type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? API<U> : T;
-declare class ReactiveArray<T> {
-    [REACTIVE_ARRAY]: boolean;
-    disposables: number;
-    private data;
-    private listeners;
-    private proxy;
-    constructor(data: Item<T>[], proxy: API<T>);
-    get length(): number;
-    set length(n: number);
-    private cleanup;
-    at(i: number): T | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
-    dispatch<K extends keyof Events<T>, V>(event: K, value?: V): void;
-    dispose(): void;
-    map<R>(fn: (this: API<T>, value: Value<T>, i: number) => R, i?: number, n?: number): R[];
-    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
-    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
-    pop(): Item<T> | undefined;
-    push(...input: T[]): number;
-    reverse(): this;
-    shift(): Item<T> | undefined;
-    sort(fn: (a: Value<T>, b: Value<T>) => number): this;
-    splice(start: number, deleteCount?: number, ...input: T[]): Item<T>[];
-    unshift(...input: T[]): number;
-}
-declare const isReactiveArray: (value: any) => value is ReactiveArray<any>;
-declare const _default: <T>(input: T[]) => API<T>;
+declare const _default: <T>(data: T[]) => API<T>;
 export default _default;
-export { isReactiveArray };
-export type { API as ReactiveArray };

package/build/reactive/array.js

@@ -1,203 +1,217 @@
-import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { isNumber } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '../constants.js';
-import { computed, dispose, isComputed, read } from '../system.js';
-import object, { isReactiveObject } from './object.js';
-class ReactiveArray {
-    [REACTIVE_ARRAY] = true;
-    disposables = 0;
-    data;
-    listeners = null;
-    proxy;
-    constructor(data, proxy) {
-        this.data = data;
-        this.proxy = proxy;
-    }
-    get length() {
-        return this.data.length;
-    }
-    set length(n) {
-        if (n > this.data.length) {
-            return;
-        }
-        this.splice(n);
-    }
-    cleanup(item) {
-        if (isReactiveObject(item)) {
-            item.dispose();
-        }
-        else if (isComputed(item)) {
-            dispose(item);
-        }
+import { dispose as d, isComputed, read } from '../system.js';
+import { isReactiveObject } from './object.js';
+function at(data, i) {
+    let value = data[i];
+    if (isComputed(value)) {
+        return read(value);
+    }
+    return value;
+}
+function cleanup(item) {
+    if (isReactiveObject(item)) {
+        item.dispose();
     }
-    at(i) {
-        let value = this.data[i];
-        if (isComputed(value)) {
-            return read(value);
-        }
-        return value;
+    else if (isComputed(item)) {
+        d(item);
     }
-    dispatch(event, value) {
-        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(value);
-                if (listener.once !== undefined) {
-                    listeners[i] = null;
-                }
-            }
-            catch {
-                listeners[i] = null;
+}
+function clear(data, listeners) {
+    dispose(data);
+    dispatch(listeners, 'clear');
+}
+function dispatch(listeners, event, value) {
+    if (listeners === null || listeners[event] === undefined) {
+        return;
+    }
+    let bucket = listeners[event];
+    for (let i = 0, n = bucket.length; i < n; i++) {
+        let listener = bucket[i];
+        if (listener === null) {
+            continue;
+        }
+        try {
+            listener(value);
+            if (listener.once !== undefined) {
+                bucket[i] = null;
             }
         }
-    }
-    dispose() {
-        for (let i = 0, n = this.data.length; i < n; i++) {
-            this.cleanup(this.data[i]);
-        }
-    }
-    map(fn, i, n) {
-        let { data, proxy } = this, values = [];
-        if (i === undefined) {
-            i = 0;
-        }
-        if (n === undefined) {
-            n = data.length;
-        }
-        n = Math.min(n, data.length);
-        for (; i < n; i++) {
-            let item = data[i];
-            values.push(fn.call(proxy, (isComputed(item) ? item.value : item), i));
-        }
-        return values;
-    }
-    on(event, listener) {
-        if (this.listeners === null) {
-            this.listeners = { [event]: [listener] };
-        }
-        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;
-                }
-            }
+        catch {
+            bucket[i] = null;
         }
     }
-    once(event, listener) {
-        listener.once = true;
-        this.on(event, listener);
-    }
-    pop() {
-        let item = this.data.pop();
-        if (item !== undefined) {
-            this.cleanup(item);
-            this.dispatch('pop', { item });
-        }
-        return item;
+}
+function dispose(data) {
+    let item;
+    while (item = data.pop()) {
+        cleanup(item);
     }
-    push(...input) {
-        let items = factory(input), n = this.data.push(...items);
-        this.dispatch('push', { items });
-        return n;
+}
+function map(data, proxy, fn, i, n) {
+    if (i === undefined) {
+        i = 0;
     }
-    reverse() {
-        this.data.reverse();
-        this.dispatch('reverse');
-        return this;
+    if (n === undefined) {
+        n = data.length;
     }
-    shift() {
-        let item = this.data.shift();
-        if (item !== undefined) {
-            this.cleanup(item);
-            this.dispatch('shift', { item });
-        }
-        return item;
+    n = Math.min(n, data.length);
+    let values = new Array(n - i);
+    for (; i < n; i++) {
+        let item = data[i];
+        values[i] = fn.call(proxy, (isComputed(item) ? item.value : item), i);
     }
-    sort(fn) {
-        this.data.sort((a, b) => fn((isComputed(a) ? a.value : a), (isComputed(b) ? b.value : b)));
-        this.dispatch('sort');
-        return this;
-    }
-    splice(start, deleteCount = this.data.length, ...input) {
-        let items = factory(input), removed = this.data.splice(start, deleteCount, ...items);
-        if (items.length > 0 || removed.length > 0) {
-            for (let i = 0, n = removed.length; i < n; i++) {
-                this.cleanup(removed[i]);
+    return values;
+}
+function on(listeners, event, listener) {
+    let bucket = listeners[event];
+    if (bucket === undefined) {
+        listeners[event] = [listener];
+    }
+    else {
+        let hole = bucket.length;
+        for (let i = 0, n = hole; i < n; i++) {
+            let l = bucket[i];
+            if (l === listener) {
+                return;
+            }
+            else if (l === null && hole === n) {
+                hole = i;
             }
-            this.dispatch('splice', {
-                deleteCount,
-                items,
-                start
-            });
         }
-        return removed;
+        bucket[hole] = listener;
     }
-    unshift(...input) {
-        let items = factory(input), length = this.data.unshift(...items);
-        this.dispatch('unshift', { items });
-        return length;
+}
+function once(listeners, event, listener) {
+    listener.once = true;
+    on(listeners, event, listener);
+}
+function pop(data, listeners) {
+    let item = data.pop();
+    if (item !== undefined) {
+        cleanup(item);
+        dispatch(listeners, 'pop', { item });
     }
+    return item;
 }
-function factory(input) {
-    let items = [];
-    for (let i = 0, n = input.length; i < n; i++) {
-        let value = input[i];
-        if (isFunction(value)) {
-            items[i] = computed(value);
-        }
-        else if (isObject(value)) {
-            items[i] = object(value);
-        }
-        else {
-            items[i] = value;
-        }
+function push(data, listeners, items) {
+    let n = data.push(...items);
+    dispatch(listeners, 'push', { items });
+    return n;
+}
+function reverse(data, listeners) {
+    data.reverse();
+    dispatch(listeners, 'reverse');
+}
+function shift(data, listeners) {
+    let item = data.shift();
+    if (item !== undefined) {
+        cleanup(item);
+        dispatch(listeners, 'shift', { item });
     }
-    return items;
+    return item;
 }
-const isReactiveArray = (value) => {
-    return isObject(value) && REACTIVE_ARRAY in value;
-};
-export default (input) => {
-    let proxy = new Proxy({}, {
+function sort(data, listeners, fn) {
+    data.sort((a, b) => fn((isComputed(a) ? a.value : a), (isComputed(b) ? b.value : b)));
+    dispatch(listeners, 'sort');
+}
+function splice(data, listeners, start, deleteCount = data.length, items = []) {
+    let removed = data.splice(start, deleteCount, ...items);
+    if (items.length > 0 || removed.length > 0) {
+        for (let i = 0, n = removed.length; i < n; i++) {
+            cleanup(removed[i]);
+        }
+        dispatch(listeners, 'splice', {
+            deleteCount,
+            items,
+            start
+        });
+    }
+    return removed;
+}
+function unshift(data, listeners, items) {
+    let length = data.unshift(...items);
+    dispatch(listeners, 'unshift', { items });
+    return length;
+}
+export default (data) => {
+    let listeners = {}, proxy = new Proxy({}, {
         get(_, key) {
             if (isNumber(key)) {
-                let value = wrapped[key];
+                let value = data[key];
                 if (isComputed(value)) {
                     return read(value);
                 }
                 return value;
             }
-            else if (key in array) {
-                return array[key];
+            else if (key in wrapper) {
+                return wrapper[key];
+            }
+            else if (key === 'length') {
+                return data.length;
             }
-            return wrapped[key];
+            return data[key];
         },
         set(_, key, value) {
             if (isNumber(key)) {
-                array.splice(key, 1, value);
-                return true;
+                splice(data, listeners, key, 1, value);
             }
             else if (key === 'length') {
-                return array.length = value;
+                if (value >= data.length) {
+                }
+                else if (value === 0) {
+                    clear(data, listeners);
+                }
+                else {
+                    splice(data, listeners, value);
+                }
             }
-            return false;
-        }
-    }), wrapped = factory(input);
-    let array = new ReactiveArray(wrapped, proxy);
+            else {
+                return false;
+            }
+            return true;
+        }
+    }), wrapper = {
+        [REACTIVE_ARRAY]: true,
+        at: (i) => at(data, i),
+        clear: () => {
+            clear(data, listeners);
+            return proxy;
+        },
+        dispatch: (event, value) => {
+            dispatch(listeners, event, value);
+            return proxy;
+        },
+        dispose: () => {
+            dispose(data);
+            return proxy;
+        },
+        map: (fn, i, n) => {
+            return map(data, proxy, fn, i, n);
+        },
+        on: (event, listener) => {
+            on(listeners, event, listener);
+            return proxy;
+        },
+        once: (event, listener) => {
+            once(listeners, event, listener);
+            return proxy;
+        },
+        pop: () => pop(data, listeners),
+        push: (...items) => push(data, listeners, items),
+        reverse: () => {
+            reverse(data, listeners);
+            return proxy;
+        },
+        shift: () => shift(data, listeners),
+        sort: (fn) => {
+            sort(data, listeners, fn);
+            return proxy;
+        },
+        splice: (start, deleteCount, ...items) => {
+            return splice(data, listeners, start, deleteCount, items);
+        },
+        unshift: (...items) => unshift(data, listeners, items),
+    };
     return proxy;
 };
-export { isReactiveArray };

package/build/reactive/index.d.ts

@@ -3,7 +3,9 @@ import object from './object.js';
 type API<T> = T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
 type Input<T> = T extends {
     dispose: any;
-} ? never : T extends Record<PropertyKey, unknown> ? T : T extends unknown[] ? Input<T[number]>[] : never;
-declare const _default: <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>) => API<T>;
+} ? {
+    never: '[ dispose, signals ] are reserved keys';
+} : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
+declare const _default: <T>(input: Input<T>) => API<T>;
 export default _default;
 export type { Input };

package/build/reactive/object.d.ts

@@ -1,11 +1,14 @@
 import { Prettify } from '@esportsplus/utilities';
 import { Infer } from '../types.js';
 import { REACTIVE_OBJECT } from '../constants.js';
-type API<T extends Record<PropertyKey, unknown>> = Prettify<{
+type API<T> = Prettify<{
     [K in keyof T]: Infer<T[K]>;
-}> & ReactiveObject<T>;
+} & {
+    dispose: VoidFunction;
+}>;
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT]: boolean;
+    private disposers;
     constructor(data: T);
     dispose(): void;
 }

package/build/reactive/object.js

@@ -1,72 +1,73 @@
 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, disposer;
+        if (!disposers) {
+            return;
+        }
+        while (disposer = disposers.pop()) {
+            disposer();
         }
     }
 }