@esportsplus/reactivity 0.0.23 → 0.0.24

package/build/api/effect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (fn: (this: import("../types").Context, previous: unknown) => unknown, options?: import("../types").Options | undefined) => Required<Partial<import("../types").Context>>;
+export default _default;

package/build/api/effect.js

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

package/build/api/index.d.ts

@@ -0,0 +1,4 @@
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
+export { default as reactive } from './reactive';

package/build/api/index.js

@@ -0,0 +1,4 @@
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
+export { default as reactive } from './reactive';

package/build/api/macro.d.ts

@@ -0,0 +1,4 @@
+import { computed } from '../signal';
+import { Computed } from '../types';
+declare const _default: <T extends <A, R>(...args: A[]) => R>(fn: T extends Promise<unknown> ? never : (this: import("../types").Context, previous: T) => T, options?: Parameters<typeof computed>[1]) => Required<((...args: Parameters<ReturnType<T extends Promise<unknown> ? never : (this: import("../types").Context, previous: T) => T>>) => unknown) & Partial<import("../types").Context>>;
+export default _default;

package/build/api/macro.js

@@ -0,0 +1,8 @@
+import { computed, read } from '../signal';
+import context from '../context';
+export default (fn, options = {}) => {
+    let node = computed(fn, options);
+    return context.node((...args) => {
+        return read(node)(...args);
+    }, node);
+};

package/build/api/promise.d.ts

@@ -0,0 +1,3 @@
+import { computed } from '../signal';
+declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => Required<((this: any, ...args: unknown[]) => void) & Partial<import("../types").Context>>;
+export default _default;

package/build/api/promise.js

