@esportsplus/reactivity 0.1.5 → 0.1.7

package/build/macro.d.ts

@@ -1,13 +1,12 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { computed } from './signal';
-import { Computed } from './types';
-type Fn<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
-type Options = Parameters<typeof computed>[1];
+import { Computed, NeverAsync, 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: Fn<A, R>, options?: Options);
+    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: (previous: (...args: A) => R) => ((...args: A) => R) extends infer T ? T extends (...args: A) => R ? T extends (...args: unknown[]) => unknown ? NeverAsync<ReturnType<T>> extends never ? never : T : T : never : never, options?: Options) => Macro<A, R>;
 export default _default;
+export { NeverAsync };

package/build/resource.d.ts

@@ -1,16 +1,15 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { computed } from './signal';
-type Fn<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
-type Options = Parameters<typeof computed>[1];
+import { Options } from './types';
+type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
 declare class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
     #private;
     stop: boolean | null;
-    constructor(fn: Fn<A, R>, options?: Options);
-    get data(): Awaited<R> | ReturnType<import("./types").PreventPromise<Awaited<R>, (previous: Awaited<R>) => Awaited<R>>>;
+    constructor(fn: Function<A, R>, options?: Options);
+    get data(): Awaited<R>;
+    get input(): A | null;
     get ok(): boolean | null;
-    get input(): A | ReturnType<import("./types").PreventPromise<A, (previous: A | null) => A | null>> | null;
     dispose(): void;
     reset(): void;
 }
-declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: Fn<A, R>, options?: Options) => Resource<A, R>;
+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

