@esportsplus/reactivity 0.1.9 → 0.1.11

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/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, 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, root, signal } from './signal';
 export * from './types';

package/build/macro.d.ts

@@ -5,7 +5,6 @@ declare class Macro<A extends unknown[], R> extends CustomFunction {
     #private;
     constructor(fn: Function<A, R>, options?: Options);
     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,19 +1,16 @@
 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);
     }
     dispose() {
         this.#factory.dispose();
     }
-    reset() {
-        this.#factory.reset();
-    }
 }
 export default (fn, options = {}) => {
     return new Macro(fn, options);

package/build/reactive/array.d.ts

@@ -37,7 +37,6 @@ declare class ReactiveArray<T> extends Array<T> {
     once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>): void;
     pop(): T | undefined;
     push(...items: T[]): number;
-    reset(): void;
     reverse(): this;
     shift(): T | undefined;
     sort(): this;
@@ -54,7 +53,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,4 @@
-import { dispose, read, signal, write } from '../signal';
+import { dispose, signal } from '../signal';
 import { ReactiveObject } from './object';
 function factory(data, options = {}) {
     let signals = [];
@@ -23,7 +23,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);
@@ -57,9 +57,6 @@ class ReactiveArray extends Array {
         this.trigger();
         return n;
     }
-    reset() {
-        this.#signal.reset();
-    }
     reverse() {
         super.reverse();
         this.dispatch('reverse');
@@ -93,7 +90,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.d.ts

@@ -5,6 +5,5 @@ declare class ReactiveObject<T extends Object> {
     nodes: Record<PropertyKey, Node>;
     constructor(data: T, options?: Options);
     dispose(): void;
-    reset(): void;
 }
 export { ReactiveObject };

package/build/reactive/object.js

@@ -1,4 +1,4 @@
-import { computed, read, signal, write } from '../signal';
+import { computed, signal } from '../signal';
 import { defineProperty, isArray } from '../utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 class ReactiveObject {
@@ -12,7 +12,7 @@ class ReactiveObject {
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     }
                 });
             }
@@ -37,10 +37,10 @@ class ReactiveObject {
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(node);
+                        return node.get();
                     },
                     set(value) {
-                        write(node, value);
+                        node.set(value);
                     }
                 });
             }
@@ -52,11 +52,5 @@ class ReactiveObject {
             nodes[key].dispose();
         }
     }
-    reset() {
-        let nodes = this.nodes;
-        for (let key in nodes) {
-            nodes[key].reset();
-        }
-    }
 }
 export { ReactiveObject };

package/build/resource.d.ts

@@ -9,7 +9,6 @@ declare class Resource<A extends unknown[], R extends Promise<unknown>> extends
     get input(): A | null;
     get ok(): boolean | null;
     dispose(): void;
-    reset(): void;
 }
 declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: Function<A, R>, options?: Options) => Resource<A, R>;
 export default _default;

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,47 +8,42 @@ 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 = signal(undefined, options);
+        this.#input = signal(null, options);
+        this.#ok = 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();
         this.#input.dispose();
         this.#ok.dispose();
     }
-    reset() {
-        this.#data.reset();
-        this.#input.reset();
-        this.#ok.reset();
-    }
 }
 export default (fn, options = {}) => {
     return new Resource(fn, options);

package/build/signal.d.ts

@@ -1,34 +1,51 @@
-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;
-    reset(): void;
+    on<T>(event: Event, listener: Listener<T>): void;
+    once<T>(event: Event, listener: Listener<T>): void;
 }
-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 class Computed<T> extends Core<T> {
+    changed: Changed;
+    fn: NeverAsync<() => T>;
+    constructor(fn: Computed<T>['fn'], options?: Options);
+    get type(): Type;
+    get(): T;
+}
+declare class Effect extends Core<null> {
+    fn: NeverAsync<(node: Effect) => void>;
+    task: Function;
+    constructor(fn: Effect['fn']);
+    get type(): Type;
+}
+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;
+    set(value: T): 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;
-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 };
+    dispose: VoidFunction;
+}>(dispose?: T | T[] | null | undefined) => T | T[] | null | undefined;
+declare const effect: (fn: Effect['fn']) => Effect;
+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, root, signal };
+export { Computed, Effect, Signal };