@@ -0,0 +1,38 @@
+import { read, root, signal, write } from '../signal';
+import context from '../context';
+export default (fn, options = {}) => {
+    let input, nodes = {
+        data: signal(options?.value, options),
+        status: signal(undefined, options)
+    };
+    function host(...args) {
+        input = args;
+        root(() => {
+            fn(...args)
+                .then((value) => {
+                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/build/api/reactive.d.ts

@@ -0,0 +1,16 @@
+import { computed, signal } from '../signal';
+import { Context } from '../types';
+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];
+declare const _default: <T>(data: Data, options?: Options) => Required<{
+    [x: string]: unknown;
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+    dispose: never;
+    on: never;
+    once: never;
+    reset: never;
+} & Partial<Context>>;
+export default _default;

package/build/api/reactive.js

@@ -0,0 +1,27 @@
+import { computed, read, signal, write } from '../signal';
+import context from '../context';
+export default (data, options = {}) => {
+    let host = {}, nodes = {};
+    for (let key in data) {
+        if (typeof data[key] === 'function') {
+            nodes[key] = computed(data[key], 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, nodes);
+};

package/build/context/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    node: <T>(host: T & Partial<import("../types").Context>, node: import("../signal").default<any>) => Required<T & Partial<import("../types").Context>>;
+    nodes: <T_1>(host: T_1 & Partial<import("../types").Context>, nodes: Record<PropertyKey, import("../signal").default<any>>) => Required<T_1 & Partial<import("../types").Context>>;
+};
+export default _default;

package/build/context/index.js

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

package/build/context/node.d.ts

@@ -0,0 +1,7 @@
+import { NODE } from '../symbols';
+import { Context, Signal } from '../types';
+type Internals = {
+    [NODE]: Signal<any>;
+};
+declare const _default: <T>(host: T & Partial<Context>, node: Internals[typeof NODE]) => Required<T & Partial<Context>>;
+export default _default;

package/build/context/node.js

@@ -0,0 +1,21 @@
+import { NODE } from '../symbols';
+function dispose() {
+    this[NODE].dispose();
+}
+function on(event, listener) {
+    this[NODE].on(event, listener);
+}
+function once(event, listener) {
+    this[NODE].once(event, listener);
+}
+function reset() {
+    this[NODE].reset();
+}
+export default (host, node) => {
+    host[NODE] = node;
+    host.dispose = dispose;
+    host.on = on;
+    host.once = once;
+    host.reset = reset;
+    return host;
+};

package/build/context/nodes.d.ts

@@ -0,0 +1,7 @@
+import { NODES } from '../symbols';
+import { Context, Signal } from '../types';
+type Internals = {
+    [NODES]: Record<PropertyKey, Signal<any>>;
+};
+declare const _default: <T>(host: T & Partial<Context>, nodes: Internals[typeof NODES]) => Required<T & Partial<Context>>;
+export default _default;

package/build/context/nodes.js

@@ -0,0 +1,33 @@
+import { NODES } from '../symbols';
+function dispose() {
+    let nodes = this[NODES];
+    for (let key in nodes) {
+        nodes[key].dispose();
+    }
+}
+function on(event, listener) {
+    let nodes = this[NODES];
+    for (let key in nodes) {
+        nodes[key].on(event, listener);
+    }
+}
+function once(event, listener) {
+    let nodes = this[NODES];
+    for (let key in nodes) {
+        nodes[key].once(event, listener);
+    }
+}
+function reset() {
+    let nodes = this[NODES];
+    for (let key in nodes) {
+        nodes[key].reset();
+    }
+}
+export default (host, nodes) => {
+    host[NODES] = nodes;
+    host.dispose = dispose;
+    host.on = on;
+    host.once = once;
+    host.reset = reset;
+    return host;
+};

package/build/index.d.ts

@@ -1,3 +1,3 @@
-export * from './primitives';
-export { default as core } from './core';
+export * from './api';
+export * as core from './signal';
 export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/index.js

@@ -1,3 +1,3 @@
-export * from './primitives';
-export { default as core } from './core';
+export * from './api';
+export * as core from './signal';
 export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/signal.d.ts

@@ -1,16 +1,31 @@
-import { Changed, Fn, Listener, Options, Root, Scheduler, State, Type, Wrapper } from './types';
-declare class Signal<T = unknown> {
+import { Changed, Computed, Context, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+declare class Signal<T> {
     changed: Changed | null;
-    context: any & Wrapper | null;
-    fn: Fn<T> | null;
-    listeners: Record<symbol, Listener[]> | null;
-    observers: Signal[] | null;
+    fn: Computed<T>['fn'] | null;
+    listeners: Record<symbol, (Listener | null)[]> | null;
+    observers: Signal<T>[] | null;
     root: Root | null;
-    sources: Signal[] | null;
+    sources: Signal<T>[] | null;
+    state: State;
     task: Parameters<Scheduler>[0] | null;
     type: Type;
-    state: State;
-    value: T;
-    constructor(data: T, state: Signal['state'], type: Signal['type'], options?: Options);
+    updating: boolean | null;
+    value: Computed<T>['value'] | T;
+    constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options?: Options);
+    dispose(): void;
+    on(event: Event, listener: Listener): void;
+    once(event: Event, listener: Listener): void;
+    reset(): void;
 }
+declare const computed: <T>(fn: T extends Promise<unknown> ? never : (this: Context, previous: T) => T, options?: Options & {
+    value?: unknown;
+}) => Computed<T>;
+declare const effect: <T>(fn: (this: Context, previous: T) => T, options?: Options) => Effect<void>;
+declare const read: <T>(node: Signal<T>) => T | ReturnType<T extends Promise<unknown> ? never : (this: Context, previous: T) => T>;
+declare const root: <T>(fn: () => T, properties?: {
+    scheduler?: Scheduler;
+}) => T;
+declare const signal: <T>(data: T, options?: Options) => Signal<T>;
+declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<T extends Promise<unknown> ? never : (this: Context, previous: T) => T>;
 export default Signal;
+export { computed, effect, read, root, signal, write };

package/build/signal.js

@@ -1,14 +1,16 @@
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from './symbols';
+let index = 0, observer = null, observers = null, scope = null;
 class Signal {
     changed = null;
-    context = null;
     fn = null;
     listeners = null;
     observers = null;
     root = null;
     sources = null;
+    state;
     task = null;
     type;
-    state;
+    updating = null;
     value;
     constructor(data, state, type, options = {}) {
         if (options?.changed) {
@@ -18,5 +20,237 @@ class Signal {
         this.type = type;
         this.value = data;
     }
+    dispose() {
+        if (this.state === DISPOSED) {
+            return;
+        }
+        this.state = DISPOSED;
+        dispatch(DISPOSE, this);
+        flush(this);
+    }
+    on(event, 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, listener) {
+        listener.once = true;
+        this.on(event, listener);
+    }
+    reset() {
+        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;
+        }
+    }
 }
+function changed(a, b) {
+    return a !== b;
+}
+function 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++) {
+        let listener = listeners[i];
+        if (!listener) {
+            continue;
+        }
+        listener(value);
+        if (listener?.once) {
+            listeners[i] = null;
+        }
+    }
+}
+function flush(node) {
+    if (node.sources) {
+        removeSourceObservers(node, 0);
+    }
+    node.listeners = null;
+    node.observers = null;
+    node.sources = null;
+}
+function notify(nodes, state) {
+    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(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 {
+        dispatch(UPDATE, node);
+        node.updating = true;
+        let value = node.fn.call(node, 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 = (fn, options = {}) => {
+    let node = new Signal(options?.value, DIRTY, COMPUTED, options);
+    node.fn = fn;
+    return node;
+};
+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 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 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;
+        notify(node.observers, DIRTY);
+    }
+    return node.value;
+};
 export default Signal;
+export { computed, effect, read, root, signal, write };

package/build/symbols.d.ts

@@ -5,9 +5,9 @@ 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;
+declare const NODE: unique symbol;
+declare const NODES: unique symbol;
 export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, NODE, NODES, RESET, SIGNAL, UPDATE };

package/build/symbols.js

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

package/build/types.d.ts

@@ -1,18 +1,29 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, NODE, NODES, SIGNAL } from './symbols';
-import S from './signal';
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './symbols';
+import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
-type Computed<T = unknown> = {
-    fn: NonNullable<Signal<T>['fn']>;
-} & Signal<T>;
-type Effect<T = unknown> = {
+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']>;
-} & Computed<T>;
-type Fn<T> = () => T;
-type Infer<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<string, unknown> ? {
+} & Omit<Computed<T>, 'fn' | 'root' | 'task'>;
+type Event = symbol;
+type Infer<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: Infer<T[K]>;
 } : T;
-type Listener = <T>(value: T) => void;
+type Listener = {
+    once?: boolean;
+    <T>(value: T): void;
+};
 type Options = {
     changed?: Changed;
 };
@@ -20,11 +31,6 @@ 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 };
+export { Changed, Computed, Context, Effect, Event, Infer, Listener, Options, Root, Scheduler, Signal, State, Type };

package/build/types.js

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

package/package.json

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

package/src/api/effect.ts

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

package/src/api/index.ts

@@ -0,0 +1,4 @@
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
+export { default as reactive } from './reactive';

package/src/api/macro.ts

@@ -0,0 +1,15 @@
+import { computed, read } from '~/signal';
+import { Computed } from '~/types';
+import context from '~/context';
+
+
+export default <T extends <A, R>(...args: A[]) => R>(fn: Computed<T>['fn'], options: Parameters<typeof computed>[1] = {}) => {
+    let node = computed(fn, options);
+
+    return context.node(
+        (...args: Parameters<ReturnType<typeof fn>>) => {
+            return (read(node) as ReturnType<typeof fn>)(...args);
+        },
+        node
+    );
+};