@esportsplus/reactivity 0.0.23 → 0.0.25

package/build/reactive.js

@@ -1,190 +0,0 @@
-import { CLEAN, CHECK, DIRTY } from './symbols';
-let index = 0, reaction = null, queue = [], scheduled = false, schedulers = new Set, stack = null;
-function mark(instances, state) {
-    if (!instances) {
-        return;
-    }
-    for (let i = 0, n = instances.length; i < n; i++) {
-        let instance = instances[i];
-        if (instance.state < state) {
-            if (instance.effect && instance.state === CLEAN) {
-                queue.push(instance);
-                if (!scheduled) {
-                    schedule();
-                }
-            }
-            instance.state = state;
-            if (instance.observers) {
-                mark(instance.observers, CHECK);
-            }
-        }
-    }
-}
-function schedule() {
-    if (scheduled) {
-        return;
-    }
-    for (let scheduler of schedulers) {
-        scheduler.schedule();
-    }
-    scheduled = true;
-}
-async function task() {
-    let n = queue.length;
-    for (let i = 0; i < n; i++) {
-        await queue[i].get();
-    }
-    queue.splice(0, n);
-    scheduled = false;
-    if (queue.length) {
-        schedule();
-    }
-}
-class Reactive {
-    fn;
-    value;
-    effect;
-    cleanup = null;
-    observers = null;
-    sources = null;
-    state;
-    constructor(data, effect = false) {
-        this.effect = effect;
-        if (typeof data === 'function') {
-            this.fn = data;
-            this.state = DIRTY;
-            this.value = undefined;
-            if (effect) {
-                this.update();
-            }
-        }
-        else {
-            this.state = CLEAN;
-            this.value = data;
-        }
-    }
-    get() {
-        if (reaction) {
-            if (!stack && reaction.sources && reaction.sources[index] == this) {
-                index++;
-            }
-            else {
-                if (!stack) {
-                    stack = [this];
-                }
-                else {
-                    stack.push(this);
-                }
-            }
-        }
-        if (this.fn) {
-            this.sync();
-        }
-        return this.value;
-    }
-    set(value) {
-        if (this.value !== value) {
-            mark(this.observers, DIRTY);
-        }
-        this.value = value;
-    }
-    removeParentObservers() {
-        if (!this.sources) {
-            return;
-        }
-        for (let i = index; i < this.sources.length; i++) {
-            let source = this.sources[i];
-            source.observers[source.observers.findIndex((v) => v === this)] = source.observers[source.observers.length - 1];
-            source.observers.pop();
-        }
-    }
-    sync() {
-        if (this.state === CHECK && this.sources) {
-            for (let i = 0, n = this.sources.length; i < n; i++) {
-                this.sources[i].sync();
-                if (this.state === DIRTY) {
-                    break;
-                }
-            }
-        }
-        if (this.state === DIRTY) {
-            this.update();
-        }
-        this.state = CLEAN;
-    }
-    update() {
-        let previous = {
-            index: index,
-            reaction: reaction,
-            stack: stack,
-            value: this.value
-        };
-        index = 0;
-        reaction = this;
-        stack = [];
-        try {
-            if (this.cleanup) {
-                for (let i = 0, n = this.cleanup.length; i < n; i++) {
-                    this.cleanup[i](this.value);
-                }
-                this.cleanup.length = 0;
-            }
-            this.value = this.fn((fn) => {
-                if (!this.cleanup) {
-                    this.cleanup = [fn];
-                }
-                else {
-                    this.cleanup.push(fn);
-                }
-            });
-            if (stack.length) {
-                this.removeParentObservers();
-                if (this.sources && index > 0) {
-                    this.sources.length = index + stack.length;
-                    for (let i = 0; i < stack.length; i++) {
-                        this.sources[index + i] = stack[i];
-                    }
-                }
-                else {
-                    this.sources = stack;
-                }
-                for (let i = index; i < this.sources.length; i++) {
-                    let source = this.sources[i];
-                    if (!source.observers) {
-                        source.observers = [this];
-                    }
-                    else {
-                        source.observers.push(this);
-                    }
-                }
-            }
-            else if (this.sources && index < this.sources.length) {
-                this.removeParentObservers();
-                this.sources.length = index;
-            }
-        }
-        finally {
-            index = previous.index;
-            reaction = previous.reaction;
-            stack = previous.stack;
-        }
-        if (this.observers && previous.value !== this.value) {
-            for (let i = 0; i < this.observers.length; i++) {
-                this.observers[i].state = DIRTY;
-            }
-        }
-        this.state = CLEAN;
-    }
-}
-const scheduler = {
-    add: (scheduler) => {
-        scheduler.tasks.add(task);
-        schedulers.add(scheduler);
-    },
-    delete: (scheduler) => {
-        scheduler.tasks.delete(task);
-        schedulers.delete(scheduler);
-    }
-};
-export default Reactive;
-export { scheduler };

package/src/core.ts

@@ -1,295 +0,0 @@
-import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, DISPOSE, EFFECT, RESET, SIGNAL, UPDATE } from './symbols';
-import { Computed, Effect, Fn, Listener, Options, Root, Scheduler } from './types';
-import Signal from './signal';
-
-
-let index = 0,
-    observer: Signal | null = null,
-    observers: Signal[] | null = null,
-    scope: Root | null = null;
-
-
-function changed(a: unknown, b: unknown) {
-    return a !== b;
-}
-
-function notify(nodes: Signal[], state: typeof CHECK | typeof DIRTY) {
-    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 as Effect).root.scheduler((node as Effect).task);
-            }
-
-            node.state = state;
-
-            if (node.observers) {
-                notify(node.observers, CHECK);
-            }
-        }
-    }
-}
-
-function removeSourceObservers(node: Signal, start: number) {
-    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: Signal) {
-    if (node.state === CHECK && node.sources) {
-        for (let i = 0, n = node.sources.length; i < n; i++) {
-            sync(node.sources[i]);
-
-            // Stop the loop here so we won't trigger updates on other parents unnecessarily
-            // If our computation changes to no longer use some sources, we don't
-            // want to update() a source we used last time, but now don't use.
-            if ((node.state as Signal['state']) === DIRTY) {
-                break;
-            }
-        }
-    }
-
-    if (node.state === DIRTY) {
-        update(node);
-    }
-    else {
-        node.state = CLEAN;
-    }
-}
-
-function update(node: Signal) {
-    let i = index,
-        o = observer,
-        os = observers;
-
-    index = 0;
-    observer = node;
-    observers = null as typeof observers;
-
-    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 = <T>(fn: Fn<T>, options: Options = {}) => {
-    let node = new Signal(undefined as unknown, DIRTY, COMPUTED, options);
-
-    node.fn = fn;
-
-    return node as Computed;
-};
-
-const dispose = (node: Signal) => {
-    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 = <T>(fn: Fn<T>, options: Options = {}) => {
-    if (!scope) {
-        throw new Error('Reactivity: effects cannot be created without a reactive root');
-    }
-
-    let node = new Signal(undefined as unknown, DIRTY, EFFECT, options);
-
-    node.fn = fn;
-    node.root = scope;
-    node.task = () => read(node);
-
-    update(node);
-
-    return node as Effect;
-};
-
-const dispatch = (event: symbol, node: Signal) => {
-    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: symbol, listener: Listener, node: Signal) => {
-    if (!node.listeners?.[event]) {
-        node.listeners ??= {};
-        node.listeners[event] = [listener];
-    }
-    else {
-        node.listeners[event].push(listener);
-    }
-};
-
-const read = (node: Signal): typeof node['value'] => {
-    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: Signal) => {
-    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 = <T>(fn: () => T, properties: { scheduler?: Scheduler } = {}) => {
-    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 as Root;
-
-    let result = fn();
-
-    observer = o;
-    scope = s;
-
-    return result;
-};
-
-const signal = <T>(data: T, options: Options = {}) => {
-    return new Signal(data, CLEAN, SIGNAL, options);
-};
-
-const write = (node: Signal, value: unknown) => {
-    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/src/primitives/closure.ts

@@ -1,15 +0,0 @@
-import { computed, read } from '~/core';
-import { NODE } from '~/symbols';
-import { Options } from '~/types';
-
-
-export default (fn: () => (...args: unknown[]) => unknown, options: Options = {}) => {
-    let node = computed(fn, options);
-
-    node.context = function (...args: Parameters<ReturnType<typeof fn>>) {
-        return (read(node) as ReturnType<typeof fn>)(...args);
-    };
-    node.context[NODE] = node;
-
-    return node.context;
-};

package/src/primitives/computed.ts

@@ -1,16 +0,0 @@
-import { computed, on, read } from '~/core';
-import { NODE } from '~/symbols';
-import { Fn, Listener, Options } from '~/types';
-
-
-export default <T>(fn: Fn<T>, options: Options = {}) => {
-    let node = computed(fn, options);
-
-    node.context = function () {
-        return read(node);
-    };
-    node.context[NODE] = node;
-    node.context.on = (event: symbol, listener: Listener) => on(event, listener, node);
-
-    return node.context;
-};

package/src/primitives/dispatch.ts

@@ -1,17 +0,0 @@
-import { dispatch } from '~/core';
-import { NODE, NODES } from '~/symbols';
-import { Wrapper } from '~/types';
-
-
-export default (key: symbol, wrapper: 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/src/primitives/dispose.ts

@@ -1,17 +0,0 @@
-import { dispose } from '~/core';
-import { NODE, NODES } from '~/symbols';
-import { Wrapper } from '~/types';
-
-
-export default (wrapper: 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/src/primitives/effect.ts

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

package/src/primitives/index.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/src/primitives/reactive.ts

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

package/src/primitives/reset.ts

@@ -1,17 +0,0 @@
-import { reset } from '~/core';
-import { NODE, NODES } from '~/symbols';
-import { Wrapper } from '~/types';
-
-
-export default (wrapper: 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/src/primitives/signal.ts

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