@esportsplus/reactivity 0.0.23 → 0.0.24

package/build/core.js

@@ -1,218 +0,0 @@
-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/methods/effect.d.ts

@@ -1,2 +0,0 @@
-declare const _default: <T>(fn: () => T) => void;
-export default _default;

package/build/methods/effect.js

@@ -1,4 +0,0 @@
-import Reactive from '../reactive';
-export default (fn) => {
-    new Reactive(fn, true);
-};

package/build/methods/index.d.ts

@@ -1,3 +0,0 @@
-import effect from './effect';
-import reactive from './reactive';
-export { effect, reactive };

package/build/methods/index.js

@@ -1,3 +0,0 @@
-import effect from './effect';
-import reactive from './reactive';
-export { effect, reactive };

package/build/methods/reactive.d.ts

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

package/build/methods/reactive.js

@@ -1,52 +0,0 @@
-import Reactive from '../reactive';
-function factory(value) {
-    if (typeof value === 'object' && value !== null && (value.constructor === Object)) {
-        return obj(value);
-    }
-    return new Reactive(value);
-}
-function fn(value) {
-    let fn = new Reactive(value);
-    return (...args) => {
-        let value = fn.get();
-        if (args.length && typeof value === 'function') {
-            value = value(...args);
-        }
-        return value;
-    };
-}
-function obj(values) {
-    let lazy = {}, properties = {};
-    for (let key in values) {
-        properties[key] = {
-            get() {
-                if (!lazy[key]) {
-                    lazy[key] = factory(values[key]);
-                }
-                if (lazy[key] instanceof Reactive) {
-                    return lazy[key].get();
-                }
-                return lazy[key];
-            },
-            set(value) {
-                if (!lazy[key]) {
-                    lazy[key] = factory(values[key]);
-                }
-                if (lazy[key] instanceof Reactive) {
-                    lazy[key].set(value);
-                }
-                else {
-                    lazy[key] = factory(value);
-                }
-            }
-        };
-    }
-    return Object.defineProperties({}, properties);
-}
-;
-export default (value) => {
-    if (typeof value === 'function') {
-        return fn(value);
-    }
-    return factory(value);
-};

package/build/primitives/closure.d.ts

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

package/build/primitives/closure.js

@@ -1,10 +0,0 @@
-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

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

package/build/primitives/computed.js

@@ -1,11 +0,0 @@
-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

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

package/build/primitives/dispatch.js

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

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

package/build/primitives/dispose.js

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/build/primitives/reactive.js

@@ -1,35 +0,0 @@
-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

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

package/build/primitives/reset.js

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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/reactive.d.ts

@@ -1,22 +0,0 @@
-import { ReactiveFn, Scheduler, State } from './types';
-declare class Reactive<T> {
-    private fn?;
-    private value;
-    effect: boolean;
-    cleanup: ((old: T) => void)[] | null;
-    observers: Reactive<any>[] | null;
-    sources: Reactive<any>[] | null;
-    state: State;
-    constructor(data: ReactiveFn<T> | T, effect?: boolean);
-    get(): T extends (...args: any[]) => any ? ReturnType<T> : T;
-    set(value: T): void;
-    private removeParentObservers;
-    private sync;
-    private update;
-}
-declare const scheduler: {
-    add: (scheduler: Scheduler) => void;
-    delete: (scheduler: Scheduler) => void;
-};
-export default Reactive;
-export { scheduler };