@esportsplus/reactivity 0.1.6 → 0.1.7

package/build/macro.d.ts

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed, Options } from './types';
+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;
@@ -7,5 +7,6 @@ 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: (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/signal.d.ts

@@ -1,4 +1,4 @@
-import { Changed, Computed, Effect, Event, Listener, Options, Root, Scheduler, State, SyncFunction, 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'] | Effect['fn'] | null;
@@ -18,7 +18,7 @@ declare class Signal<T> {
     once(event: Event, listener: Listener<any>): void;
     reset(): 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 ? SyncFunction<((previous: T) => T) extends infer T_2 ? T_2 extends (previous: T) => T ? T_2 extends (...args: unknown[]) => unknown ? ReturnType<T_2> : T_2 : never : never, (((previous: T) => T) extends infer T_2 ? T_2 extends (previous: T) => T ? T_2 extends (...args: unknown[]) => unknown ? ReturnType<T_2> : T_2 : never : never) extends infer T_3 ? T_3 extends (((previous: T) => T) extends infer T_2 ? T_2 extends (previous: T) => T ? T_2 extends (...args: unknown[]) => unknown ? ReturnType<T_2> : T_2 : never : never) ? T_3 extends (...args: unknown[]) => unknown ? ReturnType<T_3> : T_3 : never : never> extends never ? never : T_1 : T_1 : never : never, 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;
@@ -27,7 +27,7 @@ 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: SyncFunction<T, T extends (...args: unknown[]) => unknown ? ReturnType<T> : T> extends never ? never : () => T, properties?: Root) => 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;
 export default Signal;

package/build/signal.js

@@ -266,7 +266,7 @@ const reset = (reset) => {
     }
     return reset;
 };
-const root = (fn, properties) => {
+function root(fn, properties) {
     let o = observer, s = scope;
     if (properties === undefined) {
         if (scope === null) {
@@ -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,12 +1,12 @@
-import { Function, Prettify, SyncFunction } 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: SyncFunction<(previous: T) => T>;
+    fn: (previous: T) => NeverAsync<T>;
 } & Omit<Signal<T>, 'fn'>;
 type Effect = {
-    fn: SyncFunction<(node: Effect) => void>;
+    fn: (node: Effect) => NeverAsync<void>;
     root: Root;
     task: Function;
     value: void;
@@ -30,4 +30,4 @@ type Root = {
 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, Root, Scheduler, Signal, State, SyncFunction, 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.6"
+        "@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.6"
+    "version": "0.1.7"
 }

package/src/macro.ts

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

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, SyncFunction, Type } from './types';
+import { Changed, Computed, Effect, Event, Listener, NeverAsync, Options, Root, Scheduler, State, Type } from './types';
 import { isArray } from './utilities';
 
 
@@ -348,7 +348,7 @@ const reset = <T extends { reset: () => void }>(reset?: T[] | T) => {
     return reset;
 };
 
-const root = <T>(fn: SyncFunction<() => T>, properties?: Root) => {
+function root<T>(fn: () => NeverAsync<T>, properties?: Root) {
     let o = observer,
         s = scope;
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Function, Prettify, SyncFunction } 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,11 +6,11 @@ import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 
 type Computed<T> = {
-    fn: SyncFunction<(previous: T) => T>;
+    fn: (previous: T) => NeverAsync<T>;
 } & Omit<Signal<T>, 'fn'>;
 
 type Effect = {
-    fn: SyncFunction<(node: Effect) => void>;
+    fn: (node: Effect) => NeverAsync<void>;
     root: Root;
     task: Function
     value: void;
@@ -42,4 +42,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, SyncFunction, Type };
+export { Changed, Computed, Effect, Event, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };