@esportsplus/reactivity 0.0.29 → 0.1.0

package/src/signal.ts

@@ -1,5 +1,7 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from '~/symbols';
-import { Changed, Computed, Context, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from '~/types';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
+import { Changed, Computed, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+import { isArray } from './utilities';
+
 
 
 let index = 0,
@@ -11,7 +13,7 @@ let index = 0,
 class Signal<T> {
     changed: Changed | null = null;
     fn: Computed<T>['fn'] | null = null;
-    listeners: Record<symbol, (Listener | null)[]> | null = null;
+    listeners: Record<Event, (Listener<any> | null)[]> | null = null;
     observers: Signal<T>[] | null = null;
     root: Root | null = null;
     sources: Signal<T>[] | null = null;
@@ -23,7 +25,7 @@ class Signal<T> {
 
 
     constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options: Options = {}) {
-        if (options?.changed) {
+        if (options.changed !== undefined) {
             this.changed = options.changed;
         }
 
@@ -33,6 +35,35 @@ class Signal<T> {
     }
 
 
+    dispatch<D>(event: Event, data?: D) {
+        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 {
+                // @ts-ignore
+                listener( listener.length === 0 ? null : { data, value } );
+            }
+            catch {
+                listeners[i] = null;
+            }
+
+            if (listener.once !== undefined) {
+                listeners[i] = null;
+            }
+        }
+    }
+
     dispose() {
         if (this.state === DISPOSED) {
             return;
@@ -40,16 +71,16 @@ class Signal<T> {
 
         this.state = DISPOSED;
 
-        dispatch(DISPOSE, this);
+        this.dispatch('dispose', this);
         flush(this);
     }
 
-    on(event: Event, listener: Listener) {
+    on(event: Event, listener: Listener<any>) {
         if (this.updating) {
             listener.once = true;
         }
 
-        if (!this.listeners?.[event]) {
+        if (this.listeners === null || !(event in this.listeners)) {
             this.listeners ??= {};
             this.listeners[event] = [listener];
         }
@@ -69,13 +100,13 @@ class Signal<T> {
         }
     }
 
-    once(event: Event, listener: Listener) {
+    once(event: Event, listener: Listener<any>) {
         listener.once = true;
         this.on(event, listener);
     }
 
     reset() {
-        dispatch(RESET, this);
+        this.dispatch('reset', this);
         flush(this);
 
         if (this.type === COMPUTED) {
@@ -97,31 +128,8 @@ function changed(a: unknown, b: unknown) {
     return a !== b;
 }
 
-function dispatch<T>(event: Event, node: Signal<T>) {
-    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<T>(node: Signal<T>) {
-    if (node.sources) {
+    if (node.sources !== null) {
         removeSourceObservers(node, 0);
     }
 
@@ -131,7 +139,7 @@ function flush<T>(node: Signal<T>) {
 }
 
 function notify<T>(nodes: Signal<T>[] | null, state: typeof CHECK | typeof DIRTY) {
-    if (!nodes) {
+    if (nodes === null) {
         return;
     }
 
@@ -150,14 +158,14 @@ function notify<T>(nodes: Signal<T>[] | null, state: typeof CHECK | typeof DIRTY
 }
 
 function removeSourceObservers<T>(node: Signal<T>, start: number) {
-    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;
         }
 
@@ -167,7 +175,7 @@ function removeSourceObservers<T>(node: Signal<T>, start: number) {
 }
 
 function sync<T>(node: Signal<T>) {
-    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]);
 
@@ -198,18 +206,17 @@ function update<T>(node: Signal<T>) {
     observers = null as typeof observers;
 
     try {
-        dispatch(UPDATE, node);
-
+        node.dispatch('update');
         node.updating = true;
 
-        let value = node.fn!.call(node as Context, 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++) {
@@ -231,7 +238,7 @@ function update<T>(node: Signal<T>) {
                 }
             }
         }
-        else if (node.sources && index < node.sources.length) {
+        else if (node.sources !== null && index < node.sources.length) {
             removeSourceObservers(node, index);
             node.sources.length = index;
         }
@@ -255,15 +262,30 @@ function update<T>(node: Signal<T>) {
 }
 
 
-const computed = <T>(fn: Computed<T>['fn'], options: Options & { value?: unknown } = {}) => {
-    let node = new Signal(options?.value as any, DIRTY, COMPUTED, options);
+const computed = <T>(fn: Computed<T>['fn'], options: Options = {}) => {
+    let node = new Signal(options.value as any, DIRTY, COMPUTED, options);
 
     node.fn = fn;
 
     return node as Computed<T>;
 };
 
-const effect = <T>(fn: Effect<T>['fn'], options: Options = {}) => {
+const dispose = <T extends { dispose: () => void }>(dispose?: T[] | T) => {
+    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 = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) => {
     if (!scope) {
         throw new Error('Reactivity: `effects` cannot be created without a reactive root');
     }
@@ -286,7 +308,7 @@ const read = <T>(node: Signal<T>): typeof node['value'] => {
 
     if (observer) {
         if (!observers) {
-            if (observer?.sources?.[index] == node) {
+            if (observer.sources !== null && observer.sources[index] == node) {
                 index++;
             }
             else {
@@ -305,14 +327,31 @@ const read = <T>(node: Signal<T>): typeof node['value'] => {
     return node.value;
 };
 
+const reset = <T extends { reset: () => void }>(reset?: T[] | T) => {
+    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 = <T>(fn: () => T, properties: { scheduler?: Scheduler } = {}) => {
     let o = observer,
         s = scope;
 
-    properties.scheduler = properties?.scheduler || scope?.scheduler;
+    if (properties.scheduler === undefined) {
+        properties.scheduler = scope?.scheduler;
 
-    if (!properties.scheduler) {
-        throw new Error('Reactivity: `root` cannot be created without a task scheduler');
+        if (properties.scheduler === undefined) {
+            throw new Error('Reactivity: `root` cannot be created without a task scheduler');
+        }
     }
 
     observer = null;
@@ -326,12 +365,12 @@ const root = <T>(fn: () => T, properties: { scheduler?: Scheduler } = {}) => {
     return result;
 };
 
-const signal = <T>(data: T, options: Options = {}) => {
+const signal = <T>(data: T, options: Omit<Options, 'value'> = {}) => {
     return new Signal(data, CLEAN, SIGNAL, options);
 };
 
 const write = <T>(node: Signal<T>, value: unknown) => {
-    if ((node?.changed || changed)(node.value, value)) {
+    if ((node.changed === null ? changed : node.changed)(node.value, value)) {
         node.value = value as T;
         notify(node.observers, DIRTY);
     }
@@ -341,4 +380,4 @@ const write = <T>(node: Signal<T>, value: unknown) => {
 
 
 export default Signal;
-export { computed, effect, read, root, signal, write };
+export { computed, dispose, effect, read, reset, root, signal, write };

package/src/types.ts

@@ -1,47 +1,41 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './symbols';
+import { Prettify } from '@esportsplus/typescript'
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
 import Signal from './signal';
 
 
 type Changed = (a: unknown, b: unknown) => boolean;
 
 type Computed<T> = {
-    fn: T extends Promise<unknown> ? never : ((this: Context, previous: T) => T);
+    fn: T extends Promise<unknown> ? never : ((previous: T) => T);
     value: ReturnType<Computed<T>['fn']>;
 } & Omit<Signal<T>, 'fn' | 'value'>;
 
-type Context = {
-    dispose(): void;
-    on(event: Event, listener: Listener): void;
-    once(event: Event, listener: Listener): void;
-    reset(): void;
-};
-
 type Effect<T> = {
-    fn: (this: Context, previous: T) => T;
+    fn: (node: Effect<T>) => void;
     root: NonNullable<Signal<T>['root']>;
     task: NonNullable<Signal<T>['task']>
-} & Omit<Computed<T>, 'fn' | 'root' | 'task'>;
+    value: void;
+} & Omit<Signal<T>, 'fn' | 'root' | 'task' | 'value'>;
 
-type Event = symbol;
+type Event = string;
 
-type Listener = {
+type Listener<D> = {
     once?: boolean;
 
-    <T>(value: T): void;
+    <V>(event: { data?: D, value: V }): void;
 };
 
+type Object = Record<PropertyKey, unknown>;
+
 type Options = {
     changed?: Changed;
+    value?: unknown;
 };
 
 type Root = {
     scheduler: Scheduler
 };
 
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
 type Scheduler = (fn: (...args: unknown[]) => Promise<unknown> | unknown) => unknown;
 
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
@@ -49,4 +43,4 @@ type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
 
 
-export { Changed, Computed, Context, Effect, Event, Listener, Options, Prettify, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, Prettify, Root, Scheduler, Signal, State, Type };

package/src/utilities.ts

@@ -0,0 +1,6 @@
+const { isArray } = Array;
+
+const { defineProperty } = Object;
+
+
+export { defineProperty, isArray };

package/tsconfig.json

@@ -5,6 +5,6 @@
         "outDir": "build",
     },
     "exclude": ["node_modules"],
-    "extends": "@esportsplus/rspack/tsconfig.base.json",
+    "extends": "@esportsplus/typescript/tsconfig.base.json",
     "include": ["src"]
 }

package/src/context/index.ts

@@ -1,5 +0,0 @@
-import node from './node';
-import nodes from './nodes';
-
-
-export default { node, nodes };

package/src/context/node.ts

@@ -1,36 +0,0 @@
-import { NODE } from '~/symbols';
-import { Context, Event, Listener, Prettify, Signal } from '~/types';
-
-
-type Internals = {
-    [NODE]: Signal<any>;
-};
-
-
-function dispose(this: Internals) {
-    this[NODE].dispose();
-}
-
-function on(this: Internals, event: Event, listener: Listener) {
-    this[NODE].on(event,listener);
-}
-
-function once(this: Internals, event: Event, listener: Listener) {
-    this[NODE].once(event, listener);
-}
-
-function reset(this: Internals) {
-    this[NODE].reset();
-}
-
-
-export default <T>(host: T & Partial<Context>, node: Internals[typeof NODE]) => {
-    (host as unknown as Internals)[NODE] = node;
-
-    host.dispose = dispose;
-    host.on = on;
-    host.once = once;
-    host.reset = reset;
-
-    return host as Prettify< Required<typeof host> >;
-};

package/src/context/nodes.ts

@@ -1,52 +0,0 @@
-import { NODES } from '~/symbols';
-import { Context, Event, Listener, Prettify, Signal } from '~/types';
-
-
-type Internals = {
-    [NODES]: Record<PropertyKey, Signal<any>> ;
-};
-
-
-function dispose(this: Internals) {
-    let nodes = this[NODES];
-
-    for (let key in nodes) {
-        nodes[key].dispose();
-    }
-}
-
-function on(this: Internals, event: Event, listener: Listener) {
-    let nodes = this[NODES];
-
-    for (let key in nodes) {
-        nodes[key].on(event, listener);
-    }
-}
-
-function once(this: Internals, event: Event, listener: Listener) {
-    let nodes = this[NODES];
-
-    for (let key in nodes) {
-        nodes[key].once(event, listener);
-    }
-}
-
-function reset(this: Internals) {
-    let nodes = this[NODES];
-
-    for (let key in nodes) {
-        nodes[key].reset();
-    }
-}
-
-
-export default <T>(host: T & Partial<Context>, nodes: Internals[typeof NODES]) => {
-    (host as unknown as Internals)[NODES] = nodes;
-
-    host.dispose = dispose;
-    host.on = on;
-    host.once = once;
-    host.reset = reset;
-
-    return host as Prettify< Required<typeof host> >;
-};

package/src/effect.ts

@@ -1,5 +0,0 @@
-import { effect } from './signal';
-import context from './context';
-
-
-export default (...args: Parameters<typeof effect>) => context.node({}, effect(...args));

package/src/promise.ts

@@ -1,48 +0,0 @@
-import { computed, read, root, signal, write } from './signal';
-import context from './context';
-
-
-// TODO:
-// - Add status value
-// - Add reject/stop method
-export default (fn: <A, R extends Promise<any>>(...args: A[]) => R, options: Parameters<typeof computed>[1] = {}) => {
-    let input: unknown,
-        nodes = {
-            data: signal(options?.value, options),
-            status: signal(undefined, options)
-        };
-
-    function host(this: typeof host, ...args: Parameters<typeof fn>) {
-        input = args;
-
-        root(() => {
-            fn(...args)
-                .then(<T>(value: T) => {
-                    write(nodes.data, value);
-                })
-                .catch(() => {
-                    write(nodes.data, undefined);
-                });
-        });
-    }
-
-    Object.defineProperties(host, {
-        data: {
-            get() {
-                return read(nodes.data);
-            }
-        },
-        input: {
-            get() {
-                return input;
-            }
-        },
-        status: {
-            get() {
-                return read(nodes.status);
-            }
-        }
-    });
-
-    return context.nodes(host, nodes);
-};

package/src/reactive.ts

@@ -1,47 +0,0 @@
-import { computed, read, signal, write } from './signal';
-import { Context, Signal } from './types';
-import context from './context';
-
-
-type Infer<T> =
-    T extends (...args: unknown[]) => unknown
-        ? ReturnType<T>
-        : T extends Record<PropertyKey, unknown>
-            ? { [K in keyof T]: T[K] }
-            : T;
-
-type Never = { [K in keyof Context]?: never };
-
-type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
-
-
-export default <T extends Record<PropertyKey, unknown>>(data: T & Never, options: Options = {}) => {
-    let host = {},
-        nodes: Record<PropertyKey, Signal<unknown>> = {};
-
-    for (let key in (data as T)) {
-        if (typeof data[key] === 'function') {
-            nodes[key] = computed(data[key] as Parameters<typeof computed>[0], options);
-
-            Object.defineProperty(host, key, {
-                get() {
-                    return read(nodes[key]);
-                }
-            });
-        }
-        else {
-            nodes[key] = signal(data[key], options);
-
-            Object.defineProperty(host, key, {
-                get() {
-                    return read(nodes[key]);
-                },
-                set(data) {
-                    write(nodes[key], data);
-                }
-            });
-        }
-    }
-
-    return context.nodes(host as Infer<T> & Context, nodes);
-};

package/src/symbols.ts

@@ -1,29 +0,0 @@
-const CLEAN = 0;
-
-const CHECK = 1;
-
-const DIRTY = 2;
-
-const DISPOSED = 3;
-
-
-const COMPUTED = 0;
-
-const EFFECT = 1;
-
-const SIGNAL = 2;
-
-
-const DISPOSE = Symbol();
-
-const RESET = Symbol();
-
-const UPDATE = Symbol();
-
-
-const NODE = Symbol();
-
-const NODES = Symbol();
-
-
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, NODE, NODES, RESET, SIGNAL, UPDATE };