@esportsplus/reactivity 0.1.7 → 0.1.9

package/build/macro.d.ts

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed, NeverAsync, 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;
@@ -7,6 +7,5 @@ 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) 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>;
+declare const _default: <A extends unknown[], R>(fn: (previous: (...args: A) => R) => (...args: A) => R, options?: Options) => Macro<A, R>;
 export default _default;
-export { NeverAsync };

package/build/signal.d.ts

@@ -18,7 +18,7 @@ declare class Signal<T> {
     once(event: Event, listener: Listener<any>): void;
     reset(): void;
 }
-declare const computed: <T>(fn: (previous: T) => NeverAsync<T>, options?: Options) => Computed<T>;
+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 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 function root<T>(fn: () => NeverAsync<T>, properties?: Root): NeverAsync<T>;
+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;

package/build/types.d.ts

@@ -3,10 +3,10 @@ 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: (previous: T) => NeverAsync<T>;
+    fn: NeverAsync<(previous: T) => T>;
 } & Omit<Signal<T>, 'fn'>;
 type Effect = {
-    fn: (node: Effect) => NeverAsync<void>;
+    fn: NeverAsync<(node: Effect) => void>;
     root: Root;
     task: Function;
     value: void;

package/package.json

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

package/src/macro.ts

@@ -1,6 +1,6 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { computed, read } from './signal';
-import { Computed, NeverAsync, Options } from './types';
+import { Computed, Options } from './types';
 
 
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
@@ -30,5 +30,4 @@ 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

@@ -209,8 +209,8 @@ function update<T>(node: Signal<T>) {
         node.updating = true;
 
         let value = (
-                node as typeof node extends Effect ? Effect : Computed<T>
-            ).fn.call(node, node.value);
+            node as typeof node extends Effect ? Effect : Computed<T>
+        ).fn.call(node, node.value);
 
         node.updating = null;
 
@@ -348,7 +348,7 @@ const reset = <T extends { reset: () => void }>(reset?: T[] | T) => {
     return reset;
 };
 
-function root<T>(fn: () => NeverAsync<T>, properties?: Root) {
+function root<T>(fn: NeverAsync<() => T>, properties?: Root) {
     let o = observer,
         s = scope;
 

package/src/types.ts

@@ -6,11 +6,11 @@ import Signal from './signal';
 type Changed = (a: unknown, b: unknown) => boolean;
 
 type Computed<T> = {
-    fn: (previous: T) => NeverAsync<T>;
+    fn: NeverAsync<(previous: T) => T>;
 } & Omit<Signal<T>, 'fn'>;
 
 type Effect = {
-    fn: (node: Effect) => NeverAsync<void>;
+    fn: NeverAsync<(node: Effect) => void>;
     root: Root;
     task: Function
     value: void;