@esportsplus/reactivity 0.1.9 → 0.1.10

package/build/signal.js

@@ -1,66 +1,82 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
 import { isArray } from './utilities';
 let index = 0, observer = null, observers = null, scope = null;
-class Signal {
-    changed = null;
-    fn = null;
+class Core {
     listeners = null;
     observers = null;
-    root = null;
+    root;
     sources = null;
     state;
-    task = null;
-    type;
-    updating = null;
+    updating = false;
     value;
-    constructor(data, state, type, options = {}) {
-        if (options.changed !== undefined) {
-            this.changed = options.changed;
+    constructor(state, value) {
+        let root = null;
+        if (this.type !== ROOT) {
+            if (scope !== null) {
+                root = scope;
+            }
+            else if (observer !== null) {
+                root = observer.root;
+            }
+            if (root == null) {
+                if (this.type === EFFECT) {
+                    throw new Error(`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 = data;
+        this.value = value;
+    }
+    get type() {
+        throw new Error(`Reactivity: reactive primitives require 'type' getters`);
     }
     dispatch(event, data) {
-        if (this.listeners === null || !(event in this.listeners)) {
+        if (this.listeners === null || this.listeners[event] === undefined) {
             return;
         }
-        let listeners = this.listeners[event], value = this.value;
+        let listeners = this.listeners[event], parameter = {
+            data,
+            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 });
+                listener(parameter);
+                if (listener.once !== undefined) {
+                    listeners[i] = null;
+                }
             }
             catch {
                 listeners[i] = null;
             }
-            if (listener.once !== undefined) {
-                listeners[i] = null;
-            }
         }
     }
     dispose() {
         if (this.state === DISPOSED) {
             return;
         }
-        this.state = DISPOSED;
-        this.dispatch('dispose', this);
-        flush(this);
+        flush('dispose', this, DISPOSED, this.value);
     }
     on(event, listener) {
         if (this.updating) {
             listener.once = true;
         }
-        if (this.listeners === null || !(event in this.listeners)) {
-            this.listeners ??= {};
-            this.listeners[event] = [listener];
+        if (this.listeners === null) {
+            this.listeners = { [event]: [listener] };
         }
         else {
             let listeners = this.listeners[event];
-            if (listeners.indexOf(listener) === -1) {
+            if (listeners === undefined) {
+                this.listeners[event] = [listener];
+            }
+            else if (listeners.indexOf(listener) === -1) {
                 let i = listeners.indexOf(null);
                 if (i === -1) {
                     listeners.push(listener);
@@ -75,32 +91,84 @@ class Signal {
         listener.once = true;
         this.on(event, listener);
     }
+}
+class Computed extends Core {
+    changed;
+    fn;
+    constructor(fn, options) {
+        super(DIRTY, undefined);
+        this.changed = options?.changed || changed;
+        this.fn = fn;
+    }
+    get type() {
+        return COMPUTED;
+    }
+    get() {
+        return read(this);
+    }
     reset() {
-        this.dispatch('reset', this);
-        flush(this);
-        if (this.type === COMPUTED) {
-            this.state = DIRTY;
-            this.value = undefined;
-        }
-        else if (this.type === EFFECT) {
-            this.state = DIRTY;
-            update(this);
-        }
-        else if (this.type === SIGNAL) {
-            this.state = CLEAN;
-        }
+        flush('reset', this, DIRTY, undefined);
+    }
+}
+class Effect extends Core {
+    fn;
+    task;
+    constructor(fn) {
+        super(DIRTY, null);
+        this.fn = fn;
+        this.task = () => read(this);
+        update(this);
+    }
+    get type() {
+        return EFFECT;
+    }
+    reset() {
+        flush('reset', this, DIRTY, null);
+        update(this);
+    }
+}
+class Root extends Core {
+    scheduler;
+    tracking;
+    constructor(scheduler, tracking) {
+        super(CLEAN, null);
+        this.scheduler = scheduler;
+        this.tracking = tracking;
+    }
+    get type() {
+        return ROOT;
+    }
+}
+class Signal extends Core {
+    changed;
+    constructor(data, options) {
+        super(CLEAN, data);
+        this.changed = options?.changed || changed;
+    }
+    get type() {
+        return SIGNAL;
+    }
+    get() {
+        return read(this);
+    }
+    reset() {
+        flush('reset', this, CLEAN, this.value);
+    }
+    set(value) {
+        return write(this, value);
     }
 }
 function changed(a, b) {
     return a !== b;
 }
-function flush(node) {
-    if (node.sources !== null) {
-        removeSourceObservers(node, 0);
-    }
+function flush(event, node, state, value) {
+    node.dispatch(event, node);
+    removeSourceObservers(node, 0);
     node.listeners = null;
     node.observers = null;
     node.sources = null;
+    node.state = state;
+    node.value = value;
 }
 function notify(nodes, state) {
     if (nodes === null) {
@@ -117,6 +185,28 @@ function notify(nodes, state) {
         }
     }
 }
+function read(node) {
+    if (node.state === DISPOSED) {
+        return node.value;
+    }
+    if (observer !== null) {
+        if (observers === null) {
+            if (observer.sources !== null && observer.sources[index] == node) {
+                index++;
+            }
+            else {
+                observers = [node];
+            }
+        }
+        else {
+            observers.push(node);
+        }
+    }
+    if (node.type === COMPUTED || node.type === EFFECT) {
+        sync(node);
+    }
+    return node.value;
+}
 function removeSourceObservers(node, start) {
     if (node.sources === null) {
         return;
@@ -154,8 +244,8 @@ function update(node) {
     try {
         node.dispatch('update');
         node.updating = true;
-        let value = node.fn.call(node, node.value);
-        node.updating = null;
+        let value = node.fn.call(node);
+        node.updating = false;
         if (observers) {
             removeSourceObservers(node, index);
             if (node.sources !== null && index > 0) {
@@ -197,13 +287,18 @@ function update(node) {
     }
     node.state = CLEAN;
 }
-const computed = (fn, options = {}) => {
-    let node = new Signal(options.value, DIRTY, COMPUTED, options);
-    node.fn = fn;
-    return node;
+function write(node, value) {
+    if (node.changed(node.value, value)) {
+        node.value = value;
+        notify(node.observers, DIRTY);
+    }
+    return value;
+}
+const computed = (fn, options) => {
+    return new Computed(fn, options);
 };
 const dispose = (dispose) => {
-    if (dispose === undefined) {
+    if (dispose == null) {
     }
     else if (isArray(dispose)) {
         for (let i = 0, n = dispose.length; i < n; i++) {
@@ -215,46 +310,11 @@ const dispose = (dispose) => {
     }
     return dispose;
 };
-const effect = (fn, options = {}) => {
-    let node = new Signal(void 0, DIRTY, EFFECT, options);
-    if (scope !== null) {
-        node.root = scope;
-    }
-    else if (observer !== null && observer.type === EFFECT && observer.root !== null) {
-        node.root = observer.root;
-    }
-    else {
-        throw new Error('Reactivity: `effects` cannot be created without a reactive root');
-    }
-    node.fn = fn;
-    node.task = () => read(node);
-    read(node);
-    return node;
-};
-const read = (node) => {
-    if (node.state === DISPOSED) {
-        return node.value;
-    }
-    if (observer !== null) {
-        if (observers === null) {
-            if (observer.sources !== null && observer.sources[index] == node) {
-                index++;
-            }
-            else {
-                observers = [node];
-            }
-        }
-        else {
-            observers.push(node);
-        }
-    }
-    if (node.fn !== null) {
-        sync(node);
-    }
-    return node.value;
+const effect = (fn) => {
+    return new Effect(fn);
 };
 const reset = (reset) => {
-    if (reset === undefined) {
+    if (reset == null) {
     }
     else if (isArray(reset)) {
         for (let i = 0, n = reset.length; i < n; i++) {
@@ -266,31 +326,22 @@ const reset = (reset) => {
     }
     return reset;
 };
-function root(fn, properties) {
+const root = (fn, scheduler) => {
     let o = observer, s = scope;
-    if (properties === undefined) {
+    if (scheduler === undefined) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
-        properties = scope;
+        scheduler = scope.scheduler;
     }
     observer = null;
-    scope = properties;
-    let result = fn();
+    scope = new Root(scheduler, fn.length > 0);
+    let result = fn(scope);
     observer = o;
     scope = s;
     return result;
-}
-;
-const signal = (data, options = {}) => {
-    return new Signal(data, CLEAN, SIGNAL, options);
 };
-const write = (node, value) => {
-    if ((node.changed === null ? changed : node.changed)(node.value, value)) {
-        node.value = value;
-        notify(node.observers, DIRTY);
-    }
-    return node.value;
+const signal = (value, options) => {
+    return new Signal(value, options);
 };
-export default Signal;
-export { computed, dispose, effect, read, reset, root, signal, write };
+export { computed, dispose, effect, reset, root, signal, Computed, Effect, Signal };

package/build/types.d.ts

@@ -1,16 +1,7 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript';
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
-import Signal from './signal';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
+import { Computed, Effect, Signal } from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
-type Computed<T> = {
-    fn: NeverAsync<(previous: T) => T>;
-} & Omit<Signal<T>, 'fn'>;
-type Effect = {
-    fn: NeverAsync<(node: Effect) => void>;
-    root: Root;
-    task: Function;
-    value: void;
-} & Omit<Signal<void>, 'fn' | 'root' | 'task' | 'value'>;
 type Event = string;
 type Listener<D> = {
     once?: boolean;
@@ -22,12 +13,7 @@ type Listener<D> = {
 type Object = Record<PropertyKey, unknown>;
 type Options = {
     changed?: Changed;
-    value?: unknown;
 };
-type Root = {
-    scheduler: Scheduler;
-};
-type Scheduler = (fn: Function) => unknown;
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
-type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
-export { Changed, Computed, Effect, Event, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };
+type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
+export { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Signal, State, Type };

package/build/types.js

@@ -1,2 +1,2 @@
-import Signal from './signal';
-export { Signal };
+import { Computed, Effect, Signal } from './signal';
+export { Computed, Effect, Signal };

package/package.json

@@ -4,7 +4,7 @@
         "@esportsplus/custom-function": "^0.0.1"
     },
     "devDependencies": {
-        "@esportsplus/typescript": "^0.0.11"
+        "@esportsplus/typescript": "^0.0.13"
     },
     "main": "build/index.js",
     "name": "@esportsplus/reactivity",
@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.9"
+    "version": "0.1.10"
 }

package/src/constants.ts

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

package/src/index.ts

@@ -1,6 +1,5 @@
 export { default as macro } from './macro';
 export { default as resource } from './resource';
-export * as core from './signal';
-export { effect, root } from './signal';
 export { default as reactive } from './reactive';
+export { computed, dispose, effect, reset, root, signal } from './signal';
 export * from './types';

package/src/macro.ts

@@ -1,6 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { computed, read } from './signal';
-import { Computed, Options } from './types';
+import { Computed } from './signal';
+import { Options } from './types';
 
 
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
@@ -12,9 +12,9 @@ class Macro<A extends unknown[], R> extends CustomFunction {
 
     constructor(fn: Function<A,R>, options: Options = {}) {
         super((...args: A) => {
-            return read(this.#factory)(...args);
+            return this.#factory.get()(...args);
         });
-        this.#factory = computed(fn, options);
+        this.#factory = new Computed(fn, options);
     }
 
 

package/src/reactive/array.ts

@@ -1,4 +1,4 @@
-import { dispose, read, signal, write } from '~/signal';
+import { dispose } from '~/signal';
 import { Listener, Object, Options, Signal } from '~/types';
 import { ReactiveObject } from './object';
 
@@ -40,7 +40,7 @@ class ReactiveArray<T> extends Array<T> {
 
     constructor(data: T[]) {
         super(...data);
-        this.#signal = signal(false);
+        this.#signal = new Signal(false);
     }
 
 
@@ -54,7 +54,7 @@ class ReactiveArray<T> extends Array<T> {
 
 
     private trigger() {
-        write(this.#signal, !this.#signal.value);
+        this.#signal.set(!this.#signal.value);
     }
 
 
@@ -152,7 +152,7 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     track() {
-        read(this.#signal);
+        this.#signal.get();
     }
 
     unshift(...items: T[]) {

package/src/reactive/index.ts

@@ -31,7 +31,7 @@ type Node<T> =
 type Nodes<T extends Object> = { [K in keyof T]: Node<T[K]> };
 
 
-export default <T extends Object>(data: Guard<T>, options: Options = {}) => {
+export default <T extends Object>(data: Guard<T>, options?: Options) => {
     return new ReactiveObject(data, options) as any as Prettify<
         { [K in keyof T]: Infer<T[K]> } & Omit<ReactiveObject<T>, 'nodes'> & { nodes: Nodes<T> }
     >;

package/src/reactive/object.ts

@@ -1,4 +1,3 @@
-import { computed, read, signal, write } from '~/signal';
 import { Computed, Object, Options, Signal } from '~/types';
 import { defineProperty, isArray } from '~/utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
@@ -18,12 +17,12 @@ class ReactiveObject<T extends Object> {
             let input = data[key];
 
             if (typeof input === 'function') {
-                let node = nodes[key] = computed(input as Computed<unknown>['fn'], options);
+                let node = nodes[key] = new Computed(input as Computed<T>['fn'], options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     }
                 });
             }
@@ -48,15 +47,15 @@ class ReactiveObject<T extends Object> {
                 });
             }
             else {
-                let node = nodes[key] = signal<unknown>(input, options);
+                let node = nodes[key] = new Signal(input, options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     },
                     set(value) {
-                        write(node, value);
+                        node.set(value);
                     }
                 });
             }

package/src/resource.ts

@@ -1,6 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { read, signal, write } from './signal';
-import { Options, Signal } from './types';
+import { Signal } from './signal';
+import { Options } from './types';
 
 
 type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
@@ -18,8 +18,8 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
         super((...args: A) => {
             this.stop = null;
 
-            write(this.#input, args);
-            write(this.#ok, null);
+            this.#input.set(args);
+            this.#ok.set(null);
 
             fn(...args)
                 .then((value) => {
@@ -27,34 +27,34 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
                         return;
                     }
 
-                    write(this.#data, value);
-                    write(this.#ok, true);
+                    this.#data.set(value as Awaited<R>);
+                    this.#ok.set(true);
                 })
                 .catch(() => {
                     if (this.stop === true) {
                         return;
                     }
 
-                    write(this.#data, undefined);
-                    write(this.#ok, false);
+                    this.#data.set(undefined as Awaited<R>);
+                    this.#ok.set(false);
                 });
         });
-        this.#data = signal(options.value as Awaited<R>, options),
-        this.#input = signal<A | null>(null, options),
-        this.#ok = signal<boolean | null>(null, options)
+        this.#data = new Signal(undefined as Awaited<R>, options);
+        this.#input = new Signal<A | null>(null, options);
+        this.#ok = new Signal<boolean | null>(null, options);
     }
 
 
     get data() {
-        return read(this.#data);
+        return this.#data.get();
     }
 
     get input() {
-        return read(this.#input);
+        return this.#input.get();
     }
 
     get ok() {
-        return read(this.#ok);
+        return this.#ok.get();
     }