@esportsplus/reactivity 0.0.21 → 0.0.23

package/build/core.d.ts

@@ -0,0 +1,30 @@
+import { Computed, Effect, Fn, Listener, Options, Scheduler } from './types';
+import Signal from './signal';
+declare const computed: <T>(fn: Fn<T>, options?: Options) => Computed<unknown>;
+declare const dispose: (node: Signal) => void;
+declare const effect: <T>(fn: Fn<T>, options?: Options) => Effect<unknown>;
+declare const dispatch: (event: symbol, node: Signal) => void;
+declare const on: (event: symbol, listener: Listener, node: Signal) => void;
+declare const read: (node: Signal) => unknown;
+declare const reset: (node: Signal) => void;
+declare const root: <T>(fn: () => T, properties?: {
+    scheduler?: Scheduler;
+}) => T;
+declare const signal: <T>(data: T, options?: Options) => Signal<T>;
+declare const write: (node: Signal, value: unknown) => unknown;
+declare const _default: {
+    computed: <T>(fn: Fn<T>, options?: Options) => Computed<unknown>;
+    dispatch: (event: symbol, node: Signal<unknown>) => void;
+    dispose: (node: Signal<unknown>) => void;
+    effect: <T_1>(fn: Fn<T_1>, options?: Options) => Effect<unknown>;
+    on: (event: symbol, listener: Listener, node: Signal<unknown>) => void;
+    read: (node: Signal<unknown>) => unknown;
+    reset: (node: Signal<unknown>) => void;
+    root: <T_2>(fn: () => T_2, properties?: {
+        scheduler?: Scheduler | undefined;
+    }) => T_2;
+    signal: <T_3>(data: T_3, options?: Options) => Signal<T_3>;
+    write: (node: Signal<unknown>, value: unknown) => unknown;
+};
+export default _default;
+export { computed, dispatch, dispose, effect, on, read, reset, root, signal, write };

package/build/core.js

@@ -0,0 +1,218 @@
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from './symbols';
+import Signal from './signal';
+let index = 0, observer = null, observers = null, scope = null;
+function changed(a, b) {
+    return a !== b;
+}
+function notify(nodes, state) {
+    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;
+            if (node.observers) {
+                notify(node.observers, CHECK);
+            }
+        }
+    }
+}
+function removeSourceObservers(node, start) {
+    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) {
+    if (node.state === CHECK && node.sources) {
+        for (let i = 0, n = node.sources.length; i < n; i++) {
+            sync(node.sources[i]);
+            if (node.state === DIRTY) {
+                break;
+            }
+        }
+    }
+    if (node.state === DIRTY) {
+        update(node);
+    }
+    else {
+        node.state = CLEAN;
+    }
+}
+function update(node) {
+    let i = index, o = observer, os = observers;
+    index = 0;
+    observer = node;
+    observers = null;
+    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 = (fn, options = {}) => {
+    let node = new Signal(undefined, DIRTY, COMPUTED, options);
+    node.fn = fn;
+    return node;
+};
+const dispose = (node) => {
+    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 = (fn, options = {}) => {
+    if (!scope) {
+        throw new Error('Reactivity: effects cannot be created without a reactive root');
+    }
+    let node = new Signal(undefined, DIRTY, EFFECT, options);
+    node.fn = fn;
+    node.root = scope;
+    node.task = () => read(node);
+    update(node);
+    return node;
+};
+const dispatch = (event, node) => {
+    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, listener, node) => {
+    if (!node.listeners?.[event]) {
+        node.listeners ??= {};
+        node.listeners[event] = [listener];
+    }
+    else {
+        node.listeners[event].push(listener);
+    }
+};
+const read = (node) => {
+    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) => {
+    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 = (fn, properties = {}) => {
+    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;
+    let result = fn();
+    observer = o;
+    scope = s;
+    return result;
+};
+const signal = (data, options = {}) => {
+    return new Signal(data, CLEAN, SIGNAL, options);
+};
+const write = (node, value) => {
+    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/build/index.d.ts

@@ -1,12 +1,3 @@
-import { scheduler } from './reactive';
-import { effect, reactive } from './methods';
-declare const _default: {
-    effect: <T>(fn: () => T) => void;
-    reactive: <T_1>(value: T_1) => import("./types").Infer<T_1>;
-    scheduler: {
-        add: (scheduler: import("./types").Scheduler) => void;
-        delete: (scheduler: import("./types").Scheduler) => void;
-    };
-};
-export default _default;
-export { effect, reactive, scheduler };
+export * from './primitives';
+export { default as core } from './core';
+export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/index.js

@@ -1,4 +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/build/primitives/closure.d.ts

@@ -0,0 +1,3 @@
+import { Options } from '../types';
+declare const _default: (fn: () => (...args: unknown[]) => unknown, options?: Options) => any;
+export default _default;

package/build/primitives/closure.js

@@ -0,0 +1,10 @@
+import { computed, read } from '../core';
+import { NODE } from '../symbols';
+export default (fn, options = {}) => {
+    let node = computed(fn, options);
+    node.context = function (...args) {
+        return read(node)(...args);
+    };
+    node.context[NODE] = node;
+    return node.context;
+};

package/build/primitives/computed.d.ts

@@ -0,0 +1,3 @@
+import { Fn, Options } from '../types';
+declare const _default: <T>(fn: Fn<T>, options?: Options) => any;
+export default _default;

package/build/primitives/computed.js

@@ -0,0 +1,11 @@
+import { computed, on, read } from '../core';
+import { NODE } from '../symbols';
+export default (fn, options = {}) => {
+    let node = computed(fn, options);
+    node.context = function () {
+        return read(node);
+    };
+    node.context[NODE] = node;
+    node.context.on = (event, listener) => on(event, listener, node);
+    return node.context;
+};

package/build/primitives/dispatch.d.ts

@@ -0,0 +1,3 @@
+import { Wrapper } from '../types';
+declare const _default: (key: symbol, wrapper: Wrapper) => void;
+export default _default;

package/build/primitives/dispatch.js

@@ -0,0 +1,13 @@
+import { dispatch } from '../core';
+import { NODE, NODES } from '../symbols';
+export default (key, 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/build/primitives/dispose.d.ts

@@ -0,0 +1,3 @@
+import { Wrapper } from '../types';
+declare const _default: (wrapper: Wrapper) => void;
+export default _default;

package/build/primitives/dispose.js

@@ -0,0 +1,13 @@
+import { dispose } from '../core';
+import { NODE, NODES } from '../symbols';
+export default (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/build/primitives/effect.d.ts

@@ -0,0 +1,7 @@
+import { NODE } from '../symbols';
+import { Listener, Options } from '../types';
+declare const _default: (fn: () => unknown, options?: Options) => {
+    [NODE]: import("../types").Effect<unknown>;
+    on: (event: symbol, listener: Listener) => void;
+};
+export default _default;

package/build/primitives/effect.js

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

package/build/primitives/index.d.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/build/primitives/index.js

@@ -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/build/primitives/reactive.d.ts

@@ -0,0 +1,3 @@
+import { Fn, Options } from '../types';
+declare const _default: <T>(value: T | Fn<T>, options?: Options) => any;
+export default _default;

package/build/primitives/reactive.js

@@ -0,0 +1,35 @@
+import { computed as c, read, signal as s, write } from '../core';
+import { NODES } from '../symbols';
+import computed from './computed';
+import signal from './signal';
+export default (value, options = {}) => {
+    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
+        let nodes = {}, properties = {};
+        for (let key in value) {
+            if (typeof value[key] === 'function') {
+                nodes[key] = c(value[key], 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);
+    }
+    if (typeof value === 'function') {
+        return computed(value, options);
+    }
+    return signal(value, options);
+};

package/build/primitives/reset.d.ts

@@ -0,0 +1,3 @@
+import { Wrapper } from '../types';
+declare const _default: (wrapper: Wrapper) => void;
+export default _default;

package/build/primitives/reset.js

@@ -0,0 +1,13 @@
+import { reset } from '../core';
+import { NODE, NODES } from '../symbols';
+export default (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/build/primitives/signal.d.ts

@@ -0,0 +1,8 @@
+import { NODE } from '../symbols';
+import { Options } from '../types';
+declare const _default: <T>(data: T, options?: Options) => {
+    [NODE]: import("../signal").default<T>;
+    get: () => unknown;
+    set: (value: T) => void;
+};
+export default _default;

package/build/primitives/signal.js

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

package/build/signal.d.ts

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

package/build/signal.js

@@ -0,0 +1,22 @@
+class Signal {
+    changed = null;
+    context = null;
+    fn = null;
+    listeners = null;
+    observers = null;
+    root = null;
+    sources = null;
+    task = null;
+    type;
+    state;
+    value;
+    constructor(data, state, type, options = {}) {
+        if (options?.changed) {
+            this.changed = options.changed;
+        }
+        this.state = state;
+        this.type = type;
+        this.value = data;
+    }
+}
+export default Signal;

package/build/symbols.d.ts

@@ -1,4 +1,13 @@
 declare const CLEAN = 0;
 declare const CHECK = 1;
 declare const DIRTY = 2;
-export { CLEAN, CHECK, DIRTY };
+declare const DISPOSED = 3;
+declare const COMPUTED = 0;
+declare const EFFECT = 1;
+declare const SIGNAL = 2;
+declare const NODE: unique symbol;
+declare const NODES: unique symbol;
+declare const DISPOSE: unique symbol;
+declare const RESET: unique symbol;
+declare const UPDATE: unique symbol;
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, NODE, NODES, RESET, SIGNAL, UPDATE };

package/build/symbols.js

@@ -1,4 +1,13 @@
 const CLEAN = 0;
 const CHECK = 1;
 const DIRTY = 2;
-export { CLEAN, CHECK, DIRTY };
+const DISPOSED = 3;
+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/build/types.d.ts

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

package/build/types.js

@@ -1 +1 @@
-export {};
+import { NODE, NODES } from './symbols';

package/package.json

@@ -2,7 +2,7 @@
     "author": "ICJR",
     "description": "Reactivity",
     "devDependencies": {
-        "@esportsplus/webpack": "^0.0.80"
+        "@esportsplus/webpack": "^0.0.81"
     },
     "main": "build/index.js",
     "name": "@esportsplus/reactivity",
@@ -14,5 +14,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.0.21"
+    "version": "0.0.23"
 }

package/readme.md

@@ -0,0 +1,2 @@
+https://github.com/maverick-js/signals
+https://github.com/modderme123/reactively