@esportsplus/reactivity 0.1.3 → 0.1.5

package/build/index.d.ts

@@ -3,3 +3,4 @@ export { default as resource } from './resource';
 export * as core from './signal';
 export { effect, root } from './signal';
 export { default as reactive } from './reactive';
+export * from './types';

package/build/index.js

@@ -3,3 +3,4 @@ export { default as resource } from './resource';
 export * as core from './signal';
 export { effect, root } from './signal';
 export { default as reactive } from './reactive';
+export * from './types';

package/build/macro.d.ts

@@ -1,6 +1,7 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { computed } from './signal';
-type Fn<A extends unknown[], R> = Parameters<typeof computed<(...args: A) => R>>[0];
+import { Computed } from './types';
+type Fn<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 type Options = Parameters<typeof computed>[1];
 declare class Macro<A extends unknown[], R> extends CustomFunction {
     #private;

package/build/resource.d.ts

@@ -6,9 +6,9 @@ declare class Resource<A extends unknown[], R extends Promise<unknown>> extends
     #private;
     stop: boolean | null;
     constructor(fn: Fn<A, R>, options?: Options);
-    get data(): Awaited<R> | ReturnType<Awaited<R> extends infer T ? T extends Awaited<R> ? T extends Promise<unknown> ? never : (previous: T) => T : never : never>;
+    get data(): Awaited<R> | ReturnType<import("./types").PreventPromise<Awaited<R>, (previous: Awaited<R>) => Awaited<R>>>;
     get ok(): boolean | null;
-    get input(): A | ReturnType<A extends Promise<unknown> ? never : (previous: A) => A> | null;
+    get input(): A | ReturnType<import("./types").PreventPromise<A, (previous: A | null) => A | null>> | null;
     dispose(): void;
     reset(): void;
 }

package/build/signal.d.ts

