@esportsplus/reactivity 0.0.30 → 0.1.0

package/build/bench.d.ts

@@ -0,0 +1 @@
+export {};

package/build/bench.js

@@ -0,0 +1,46 @@
+import object from './reactive';
+import object2 from './reactive/object2';
+console.time('original');
+for (let i = 0, n = 10000; i < n; i++) {
+    let obj = object({
+        something: 'else',
+        what: 0,
+        does: 'sadsadsadsaasd',
+        elser: true,
+        hey: [
+            {
+                something: 'else',
+                what: 0,
+                does: 'sadsadsadsaasd',
+                elser: true,
+            }
+        ]
+    });
+    obj.something;
+    obj.what;
+    obj.does;
+    obj.hey[0].something;
+}
+console.timeEnd('original');
+console.time('lazy');
+for (let i = 0, n = 10000; i < n; i++) {
+    let obj = object2({
+        something: 'else',
+        what: 0,
+        does: 'sadsadsadsaasd',
+        elser: true,
+        hey: [
+            {
+                something: 'else',
+                what: 0,
+                does: 'sadsadsadsaasd',
+                elser: true,
+            }
+        ]
+    });
+    obj.something;
+    obj.what;
+    obj.does;
+    obj.hey[0].something;
+}
+console.timeEnd('lazy');

package/build/constants.d.ts

@@ -0,0 +1,8 @@
+declare const CLEAN = 0;
+declare const CHECK = 1;
+declare const DIRTY = 2;
+declare const DISPOSED = 3;
+declare const COMPUTED = 0;
+declare const EFFECT = 1;
+declare const SIGNAL = 2;
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL };

package/build/constants.js

@@ -0,0 +1,8 @@
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+const DISPOSED = 3;
+const COMPUTED = 0;
+const EFFECT = 1;
+const SIGNAL = 2;
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL };

package/build/context/node.d.ts

@@ -1,4 +1,4 @@
-import { NODE } from '../symbols';
+import { NODE } from '../constants';
 import { Context, Signal } from '../types';
 type Internals = {
     [NODE]: Signal<any>;

package/build/context/node.js

@@ -1,4 +1,4 @@
-import { NODE } from '../symbols';
+import { NODE } from '../constants';
 function dispose() {
     this[NODE].dispose();
 }

package/build/context/nodes.d.ts

@@ -1,4 +1,4 @@
-import { NODES } from '../symbols';
+import { NODES } from '../constants';
 import { Context, Signal } from '../types';
 type Internals = {
     [NODES]: Record<PropertyKey, Signal<any>>;

package/build/context/nodes.js

@@ -1,4 +1,4 @@
-import { NODES } from '../symbols';
+import { NODES } from '../constants';
 function dispose() {
     let nodes = this[NODES];
     for (let key in nodes) {

package/build/effect.d.ts

@@ -1,7 +1,3 @@
-declare const _default: (fn: (this: import("./types").Context, previous: unknown) => unknown, options?: import("./types").Options | undefined) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("./types").Listener) => void;
-    once: (event: symbol, listener: import("./types").Listener) => void;
-    reset: () => void;
-};
+import { API, Effect, Options, Prettify } from './types';
+declare const _default: <T>(fn: (previous: T) => T, options: Options) => Omit<API<T>, "value"> extends infer T_1 ? { [K in keyof T_1]: Omit<API<T>, "value">[K]; } : never;
 export default _default;

package/build/effect.js

@@ -1,3 +1,2 @@
 import { effect } from './signal';
-import context from './context';
-export default (...args) => context.node({}, effect(...args));
+export default effect;

package/build/index.d.ts

@@ -1,7 +1,5 @@
-export { default as effect } from './effect';
 export { default as macro } from './macro';
-export { default as promise } from './promise';
+export { default as resource } from './resource';
 export * as core from './signal';
-export { root } from './signal';
+export { effect, root } from './signal';
 export { default as reactive } from './reactive';
-export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/index.js

@@ -1,7 +1,5 @@
-export { default as effect } from './effect';
 export { default as macro } from './macro';
-export { default as promise } from './promise';
+export { default as resource } from './resource';
 export * as core from './signal';
-export { root } from './signal';
+export { effect, root } from './signal';
 export { default as reactive } from './reactive';
-export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/macro.d.ts

@@ -1,9 +1,12 @@
+import CustomFunction from '@esportsplus/custom-function';
 import { computed } from './signal';
-import { Computed } from './types';
-declare const _default: <T extends <A, R>(...args: A[]) => R>(fn: T extends Promise<unknown> ? never : (this: import("./types").Context, previous: T) => T, options?: Parameters<typeof computed>[1]) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("./types").Listener) => void;
-    once: (event: symbol, listener: import("./types").Listener) => void;
-    reset: () => void;
-};
+type Fn<A extends unknown[], R> = Parameters<typeof computed<(...args: A) => R>>[0];
+type Options = Parameters<typeof computed>[1];
+declare class Macro<A extends unknown[], R> extends CustomFunction {
+    #private;
+    constructor(fn: Fn<A, R>, options?: Options);
+    dispose(): void;
+    reset(): void;
+}
+declare const _default: <A extends unknown[], R>(fn: (previous: (...args: A) => R) => (...args: A) => R, options?: Options) => Macro<A, R>;
 export default _default;

package/build/macro.js

@@ -1,8 +1,20 @@
+import CustomFunction from '@esportsplus/custom-function';
 import { computed, read } from './signal';
-import context from './context';
+class Macro extends CustomFunction {
+    #factory;
+    constructor(fn, options = {}) {
+        super((...args) => {
+            return read(this.#factory)(...args);
+        });
+        this.#factory = computed(fn, options);
+    }
+    dispose() {
+        this.#factory.dispose();
+    }
+    reset() {
+        this.#factory.reset();
+    }
+}
 export default (fn, options = {}) => {
-    let node = computed(fn, options);
-    return context.node((...args) => {
-        return read(node)(...args);
-    }, node);
+    return new Macro(fn, options);
 };

package/build/promise.d.ts

@@ -1,8 +1,28 @@
+import CustomFunction from '@esportsplus/custom-function';
 import { computed } from './signal';
-declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("./types").Listener) => void;
-    once: (event: symbol, listener: import("./types").Listener) => void;
-    reset: () => void;
+import { API, Signal } from './types';
+type Fn = <A, R extends Promise<any>>(...args: A[]) => R;
+type Options = Parameters<typeof computed>[1];
+type R<T extends Fn> = Omit<ReactivePromise<T>, 'fn' | 'input' | 'nodes'> & {
+    readonly fn: T;
+    readonly input: Parameters<T> | null;
+    readonly nodes: {
+        data: API<ReturnType<T>>;
+        ok: API<boolean | null>;
+    };
 };
+declare class ReactivePromise<T extends Fn> extends CustomFunction {
+    fn: T;
+    input: Parameters<T> | null;
+    nodes: {
+        data: Signal<ReturnType<T>>;
+        ok: Signal<boolean | null>;
+    };
+    stop: boolean | null;
+    constructor(fn: T, options?: Options);
+    get data(): ReturnType<T> | ReturnType<ReturnType<T> extends infer T_1 ? T_1 extends ReturnType<T> ? T_1 extends Promise<unknown> ? never : (previous: T_1) => T_1 : never : never>;
+    get ok(): boolean | null;
+    invoke(...args: Parameters<T>): void;
+}
+declare const _default: <T extends Fn>(fn: T, options?: Options) => R<T>;
 export default _default;

package/build/promise.js

@@ -1,38 +1,45 @@
+import CustomFunction from '@esportsplus/custom-function';
 import { read, root, signal, write } from './signal';
