@esportsplus/reactivity 0.0.22 → 0.0.24

package/src/api/promise.ts

@@ -0,0 +1,45 @@
+import { computed, read, root, signal, write } from '~/signal';
+import context from '~/context';
+
+
+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/api/reactive.ts

@@ -0,0 +1,42 @@
+import { computed, read, signal, write } from '~/signal';
+import { Computed, Context, Infer, Signal } from '~/types';
+import context from '~/context';
+
+
+type Data = {
+    [key in keyof Context]: never
+} & Record<PropertyKey, Parameters<typeof computed>[0] | Parameters<typeof signal>[0]>;
+
+type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
+
+
+export default <T>(data: Data, options: Options = {}) => {
+    let host = {},
+        nodes: Record<PropertyKey, Signal<any>> = {};
+
+    for (let key in data) {
+        if (typeof data[key] === 'function') {
+            nodes[key] = computed(data[key] as Computed<T>['fn'], 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<typeof data>, nodes);
+};

package/src/context/index.ts

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

package/src/context/node.ts

@@ -0,0 +1,36 @@
+import { NODE } from '~/symbols';
+import { Context, Event, Listener, 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 Required<typeof host>;
+};

package/src/context/nodes.ts

@@ -0,0 +1,52 @@
+import { NODES } from '~/symbols';
+import { Context, Event, Listener, 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 Required<typeof host>;
+};

package/src/index.ts

@@ -1,6 +1,3 @@
-import { scheduler } from './reactive';
-import { effect, reactive } from './methods';
-
-
-export default { effect, reactive, scheduler };
-export { effect, reactive, scheduler };
+export * from './api';
+export * as core from './signal';
+export { DISPOSE, RESET, UPDATE } from './symbols';

package/src/signal.ts

@@ -0,0 +1,344 @@
+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';
+
+
+let index = 0,
+    observer: Signal<any> | null = null,
+    observers: Signal<any>[] | null = null,
+    scope: Root | null = null;
+
+
+class Signal<T> {
+    changed: Changed | null = null;
+    fn: Computed<T>['fn'] | null = null;
+    listeners: Record<symbol, (Listener | null)[]> | null = null;
+    observers: Signal<T>[] | null = null;
+    root: Root | null = null;
+    sources: Signal<T>[] | null = null;
+    state: State;
+    task: Parameters<Scheduler>[0] | null = null;
+    type: Type;
+    updating: boolean | null = null;
+    value: Computed<T>['value'] | T;
+
+
+    constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options: Options = {}) {
+        if (options?.changed) {
+            this.changed = options.changed;
+        }
+
+        this.state = state;
+        this.type = type;
+        this.value = data;
+    }
+
+
+    dispose() {
+        if (this.state === DISPOSED) {
+            return;
+        }
+
+        this.state = DISPOSED;
+
+        dispatch(DISPOSE, this);
+        flush(this);
+    }
+
+    on(event: Event, listener: Listener) {
+        if (this.updating) {
+            listener.once = true;
+        }
+
+        if (!this.listeners?.[event]) {
+            this.listeners ??= {};
+            this.listeners[event] = [listener];
+        }
+        else {
+            let listeners = this.listeners[event];
+
+            if (listeners.indexOf(listener) === -1) {
+                let i = listeners.indexOf(null);
+
+                if (i === -1) {
+                    listeners.push(listener);
+                }
+                else {
+                    listeners[i] = listener;
+                }
+            }
+        }
+    }
+
+    once(event: Event, listener: Listener) {
+        listener.once = true;
+        this.on(event, listener);
+    }
+
+    reset() {
+        dispatch(RESET, this);
+        flush(this);
+
+        if (this.type === COMPUTED) {
+            this.state = DIRTY;
+            this.value = undefined as T;
+        }
+        else if (this.type === EFFECT) {
+            this.state = DIRTY;
+            update(this);
+        }
+        else if (this.type === SIGNAL) {
+            this.state = CLEAN;
+        }
+    }
+}
+
+
+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) {
+        removeSourceObservers(node, 0);
+    }
+
+    node.listeners = null;
+    node.observers = null;
+    node.sources = null;
+}
+
+function notify<T>(nodes: Signal<T>[] | null, state: typeof CHECK | typeof DIRTY) {
+    if (!nodes) {
+        return;
+    }
+
+    for (let i = 0, n = nodes.length; i < n; i++) {
+        let node = nodes[i];
+
+        if (node.state < state) {
+            if (node.type === EFFECT && node.state === CLEAN) {
+                node.root!.scheduler(node.task!);
+            }
+
+            node.state = state;
+            notify(node.observers, CHECK);
+        }
+    }
+}
+
+function removeSourceObservers<T>(node: Signal<T>, start: number) {
+    if (!node.sources) {
+        return;
+    }
+
+    for (let i = start, n = node.sources.length; i < n; i++) {
+        let source = node.sources[i];
+
+        if (!source?.observers) {
+            continue;
+        }
+
+        source.observers[source.observers.indexOf(node)] = source.observers[source.observers.length - 1];
+        source.observers.pop();
+    }
+}
+
+function sync<T>(node: Signal<T>) {
+    if (node.state === CHECK && node.sources) {
+        for (let i = 0, n = node.sources.length; i < n; i++) {
+            sync(node.sources[i]);
+
+            // Stop the loop here so we won't trigger updates on other parents unnecessarily
+            // If our computation changes to no longer use some sources, we don't
+            // want to update() a source we used last time, but now don't use.
+            if ((node.state as State) === DIRTY) {
+                break;
+            }
+        }
+    }
+
+    if (node.state === DIRTY) {
+        update(node);
+    }
+    else {
+        node.state = CLEAN;
+    }
+}
+
+function update<T>(node: Signal<T>) {
+    let i = index,
+        o = observer,
+        os = observers;
+
+    index = 0;
+    observer = node;
+    observers = null as typeof observers;
+
+    try {
+        dispatch(UPDATE, node);
+
+        node.updating = true;
+
+        let value = node.fn!.call(node as Context, node?.value);
+
+        node.updating = null;
+
+        if (observers) {
+            removeSourceObservers(node, index);
+
+            if (node.sources && index > 0) {
+                node.sources.length = index + observers.length;
+
+                for (let i = 0, n = observers.length; i < n; i++) {
+                    node.sources[index + i] = observers[i];
+                }
+            }
+            else {
+                node.sources = observers;
+            }
+
+            for (let i = index, n = node.sources.length; i < n; i++) {
+                let source = node.sources[i];
+
+                if (!source.observers) {
+                    source.observers = [node];
+                }
+                else {
+                    source.observers.push(node);
+                }
+            }
+        }
+        else if (node.sources && index < node.sources.length) {
+            removeSourceObservers(node, index);
+            node.sources.length = index;
+        }
+
+        if (node.type === COMPUTED) {
+            write(node, value);
+        }
+    }
+    catch {
+        if (node.state === DIRTY) {
+            removeSourceObservers(node, 0);
+        }
+    }
+    finally {
+        index = i;
+        observer = o;
+        observers = os;
+    }
+
+    node.state = CLEAN;
+}
+
+
+const computed = <T>(fn: Computed<T>['fn'], options: Options & { value?: unknown } = {}) => {
+    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 = {}) => {
+    if (!scope) {
+        throw new Error('Reactivity: `effects` cannot be created without a reactive root');
+    }
+
+    let node = new Signal(undefined as any, DIRTY, EFFECT, options);
+
+    node.fn = fn;
+    node.root = scope;
+    node.task = () => read(node);
+
+    update(node);
+
+    return node as Effect<void>;
+};
+
+const read = <T>(node: Signal<T>): typeof node['value'] => {
+    if (node.state === DISPOSED) {
+        return node.value;
+    }
+
+    if (observer) {
+        if (!observers) {
+            if (observer?.sources?.[index] == node) {
+                index++;
+            }
+            else {
+                observers = [node];
+            }
+        }
+        else {
+            observers.push(node);
+        }
+    }
+
+    if (node.fn) {
+        sync(node);
+    }
+
+    return node.value;
+};
+
+const root = <T>(fn: () => T, properties: { scheduler?: Scheduler } = {}) => {
+    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');
+    }
+
+    observer = null;
+    scope = properties as Root;
+
+    let result = fn();
+
+    observer = o;
+    scope = s;
+
+    return result;
+};
+
+const signal = <T>(data: T, options: Options = {}) => {
+    return new Signal(data, CLEAN, SIGNAL, options);
+};
+
+const write = <T>(node: Signal<T>, value: unknown) => {
+    if ((node?.changed || changed)(node.value, value)) {
+        node.value = value as T;
+        notify(node.observers, DIRTY);
+    }
+
+    return node.value;
+};
+
+
+export default Signal;
+export { computed, effect, read, root, signal, write };

package/src/symbols.ts

@@ -4,5 +4,26 @@ const CHECK = 1;
 
 const DIRTY = 2;
 
+const DISPOSED = 3;
 
-export { CLEAN, CHECK, DIRTY };
+
+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 };

package/src/types.ts

@@ -1,28 +1,55 @@
-import { CLEAN, CHECK, DIRTY } from './symbols';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './symbols';
+import Signal from './signal';
 
 
-type Fn = () => Promise<unknown> | unknown;
+type Changed = (a: unknown, b: unknown) => boolean;
+
+type Computed<T> = {
+    fn: T extends Promise<unknown> ? never : ((this: Context, 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;
+    root: NonNullable<Signal<T>['root']>;
+    task: NonNullable<Signal<T>['task']>
+} & Omit<Computed<T>, 'fn' | 'root' | 'task'>;
+
+type Event = symbol;
 
 type Infer<T> =
     T extends (...args: any[]) => any
         ? ReturnType<T>
-        : T extends Record<string, Primitives>
+        : T extends Record<PropertyKey, unknown>
             ? { [K in keyof T]: Infer<T[K]> }
             : T;
 
-type Primitives = any[] | boolean | number | string | null | undefined | ((...args: any[]) => any);
+type Listener = {
+    once?: boolean;
 
-type ReactiveFn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
+    <T>(value: T): void;
+};
+
+type Options = {
+    changed?: Changed;
+};
 
-type Scheduler = {
-    schedule(): void;
-    tasks: {
-        add: (fn: Fn) => void;
-        delete: (fn: Fn) => void;
-    }
+type Root = {
+    scheduler: Scheduler
 };
 
-type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
+type Scheduler = (fn: (...args: unknown[]) => Promise<unknown> | unknown) => unknown;
+
+type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
+
+type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
 
 
-export { Infer, ReactiveFn, Scheduler, State };
+export { Changed, Computed, Context, Effect, Event, Infer, Listener, Options, Root, Scheduler, Signal, State, Type };

package/tsconfig.json

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