@esportsplus/reactivity 0.0.22 → 0.0.23

package/src/core.ts

@@ -0,0 +1,295 @@
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from './symbols';
+import { Computed, Effect, Fn, Listener, Options, Root, Scheduler } from './types';
+import Signal from './signal';
+
+
+let index = 0,
+    observer: Signal | null = null,
+    observers: Signal[] | null = null,
+    scope: Root | null = null;
+
+
+function changed(a: unknown, b: unknown) {
+    return a !== b;
+}
+
+function notify(nodes: Signal[], state: typeof CHECK | typeof DIRTY) {
+    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 as Effect).root.scheduler((node as Effect).task);
+            }
+
+            node.state = state;
+
+            if (node.observers) {
+                notify(node.observers, CHECK);
+            }
+        }
+    }
+}
+
+function removeSourceObservers(node: Signal, 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(node: Signal) {
+    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 Signal['state']) === DIRTY) {
+                break;
+            }
+        }
+    }
+
+    if (node.state === DIRTY) {
+        update(node);
+    }
+    else {
+        node.state = CLEAN;
+    }
+}
+
+function update(node: Signal) {
+    let i = index,
+        o = observer,
+        os = observers;
+
+    index = 0;
+    observer = node;
+    observers = null as typeof observers;
+
+    try {
+        if (node.listeners) {
+            dispatch(UPDATE, node);
+        }
+
+        let value = node.fn!.call( node.context );
+
+        if (observers) {
+            if (node.sources) {
+                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 && node.sources) {
+            removeSourceObservers(node, 0);
+        }
+        return;
+    }
+    finally {
+        index = i;
+        observer = o;
+        observers = os;
+    }
+
+    node.state = CLEAN;
+}
+
+
+const computed = <T>(fn: Fn<T>, options: Options = {}) => {
+    let node = new Signal(undefined as unknown, DIRTY, COMPUTED, options);
+
+    node.fn = fn;
+
+    return node as Computed;
+};
+
+const dispose = (node: Signal) => {
+    if (node.state === DISPOSED) {
+        return;
+    }
+
+    node.state = DISPOSED;
+
+    if (node.listeners) {
+        dispatch(DISPOSE, node);
+    }
+
+    if (node.sources) {
+        removeSourceObservers(node, 0);
+    }
+
+    node.observers = null;
+    node.sources = null;
+};
+
+const effect = <T>(fn: Fn<T>, options: Options = {}) => {
+    if (!scope) {
+        throw new Error('Reactivity: effects cannot be created without a reactive root');
+    }
+
+    let node = new Signal(undefined as unknown, DIRTY, EFFECT, options);
+
+    node.fn = fn;
+    node.root = scope;
+    node.task = () => read(node);
+
+    update(node);
+
+    return node as Effect;
+};
+
+const dispatch = (event: symbol, node: Signal) => {
+    if (!node.listeners?.[event]) {
+        return;
+    }
+
+    let listeners = node.listeners[event],
+        value = node.value;
+
+    for (let i = 0, n = listeners.length; i < n; i++) {
+        listeners[i](value);
+    }
+
+    node.listeners = null;
+};
+
+const on = (event: symbol, listener: Listener, node: Signal) => {
+    if (!node.listeners?.[event]) {
+        node.listeners ??= {};
+        node.listeners[event] = [listener];
+    }
+    else {
+        node.listeners[event].push(listener);
+    }
+};
+
+const read = (node: Signal): 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 reset = (node: Signal) => {
+    if (node.listeners) {
+        dispatch(RESET, node);
+    }
+
+    if (node.sources) {
+        removeSourceObservers(node, 0);
+    }
+
+    node.observers = null;
+    node.sources = null;
+
+    if (node.type === COMPUTED) {
+        node.state = DIRTY;
+        node.value = undefined;
+    }
+    else if (node.type === SIGNAL) {
+        node.state = CLEAN;
+    }
+};
+
+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 = (node: Signal, value: unknown) => {
+    if ((node?.changed || changed)(node.value, value)) {
+        node.value = value;
+
+        if (node.observers) {
+            notify(node.observers, DIRTY);
+        }
+    }
+
+    return node.value;
+};
+
+
+export default { computed, dispatch, dispose, effect, on, read, reset, root, signal, write };
+export { computed, dispatch, dispose, effect, on, read, reset, root, signal, write };

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 './primitives';
+export { default as core } from './core';
+export { DISPOSE, RESET, UPDATE } from './symbols';

package/src/primitives/closure.ts

@@ -0,0 +1,15 @@
+import { computed, read } from '~/core';
+import { NODE } from '~/symbols';
+import { Options } from '~/types';
+
+
+export default (fn: () => (...args: unknown[]) => unknown, options: Options = {}) => {
+    let node = computed(fn, options);
+
+    node.context = function (...args: Parameters<ReturnType<typeof fn>>) {
+        return (read(node) as ReturnType<typeof fn>)(...args);
+    };
+    node.context[NODE] = node;
+
+    return node.context;
+};

package/src/primitives/computed.ts

@@ -0,0 +1,16 @@
+import { computed, on, read } from '~/core';
+import { NODE } from '~/symbols';
+import { Fn, Listener, Options } from '~/types';
+
+
+export default <T>(fn: Fn<T>, options: Options = {}) => {
+    let node = computed(fn, options);
+
+    node.context = function () {
+        return read(node);
+    };
+    node.context[NODE] = node;
+    node.context.on = (event: symbol, listener: Listener) => on(event, listener, node);
+
+    return node.context;
+};

package/src/primitives/dispatch.ts

@@ -0,0 +1,17 @@
+import { dispatch } from '~/core';
+import { NODE, NODES } from '~/symbols';
+import { Wrapper } from '~/types';
+
+
+export default (key: symbol, wrapper: Wrapper) => {
+    if (wrapper[NODE]) {
+        dispatch(key, wrapper[NODE]);
+    }
+    else if (wrapper[NODES]) {
+        let nodes = wrapper[NODES];
+
+        for (let i = 0, n = nodes.length; i < n; i++) {
+            dispatch(key, nodes[i]);
+        }
+    }
+};

package/src/primitives/dispose.ts

@@ -0,0 +1,17 @@
+import { dispose } from '~/core';
+import { NODE, NODES } from '~/symbols';
+import { Wrapper } from '~/types';
+
+
+export default (wrapper: Wrapper) => {
+    if (wrapper[NODE]) {
+        dispose(wrapper[NODE]);
+    }
+    else if (wrapper[NODES]) {
+        let nodes = wrapper[NODES];
+
+        for (let i = 0, n = nodes.length; i < n; i++) {
+            dispose(nodes[i]);
+        }
+    }
+};

package/src/primitives/effect.ts

@@ -0,0 +1,13 @@
+import { effect, on } from '~/core';
+import { NODE } from '~/symbols';
+import { Listener, Options } from '~/types';
+
+
+export default (fn: () => unknown, options: Options = {}) => {
+    let node = effect(fn, options);
+
+    return node.context = {
+        [NODE]: node,
+        on: (event: symbol, listener: Listener) => on(event, listener, node)
+    };
+};

package/src/primitives/index.ts

@@ -0,0 +1,8 @@
+export { default as closure } from './closure';
+export { default as computed } from './computed';
+export { default as dispatch } from './dispatch';
+export { default as dispose } from './dispose';
+export { default as effect } from './effect';
+export { default as reactive } from './reactive';
+export { default as reset } from './reset';
+export { default as signal } from './signal';

package/src/primitives/reactive.ts

@@ -0,0 +1,43 @@
+import { computed as c, read, signal as s, write } from '~/core';
+import { NODES } from '~/symbols';
+import { Fn, Infer, Options, Signal } from '~/types';
+import computed from './computed';
+import signal from './signal';
+
+
+export default <T>(value: Fn<T> | T, options: Options = {}) => {
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        let nodes: Record<string, Signal> = {},
+            properties: PropertyDescriptorMap = {};
+
+        for (let key in value) {
+            if (typeof value[key] === 'function') {
+                nodes[key] = c(value[key] as Parameters<typeof c>[0], options);
+                properties[key] = {
+                    get() {
+                        return read(nodes[key]);
+                    }
+                };
+            }
+            else {
+                nodes[key] = s(value[key], options);
+                properties[key] = {
+                    get() {
+                        return read(nodes[key]);
+                    },
+                    set(value) {
+                        write(nodes[key], value);
+                    }
+                };
+            }
+        }
+
+        return Object.defineProperties({ [NODES]: Object.values(nodes) }, properties) as Infer<typeof value>;
+    }
+
+    if (typeof value === 'function') {
+        return computed(value as Parameters<typeof computed>[0], options);
+    }
+
+    return signal(value, options);
+};

