@esportsplus/reactivity 0.1.10 → 0.1.12

package/build/index.d.ts

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

package/build/index.js

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

package/build/macro.d.ts

@@ -1,12 +1,10 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed } from './signal';
-import { Options } from './types';
+import { Computed, Options } from './types';
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 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: () => (...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 } from './signal';
+import { computed } from './signal';
 class Macro extends CustomFunction {
     #factory;
     constructor(fn, options = {}) {
         super((...args) => {
             return this.#factory.get()(...args);
         });
-        this.#factory = new Computed(fn, options);
+        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;

package/build/reactive/array.js

@@ -1,5 +1,4 @@
-import { dispose } from '../signal';
-import { Signal } from '../types';
+import { dispose, signal } from '../signal';
 import { ReactiveObject } from './object';
 function factory(data, options = {}) {
     let signals = [];
@@ -15,7 +14,7 @@ class ReactiveArray extends Array {
     #signal;
     constructor(data) {
         super(...data);
-        this.#signal = new Signal(false);
+        this.#signal = signal(false);
     }
     set length(n) {
         if (n > this.length) {
@@ -58,9 +57,6 @@ class ReactiveArray extends Array {
         this.trigger();
         return n;
     }
-    reset() {
-        this.#signal.reset();
-    }
     reverse() {
         super.reverse();
         this.dispatch('reverse');

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, Signal } from '../types';
+import { computed, signal } from '../signal';
 import { defineProperty, isArray } from '../utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 class ReactiveObject {
@@ -8,7 +8,7 @@ class ReactiveObject {
         for (let key in data) {
             let input = data[key];
             if (typeof input === 'function') {
-                let node = nodes[key] = new Computed(input, options);
+                let node = nodes[key] = computed(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
@@ -33,7 +33,7 @@ class ReactiveObject {
                 });
             }
             else {
-                let node = nodes[key] = new Signal(input, options);
+                let node = nodes[key] = signal(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
@@ -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 { Signal } from './signal';
+import { signal } from './signal';
 class Resource extends CustomFunction {
     #data;
     #input;
@@ -26,9 +26,9 @@ class Resource extends CustomFunction {
                 this.#ok.set(false);
             });
         });
-        this.#data = new Signal(undefined, options);
-        this.#input = new Signal(null, options);
-        this.#ok = new Signal(null, options);
+        this.#data = signal(undefined, options);
+        this.#input = signal(null, options);
+        this.#ok = signal(null, options);
     }
     get data() {
         return this.#data.get();
@@ -44,11 +44,6 @@ class Resource extends CustomFunction {
         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

@@ -20,14 +20,12 @@ declare class Computed<T> extends Core<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;
@@ -40,7 +38,6 @@ declare class Signal<T> extends Core<T> {
     constructor(data: T, options?: Options);
     get type(): Type;
     get(): T;
-    reset(): void;
     set(value: T): T;
 }
 declare const computed: <T>(fn: () => T extends unknown ? T : NeverAsync<T>, options?: Options) => Computed<T>;
@@ -48,9 +45,7 @@ declare const dispose: <T extends {
     dispose: VoidFunction;
 }>(dispose?: T | T[] | null | undefined) => T | T[] | null | undefined;
 declare const effect: (fn: Effect['fn']) => Effect;
-declare const reset: <T extends {
-    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 };
+export { computed, dispose, effect, root, signal };
+export { Computed, Effect, Root, Signal };

package/build/signal.js

@@ -62,7 +62,12 @@ class Core {
         if (this.state === DISPOSED) {
             return;
         }
-        flush('dispose', this, DISPOSED, this.value);
+        this.dispatch('dispose', this);
+        removeSourceObservers(this, 0);
+        this.listeners = null;
+        this.observers = null;
+        this.sources = null;
+        this.state = DISPOSED;
     }
     on(event, listener) {
         if (this.updating) {
@@ -106,9 +111,6 @@ class Computed extends Core {
     get() {
         return read(this);
     }
-    reset() {
-        flush('reset', this, DIRTY, undefined);
-    }
 }
 class Effect extends Core {
     fn;
@@ -122,10 +124,6 @@ class Effect extends Core {
     get type() {
         return EFFECT;
     }
-    reset() {
-        flush('reset', this, DIRTY, null);
-        update(this);
-    }
 }
 class Root extends Core {
     scheduler;
@@ -151,9 +149,6 @@ class Signal extends Core {
     get() {
         return read(this);
     }
-    reset() {
-        flush('reset', this, CLEAN, this.value);
-    }
     set(value) {
         return write(this, value);
     }
@@ -161,15 +156,6 @@ class Signal extends Core {
 function changed(a, b) {
     return a !== b;
 }
-function flush(event, node, state, value) {
-    node.dispatch(event, node);
-    removeSourceObservers(node, 0);
-    node.listeners = null;
-    node.observers = null;
-    node.sources = null;
-    node.state = state;
-    node.value = value;
-}
 function notify(nodes, state) {
     if (nodes === null) {
         return;
@@ -313,19 +299,6 @@ const dispose = (dispose) => {
 const effect = (fn) => {
     return new Effect(fn);
 };
-const reset = (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;
-};
 const root = (fn, scheduler) => {
     let o = observer, s = scope;
     if (scheduler === undefined) {
@@ -344,4 +317,5 @@ const root = (fn, scheduler) => {
 const signal = (value, options) => {
     return new Signal(value, options);
 };
-export { computed, dispose, effect, reset, root, signal, Computed, Effect, Signal };
+export { computed, dispose, effect, root, signal };
+export { Computed, Effect, Root, Signal };

package/build/types.d.ts

@@ -1,6 +1,6 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript';
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Computed, Effect, Signal } from './signal';
+import { Computed, Effect, Root, Signal } from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 type Event = string;
 type Listener<D> = {
@@ -16,4 +16,4 @@ type Options = {
 };
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
-export { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Signal, State, Type };
+export type { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Root, Signal, State, Type };

package/build/types.js

@@ -1,2 +1 @@
-import { Computed, Effect, Signal } from './signal';
-export { Computed, Effect, Signal };
+export {};

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.10"
+    "version": "0.1.12"
 }

package/src/index.ts

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

package/src/macro.ts

@@ -1,6 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed } from './signal';
-import { Options } from './types';
+import { computed } from './signal';
+import { Computed, Options } from './types';
 
 
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
@@ -14,17 +14,13 @@ class Macro<A extends unknown[], R> extends CustomFunction {
         super((...args: A) => {
             return this.#factory.get()(...args);
         });
-        this.#factory = new Computed(fn, options);
+        this.#factory = computed(fn, options);
     }
 
 
     dispose() {
         this.#factory.dispose();
     }
-
-    reset() {
-        this.#factory.reset();
-    }
 }
 
 

package/src/reactive/array.ts

@@ -1,4 +1,4 @@
-import { dispose } from '~/signal';
+import { dispose, signal } from '~/signal';
 import { Listener, Object, Options, Signal } from '~/types';
 import { ReactiveObject } from './object';
 
@@ -40,7 +40,7 @@ class ReactiveArray<T> extends Array<T> {
 
     constructor(data: T[]) {
         super(...data);
-        this.#signal = new Signal(false);
+        this.#signal = signal(false);
     }
 
 
@@ -103,10 +103,6 @@ class ReactiveArray<T> extends Array<T> {
         return n;
     }
 
-    reset() {
-        this.#signal.reset();
-    }
-
     reverse() {
         super.reverse();
 

package/src/reactive/object.ts

@@ -1,3 +1,4 @@
+import { computed, signal } from '~/signal';
 import { Computed, Object, Options, Signal } from '~/types';
 import { defineProperty, isArray } from '~/utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
@@ -17,7 +18,7 @@ class ReactiveObject<T extends Object> {
             let input = data[key];
 
             if (typeof input === 'function') {
-                let node = nodes[key] = new Computed(input as Computed<T>['fn'], options);
+                let node = nodes[key] = computed(input as Computed<T>['fn'], options);
 
                 defineProperty(this, key, {
                     enumerable: true,
@@ -47,7 +48,7 @@ class ReactiveObject<T extends Object> {
                 });
             }
             else {
-                let node = nodes[key] = new Signal(input, options);
+                let node = nodes[key] = signal(input, options);
 
                 defineProperty(this, key, {
                     enumerable: true,
@@ -70,14 +71,6 @@ class ReactiveObject<T extends Object> {
             nodes[key].dispose();
         }
     }
-
-    reset() {
-        let nodes = this.nodes;
-
-        for (let key in nodes) {
-            nodes[key].reset();
-        }
-    }
 }
 
 

package/src/resource.ts

@@ -1,6 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Signal } from './signal';
-import { Options } from './types';
+import { signal } from './signal';
+import { Options, Signal } from './types';
 
 
 type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
@@ -39,9 +39,9 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
                     this.#ok.set(false);
                 });
         });
-        this.#data = new Signal(undefined as Awaited<R>, options);
-        this.#input = new Signal<A | null>(null, options);
-        this.#ok = new Signal<boolean | null>(null, options);
+        this.#data = signal(undefined as Awaited<R>, options);
+        this.#input = signal<A | null>(null, options);
+        this.#ok = signal<boolean | null>(null, options);
     }
 
 
@@ -63,12 +63,6 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
         this.#input.dispose();
         this.#ok.dispose();
     }
-
-    reset() {
-        this.#data.reset();
-        this.#input.reset();
-        this.#ok.reset();
-    }
 }
 
 

package/src/signal.ts

@@ -87,7 +87,14 @@ class Core<T> {
             return;
         }
 
-        flush('dispose', this, DISPOSED, this.value);
+        this.dispatch('dispose', this);
+
+        removeSourceObservers(this, 0);
+
+        this.listeners = null;
+        this.observers = null;
+        this.sources = null;
+        this.state = DISPOSED;
     }
 
     on<T>(event: Event, listener: Listener<T>) {
@@ -143,10 +150,6 @@ class Computed<T> extends Core<T> {
     get() {
         return read(this);
     }
-
-    reset() {
-        flush('reset', this, DIRTY, undefined as T);
-    }
 }
 
 class Effect extends Core<null> {
@@ -166,12 +169,6 @@ class Effect extends Core<null> {
     get type(): Type {
         return EFFECT;
     }
-
-
-    reset() {
-        flush('reset', this, DIRTY, null);
-        update(this);
-    }
 }
 
 class Root extends Core<null> {
@@ -210,10 +207,6 @@ class Signal<T> extends Core<T> {
         return read(this);
     }
 
-    reset() {
-        flush('reset', this, CLEAN, this.value);
-    }
-
     set(value: T): T {
         return write(this, value);
     }
@@ -224,18 +217,6 @@ function changed(a: unknown, b: unknown) {
     return a !== b;
 }
 
-function flush<T>(event: Event, node: Core<T>, state: State, value: T) {
-    node.dispatch(event, node);
-
-    removeSourceObservers(node, 0);
-
-    node.listeners = null;
-    node.observers = null;
-    node.sources = null;
-    node.state = state;
-    node.value = value;
-}
-
 function notify<T>(nodes: Core<T>[] | null, state: typeof CHECK | typeof DIRTY) {
     if (nodes === null) {
         return;
@@ -313,8 +294,7 @@ function sync<T>(node: Core<T>) {
     }
 
     if (node.state === DIRTY) {
-        // @ts-ignore
-        update(node);
+        update(node as Computed<T> | Effect);
     }
     else {
         node.state = CLEAN;
@@ -420,21 +400,6 @@ const effect = (fn: Effect['fn']) => {
     return new Effect(fn);
 };
 
-const reset = <T extends { reset: VoidFunction }>(reset?: T[] | T | null) => {
-    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;
-};
-
 const root = <T>(fn: NeverAsync<(root: Root) => T>, scheduler?: Root['scheduler']) => {
     let o = observer,
         s = scope;
@@ -463,4 +428,5 @@ const signal = <T>(value: T, options?: Options) => {
 };
 
 
-export { computed, dispose, effect, reset, root, signal, Computed, Effect, Signal };
+export { computed, dispose, effect, root, signal };
+export { Computed, Effect, Root, Signal };

package/src/types.ts

@@ -1,6 +1,6 @@
 import { Function, NeverAsync, Prettify } from '@esportsplus/typescript'
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL } from './constants';
-import { Computed, Effect, Signal } from './signal';
+import { Computed, Effect, Root, Signal } from './signal';
 
 
 type Changed = (a: unknown, b: unknown) => boolean;
@@ -24,4 +24,4 @@ type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
 
 
-export { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Signal, State, Type };
+export type { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Root, Signal, State, Type };

package/build/dispose.d.ts

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

package/build/dispose.js

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

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

package/build/reset.js

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