@esportsplus/reactivity 0.0.30 → 0.1.0

package/build/reactive/types.d.ts

@@ -0,0 +1,33 @@
+import { computed, signal } from '../signal';
+import { Computed, Signal } from '../types';
+import { ReactiveObject } from './object';
+import ReactiveArray from './array';
+type Events<T> = {
+    pop: {
+        item: T;
+    };
+    push: {
+        items: T[];
+    };
+    shift: {
+        item: T;
+    };
+    splice: {
+        deleteCount: number;
+        items: T[];
+        start: number;
+    };
+    unshift: {
+        items: T[];
+    };
+};
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends unknown[] ? Infer<T> : T extends Record<Key, unknown> ? {
+    [K in keyof T]: T[K];
+} : T;
+type Key = string | symbol;
+type Node<K extends Key, V> = Computed<V> | ReactiveArray<K, V> | Signal<V>;
+type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
+type Values<K extends Key, V> = Record<K, V> & {
+    [K in keyof ReactiveObject<Key, unknown>]?: never;
+};
+export { Events, Infer, Key, Node, Options, Values };

package/build/reactive/types.js

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

package/build/reactive-array.d.ts

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

package/build/reactive-array.js

@@ -0,0 +1,106 @@
+import { read, signal } from './signal';
+import { Trigger } from './trigger';
+let { isArray } = Array;
+function dispose(dispose) {
+    if (dispose === undefined) {
+    }
+    else if (isArray(dispose)) {
+        for (let i = 0, n = dispose.length; i < n; i++) {
+            dispose[i].dispose();
+        }
+    }
+    else {
+        dispose.dispose();
+    }
+    return dispose;
+}
+class Reactive extends Trigger {
+    nodes;
+    constructor(nodes) {
+        super();
+        this.nodes = nodes;
+    }
+    [Symbol.iterator]() {
+        let i = 0;
+        return {
+            next: () => {
+                if (i < this.nodes.length) {
+                    return {
+                        done: false,
+                        value: read(this.nodes[i++])
+                    };
+                }
+                return { done: true };
+            }
+        };
+    }
+    get length() {
+        return this.nodes.length;
+    }
+    set length(n) {
+        this.splice(n);
+    }
+    get(index) {
+        if (index in this.nodes) {
+            return read(this.nodes[index]);
+        }
+        return undefined;
+    }
+    pop() {
+        let signal = dispose(this.nodes.pop());
+        if (signal !== undefined) {
+            this.dispatch('action', {
+                signal,
+                type: 'pop'
+            });
+        }
+        return signal;
+    }
+    push(...values) {
+        let signals = [];
+        for (let i = 0, n = values.length; i < n; i++) {
+            signals.push(signal(values[i]));
+        }
+        this.nodes.push(...signals);
+        this.dispatch('action', {
+            signals,
+            type: 'push'
+        });
+        return this.nodes.length;
+    }
+    shift() {
+        let signal = dispose(this.nodes.shift());
+        if (signal !== undefined) {
+            this.dispatch('action', {
+                signal,
+                type: 'shift'
+            });
+        }
+        return signal;
+    }
+    splice(start, deleteCount = this.nodes.length, ...values) {
+        let signals = [];
+        for (let i = 0, n = values.length; i < n; i++) {
+            signals.push(signal(values[i]));
+        }
+        let disposed = dispose(this.nodes.splice(start, deleteCount, ...signals));
+        this.dispatch('action', {
+            deleteCount,
+            signals,
+            start,
+            type: 'splice'
+        });
+        return disposed;
+    }
+    unshift(...values) {
+        let signals = [];
+        for (let i = 0, n = values.length; i < n; i++) {
+            signals.push(signal(values[i]));
+        }
+        this.dispatch('action', {
+            signals,
+            type: 'unshift'
+        });
+        return this.nodes.unshift(...signals);
+    }
+}

package/build/reactive.js

@@ -17,8 +17,8 @@ export default (data, options = {}) => {
                 get() {
                     return read(nodes[key]);
                 },
-                set(data) {
-                    write(nodes[key], data);
+                set(value) {
+                    write(nodes[key], value);
                 }
             });
         }

package/build/resource.d.ts

@@ -0,0 +1,16 @@
+import CustomFunction from '@esportsplus/custom-function';
+import { computed } from './signal';
+type Fn<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
+type Options = Parameters<typeof computed>[1];
+declare class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+    #private;
+    stop: boolean | null;
+    constructor(fn: Fn<A, R>, options?: Options);
+    get data(): Awaited<R> | ReturnType<Awaited<R> extends infer T ? T extends Awaited<R> ? T extends Promise<unknown> ? never : (previous: T) => T : never : never>;
+    get ok(): boolean | null;
+    get input(): A | ReturnType<A extends Promise<unknown> ? never : (previous: A) => A> | null;
+    dispose(): void;
+    reset(): void;
+}
+declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: Fn<A, R>, options?: Options) => Resource<A, R>;
+export default _default;

package/build/resource.js

@@ -0,0 +1,55 @@
+import CustomFunction from '@esportsplus/custom-function';
+import { read, signal, write } from './signal';
+class Resource extends CustomFunction {
+    #data;
+    #input;
+    #ok;
+    stop = null;
+    constructor(fn, options = {}) {
+        super((...args) => {
+            this.stop = null;
+            write(this.#input, args);
+            write(this.#ok, null);
+            fn(...args)
+                .then((value) => {
+                if (this.stop === true) {
+                    return;
+                }
+                write(this.#data, value);
+                write(this.#ok, true);
+            })
+                .catch(() => {
+                if (this.stop === true) {
+                    return;
+                }
+                write(this.#data, undefined);
+                write(this.#ok, false);
+            });
+        });
+        this.#data = signal(options.value, options),
+            this.#input = signal(null, options),
+            this.#ok = signal(null, options);
+    }
+    get data() {
+        return read(this.#data);
+    }
+    get ok() {
+        return read(this.#ok);
+    }
+    get input() {
+        return read(this.#input);
+    }
+    dispose() {
+        this.#data.dispose();
+        this.#input.dispose();
+        this.#ok.dispose();
+    }
+    reset() {
+        this.#data.reset();
+        this.#input.reset();
+        this.#ok.reset();
+    }
+}
+export default (fn, options = {}) => {
+    return new Resource(fn, options);
+};

package/build/signal.d.ts

@@ -1,8 +1,8 @@
-import { Changed, Computed, Context, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+import { Changed, Computed, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
 declare class Signal<T> {
     changed: Changed | null;
     fn: Computed<T>['fn'] | null;
-    listeners: Record<symbol, (Listener | null)[]> | null;
+    listeners: Record<Event, (Listener<any> | null)[]> | null;
     observers: Signal<T>[] | null;
     root: Root | null;
     sources: Signal<T>[] | null;
@@ -12,20 +12,25 @@ declare class Signal<T> {
     updating: boolean | null;
     value: Computed<T>['value'] | T;
     constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options?: Options);
+    dispatch<D>(event: Event, data?: D): void;
     dispose(): void;
-    on(event: Event, listener: Listener): void;
-    once(event: Event, listener: Listener): void;
+    on(event: Event, listener: Listener<any>): void;
+    once(event: Event, listener: Listener<any>): void;
     reset(): void;
 }
-declare const computed: <T>(fn: T extends Promise<unknown> ? never : (this: Context, previous: T) => T, options?: Options & {
-    value?: unknown;
-}) => Computed<T>;
-declare const effect: <T>(fn: (this: Context, previous: T) => T, options?: Options) => Effect<void>;
-declare const read: <T>(node: Signal<T>) => T | ReturnType<T extends Promise<unknown> ? never : (this: Context, previous: T) => T>;
+declare const computed: <T>(fn: T extends Promise<unknown> ? never : (previous: T) => T, options?: Options) => Computed<T>;
+declare const dispose: <T extends {
+    dispose: () => void;
+}>(dispose?: T | T[] | undefined) => T | T[] | undefined;
+declare const effect: <T>(fn: (node: Effect<T>) => void, options?: Omit<Options, 'value'>) => Effect<void>;
+declare const read: <T>(node: Signal<T>) => T | ReturnType<T extends Promise<unknown> ? never : (previous: T) => T>;
+declare const reset: <T extends {
+    reset: () => void;
+}>(reset?: T | T[] | undefined) => T | T[] | undefined;
 declare const root: <T>(fn: () => T, properties?: {
     scheduler?: Scheduler;
 }) => T;
-declare const signal: <T>(data: T, options?: Options) => Signal<T>;
-declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<T extends Promise<unknown> ? never : (this: Context, previous: T) => T>;
+declare const signal: <T>(data: T, options?: Omit<Options, 'value'>) => Signal<T>;
+declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<T extends Promise<unknown> ? never : (previous: T) => T>;
 export default Signal;
-export { computed, effect, read, root, signal, write };
+export { computed, dispose, effect, read, reset, root, signal, write };

package/build/signal.js

@@ -1,4 +1,5 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from './symbols';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
+import { isArray } from './utilities';
 let index = 0, observer = null, observers = null, scope = null;
 class Signal {
     changed = null;
@@ -13,26 +14,47 @@ class Signal {
     updating = null;
     value;
     constructor(data, state, type, options = {}) {
-        if (options?.changed) {
+        if (options.changed !== undefined) {
             this.changed = options.changed;
         }
         this.state = state;
         this.type = type;
         this.value = data;
     }
+    dispatch(event, data) {
+        if (this.listeners === null || !(event in this.listeners)) {
+            return;
+        }
+        let listeners = this.listeners[event], value = this.value;
+        for (let i = 0, n = listeners.length; i < n; i++) {
+            let listener = listeners[i];
+            if (listener === null) {
+                continue;
+            }
+            try {
+                listener(listener.length === 0 ? null : { data, value });
+            }
+            catch {
+                listeners[i] = null;
+            }
+            if (listener.once !== undefined) {
+                listeners[i] = null;
+            }
+        }
+    }
     dispose() {
         if (this.state === DISPOSED) {
             return;
         }
         this.state = DISPOSED;
-        dispatch(DISPOSE, this);
+        this.dispatch('dispose', this);
         flush(this);
     }
     on(event, listener) {
         if (this.updating) {
             listener.once = true;
         }
-        if (!this.listeners?.[event]) {
+        if (this.listeners === null || !(event in this.listeners)) {
             this.listeners ??= {};
             this.listeners[event] = [listener];
         }
@@ -54,7 +76,7 @@ class Signal {
         this.on(event, listener);
     }
     reset() {
-        dispatch(RESET, this);
+        this.dispatch('reset', this);
         flush(this);
         if (this.type === COMPUTED) {
             this.state = DIRTY;
@@ -72,24 +94,8 @@ class Signal {
 function changed(a, b) {
     return a !== b;
 }
-function dispatch(event, node) {
-    if (!node.listeners?.[event]) {
-        return;
-    }
-    let listeners = node.listeners[event], value = node.value;
-    for (let i = 0, n = listeners.length; i < n; i++) {
-        let listener = listeners[i];
-        if (!listener) {
-            continue;
-        }
-        listener(value);
-        if (listener?.once) {
-            listeners[i] = null;
-        }
-    }
-}
 function flush(node) {
-    if (node.sources) {
+    if (node.sources !== null) {
         removeSourceObservers(node, 0);
     }
     node.listeners = null;
@@ -97,7 +103,7 @@ function flush(node) {
     node.sources = null;
 }
 function notify(nodes, state) {
-    if (!nodes) {
+    if (nodes === null) {
         return;
     }
     for (let i = 0, n = nodes.length; i < n; i++) {
@@ -112,12 +118,12 @@ function notify(nodes, state) {
     }
 }
 function removeSourceObservers(node, start) {
-    if (!node.sources) {
+    if (node.sources === null) {
         return;
     }
     for (let i = start, n = node.sources.length; i < n; i++) {
         let source = node.sources[i];
-        if (!source?.observers) {
+        if (source.observers === null) {
             continue;
         }
         source.observers[source.observers.indexOf(node)] = source.observers[source.observers.length - 1];
@@ -125,7 +131,7 @@ function removeSourceObservers(node, start) {
     }
 }
 function sync(node) {
-    if (node.state === CHECK && node.sources) {
+    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) {
@@ -146,13 +152,13 @@ function update(node) {
     observer = node;
     observers = null;
     try {
-        dispatch(UPDATE, node);
+        node.dispatch('update');
         node.updating = true;
-        let value = node.fn.call(node, node?.value);
+        let value = node.fn.call(node, node.value);
         node.updating = null;
         if (observers) {
             removeSourceObservers(node, index);
-            if (node.sources && index > 0) {
+            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];
@@ -171,7 +177,7 @@ function update(node) {
                 }
             }
         }
-        else if (node.sources && index < node.sources.length) {
+        else if (node.sources !== null && index < node.sources.length) {
             removeSourceObservers(node, index);
             node.sources.length = index;
         }
@@ -192,10 +198,23 @@ function update(node) {
     node.state = CLEAN;
 }
 const computed = (fn, options = {}) => {
-    let node = new Signal(options?.value, DIRTY, COMPUTED, options);
+    let node = new Signal(options.value, DIRTY, COMPUTED, options);
     node.fn = fn;
     return node;
 };
+const dispose = (dispose) => {
+    if (dispose === undefined) {
+    }
+    else if (isArray(dispose)) {
+        for (let i = 0, n = dispose.length; i < n; i++) {
+            dispose[i].dispose();
+        }
+    }
+    else {
+        dispose.dispose();
+    }
+    return dispose;
+};
 const effect = (fn, options = {}) => {
     if (!scope) {
         throw new Error('Reactivity: `effects` cannot be created without a reactive root');
@@ -213,7 +232,7 @@ const read = (node) => {
     }
     if (observer) {
         if (!observers) {
-            if (observer?.sources?.[index] == node) {
+            if (observer.sources !== null && observer.sources[index] == node) {
                 index++;
             }
             else {
@@ -229,11 +248,26 @@ const read = (node) => {
     }
     return node.value;
 };
+const reset = (reset) => {
+    if (reset === undefined) {
+    }
+    else if (isArray(reset)) {
+        for (let i = 0, n = reset.length; i < n; i++) {
+            reset[i].reset();
+        }
+    }
+    else {
+        reset.reset();
+    }
+    return reset;
+};
 const root = (fn, properties = {}) => {
     let o = observer, s = scope;
-    properties.scheduler = properties?.scheduler || scope?.scheduler;
-    if (!properties.scheduler) {
-        throw new Error('Reactivity: `root` cannot be created without a task scheduler');
+    if (properties.scheduler === undefined) {
+        properties.scheduler = scope?.scheduler;
+        if (properties.scheduler === undefined) {
+            throw new Error('Reactivity: `root` cannot be created without a task scheduler');
+        }
     }
     observer = null;
     scope = properties;
@@ -246,11 +280,11 @@ const signal = (data, options = {}) => {
     return new Signal(data, CLEAN, SIGNAL, options);
 };
 const write = (node, value) => {
-    if ((node?.changed || changed)(node.value, value)) {
+    if ((node.changed === null ? changed : node.changed)(node.value, value)) {
         node.value = value;
         notify(node.observers, DIRTY);
     }
     return node.value;
 };
 export default Signal;
-export { computed, effect, read, root, signal, write };
+export { computed, dispose, effect, read, reset, root, signal, write };

package/build/testing/node.d.ts

@@ -0,0 +1,13 @@
+import { Event, Listener, Signal } from '../types';
+import CustomFunction from '@esportsplus/custom-function';
+type Node = Signal<any>;
+declare class Context<T extends Function> extends CustomFunction {
+    signal: Signal<any>;
+    constructor(host: T, node: Node);
+    dispose(): void;
+    on(event: Event, listener: Listener): void;
+    once(event: Event, listener: Listener): void;
+    reset(): void;
+}
+declare const _default: <T extends Function>(fn: T, node: Node) => Context<T>;
+export default _default;

package/build/testing/node.js

@@ -0,0 +1,21 @@
+import CustomFunction from '@esportsplus/custom-function';
+class Context extends CustomFunction {
+    signal;
+    constructor(host, node) {
+        super(host);
+        this.signal = node;
+    }
+    dispose() {
+        this.signal.dispose();
+    }
+    on(event, listener) {
+        this.signal.on(event, listener);
+    }
+    once(event, listener) {
+        this.signal.once(event, listener);
+    }
+    reset() {
+        this.signal.reset();
+    }
+}
+export default (fn, node) => new Context(fn, node);

package/build/testing/nodes.d.ts

@@ -0,0 +1,13 @@
+import { Event, Listener, Signal } from '../types';
+import CustomFunction from '@esportsplus/custom-function';
+type Nodes = Record<PropertyKey, Signal<any>>;
+declare class Context<T extends Function> extends CustomFunction {
+    #private;
+    constructor(host: T, nodes: Nodes);
+    dispose(): void;
+    on(event: Event, listener: Listener): void;
+    once(event: Event, listener: Listener): void;
+    reset(): void;
+}
+declare const _default: <T extends Function>(fn: T, nodes?: Nodes) => Context<T>;
+export default _default;

package/build/testing/nodes.js

@@ -0,0 +1,33 @@
+import CustomFunction from '@esportsplus/custom-function';
+class Context extends CustomFunction {
+    #nodes;
+    constructor(host, nodes) {
+        super(host);
+        this.#nodes = nodes;
+    }
+    dispose() {
+        let nodes = this.#nodes;
+        for (let key in nodes) {
+            nodes[key].dispose();
+        }
+    }
+    on(event, listener) {
+        let nodes = this.#nodes;
+        for (let key in nodes) {
+            nodes[key].on(event, listener);
+        }
+    }
+    once(event, listener) {
+        let nodes = this.#nodes;
+        for (let key in nodes) {
+            nodes[key].once(event, listener);
+        }
+    }
+    reset() {
+        let nodes = this.#nodes;
+        for (let key in nodes) {
+            nodes[key].reset();
+        }
+    }
+}
+export default (fn, nodes = {}) => new Context(fn, nodes);

package/build/testing/reactive.js

@@ -0,0 +1 @@
+"use strict";

package/build/trigger.d.ts

@@ -0,0 +1,15 @@
+import { Event, Listener, Signal } from './types';
+declare class Trigger {
+    signal: Signal<boolean>;
+    constructor();
+    dispatch<T>(event: Event, data?: T): void;
+    dispose(): void;
+    on(event: Event, listener: Listener): void;
+    once(event: Event, listener: Listener): void;
+    reset(): void;
+    track(): void;
+    trigger(): void;
+}
+declare const _default: () => Trigger;
+export default _default;
+export { Trigger };

package/build/trigger.js

@@ -0,0 +1,30 @@
+import { read, signal, write } from './signal';
+class Trigger {
+    signal;
+    constructor() {
+        this.signal = signal(false);
+    }
+    dispatch(event, data) {
+        this.signal.dispatch(event, data);
+    }
+    dispose() {
+        this.signal.dispose();
+    }
+    on(event, listener) {
+        this.signal.on(event, listener);
+    }
+    once(event, listener) {
+        this.signal.once(event, listener);
+    }
+    reset() {
+        this.signal.reset();
+    }
+    track() {
+        read(this.signal);
+    }
+    trigger() {
+        write(this.signal, !this.signal.value);
+    }
+}
+export default () => new Trigger();
+export { Trigger };