@esportsplus/reactivity 0.0.24 → 0.0.25

package/build/api/effect.d.ts

@@ -1,2 +1,7 @@
-declare const _default: (fn: (this: import("../types").Context, previous: unknown) => unknown, options?: import("../types").Options | undefined) => Required<Partial<import("../types").Context>>;
+declare const _default: (fn: (this: import("../types").Context, previous: unknown) => unknown, options?: import("../types").Options | undefined) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
 export default _default;

package/build/api/macro.d.ts

@@ -1,4 +1,9 @@
 import { computed } from '../signal';
 import { Computed } from '../types';
-declare const _default: <T extends <A, R>(...args: A[]) => R>(fn: T extends Promise<unknown> ? never : (this: import("../types").Context, previous: T) => T, options?: Parameters<typeof computed>[1]) => Required<((...args: Parameters<ReturnType<T extends Promise<unknown> ? never : (this: import("../types").Context, previous: T) => T>>) => unknown) & Partial<import("../types").Context>>;
+declare const _default: <T extends <A, R>(...args: A[]) => R>(fn: T extends Promise<unknown> ? never : (this: import("../types").Context, previous: T) => T, options?: Parameters<typeof computed>[1]) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
 export default _default;

package/build/api/promise.d.ts

@@ -1,3 +1,8 @@
 import { computed } from '../signal';
-declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => Required<((this: any, ...args: unknown[]) => void) & Partial<import("../types").Context>>;
+declare const _default: (fn: <A, R extends Promise<any>>(...args: A[]) => R, options?: Parameters<typeof computed>[1]) => {
+    dispose: () => void;
+    on: (event: symbol, listener: import("../types").Listener) => void;
+    once: (event: symbol, listener: import("../types").Listener) => void;
+    reset: () => void;
+};
 export default _default;

package/build/api/reactive.d.ts

@@ -1,16 +1,11 @@
 import { computed, signal } from '../signal';
 import { Context } from '../types';
-type Data = {
-    [key in keyof Context]: never;
-} & Record<PropertyKey, Parameters<typeof computed>[0] | Parameters<typeof signal>[0]>;
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: Infer<T[K]>;
+} : T;
+type Never = {
+    [K in keyof Context]?: never;
+};
 type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
-declare const _default: <T>(data: Data, options?: Options) => Required<{
-    [x: string]: unknown;
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-    dispose: never;
-    on: never;
-    once: never;
-    reset: never;
-} & Partial<Context>>;
+declare const _default: <T extends Record<PropertyKey, unknown>>(data: T & Never, options?: Options) => Required<Infer<T> & Context & Partial<Context>> extends infer T_1 ? { [K in keyof T_1]: Required<Infer<T> & Context & Partial<Context>>[K]; } : never;
 export default _default;

package/build/context/index.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    node: <T>(host: T & Partial<import("../types").Context>, node: import("../signal").default<any>) => Required<T & Partial<import("../types").Context>>;
-    nodes: <T_1>(host: T_1 & Partial<import("../types").Context>, nodes: Record<PropertyKey, import("../signal").default<any>>) => Required<T_1 & Partial<import("../types").Context>>;
+    node: <T>(host: T & Partial<import("../types").Context>, node: import("../signal").default<any>) => Required<T & Partial<import("../types").Context>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<import("../types").Context>>[K]; } : never;
+    nodes: <T_2>(host: T_2 & Partial<import("../types").Context>, nodes: Record<PropertyKey, import("../signal").default<any>>) => Required<T_2 & Partial<import("../types").Context>> extends infer T_3 ? { [K_1 in keyof T_3]: Required<T_2 & Partial<import("../types").Context>>[K_1]; } : never;
 };
 export default _default;

package/build/context/node.d.ts

@@ -3,5 +3,5 @@ import { Context, Signal } from '../types';
 type Internals = {
     [NODE]: Signal<any>;
 };
-declare const _default: <T>(host: T & Partial<Context>, node: Internals[typeof NODE]) => Required<T & Partial<Context>>;
+declare const _default: <T>(host: T & Partial<Context>, node: Internals[typeof NODE]) => Required<T & Partial<Context>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
 export default _default;

package/build/context/nodes.d.ts

@@ -3,5 +3,5 @@ import { Context, Signal } from '../types';
 type Internals = {
     [NODES]: Record<PropertyKey, Signal<any>>;
 };
-declare const _default: <T>(host: T & Partial<Context>, nodes: Internals[typeof NODES]) => Required<T & Partial<Context>>;
+declare const _default: <T>(host: T & Partial<Context>, nodes: Internals[typeof NODES]) => Required<T & Partial<Context>> extends infer T_1 ? { [K in keyof T_1]: Required<T & Partial<Context>>[K]; } : never;
 export default _default;

package/build/types.d.ts

