@esportsplus/reactivity 0.4.8 → 0.6.0

package/build/constants.d.ts

@@ -1,9 +1,7 @@
-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 ROOT = 2;
-declare const SIGNAL = 3;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };
+declare const REACTIVE: unique symbol;
+declare const STATE_NONE = 0;
+declare const STATE_CHECK: number;
+declare const STATE_DIRTY: number;
+declare const STATE_RECOMPUTING: number;
+declare const STATE_IN_HEAP: number;
+export { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/constants.js

@@ -1,9 +1,7 @@
-const CLEAN = 0;
-const CHECK = 1;
-const DIRTY = 2;
-const DISPOSED = 3;
-const COMPUTED = 0;
-const EFFECT = 1;
-const ROOT = 2;
-const SIGNAL = 3;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };
+const REACTIVE = Symbol('reactive');
+const STATE_NONE = 0;
+const STATE_CHECK = 1 << 0;
+const STATE_DIRTY = 1 << 1;
+const STATE_RECOMPUTING = 1 << 2;
+const STATE_IN_HEAP = 1 << 3;
+export { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/index.d.ts

@@ -1,5 +1,3 @@
-export { default as macro } from './macro.js';
 export { default as reactive } from './reactive/index.js';
-export { computed, dispose, effect, root, signal } from './signal.js';
-export * from './constants.js';
+export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
 export * from './types.js';

package/build/index.js

@@ -1,5 +1,3 @@
-export { default as macro } from './macro.js';
 export { default as reactive } from './reactive/index.js';
-export { computed, dispose, effect, root, signal } from './signal.js';
-export * from './constants.js';
+export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
 export * from './types.js';

package/build/reactive/array.d.ts

@@ -1,5 +1,6 @@
-import { Infer } from '../types.js';
-import { Listener, Options, ReactiveObject, Signal } from '../types.js';
+import { Computed, Infer } from '../types.js';
+import { ReactiveObject } from './object.js';
+import { Disposable } from './disposable.js';
 type API<T> = Infer<T>[] & ReactiveArray<T>;
 type Events<T> = {
     pop: {
@@ -26,30 +27,32 @@ type Events<T> = {
         items: Item<T>[];
     };
 };
-type Item<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : Signal<T>;
-declare class ReactiveArray<T> {
+type Item<T> = Computed<T> | ReactiveArray<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
+type Listener<V> = {
+    once?: boolean;
+    (value: V): void;
+};
+type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? ReactiveArray<U> : T;
+declare class ReactiveArray<T> extends Disposable {
     private data;
-    private options;
+    private listeners;
     private proxy;
-    private signal;
-    constructor(data: Item<T>[], proxy: API<T>, options?: Options);
+    constructor(data: Item<T>[], proxy: API<T>);
     get length(): number;
     set length(n: number);
-    at(i: number): any;
-    dispatch<E extends keyof Events<unknown>>(event: E, data?: Events<T>[E]): void;
+    at(i: number): ReactiveArray<T> | T | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
+    dispatch<D>(event: keyof Events<T>, value?: D): void;
     dispose(): void;
-    indexOf(value: T, fromIndex?: number): number;
-    map<U>(fn: (this: API<T>, value: T, i: number) => U, i?: number, n?: number): U[];
-    on<E extends keyof Events<unknown>>(event: E, listener: Listener<Events<T>[E]>): void;
-    once<E extends keyof Events<unknown>>(event: E, listener: Listener<Events<T>[E]>): void;
+    map<R>(fn: (this: API<T>, value: Value<T>, i: number) => R, i?: number, n?: number): R[];
+    on<T>(event: keyof Events<T>, listener: Listener<T>): void;
+    once<T>(event: keyof Events<T>, listener: Listener<T>): void;
     pop(): Item<T> | undefined;
     push(...input: T[]): number;
     reverse(): this;
     shift(): Item<T> | undefined;
-    sort(fn: (a: T, b: T) => number): this;
+    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 _default: <T>(input: T[], options?: Options) => API<T>;
-export default _default;
-export type { API as ReactiveArray };
+export default function array<T>(input: T[]): API<T>;
+export { ReactiveArray };

package/build/reactive/array.js

@@ -1,16 +1,15 @@
-import { isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { dispose, signal, Reactive } from '../signal.js';
+import { isArray, isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
+import { computed, dispose, isComputed, read } from '../signal.js';
 import object from './object.js';
-class ReactiveArray {
+import { Disposable } from './disposable.js';
+class ReactiveArray extends Disposable {
     data;
-    options;
+    listeners = null;
     proxy;
-    signal;
-    constructor(data, proxy, options = {}) {
+    constructor(data, proxy) {
+        super();
         this.data = data;
-        this.options = options;
         this.proxy = proxy;
-        this.signal = signal(false);
     }
     get length() {
         return this.data.length;
@@ -23,26 +22,44 @@ class ReactiveArray {
     }
     at(i) {
         let value = this.data[i];
-        if (isInstanceOf(value, Reactive)) {
-            return value.get();
+        if (isComputed(value)) {
+            return read(value);
         }
         return value;
     }
-    dispatch(event, data) {
-        this.signal.dispatch(event, data);
+    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;
+            }
+        }
     }
     dispose() {
-        this.signal.dispose();
-        dispose(this.data);
-    }
-    indexOf(value, fromIndex) {
         let data = this.data;
-        for (let i = fromIndex ?? 0, n = data.length; i < n; i++) {
-            if (data[i].value === value) {
-                return i;
+        for (let i = 0, n = data.length; i < n; i++) {
+            let value = data[i];
+            if (isInstanceOf(value, Disposable)) {
+                value.dispose();
+            }
+            else if (isComputed(value)) {
+                dispose(value);
             }
         }
-        return -1;
+        this.listeners = null;
     }
     map(fn, i, n) {
         let { data, proxy } = this, values = [];
@@ -55,52 +72,79 @@ class ReactiveArray {
         n = Math.min(n, data.length);
         for (; i < n; i++) {
             let item = data[i];
-            values.push(fn.call(proxy, isInstanceOf(item, Reactive) ? item.value : item, i));
+            values.push(fn.call(proxy, (isComputed(item) ? item.value : item), i));
         }
         return values;
     }
     on(event, listener) {
-        this.signal.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;
+                }
+            }
+        }
     }
     once(event, listener) {
-        this.signal.once(event, listener);
+        listener.once = true;
+        this.on(event, listener);
     }
     pop() {
         let item = this.data.pop();
         if (item !== undefined) {
-            dispose(item);
-            this.signal.dispatch('pop', { item });
+            if (isComputed(item)) {
+                dispose(item);
+            }
+            this.dispatch('pop', { item });
         }
         return item;
     }
     push(...input) {
-        let items = factory(input, this.options), n = this.data.push(...items);
-        this.signal.dispatch('push', { items });
+        let items = factory(input), n = this.data.push(...items);
+        this.dispatch('push', { items });
         return n;
     }
     reverse() {
         this.data.reverse();
-        this.signal.dispatch('reverse');
+        this.dispatch('reverse');
         return this;
     }
     shift() {
         let item = this.data.shift();
         if (item !== undefined) {
-            dispose(item);
-            this.signal.dispatch('shift', { item });
+            if (isComputed(item)) {
+                dispose(item);
+            }
+            this.dispatch('shift', { item });
         }
         return item;
     }
     sort(fn) {
-        this.data.sort((a, b) => fn(isInstanceOf(a, Reactive) ? a.value : a, isInstanceOf(b, Reactive) ? b.value : b));
-        this.signal.dispatch('sort');
+        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, this.options), removed = this.data.splice(start, deleteCount, ...items);
+        let items = factory(input), removed = this.data.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
-            dispose(removed);
-            this.signal.dispatch('splice', {
+            for (let i = 0, n = removed.length; i < n; i++) {
+                let item = removed[i];
+                if (isComputed(item)) {
+                    dispose(item);
+                }
+            }
+            this.dispatch('splice', {
                 deleteCount,
                 items,
                 start
@@ -109,31 +153,37 @@ class ReactiveArray {
         return removed;
     }
     unshift(...input) {
-        let items = factory(input, this.options), length = this.data.unshift(...items);
-        this.signal.dispatch('unshift', { items });
+        let items = factory(input), length = this.data.unshift(...items);
+        this.dispatch('unshift', { items });
         return length;
     }
 }
-function factory(input, options = {}) {
+function factory(input) {
     let items = [];
     for (let i = 0, n = input.length; i < n; i++) {
         let value = input[i];
-        if (isObject(value)) {
-            items[i] = object(value, options);
+        if (isArray(value)) {
+            items[i] = array(value);
+        }
+        else if (isFunction(value)) {
+            items[i] = computed(value);
+        }
+        else if (isObject(value)) {
+            items[i] = object(value);
         }
         else {
-            items[i] = signal(value);
+            items[i] = value;
         }
     }
     return items;
 }
-export default (input, options = {}) => {
-    let wrapped = factory(input, options), proxy = new Proxy({}, {
+export default function array(input) {
+    let proxy = new Proxy({}, {
         get(_, key) {
             if (isNumber(key)) {
                 let value = wrapped[key];
-                if (isInstanceOf(value, Reactive)) {
-                    return value.get();
+                if (isComputed(value)) {
+                    return read(value);
                 }
                 return value;
             }
@@ -145,11 +195,8 @@ export default (input, options = {}) => {
         set(_, key, value) {
             if (isNumber(key)) {
                 let host = wrapped[key];
-                if (host === undefined) {
-                    wrapped[key] = factory([value], options)[0];
-                }
-                else if (isInstanceOf(host, Reactive)) {
-                    host.set(value);
+                if (host === undefined || !isComputed(host)) {
+                    wrapped[key] = factory([value])[0];
                 }
                 else {
                     return false;
@@ -161,7 +208,9 @@ export default (input, options = {}) => {
             }
             return false;
         }
-    });
+    }), wrapped = factory(input);
     let a = new ReactiveArray(wrapped, proxy);
     return proxy;
-};
+}
+;
+export { ReactiveArray };

package/build/reactive/disposable.d.ts

@@ -0,0 +1,4 @@
+declare class Disposable {
+    dispose(): void;
+}
+export { Disposable };

package/build/reactive/disposable.js

@@ -0,0 +1,6 @@
+class Disposable {
+    dispose() {
+        throw new Error('@esportsplus/reactivity: Disposable should not be instantiated directly.');
+    }
+}
+export { Disposable };

package/build/reactive/index.d.ts

@@ -1,10 +1,10 @@
-import { Options, Reactive } from '../types.js';
-type Guard<T> = T extends {
+import { Reactive } from '../types.js';
+type Guard<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>, options?: Options) => Reactive<T>;
+declare const _default: <T>(data: Guard<T>) => Reactive<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,13 +1,17 @@
-import { isArray, isObject } from '@esportsplus/utilities';
-import { default as array } from './array.js';
-import { default as object } from './object.js';
-export default (data, options = {}) => {
+import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import array from './array.js';
+import object from './object.js';
+import promise from './promise.js';
+export default (data) => {
     let value;
     if (isArray(data)) {
-        value = array(data, options);
+        value = array(data);
     }
     else if (isObject(data)) {
-        value = object(data, options);
+        value = object(data);
+    }
+    else if (isPromise(data)) {
+        value = promise(data);
     }
     else {
         throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);

package/build/reactive/object.d.ts

@@ -1,8 +1,13 @@
-import { Infer, Options, Prettify } from '../types.js';
-type API<T> = Prettify<{
+import { Prettify } from '@esportsplus/utilities';
+import { Infer } from '../types.js';
+import { Disposable } from './disposable.js';
+type API<T extends Record<PropertyKey, unknown>> = Prettify<{
     [K in keyof T]: Infer<T[K]>;
-} & {
-    dispose: VoidFunction;
-}>;
-export default function object<T extends Record<PropertyKey, unknown>>(input: T, options?: Options): API<T>;
-export type { API as ReactiveObject };
+}> & ReactiveObject<T>;
+declare class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable {
+    private disposable;
+    constructor(data: T);
+    dispose(): void;
+}
+export default function object<T extends Record<PropertyKey, unknown>>(input: T): API<T>;
+export { ReactiveObject };

package/build/reactive/object.js

@@ -1,61 +1,94 @@
-import { defineProperty, isArray, isFunction, isObject } from '@esportsplus/utilities';
-import { computed, signal } from '../signal.js';
-import { default as array } from './array.js';
-class ReactiveObject {
-    signals = {};
-    constructor(data, options = {}) {
-        let signals = this.signals;
+import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, isObject } from '@esportsplus/utilities';
+import array from './array.js';
+import { computed, dispose, read, signal } from '../signal.js';
+import { Disposable } from './disposable.js';
+import promise from './promise.js';
+let { set } = signal;
+class ReactiveObject extends Disposable {
+    disposable = {};
+    constructor(data) {
+        super();
+        let disposable = this.disposable, triggers = {};
         for (let key in data) {
             let value = data[key];
             if (isArray(value)) {
-                let s = signals[key] = array(value, options);
+                let a = disposable[key] = array(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s;
+                        read(t);
+                        return a;
+                    },
+                    set(v) {
+                        set(t, !!t.value);
+                        a = disposable[key] = array(v);
+                    }
+                });
+            }
+            if (isAsyncFunction(value)) {
+                let p = promise(value);
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        return p;
                     }
                 });
             }
             else if (isFunction(value)) {
-                let s = signals[key] = computed(value, options);
+                let c = disposable[key] = computed(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        return read(c);
                     }
                 });
             }
             else if (isObject(value)) {
-                let s = signals[key] = new ReactiveObject(value, options);
+                let o = disposable[key] = new ReactiveObject(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s;
+                        read(t);
+                        return o;
+                    },
+                    set(v) {
+                        set(t, !!t.value);
+                        o = disposable[key] = new ReactiveObject(v);
                     }
                 });
             }
             else {
-                let s = signals[key] = signal(value, options);
+                let s = signal(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        if (s === undefined) {
+                            s = signal(value);
+                        }
+                        return read(s);
                     },
-                    set(value) {
-                        s.set(value);
+                    set(v) {
+                        set(s, v);
                     }
                 });
             }
         }
     }
     dispose() {
-        let signals = this.signals;
-        for (let key in signals) {
-            signals[key].dispose();
+        for (let key in this.disposable) {
+            let value = this.disposable[key];
+            if (isInstanceOf(value, Disposable)) {
+                value.dispose();
+            }
+            else {
+                dispose(value);
+            }
         }
+        this.disposable = {};
     }
 }
-export default function object(input, options = {}) {
-    return new ReactiveObject(input, options);
+export default function object(input) {
+    return new ReactiveObject(input);
 }
 ;
+export { ReactiveObject };

package/build/reactive/promise.d.ts

@@ -0,0 +1,13 @@
+import CustomFunction from '@esportsplus/custom-function';
+declare class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+    private arguments;
+    private okay;
+    private response;
+    stop: boolean | null;
+    constructor(fn: (...args: A) => R);
+    get data(): Awaited<R> | null;
+    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>;
+export default _default;

package/build/reactive/promise.js

@@ -0,0 +1,48 @@
+import CustomFunction from '@esportsplus/custom-function';
+import { read, root, signal } from '../signal.js';
+let { set } = signal;
+class ReactivePromise extends CustomFunction {
+    arguments;
+    okay;
+    response;
+    stop = null;
+    constructor(fn) {
+        super((...args) => {
+            this.stop = null;
+            set(this.arguments, args);
+            set(this.okay, null);
+            return root(() => {
+                return fn(...args)
+                    .then((value) => {
+                    if (this.stop === true) {
+                        return;
+                    }
+                    set(this.response, value);
+                    set(this.okay, true);
+                })
+                    .catch(() => {
+                    if (this.stop === true) {
+                        return;
+                    }
+                    set(this.response, null);
+                    set(this.okay, false);
+                });
+            });
+        });
+        this.response = signal(null);
+        this.arguments = signal(null);
+        this.okay = signal(null);
+    }
+    get data() {
+        return read(this.response);
+    }
+    get input() {
+        return read(this.arguments);
+    }
+    get ok() {
+        return read(this.okay);
+    }
+}
+export default (fn) => {
+    return new ReactivePromise(fn);
+};