@@ -33,12 +33,12 @@ class Resource extends CustomFunction {
     get data() {
         return read(this.#data);
     }
-    get ok() {
-        return read(this.#ok);
-    }
     get input() {
         return read(this.#input);
     }
+    get ok() {
+        return read(this.#ok);
+    }
     dispose() {
         this.#data.dispose();
         this.#input.dispose();

package/build/signal.d.ts

@@ -1,7 +1,7 @@
-import { Changed, Computed, Effect, Event, Listener, PreventPromise, Options, Root, Scheduler, State, Type } from './types';
+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'] | null;
+    fn: Computed<T>['fn'] | Effect['fn'] | null;
     listeners: Record<Event, (Listener<any> | null)[]> | null;
     observers: Signal<T>[] | null;
     root: Root | null;
@@ -10,7 +10,7 @@ declare class Signal<T> {
     task: Parameters<Scheduler>[0] | null;
     type: Type;
     updating: boolean | null;
-    value: Computed<T>['value'] | T;
+    value: T;
     constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options?: Options);
     dispatch<D>(event: Event, data?: D): void;
     dispose(): void;
@@ -18,19 +18,17 @@ declare class Signal<T> {
     once(event: Event, listener: Listener<any>): void;
     reset(): void;
 }
-declare const computed: <T>(fn: PreventPromise<T, (previous: T) => T>, options?: Options) => Computed<T>;
+declare const computed: <T>(fn: (previous: T) => NeverAsync<T>, options?: Options) => Computed<T>;
 declare const dispose: <T extends {
     dispose: () => void;
 }>(dispose?: T | T[] | undefined) => T | T[] | undefined;
-declare const effect: <T>(fn: PreventPromise<T, (node: Effect<T>) => void>, options?: Omit<Options, 'value'>) => Effect<void>;
-declare const read: <T>(node: Signal<T>) => T | ReturnType<PreventPromise<T, (previous: T) => T>>;
+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 const root: <T>(fn: PreventPromise<T, () => T>, properties?: {
-    scheduler?: Scheduler;
-}) => T;
+declare function root<T>(fn: () => NeverAsync<T>, properties?: Root): NeverAsync<T>;
 declare const signal: <T>(data: T, options?: Omit<Options, 'value'>) => Signal<T>;
-declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<PreventPromise<T, (previous: T) => T>>;
+declare const write: <T>(node: Signal<T>, value: unknown) => T;
 export default Signal;
 export { computed, dispose, effect, read, reset, root, signal, write };

package/build/signal.js

@@ -216,11 +216,11 @@ const dispose = (dispose) => {
     return dispose;
 };
 const effect = (fn, options = {}) => {
-    let node = new Signal(undefined, DIRTY, EFFECT, options);
+    let node = new Signal(void 0, DIRTY, EFFECT, options);
     if (scope !== null) {
         node.root = scope;
     }
-    else if (observer !== null && observer.type === EFFECT) {
+    else if (observer !== null && observer.type === EFFECT && observer.root !== null) {
         node.root = observer.root;
     }
     else {
@@ -266,13 +266,13 @@ const reset = (reset) => {
     }
     return reset;
 };
-const root = (fn, properties = {}) => {
+function root(fn, properties) {
     let o = observer, s = scope;
-    if (properties.scheduler === undefined) {
+    if (properties === undefined) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
-        properties.scheduler = scope.scheduler;
+        properties = scope;
     }
     observer = null;
     scope = properties;
@@ -280,7 +280,8 @@ const root = (fn, properties = {}) => {
     observer = o;
     scope = s;
     return result;
-};
+}
+;
 const signal = (data, options = {}) => {
     return new Signal(data, CLEAN, SIGNAL, options);
 };

package/build/types.d.ts

@@ -1,17 +1,16 @@
-import { Prettify } from '@esportsplus/typescript';
+import { Function, NeverAsync, Prettify } from '@esportsplus/typescript';
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
 import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 type Computed<T> = {
-    fn: PreventPromise<T, (previous: T) => T>;
-    value: ReturnType<Computed<T>['fn']>;
-} & Omit<Signal<T>, 'fn' | 'value'>;
-type Effect<T> = {
-    fn: PreventPromise<T, (node: Effect<T>) => void>;
-    root: NonNullable<Signal<T>['root']>;
-    task: NonNullable<Signal<T>['task']>;
+    fn: (previous: T) => NeverAsync<T>;
+} & Omit<Signal<T>, 'fn'>;
+type Effect = {
+    fn: (node: Effect) => NeverAsync<void>;
+    root: Root;
+    task: Function;
     value: void;
-} & Omit<Signal<T>, 'fn' | 'root' | 'task' | 'value'>;
+} & Omit<Signal<void>, 'fn' | 'root' | 'task' | 'value'>;
 type Event = string;
 type Listener<D> = {
     once?: boolean;
@@ -25,11 +24,10 @@ type Options = {
     changed?: Changed;
     value?: unknown;
 };
-type PreventPromise<T, R> = T extends Promise<unknown> ? never : R;
 type Root = {
     scheduler: Scheduler;
 };
-type Scheduler = (fn: (...args: unknown[]) => Promise<unknown> | unknown) => unknown;
+type Scheduler = (fn: Function) => unknown;
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
-export { Changed, Computed, Effect, Event, Listener, Object, Options, Prettify, PreventPromise, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };

package/package.json

@@ -4,7 +4,7 @@
         "@esportsplus/custom-function": "^0.0.1"
     },
     "devDependencies": {
-        "@esportsplus/typescript": "^0.0.3"
+        "@esportsplus/typescript": "^0.0.7"
     },
     "main": "build/index.js",
     "name": "@esportsplus/reactivity",
@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.5"
+    "version": "0.1.7"
 }

package/src/macro.ts

@@ -1,18 +1,16 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { computed, read } from './signal';
-import { Computed } from './types';
+import { Computed, NeverAsync, Options } from './types';
 
 
-type Fn<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
-
-type Options = Parameters<typeof computed>[1];
+type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 
 
 class Macro<A extends unknown[], R> extends CustomFunction {
-    #factory: Computed< ReturnType<Fn<A,R>> >;
+    #factory: Computed<(...args: A) => R>;
 
 
-    constructor(fn: Fn<A,R>, options: Options = {}) {
+    constructor(fn: Function<A,R>, options: Options = {}) {
         super((...args: A) => {
             return read(this.#factory)(...args);
         });
@@ -30,6 +28,7 @@ class Macro<A extends unknown[], R> extends CustomFunction {
 }
 
 
-export default <A extends unknown[], R>(fn: Fn<A,R>, options: Options = {}) => {
+export default <A extends unknown[], R>(fn: Function<A,R>, options: Options = {}) => {
     return new Macro(fn, options);
-};
+};
+export { NeverAsync };

package/src/resource.ts

@@ -1,11 +1,9 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { computed, read, signal, write } from './signal';
-import { Signal } from './types';
+import { read, signal, write } from './signal';
+import { Options, Signal } from './types';
 
 
-type Fn<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
-
-type Options = Parameters<typeof computed>[1];
+type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
 
 
 class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
@@ -16,7 +14,7 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
     stop: boolean | null = null;
 
 
-    constructor(fn: Fn<A,R>, options: Options = {}) {
+    constructor(fn: Function<A,R>, options: Options = {}) {
         super((...args: A) => {
             this.stop = null;
 
@@ -51,14 +49,14 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
         return read(this.#data);
     }
 
-    get ok() {
-        return read(this.#ok);
-    }
-
     get input() {
         return read(this.#input);
     }
 
+    get ok() {
+        return read(this.#ok);
+    }
+
 
     dispose() {
         this.#data.dispose();
@@ -74,6 +72,6 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
 }
 
 
-export default <A extends unknown[], R extends Promise<unknown>>(fn: Fn<A,R>, options: Options = {}) => {
+export default <A extends unknown[], R extends Promise<unknown>>(fn: Function<A,R>, options: Options = {}) => {
     return new Resource(fn, options);
 };

package/src/signal.ts

@@ -1,9 +1,8 @@
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
-import { Changed, Computed, Effect, Event, Listener, PreventPromise, Options, Root, Scheduler, State, Type } from './types';
+import { Changed, Computed, Effect, Event, Listener, NeverAsync, Options, Root, Scheduler, State, Type } from './types';
 import { isArray } from './utilities';
 
 
-
 let index = 0,
     observer: Signal<any> | null = null,
     observers: Signal<any>[] | null = null,
@@ -12,7 +11,7 @@ let index = 0,
 
 class Signal<T> {
     changed: Changed | null = null;
-    fn: Computed<T>['fn'] | null = null;
+    fn: Computed<T>['fn'] | Effect['fn'] | null = null;
     listeners: Record<Event, (Listener<any> | null)[]> | null = null;
     observers: Signal<T>[] | null = null;
     root: Root | null = null;
@@ -21,7 +20,7 @@ class Signal<T> {
     task: Parameters<Scheduler>[0] | null = null;
     type: Type;
     updating: boolean | null = null;
-    value: Computed<T>['value'] | T;
+    value: T;
 
 
     constructor(data: T, state: Signal<T>['state'], type: Signal<T>['type'], options: Options = {}) {
@@ -209,7 +208,9 @@ function update<T>(node: Signal<T>) {
         node.dispatch('update');
         node.updating = true;
 
-        let value = node.fn!.call(node, node.value);
+        let value = (
+                node as typeof node extends Effect ? Effect : Computed<T>
+            ).fn.call(node, node.value);
 
         node.updating = null;
 
@@ -263,11 +264,11 @@ function update<T>(node: Signal<T>) {
 
 
 const computed = <T>(fn: Computed<T>['fn'], options: Options = {}) => {
-    let node = new Signal(options.value as any, DIRTY, COMPUTED, options);
+    let node = new Signal(options.value as T, DIRTY, COMPUTED, options) as Computed<T>;
 
     node.fn = fn;
 
-    return node as Computed<T>;
+    return node;
 };
 
 const dispose = <T extends { dispose: () => void }>(dispose?: T[] | T) => {
@@ -285,13 +286,13 @@ const dispose = <T extends { dispose: () => void }>(dispose?: T[] | T) => {
     return dispose;
 };
 
-const effect = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) => {
-    let node = new Signal(undefined as any, DIRTY, EFFECT, options);
+const effect = (fn: Effect['fn'], options: Omit<Options, 'value'> = {}) => {
+    let node = new Signal(void 0, DIRTY, EFFECT, options) as Effect;
 
     if (scope !== null) {
         node.root = scope;
     }
-    else if (observer !== null && observer.type === EFFECT) {
+    else if (observer !== null && observer.type === EFFECT && observer.root !== null) {
         node.root = observer.root;
     }
     else {
@@ -303,7 +304,7 @@ const effect = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) =>
 
     read(node);
 
-    return node as Effect<void>;
+    return node;
 };
 
 const read = <T>(node: Signal<T>): typeof node['value'] => {
@@ -347,20 +348,20 @@ const reset = <T extends { reset: () => void }>(reset?: T[] | T) => {
     return reset;
 };
 
-const root = <T>(fn: PreventPromise<T, () => T>, properties: { scheduler?: Scheduler } = {}) => {
+function root<T>(fn: () => NeverAsync<T>, properties?: Root) {
     let o = observer,
         s = scope;
 
-    if (properties.scheduler === undefined) {
+    if (properties === undefined) {
         if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
 
-        properties.scheduler = scope.scheduler;
+        properties = scope;
     }
 
     observer = null;
-    scope = properties as Root;
+    scope = properties;
 
     let result = fn();
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Prettify } from '@esportsplus/typescript'
+import { Function, NeverAsync, Prettify } from '@esportsplus/typescript'
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
 import Signal from './signal';
 
@@ -6,16 +6,15 @@ import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 
 type Computed<T> = {
-    fn: PreventPromise<T, (previous: T) => T>;
-    value: ReturnType<Computed<T>['fn']>;
-} & Omit<Signal<T>, 'fn' | 'value'>;
-
-type Effect<T> = {
-    fn: PreventPromise<T, (node: Effect<T>) => void>;
-    root: NonNullable<Signal<T>['root']>;
-    task: NonNullable<Signal<T>['task']>
+    fn: (previous: T) => NeverAsync<T>;
+} & Omit<Signal<T>, 'fn'>;
+
+type Effect = {
+    fn: (node: Effect) => NeverAsync<void>;
+    root: Root;
+    task: Function
     value: void;
-} & Omit<Signal<T>, 'fn' | 'root' | 'task' | 'value'>;
+} & Omit<Signal<void>, 'fn' | 'root' | 'task' | 'value'>;
 
 type Event = string;
 
@@ -32,17 +31,15 @@ type Options = {
     value?: unknown;
 };
 
-type PreventPromise<T, R> = T extends Promise<unknown> ? never : R;
-
 type Root = {
     scheduler: Scheduler
 };
 
-type Scheduler = (fn: (...args: unknown[]) => Promise<unknown> | unknown) => unknown;
+type Scheduler = (fn: Function) => unknown;
 
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 
 type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
 
 
-export { Changed, Computed, Effect, Event, Listener, Object, Options, Prettify, PreventPromise, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };