@esportsplus/reactivity 0.0.26 → 0.0.28

package/build/api/effect.d.ts

@@ -1,7 +1,7 @@
-declare const _default: (fn: (this: import("../types").Context, previous: unknown) => unknown, options?: import("../types").Options | undefined) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("../types").Listener) => void;
-    once: (event: symbol, listener: import("../types").Listener) => void;
-    reset: () => void;
-};
-export default _default;
+declare const _default: (fn: (this: import("../types").Context, previous: unknown) => unknown, options?: import("../types").Options | undefined) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
+export default _default;

package/build/api/effect.js

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

package/build/api/index.d.ts

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

package/build/api/index.js

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

package/build/api/macro.d.ts

@@ -1,9 +1,9 @@
-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]) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("../types").Listener) => void;
-    once: (event: symbol, listener: import("../types").Listener) => void;
-    reset: () => void;
-};
-export default _default;
+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]) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
+export default _default;

package/build/api/macro.js

@@ -1,8 +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);
-};
+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

@@ -1,8 +1,8 @@
-import { computed } from '../signal';
-declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => {
-    dispose: () => void;
-    on: (event: symbol, listener: import("../types").Listener) => void;
-    once: (event: symbol, listener: import("../types").Listener) => void;
-    reset: () => void;
-};
-export default _default;
+import { computed } from '../signal';
+declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
+export default _default;

package/build/api/promise.js

@@ -1,38 +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);
-};
+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/store.d.ts

@@ -1,11 +1,11 @@
-import { computed, signal } from '../signal';
-import { Context } from '../types';
-type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: Infer<T[K]>;
-} : T;
-type Never = {
-    [K in keyof Context]?: never;
-};
-type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
-declare const _default: <T extends Record<PropertyKey, unknown>>(data: T & Never, options?: Options) => Required<Infer<T> & Context & Partial<Context>> extends infer T_1 ? { [K in keyof T_1]: Required<Infer<T> & Context & Partial<Context>>[K]; } : never;
-export default _default;
+import { computed, signal } from '../signal';
+import { Context } from '../types';
+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];
+declare const _default: <T extends Record<PropertyKey, unknown>>(data: T & Never, options?: Options) => Required<Infer<T> & Context & Partial<Context>> extends infer T_1 ? { [K in keyof T_1]: Required<Infer<T> & Context & Partial<Context>>[K]; } : never;
+export default _default;

package/build/api/store.js

@@ -1,27 +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);
-};
+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

@@ -1,5 +1,5 @@
-declare const _default: {
-    node: <T>(host: T & Partial<import("../types").Context>, node: import("../signal").default<any>) => Required<T & Partial<import("../types").Context>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<import("../types").Context>>[K]; } : never;
-    nodes: <T_2>(host: T_2 & Partial<import("../types").Context>, nodes: Record<PropertyKey, import("../signal").default<any>>) => Required<T_2 & Partial<import("../types").Context>> extends infer T_3 ? { [K_1 in keyof T_3]: Required<T_2 & Partial<import("../types").Context>>[K_1]; } : never;
-};
-export default _default;
+declare const _default: {
+    node: <T>(host: T & Partial<import("../types").Context>, node: import("../signal").default<any>) => Required<T & Partial<import("../types").Context>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<import("../types").Context>>[K]; } : never;
+    nodes: <T_2>(host: T_2 & Partial<import("../types").Context>, nodes: Record<PropertyKey, import("../signal").default<any>>) => Required<T_2 & Partial<import("../types").Context>> extends infer T_3 ? { [K_1 in keyof T_3]: Required<T_2 & Partial<import("../types").Context>>[K_1]; } : never;
+};
+export default _default;

package/build/context/index.js

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

package/build/context/node.d.ts

@@ -1,7 +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>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
-export default _default;
+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>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
+export default _default;

package/build/context/node.js

@@ -1,21 +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;
-};
+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

@@ -1,7 +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>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
-export default _default;
+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>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
+export default _default;

package/build/context/nodes.js

@@ -1,33 +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;
-};
+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 './api';
-export * as core from './signal';
-export { DISPOSE, RESET, UPDATE } from './symbols';
+export * from './api';
+export * as core from './signal';
+export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/index.js

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

package/build/signal.d.ts

@@ -1,31 +1,31 @@
-import { Changed, Computed, Context, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
-declare class Signal<T> {
-    changed: Changed | null;
-    fn: Computed<T>['fn'] | null;
-    listeners: Record<symbol, (Listener | null)[]> | null;
-    observers: Signal<T>[] | null;
-    root: Root | null;
-    sources: Signal<T>[] | null;
-    state: State;
-    task: Parameters<Scheduler>[0] | null;
-    type: Type;
-    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 };
+import { Changed, Computed, Context, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+declare class Signal<T> {
+    changed: Changed | null;
+    fn: Computed<T>['fn'] | null;
+    listeners: Record<symbol, (Listener | null)[]> | null;
+    observers: Signal<T>[] | null;
+    root: Root | null;
+    sources: Signal<T>[] | null;
+    state: State;
+    task: Parameters<Scheduler>[0] | null;
+    type: Type;
+    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,256 +1,256 @@
-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;
-    fn = null;
-    listeners = null;
-    observers = null;
-    root = null;
-    sources = null;
-    state;
-    task = null;
-    type;
-    updating = null;
-    value;
-    constructor(data, state, type, 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, 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);
-    node.root.scheduler(node.task);
-    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 };
+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;
+    fn = null;
+    listeners = null;
+    observers = null;
+    root = null;
+    sources = null;
+    state;
+    task = null;
+    type;
+    updating = null;
+    value;
+    constructor(data, state, type, 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, 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);
+    node.root.scheduler(node.task);
+    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

@@ -1,13 +1,13 @@
-declare const CLEAN = 0;
-declare const CHECK = 1;
-declare const DIRTY = 2;
-declare const DISPOSED = 3;
-declare const COMPUTED = 0;
-declare const EFFECT = 1;
-declare const SIGNAL = 2;
-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 };
+declare const CLEAN = 0;
+declare const CHECK = 1;
+declare const DIRTY = 2;
+declare const DISPOSED = 3;
+declare const COMPUTED = 0;
+declare const EFFECT = 1;
+declare const SIGNAL = 2;
+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

@@ -1,13 +1,13 @@
-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 };
+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 };

package/build/types.d.ts

@@ -1,36 +1,36 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './symbols';
-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);
-    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 Listener = {
-    once?: boolean;
-    <T>(value: T): void;
-};
-type Options = {
-    changed?: Changed;
-};
-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;
-type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
-export { Changed, Computed, Context, Effect, Event, Listener, Options, Prettify, Root, Scheduler, Signal, State, Type };
+import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './symbols';
+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);
+    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 Listener = {
+    once?: boolean;
+    <T>(value: T): void;
+};
+type Options = {
+    changed?: Changed;
+};
+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;
+type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
+export { Changed, Computed, Context, Effect, Event, Listener, Options, Prettify, Root, Scheduler, Signal, State, Type };

package/build/types.js

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

package/package.json

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

package/src/api/store.ts

@@ -7,7 +7,7 @@ type Infer<T> =
     T extends (...args: unknown[]) => unknown
         ? ReturnType<T>
         : T extends Record<PropertyKey, unknown>
-            ? { [K in keyof T]: Infer<T[K]> }
+            ? { [K in keyof T]: T[K] }
             : T;
 
 type Never = { [K in keyof Context]?: never };