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

package/build/signal.d.ts

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

package/build/signal.js

@@ -0,0 +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);
+    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

@@ -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 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,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 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,16 +1,36 @@
-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, 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 Infer<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: Infer<T[K]>;
 } : T;
-type Primitives = any[] | boolean | number | string | null | undefined | ((...args: any[]) => any);
-type ReactiveFn<T> = (onCleanup?: (fn: VoidFunction) => void) => T;
-type Scheduler = {
-    schedule(): void;
-    tasks: {
-        add: (fn: Fn) => void;
-        delete: (fn: Fn) => void;
-    };
+type Listener = {
+    once?: boolean;
+    <T>(value: T): void;
+};
+type Options = {
+    changed?: Changed;
+};
+type Root = {
+    scheduler: Scheduler;
 };
-type State = typeof CHECK | typeof CLEAN | typeof DIRTY;
-export { Infer, ReactiveFn, Scheduler, State };
+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, Infer, Listener, Options, Root, Scheduler, Signal, State, Type };

package/build/types.js

@@ -1 +1,2 @@
-export {};
+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.22"
+    "version": "0.0.24"
 }

package/readme.md

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

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
+    );
+};