-import context from './context';
-export default (fn, options = {}) => {
-    let input, nodes = {
-        data: signal(options?.value, options),
-        status: signal(undefined, options)
-    };
-    function host(...args) {
-        input = args;
+class ReactivePromise extends CustomFunction {
+    fn;
+    input = null;
+    nodes;
+    stop = null;
+    constructor(fn, options = {}) {
+        super((...args) => this.invoke(...args));
+        this.fn = fn;
+        this.nodes = {
+            data: signal(options.value, options),
+            ok: signal(null, options)
+        };
+    }
+    get data() {
+        return read(this.nodes.data);
+    }
+    get ok() {
+        return read(this.nodes.ok);
+    }
+    invoke(...args) {
+        this.input = args;
+        this.stop = null;
         root(() => {
-            fn(...args)
+            write(this.nodes.ok, null);
+            this.fn(...args)
                 .then((value) => {
-                write(nodes.data, value);
+                if (this.stop === true) {
+                    return;
+                }
+                write(this.nodes.data, value);
+                write(this.nodes.ok, true);
             })
                 .catch(() => {
-                write(nodes.data, undefined);
+                if (this.stop === true) {
+                    return;
+                }
+                write(this.nodes.data, undefined);
+                write(this.nodes.ok, false);
             });
         });
     }
-    Object.defineProperties(host, {
-        data: {
-            get() {
-                return read(nodes.data);
-            }
-        },
-        input: {
-            get() {
-                return input;
-            }
-        },
-        status: {
-            get() {
-                return read(nodes.status);
-            }
-        }
-    });
-    return context.nodes(host, nodes);
-};
+}
+export default (fn, options = {}) => new ReactivePromise(fn, options);

package/build/reactive/array.d.ts

@@ -0,0 +1,60 @@
+import { Listener, Options } from '../types';
+import { ReactiveObject } from './object';
+type Events<T> = {
+    fill: {
+        value: T;
+    };
+    pop: {
+        item: T;
+    };
+    push: {
+        items: T[];
+    };
+    reverse: undefined;
+    shift: {
+        item: T;
+    };
+    sort: undefined;
+    splice: {
+        deleteCount: number;
+        items: T[];
+        start: number;
+    };
+    unshift: {
+        items: T[];
+    };
+};
+type Node<T extends Record<PropertyKey, unknown>> = ReactiveObject<T>;
+declare class ReactiveArray<T> extends Array<T> {
+    #private;
+    constructor(data: T[]);
+    set length(n: number);
+    private trigger;
+    dispatch<E extends keyof Events<T>>(event: E, data?: Events<T>[E]): void;
+    dispose(): void;
+    fill(value: T, start?: number, end?: number): this;
+    on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>): void;
+    once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>): void;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    reset(): void;
+    reverse(): this;
+    shift(): T | undefined;
+    sort(): this;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    track(): void;
+    unshift(...items: T[]): number;
+}
+declare class ReactiveObjectArray<T extends Record<PropertyKey, unknown>> extends ReactiveArray<Node<T>> {
+    #private;
+    constructor(data: T[], options?: Options);
+    fill(): never;
+    reverse(): never;
+    pop(): Node<T> | undefined;
+    push(...values: T[]): number;
+    shift(): Node<T> | undefined;
+    sort(): never;
+    splice(start: number, deleteCount?: number, ...values: T[]): Node<T> | Node<T>[] | undefined;
+    unshift(...values: T[]): number;
+}
+export { ReactiveArray, ReactiveObjectArray };

package/build/reactive/array.js

@@ -0,0 +1,136 @@
+import { dispose, read, signal, write } from '../signal';
+import { ReactiveObject } from './object';
+function factory(data, options = {}) {
+    let signals = [];
+    for (let i = 0, n = data.length; i < n; i++) {
+        signals.push(new ReactiveObject(data[i], options));
+    }
+    return signals;
+}
+function unsupported(method) {
+    throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
+}
+class ReactiveArray extends Array {
+    #signal;
+    constructor(data) {
+        super(...data);
+        this.#signal = signal(false);
+    }
+    set length(n) {
+        if (n > this.length) {
+            return;
+        }
+        this.splice(n);
+    }
+    trigger() {
+        write(this.#signal, !this.#signal.value);
+    }
+    dispatch(event, data) {
+        this.#signal.dispatch(event, data);
+    }
+    dispose() {
+        this.#signal.dispose();
+    }
+    fill(value, start, end) {
+        super.fill(value, start, end);
+        this.dispatch('fill', { value });
+        this.trigger();
+        return this;
+    }
+    on(event, listener) {
+        this.#signal.on(event, listener);
+    }
+    once(event, listener) {
+        this.#signal.once(event, listener);
+    }
+    pop() {
+        let item = super.pop();
+        if (item !== undefined) {
+            this.dispatch('pop', { item });
+            this.trigger();
+        }
+        return item;
+    }
+    push(...items) {
+        let n = super.push(...items);
+        this.dispatch('push', { items });
+        this.trigger();
+        return n;
+    }
+    reset() {
+        this.#signal.reset();
+    }
+    reverse() {
+        super.reverse();
+        this.dispatch('reverse');
+        this.trigger();
+        return this;
+    }
+    shift() {
+        let item = super.shift();
+        if (item !== undefined) {
+            this.dispatch('shift', { item });
+            this.trigger();
+        }
+        return item;
+    }
+    sort() {
+        super.sort();
+        this.dispatch('sort');
+        this.trigger();
+        return this;
+    }
+    splice(start, deleteCount = super.length, ...items) {
+        let removed = super.splice(start, deleteCount, ...items);
+        if (items.length > 0 || removed.length > 0) {
+            this.dispatch('splice', {
+                deleteCount,
+                items,
+                start
+            });
+            this.trigger();
+        }
+        return removed;
+    }
+    track() {
+        read(this.#signal);
+    }
+    unshift(...items) {
+        let length = super.unshift(...items);
+        this.dispatch('unshift', { items });
+        this.trigger();
+        return length;
+    }
+}
+class ReactiveObjectArray extends ReactiveArray {
+    #options;
+    constructor(data, options = {}) {
+        super(factory(data, options));
+        this.#options = options;
+    }
+    fill() {
+        return unsupported('fill');
+    }
+    reverse() {
+        return unsupported('reverse');
+    }
+    pop() {
+        return dispose(super.pop());
+    }
+    push(...values) {
+        return super.push(...factory(values, this.#options));
+    }
+    shift() {
+        return dispose(super.shift());
+    }
+    sort() {
+        return unsupported('sort');
+    }
+    splice(start, deleteCount = super.length, ...values) {
+        return dispose(super.splice(start, deleteCount, ...factory(values, this.#options)));
+    }
+    unshift(...values) {
+        return super.unshift(...factory(values, this.#options));
+    }
+}
+export { ReactiveArray, ReactiveObjectArray };

package/build/reactive/index.d.ts

@@ -0,0 +1,11 @@
+import { Object, Options } from '../types';
+import { ReactiveObject } from './object';
+type Guard<T> = T extends Object ? {
+    [K in keyof T]: Never<K, Guard<T[K]>>;
+} : T extends unknown[] ? Guard<T[number]>[] : T;
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends unknown[] ? Infer<T[number]>[] : T extends Object ? {
+    [K in keyof T]: T[K];
+} : T;
+type Never<K, V> = K extends keyof ReactiveObject<Object> ? never : V;
+declare const _default: <T extends Object>(data: Guard<T>, options?: Options) => { [K_1 in keyof T]: Infer<T[K_1]>; } & ReactiveObject<T> extends infer T_1 ? { [K in keyof T_1]: ({ [K_1 in keyof T]: Infer<T[K_1]>; } & ReactiveObject<T>)[K]; } : never;
+export default _default;

package/build/reactive/index.js

@@ -0,0 +1,4 @@
+import { ReactiveObject } from './object';
+export default (data, options = {}) => {
+    return new ReactiveObject(data, options);
+};

package/build/reactive/object.d.ts

@@ -0,0 +1,14 @@
+import { Computed, Options, Signal } from '../types';
+import { ReactiveArray, ReactiveObjectArray } from './array';
+type Node<T> = T extends (...args: unknown[]) => unknown ? Computed<T> : T extends unknown[] ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T> : Signal<T>;
+type Nodes<T extends Object> = {
+    [K in keyof T]: Node<T[K]>;
+};
+type Object = Record<PropertyKey, unknown>;
+declare class ReactiveObject<T extends Object> {
+    nodes: Nodes<T>;
+    constructor(data: T, options?: Options);
+    dispose(): void;
+    reset(): void;
+}
+export { ReactiveObject };

package/build/reactive/object.js

@@ -0,0 +1,60 @@
+import { computed, read, signal, write } from '../signal';
+import { defineProperty, isArray } from '../utilities';
+import { ReactiveArray, ReactiveObjectArray } from './array';
+class ReactiveObject {
+    nodes;
+    constructor(data, options = {}) {
+        let nodes = {};
+        for (let key in data) {
+            let input = data[key];
+            if (typeof input === 'function') {
+                let node = nodes[key] = computed(input, options);
+                defineProperty(this, key, {
+                    get() {
+                        return read(node);
+                    }
+                });
+            }
+            else if (isArray(input)) {
+                let node, test = input[0];
+                if (typeof test === 'object' && test !== null && test.constructor.name === 'Object') {
+                    node = nodes[key] = new ReactiveObjectArray(input, options);
+                }
+                else {
+                    node = nodes[key] = new ReactiveArray(input);
+                }
+                defineProperty(this, key, {
+                    get() {
+                        node.track();
+                        return node;
+                    }
+                });
+            }
+            else {
+                let node = nodes[key] = signal(input, options);
+                defineProperty(this, key, {
+                    get() {
+                        return read(node);
+                    },
+                    set(value) {
+                        write(node, value);
+                    }
+                });
+            }
+        }
+        this.nodes = nodes;
+    }
+    dispose() {
+        let nodes = this.nodes;
+        for (let key in nodes) {
+            nodes[key].dispose();
+        }
+    }
+    reset() {
+        let nodes = this.nodes;
+        for (let key in nodes) {
+            nodes[key].reset();
+        }
+    }
+}
+export { ReactiveObject };

package/build/reactive/object2.d.ts

@@ -0,0 +1,10 @@
+import { Infer, Key, Node, Options, Values } from './types';
+declare class ReactiveObject<K extends Key, V> {
+    nodes: Record<K, Node<K, V>>;
+    constructor(data: Values<K, V>, options?: Options);
+    dispose(): void;
+    reset(): void;
+}
+declare const _default: <K extends Key, V>(data: Values<K, V>, options?: Options) => ReactiveObject<K, V> & Infer<Record<K, V>>;
+export default _default;
+export { ReactiveObject };

package/build/reactive/object2.js

@@ -0,0 +1,65 @@
+import { computed, read, signal, write } from '../signal';
+import { isArray } from '../utilities';
+import ReactiveArray from './array';
+class ReactiveObject {
+    nodes = {};
+    constructor(data, options = {}) {
+        let nodes = this.nodes;
+        for (let key in data) {
+            let node = nodes[key], value = data[key];
+            if (typeof value === 'function') {
+                Object.defineProperty(this, key, {
+                    get() {
+                        if (node === undefined) {
+                            node = nodes[key] = computed(value, options);
+                        }
+                        return read(node);
+                    }
+                });
+            }
+            else if (isArray(value) && value[0]?.constructor?.name === 'Object') {
+                Object.defineProperty(this, key, {
+                    get() {
+                        if (node === undefined) {
+                            node = nodes[key] = new ReactiveArray(value, options);
+                        }
+                        node.track();
+                        return node;
+                    }
+                });
+            }
+            else {
+                Object.defineProperty(this, key, {
+                    get() {
+                        if (node === undefined) {
+                            node = nodes[key] = signal(value, options);
+                        }
+                        return read(node);
+                    },
+                    set(value) {
+                        if (node === undefined) {
+                            node = nodes[key] = signal(value, options);
+                        }
+                        write(node, value);
+                    }
+                });
+            }
+        }
+    }
+    dispose() {
+        let nodes = this.nodes;
+        for (let key in nodes) {
+            nodes[key].dispose();
+        }
+    }
+    reset() {
+        let nodes = this.nodes;
+        for (let key in nodes) {
+            nodes[key].reset();
+        }
+    }
+}
+export default (data, options = {}) => {
+    return new ReactiveObject(data, options);
+};
+export { ReactiveObject };