@esportsplus/reactivity 0.0.28 → 0.0.29

package/build/effect.d.ts

@@ -0,0 +1,7 @@
+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/effect.js

@@ -0,0 +1,3 @@
+import { effect } from './signal';
+import context from './context';
+export default (...args) => context.node({}, effect(...args));

package/build/index.d.ts

@@ -1,3 +1,7 @@
-export * from './api';
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
 export * as core from './signal';
+export { root } from './signal';
+export { default as reactive } from './reactive';
 export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/index.js

@@ -1,3 +1,7 @@
-export * from './api';
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
 export * as core from './signal';
+export { root } from './signal';
+export { default as reactive } from './reactive';
 export { DISPOSE, RESET, UPDATE } from './symbols';

package/build/macro.d.ts

@@ -0,0 +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]) => {
+    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/macro.js

@@ -0,0 +1,8 @@
+import { computed, read } from './signal';
+import context from './context';
+export default (fn, options = {}) => {
+    let node = computed(fn, options);
+    return context.node((...args) => {
+        return read(node)(...args);
+    }, node);
+};

package/build/promise.d.ts

@@ -0,0 +1,8 @@
+import { computed } from './signal';
+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/promise.js

@@ -0,0 +1,38 @@
+import { read, root, signal, write } from './signal';
+import context from './context';
+export default (fn, options = {}) => {
+    let input, nodes = {
+        data: signal(options?.value, options),
+        status: signal(undefined, options)
+    };
+    function host(...args) {
+        input = args;
+        root(() => {
+            fn(...args)
+                .then((value) => {
+                write(nodes.data, value);
+            })
+                .catch(() => {
+                write(nodes.data, undefined);
+            });
+        });
+    }
+    Object.defineProperties(host, {
+        data: {
+            get() {
+                return read(nodes.data);
+            }
+        },
+        input: {
+            get() {
+                return input;
+            }
+        },
+        status: {
+            get() {
+                return read(nodes.status);
+            }
+        }
+    });
+    return context.nodes(host, nodes);
+};

package/build/reactive.d.ts

@@ -0,0 +1,11 @@
+import { computed, signal } from './signal';
+import { Context } from './types';
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: T[K];
+} : T;
+type Never = {
+    [K in keyof Context]?: never;
+};
+type Options = Parameters<typeof computed>[1] | Parameters<typeof signal>[1];
+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/reactive.js

@@ -0,0 +1,27 @@
+import { computed, read, signal, write } from './signal';
+import context from './context';
+export default (data, options = {}) => {
+    let host = {}, nodes = {};
+    for (let key in data) {
+        if (typeof data[key] === 'function') {
+            nodes[key] = computed(data[key], options);
+            Object.defineProperty(host, key, {
+                get() {
+                    return read(nodes[key]);
+                }
+            });
+        }
+        else {
+            nodes[key] = signal(data[key], options);
+            Object.defineProperty(host, key, {
+                get() {
+                    return read(nodes[key]);
+                },
+                set(data) {
+                    write(nodes[key], data);
+                }
+            });
+        }
+    }
+    return context.nodes(host, nodes);
+};

package/package.json

@@ -1,6 +1,5 @@
 {
     "author": "ICJR",
-    "description": "Reactivity",
     "devDependencies": {
         "@esportsplus/rspack": "^0.0.15"
     },
@@ -14,5 +13,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.0.28"
+    "version": "0.0.29"
 }

package/src/effect.ts

@@ -0,0 +1,5 @@
+import { effect } from './signal';
+import context from './context';
+
+
+export default (...args: Parameters<typeof effect>) => context.node({}, effect(...args));

package/src/index.ts

@@ -1,3 +1,7 @@
-export * from './api';
+export { default as effect } from './effect';
+export { default as macro } from './macro';
+export { default as promise } from './promise';
 export * as core from './signal';
+export { root } from './signal';
+export { default as reactive } from './reactive';
 export { DISPOSE, RESET, UPDATE } from './symbols';

package/src/{api/macro.ts → macro.ts}

@@ -1,6 +1,6 @@
-import { computed, read } from '~/signal';
-import { Computed } from '~/types';
-import context from '~/context';
+import { computed, read } from './signal';
+import { Computed } from './types';
+import context from './context';
 
 
 export default <T extends <A, R>(...args: A[]) => R>(fn: Computed<T>['fn'], options: Parameters<typeof computed>[1] = {}) => {

package/src/{api/promise.ts → promise.ts}

@@ -1,5 +1,5 @@
-import { computed, read, root, signal, write } from '~/signal';
-import context from '~/context';
+import { computed, read, root, signal, write } from './signal';
+import context from './context';
 
 
 // TODO:

package/src/{api/store.ts → reactive.ts}

@@ -1,6 +1,6 @@
-import { computed, read, signal, write } from '~/signal';
-import { Context, Signal } from '~/types';
-import context from '~/context';
+import { computed, read, signal, write } from './signal';
+import { Context, Signal } from './types';
+import context from './context';
 
 
 type Infer<T> =

package/src/api/effect.ts

@@ -1,5 +0,0 @@
-import { effect } from '~/signal';
-import context from '~/context';
-
-
-export default (...args: Parameters<typeof effect>) => context.node({}, effect(...args));

package/src/api/index.ts

@@ -1,4 +0,0 @@
-export { default as effect } from './effect';
-export { default as macro } from './macro';
-export { default as promise } from './promise';
-export { default as store } from './store';