@@ -1,4 +1,4 @@
-import { Changed, Computed, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+import { Changed, Computed, Effect, Event, Listener, PreventPromise, Options, Root, Scheduler, State, Type } from './types';
 declare class Signal<T> {
     changed: Changed | null;
     fn: Computed<T>['fn'] | null;
@@ -18,19 +18,19 @@ declare class Signal<T> {
     once(event: Event, listener: Listener<any>): void;
     reset(): void;
 }
-declare const computed: <T>(fn: T extends Promise<unknown> ? never : (previous: T) => T, options?: Options) => Computed<T>;
+declare const computed: <T>(fn: PreventPromise<T, (previous: T) => T>, options?: Options) => Computed<T>;
 declare const dispose: <T extends {
     dispose: () => void;
 }>(dispose?: T | T[] | undefined) => T | T[] | undefined;
-declare const effect: <T>(fn: (node: Effect<T>) => void, options?: Omit<Options, 'value'>) => Effect<void>;
-declare const read: <T>(node: Signal<T>) => T | ReturnType<T extends Promise<unknown> ? never : (previous: T) => T>;
+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 reset: <T extends {
     reset: () => void;
 }>(reset?: T | T[] | undefined) => T | T[] | undefined;
-declare const root: <T>(fn: () => T, properties?: {
+declare const root: <T>(fn: PreventPromise<T, () => T>, properties?: {
     scheduler?: Scheduler;
 }) => T;
 declare const signal: <T>(data: T, options?: Omit<Options, 'value'>) => Signal<T>;
-declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<T extends Promise<unknown> ? never : (previous: T) => T>;
+declare const write: <T>(node: Signal<T>, value: unknown) => T | ReturnType<PreventPromise<T, (previous: T) => T>>;
 export default Signal;
 export { computed, dispose, effect, read, reset, root, signal, write };

package/build/signal.js

@@ -220,7 +220,7 @@ const effect = (fn, options = {}) => {
     if (scope !== null) {
         node.root = scope;
     }
-    else if (observer !== null && observer.type === EFFECT && observer.root !== null) {
+    else if (observer !== null && observer.type === EFFECT) {
         node.root = observer.root;
     }
     else {
@@ -228,7 +228,7 @@ const effect = (fn, options = {}) => {
     }
     node.fn = fn;
     node.task = () => read(node);
-    node.root.scheduler(node.task);
+    read(node);
     return node;
 };
 const read = (node) => {
@@ -269,10 +269,10 @@ const reset = (reset) => {
 const root = (fn, properties = {}) => {
     let o = observer, s = scope;
     if (properties.scheduler === undefined) {
-        properties.scheduler = scope?.scheduler;
-        if (properties.scheduler === undefined) {
+        if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
+        properties.scheduler = scope.scheduler;
     }
     observer = null;
     scope = properties;

package/build/types.d.ts

@@ -3,11 +3,11 @@ import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './const
 import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 type Computed<T> = {
-    fn: T extends Promise<unknown> ? never : ((previous: T) => T);
+    fn: PreventPromise<T, (previous: T) => T>;
     value: ReturnType<Computed<T>['fn']>;
 } & Omit<Signal<T>, 'fn' | 'value'>;
 type Effect<T> = {
-    fn: (node: Effect<T>) => void;
+    fn: PreventPromise<T, (node: Effect<T>) => void>;
     root: NonNullable<Signal<T>['root']>;
     task: NonNullable<Signal<T>['task']>;
     value: void;
@@ -25,10 +25,11 @@ 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 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, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, Prettify, PreventPromise, Root, Scheduler, Signal, State, Type };

package/package.json

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

package/src/index.ts

@@ -2,4 +2,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 { default as reactive } from './reactive';
+export * from './types';

package/src/macro.ts

@@ -3,7 +3,7 @@ import { computed, read } from './signal';
 import { Computed } from './types';
 
 
-type Fn<A extends unknown[], R> = Parameters<typeof computed<(...args: A) => R>>[0];
+type Fn<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 
 type Options = Parameters<typeof computed>[1];
 

package/src/reactive/object.ts

@@ -48,7 +48,7 @@ class ReactiveObject<T extends Object> {
                 });
             }
             else {
-                let node = nodes[key] = signal(input, options);
+                let node = nodes[key] = signal<unknown>(input, options);
 
                 defineProperty(this, key, {
                     enumerable: true,

package/src/resource.ts

@@ -42,8 +42,8 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
                 });
         });
         this.#data = signal(options.value as Awaited<R>, options),
-        this.#input = signal(null, options),
-        this.#ok = signal(null, options)
+        this.#input = signal<A | null>(null, options),
+        this.#ok = signal<boolean | null>(null, options)
     }
 
 

package/src/signal.ts

@@ -1,5 +1,5 @@
 import { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, SIGNAL } from './constants';
-import { Changed, Computed, Effect, Event, Listener, Options, Root, Scheduler, State, Type } from './types';
+import { Changed, Computed, Effect, Event, Listener, PreventPromise, Options, Root, Scheduler, State, Type } from './types';
 import { isArray } from './utilities';
 
 
@@ -291,7 +291,7 @@ const effect = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) =>
     if (scope !== null) {
         node.root = scope;
     }
-    else if (observer !== null && observer.type === EFFECT && observer.root !== null) {
+    else if (observer !== null && observer.type === EFFECT) {
         node.root = observer.root;
     }
     else {
@@ -301,7 +301,7 @@ const effect = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) =>
     node.fn = fn;
     node.task = () => read(node);
 
-    node.root.scheduler(node.task);
+    read(node);
 
     return node as Effect<void>;
 };
@@ -347,16 +347,16 @@ const reset = <T extends { reset: () => void }>(reset?: T[] | T) => {
     return reset;
 };
 
-const root = <T>(fn: () => T, properties: { scheduler?: Scheduler } = {}) => {
+const root = <T>(fn: PreventPromise<T, () => T>, properties: { scheduler?: Scheduler } = {}) => {
     let o = observer,
         s = scope;
 
     if (properties.scheduler === undefined) {
-        properties.scheduler = scope?.scheduler;
-
-        if (properties.scheduler === undefined) {
+        if (scope === null) {
             throw new Error('Reactivity: `root` cannot be created without a task scheduler');
         }
+
+        properties.scheduler = scope.scheduler;
     }
 
     observer = null;

package/src/types.ts

@@ -6,12 +6,12 @@ import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 
 type Computed<T> = {
-    fn: T extends Promise<unknown> ? never : ((previous: T) => T);
+    fn: PreventPromise<T, (previous: T) => T>;
     value: ReturnType<Computed<T>['fn']>;
 } & Omit<Signal<T>, 'fn' | 'value'>;
 
 type Effect<T> = {
-    fn: (node: Effect<T>) => void;
+    fn: PreventPromise<T, (node: Effect<T>) => void>;
     root: NonNullable<Signal<T>['root']>;
     task: NonNullable<Signal<T>['task']>
     value: void;
@@ -32,6 +32,8 @@ type Options = {
     value?: unknown;
 };
 
+type PreventPromise<T, R> = T extends Promise<unknown> ? never : R;
+
 type Root = {
     scheduler: Scheduler
 };
@@ -43,4 +45,4 @@ 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, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, Prettify, PreventPromise, Root, Scheduler, Signal, State, Type };