package/src/primitives/reset.ts

@@ -0,0 +1,17 @@
+import { reset } from '~/core';
+import { NODE, NODES } from '~/symbols';
+import { Wrapper } from '~/types';
+
+
+export default (wrapper: Wrapper) => {
+    if (wrapper[NODE]) {
+        reset(wrapper[NODE]);
+    }
+    else if (wrapper[NODES]) {
+        let nodes = wrapper[NODES];
+
+        for (let i = 0, n = nodes.length; i < n; i++) {
+            reset(nodes[i]);
+        }
+    }
+};

package/src/primitives/signal.ts

@@ -0,0 +1,18 @@
+import { read, signal, write } from '~/core';
+import { NODE } from '~/symbols';
+import { Options } from '~/types';
+
+
+export default <T>(data: T, options: Options = {}) => {
+    let node = signal(data, options);
+
+    return node.context = {
+        [NODE]: node,
+        get: () => {
+            return read(node);
+        },
+        set: (value: T) => {
+            write(node, value);
+        }
+    };
+};

package/src/signal.ts

@@ -0,0 +1,30 @@
+import { Changed, Fn, Listener, Options, Root, Scheduler, State, Type, Wrapper } from './types';
+
+
+class Signal<T = unknown> {
+    changed: Changed | null = null;
+    context: any & Wrapper | null = null;
+    fn: Fn<T> | null = null;
+    listeners: Record<symbol, Listener[]> | null = null;
+    observers: Signal[] | null = null;
+    root: Root | null = null;
+    sources: Signal[] | null = null;
+    task: Parameters<Scheduler>[0] | null = null;
+    type: Type;
+    state: State;
+    value: T;
+
+
+    constructor(data: T, state: Signal['state'], type: Signal['type'], options: Options = {}) {
+        if (options?.changed) {
+            this.changed = options.changed;
+        }
+
+        this.state = state;
+        this.type = type;
+        this.value = data;
+    }
+}
+
+
+export default Signal;

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 NODE = Symbol();
+
+const NODES = Symbol();
+
+
+const DISPOSE = Symbol();
+
+const RESET = Symbol();
+
+const UPDATE = Symbol();
+
+
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, NODE, NODES, RESET, SIGNAL, UPDATE };

package/src/types.ts

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