@esportsplus/reactivity 0.1.9 → 0.1.10

package/build/constants.d.ts

@@ -4,5 +4,6 @@ declare const DIRTY = 2;
 declare const DISPOSED = 3;
 declare const COMPUTED = 0;
 declare const EFFECT = 1;
-declare const SIGNAL = 2;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL };
+declare const ROOT = 2;
+declare const SIGNAL = 3;
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };

package/build/constants.js

@@ -4,5 +4,6 @@ const DIRTY = 2;
 const DISPOSED = 3;
 const COMPUTED = 0;
 const EFFECT = 1;
-const SIGNAL = 2;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL };
+const ROOT = 2;
+const SIGNAL = 3;
+export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };

package/build/dispose.d.ts

@@ -0,0 +1,4 @@
+declare const _default: <T extends {
+    dispose: VoidFunction;
+}>(dispose?: T | T[] | null | undefined) => T | T[] | null | undefined;
+export default _default;

package/build/dispose.js

@@ -0,0 +1,14 @@
+import { isArray } from './utilities';
+export default (dispose) => {
+    if (dispose == null) {
+    }
+    else if (isArray(dispose)) {
+        for (let i = 0, n = dispose.length; i < n; i++) {
+            dispose[i].dispose();
+        }
+    }
+    else {
+        dispose.dispose();
+    }
+    return dispose;
+};

package/build/index.d.ts

@@ -1,6 +1,5 @@
 export { default as macro } from './macro';
 export { default as resource } from './resource';
-export * as core from './signal';
-export { effect, root } from './signal';
 export { default as reactive } from './reactive';
+export { computed, dispose, effect, reset, root, signal } from './signal';
 export * from './types';

package/build/index.js

@@ -1,6 +1,5 @@
 export { default as macro } from './macro';
 export { default as resource } from './resource';
-export * as core from './signal';
-export { effect, root } from './signal';
 export { default as reactive } from './reactive';
+export { computed, dispose, effect, reset, root, signal } from './signal';
 export * from './types';

package/build/macro.d.ts