@@ -17,9 +17,6 @@ type Effect<T> = {
     task: NonNullable<Signal<T>['task']>;
 } & Omit<Computed<T>, 'fn' | 'root' | 'task'>;
 type Event = symbol;
-type Infer<T> = T extends (...args: any[]) => any ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: Infer<T[K]>;
-} : T;
 type Listener = {
     once?: boolean;
     <T>(value: T): void;
@@ -30,7 +27,10 @@ type Options = {
 type Root = {
     scheduler: Scheduler;
 };
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 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, Context, Effect, Event, Infer, Listener, Options, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Context, Effect, Event, Listener, Options, Prettify, Root, Scheduler, Signal, State, Type };

package/package.json

@@ -14,5 +14,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.0.24"
+    "version": "0.0.25"
 }

package/src/api/promise.ts

@@ -2,6 +2,9 @@ import { computed, read, root, signal, write } from '~/signal';
 import context from '~/context';
 
 
+// TODO:
+// - Add status value
+// - Add reject/stop method
 export default (fn: <A, R extends Promise<any>>(...args: A[]) => R, options: Parameters<typeof computed>[1] = {}) => {
     let input: unknown,
         nodes = {

package/src/api/reactive.ts

@@ -1,22 +1,27 @@
 import { computed, read, signal, write } from '~/signal';
-import { Computed, Context, Infer, Signal } from '~/types';
+import { Context, Signal } from '~/types';
 import context from '~/context';
 
 
-type Data = {
-    [key in keyof Context]: never
-} & Record<PropertyKey, Parameters<typeof computed>[0] | Parameters<typeof signal>[0]>;
+type Infer<T> =
+    T extends (...args: unknown[]) => unknown
+        ? ReturnType<T>
+        : T extends Record<PropertyKey, unknown>
+            ? { [K in keyof T]: Infer<T[K]> }
+            : T;
+
+type Never = { [K in keyof Context]?: never };
 
 type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
 
 
-export default <T>(data: Data, options: Options = {}) => {
+export default <T extends Record<PropertyKey, unknown>>(data: T & Never, options: Options = {}) => {
     let host = {},
-        nodes: Record<PropertyKey, Signal<any>> = {};
+        nodes: Record<PropertyKey, Signal<unknown>> = {};
 
-    for (let key in data) {
+    for (let key in (data as T)) {
         if (typeof data[key] === 'function') {
-            nodes[key] = computed(data[key] as Computed<T>['fn'], options);
+            nodes[key] = computed(data[key] as Parameters<typeof computed>[0], options);
 
             Object.defineProperty(host, key, {
                 get() {
@@ -38,5 +43,5 @@ export default <T>(data: Data, options: Options = {}) => {
         }
     }
 
-    return context.nodes(host as Infer<typeof data>, nodes);
+    return context.nodes(host as Infer<T> & Context, nodes);
 };

package/src/context/node.ts

@@ -1,5 +1,5 @@
 import { NODE } from '~/symbols';
-import { Context, Event, Listener, Signal } from '~/types';
+import { Context, Event, Listener, Prettify, Signal } from '~/types';
 
 
 type Internals = {
@@ -32,5 +32,5 @@ export default <T>(host: T & Partial<Context>, node: Internals[typeof NODE]) =>
     host.once = once;
     host.reset = reset;
 
-    return host as Required<typeof host>;
+    return host as Prettify< Required<typeof host> >;
 };

package/src/context/nodes.ts

@@ -1,5 +1,5 @@
 import { NODES } from '~/symbols';
-import { Context, Event, Listener, Signal } from '~/types';
+import { Context, Event, Listener, Prettify, Signal } from '~/types';
 
 
 type Internals = {
@@ -48,5 +48,5 @@ export default <T>(host: T & Partial<Context>, nodes: Internals[typeof NODES]) =
     host.once = once;
     host.reset = reset;
 
-    return host as Required<typeof host>;
+    return host as Prettify< Required<typeof host> >;
 };

package/src/types.ts

@@ -24,13 +24,6 @@ type Effect<T> = {
 
 type Event = symbol;
 
-type Infer<T> =
-    T extends (...args: any[]) => any
-        ? ReturnType<T>
-        : T extends Record<PropertyKey, unknown>
-            ? { [K in keyof T]: Infer<T[K]> }
-            : T;
-
 type Listener = {
     once?: boolean;
 
@@ -45,6 +38,10 @@ type Root = {
     scheduler: Scheduler
 };
 
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
 type Scheduler = (fn: (...args: unknown[]) => Promise<unknown> | unknown) => unknown;
 
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
@@ -52,4 +49,4 @@ type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof SIGNAL;
 
 
-export { Changed, Computed, Context, Effect, Event, Infer, Listener, Options, Root, Scheduler, Signal, State, Type };
+export { Changed, Computed, Context, Effect, Event, Listener, Options, Prettify, Root, Scheduler, Signal, State, Type };