@@ -1,5 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed, Options } from './types';
+import { Computed } from './signal';
+import { Options } from './types';
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 declare class Macro<A extends unknown[], R> extends CustomFunction {
     #private;
@@ -7,5 +8,5 @@ declare class Macro<A extends unknown[], R> extends CustomFunction {
     dispose(): void;
     reset(): void;
 }
-declare const _default: <A extends unknown[], R>(fn: (previous: (...args: A) => R) => (...args: A) => R, options?: Options) => Macro<A, R>;
+declare const _default: <A extends unknown[], R>(fn: () => (...args: A) => R, options?: Options) => Macro<A, R>;
 export default _default;

package/build/macro.js

@@ -1,12 +1,12 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { computed, read } from './signal';
+import { Computed } from './signal';
 class Macro extends CustomFunction {
     #factory;
     constructor(fn, options = {}) {
         super((...args) => {
-            return read(this.#factory)(...args);
+            return this.#factory.get()(...args);
         });
-        this.#factory = computed(fn, options);
+        this.#factory = new Computed(fn, options);
     }
     dispose() {
         this.#factory.dispose();

package/build/reactive/array.d.ts

@@ -54,7 +54,7 @@ declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<Node<T
     push(...values: T[]): number;
     shift(): Node<T> | undefined;
     sort(): never;
-    splice(start: number, deleteCount?: number, ...values: T[]): Node<T> | Node<T>[] | undefined;
+    splice(start: number, deleteCount?: number, ...values: T[]): Node<T> | Node<T>[] | null | undefined;
     unshift(...values: T[]): number;
 }
 export { ReactiveArray, ReactiveObjectArray };

package/build/reactive/array.js

@@ -1,4 +1,5 @@
-import { dispose, read, signal, write } from '../signal';
+import { dispose } from '../signal';
+import { Signal } from '../types';
 import { ReactiveObject } from './object';
 function factory(data, options = {}) {
     let signals = [];
@@ -14,7 +15,7 @@ class ReactiveArray extends Array {
     #signal;
     constructor(data) {
         super(...data);
-        this.#signal = signal(false);
+        this.#signal = new Signal(false);
     }
     set length(n) {
         if (n > this.length) {
@@ -23,7 +24,7 @@ class ReactiveArray extends Array {
         this.splice(n);
     }
     trigger() {
-        write(this.#signal, !this.#signal.value);
+        this.#signal.set(!this.#signal.value);
     }
     dispatch(event, data) {
         this.#signal.dispatch(event, data);
@@ -93,7 +94,7 @@ class ReactiveArray extends Array {
         return removed;
     }
     track() {
-        read(this.#signal);
+        this.#signal.get();
     }
     unshift(...items) {
         let length = super.unshift(...items);

package/build/reactive/index.js

@@ -1,4 +1,4 @@
 import { ReactiveObject } from './object';
-export default (data, options = {}) => {
+export default (data, options) => {
     return new ReactiveObject(data, options);
 };

package/build/reactive/object.js

@@ -1,4 +1,4 @@
-import { computed, read, signal, write } from '../signal';
+import { Computed, Signal } from '../types';
 import { defineProperty, isArray } from '../utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 class ReactiveObject {
@@ -8,11 +8,11 @@ class ReactiveObject {
         for (let key in data) {
             let input = data[key];
             if (typeof input === 'function') {
-                let node = nodes[key] = computed(input, options);
+                let node = nodes[key] = new Computed(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     }
                 });
             }
@@ -33,14 +33,14 @@ class ReactiveObject {
                 });
             }
             else {
-                let node = nodes[key] = signal(input, options);
+                let node = nodes[key] = new Signal(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     },
                     set(value) {
-                        write(node, value);
+                        node.set(value);
                     }
                 });
             }

package/build/reset.d.ts

@@ -0,0 +1,4 @@
+declare const _default: <T extends {
+    reset: VoidFunction;
+}>(reset?: T | T[] | null | undefined) => T | T[] | null | undefined;
+export default _default;

package/build/reset.js

@@ -0,0 +1,14 @@
+import { isArray } from './utilities';
+export default (reset) => {
+    if (reset == null) {
+    }
+    else if (isArray(reset)) {
+        for (let i = 0, n = reset.length; i < n; i++) {
+            reset[i].reset();
+        }
+    }
+    else {
+        reset.reset();
+    }
+    return reset;
+};

package/build/resource.js

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { read, signal, write } from './signal';
+import { Signal } from './signal';
 class Resource extends CustomFunction {
     #data;
     #input;
@@ -8,36 +8,36 @@ class Resource extends CustomFunction {
     constructor(fn, options = {}) {
         super((...args) => {
             this.stop = null;
-            write(this.#input, args);
-            write(this.#ok, null);
+            this.#input.set(args);
+            this.#ok.set(null);
             fn(...args)
                 .then((value) => {
                 if (this.stop === true) {
                     return;
                 }
-                write(this.#data, value);
-                write(this.#ok, true);
+                this.#data.set(value);
+                this.#ok.set(true);
             })
                 .catch(() => {
                 if (this.stop === true) {
                     return;
                 }
-                write(this.#data, undefined);
-                write(this.#ok, false);
+                this.#data.set(undefined);
+                this.#ok.set(false);
             });
         });
-        this.#data = signal(options.value, options),
-            this.#input = signal(null, options),
-            this.#ok = signal(null, options);
+        this.#data = new Signal(undefined, options);
+        this.#input = new Signal(null, options);
+        this.#ok = new Signal(null, options);
     }
     get data() {
-        return read(this.#data);
+        return this.#data.get();
     }
     get input() {
-        return read(this.#input);
+        return this.#input.get();
     }
     get ok() {
-        return read(this.#ok);
+        return this.#ok.get();
     }
     dispose() {
         this.#data.dispose();

package/build/signal.d.ts

@@ -1,34 +1,56 @@
-import { Changed, Computed, Effect, Event, Listener, NeverAsync, Options, Root, Scheduler, State, Type } from './types';
-declare class Signal<T> {
-    changed: Changed | null;
-    fn: Computed<T>['fn'] | Effect['fn'] | null;
+import { Changed, Event, Function, Listener, NeverAsync, Options, State, Type } from './types';
+declare class Core<T> {
     listeners: Record<Event, (Listener<any> | null)[]> | null;
-    observers: Signal<T>[] | null;
+    observers: Core<any>[] | null;
     root: Root | null;
-    sources: Signal<T>[] | null;
+    sources: Core<any>[] | null;
     state: State;
-    task: Parameters<Scheduler>[0] | null;
-    type: Type;
-    updating: boolean | null;
+    updating: boolean;
     value: T;
-    constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options?: Options);
+    constructor(state: State, value: T);
+    get type(): Type | never;
     dispatch<D>(event: Event, data?: D): void;
     dispose(): void;
-    on(event: Event, listener: Listener<any>): void;
-    once(event: Event, listener: Listener<any>): void;
+    on<T>(event: Event, listener: Listener<T>): void;
+    once<T>(event: Event, listener: Listener<T>): void;
+}
+declare class Computed<T> extends Core<T> {
+    changed: Changed;
+    fn: NeverAsync<() => T>;
+    constructor(fn: Computed<T>['fn'], options?: Options);
+    get type(): Type;
+    get(): T;
+    reset(): void;
+}
+declare class Effect extends Core<null> {
+    fn: NeverAsync<(node: Effect) => void>;
+    task: Function;
+    constructor(fn: Effect['fn']);
+    get type(): Type;
+    reset(): void;
+}
+declare class Root extends Core<null> {
+    scheduler: (fn: Function) => unknown;
+    tracking: boolean;
+    constructor(scheduler: Root['scheduler'], tracking: boolean);
+    get type(): Type;
+}
+declare class Signal<T> extends Core<T> {
+    changed: Changed;
+    constructor(data: T, options?: Options);
+    get type(): Type;
+    get(): T;
     reset(): void;
+    set(value: T): T;
 }
-declare const computed: <T>(fn: ((previous: T) => T) extends infer T_1 ? T_1 extends (previous: T) => T ? T_1 extends (...args: unknown[]) => unknown ? (...args: Parameters<T_1>) => ReturnType<T_1> extends unknown ? ReturnType<T_1> : NeverAsync<ReturnType<T_1>> : T_1 : never : never, options?: Options) => Computed<T>;
+declare const computed: <T>(fn: () => T extends unknown ? T : NeverAsync<T>, options?: Options) => Computed<T>;
 declare const dispose: <T extends {
-    dispose: () => void;
-}>(dispose?: T | T[] | undefined) => T | T[] | undefined;
-declare const effect: (fn: Effect['fn'], options?: Omit<Options, 'value'>) => Effect;
-declare const read: <T>(node: Signal<T>) => T;
+    dispose: VoidFunction;
+}>(dispose?: T | T[] | null | undefined) => T | T[] | null | undefined;
+declare const effect: (fn: Effect['fn']) => Effect;
 declare const reset: <T extends {
-    reset: () => void;
-}>(reset?: T | T[] | undefined) => T | T[] | undefined;
-declare function root<T>(fn: NeverAsync<() => T>, properties?: Root): T extends unknown ? T : NeverAsync<T>;
-declare const signal: <T>(data: T, options?: Omit<Options, 'value'>) => Signal<T>;
-declare const write: <T>(node: Signal<T>, value: unknown) => T;
-export default Signal;
-export { computed, dispose, effect, read, reset, root, signal, write };
+    reset: VoidFunction;
+}>(reset?: T | T[] | null | undefined) => T | T[] | null | undefined;
+declare const root: <T>(fn: (root: Root) => T, scheduler?: Root['scheduler']) => T;
+declare const signal: <T>(value: T, options?: Options) => Signal<T>;
+export { computed, dispose, effect, reset, root, signal, Computed, Effect, Signal };