@esportsplus/reactivity 0.1.2 → 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/reactive/object.d.ts

@@ -1,7 +1,8 @@
 import { Computed, Object, Options, Signal } from '../types';
 import { ReactiveArray, ReactiveObjectArray } from './array';
+type Node = Computed<unknown> | ReactiveArray<unknown> | ReactiveObjectArray<Object> | Signal<unknown>;
 declare class ReactiveObject<T extends Object> {
-    nodes: Record<PropertyKey, Computed<unknown> | ReactiveObjectArray<Object> | ReactiveArray<unknown> | Signal<unknown>>;
+    nodes: Record<PropertyKey, Node>;
     constructor(data: T, options?: Options);
     dispose(): void;
     reset(): void;

package/build/reactive/object.js

@@ -10,6 +10,7 @@ class ReactiveObject {
             if (typeof input === 'function') {
                 let node = nodes[key] = computed(input, options);
                 defineProperty(this, key, {
+                    enumerable: true,
                     get() {
                         return read(node);
                     }
@@ -17,13 +18,14 @@ class ReactiveObject {
             }
             else if (isArray(input)) {
                 let node, test = input[0];
-                if (typeof test === 'object' && test !== null && test.constructor.name === 'Object') {
+                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
                     node = nodes[key] = new ReactiveObjectArray(input, options);
                 }
                 else {
                     node = nodes[key] = new ReactiveArray(input);
                 }
                 defineProperty(this, key, {
+                    enumerable: true,
                     get() {
                         node.track();
                         return node;
@@ -33,6 +35,7 @@ class ReactiveObject {
             else {
                 let node = nodes[key] = signal(input, options);
                 defineProperty(this, key, {
+                    enumerable: true,
                     get() {
                         return read(node);
                     },

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

@@ -216,22 +216,27 @@ const dispose = (dispose) => {
     return dispose;
 };
 const effect = (fn, options = {}) => {
-    if (!scope) {
+    let node = new Signal(undefined, DIRTY, EFFECT, options);
+    if (scope !== null) {
+        node.root = scope;
+    }
+    else if (observer !== null && observer.type === EFFECT) {
+        node.root = observer.root;
+    }
+    else {
         throw new Error('Reactivity: `effects` cannot be created without a reactive root');
     }
-    let node = new Signal(undefined, DIRTY, EFFECT, options);
     node.fn = fn;
-    node.root = scope;
     node.task = () => read(node);
-    node.root.scheduler(node.task);
+    read(node);
     return node;
 };
 const read = (node) => {
     if (node.state === DISPOSED) {
         return node.value;
     }
-    if (observer) {
-        if (!observers) {
+    if (observer !== null) {
+        if (observers === null) {
             if (observer.sources !== null && observer.sources[index] == node) {
                 index++;
             }
@@ -243,7 +248,7 @@ const read = (node) => {
             observers.push(node);
         }
     }
-    if (node.fn) {
+    if (node.fn !== null) {
         sync(node);
     }
     return node.value;
@@ -264,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.2"
+    "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

@@ -4,8 +4,11 @@ import { defineProperty, isArray } from '~/utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 
 
+type Node = Computed<unknown> | ReactiveArray<unknown> | ReactiveObjectArray<Object> | Signal<unknown>;
+
+
 class ReactiveObject<T extends Object> {
-    nodes: Record<PropertyKey, Computed<unknown> | ReactiveObjectArray<Object> | ReactiveArray<unknown> | Signal<unknown>> = {};
+    nodes: Record<PropertyKey, Node> = {};
 
 
     constructor(data: T, options: Options = {}) {
@@ -18,6 +21,7 @@ class ReactiveObject<T extends Object> {
                 let node = nodes[key] = computed(input as Computed<unknown>['fn'], options);
 
                 defineProperty(this, key, {
+                    enumerable: true,
                     get() {
                         return read(node);
                     }
@@ -27,7 +31,7 @@ class ReactiveObject<T extends Object> {
                 let node: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
                     test = input[0];
 
-                if (typeof test === 'object' && test !== null && test.constructor.name === 'Object') {
+                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
                     node = nodes[key] = new ReactiveObjectArray(input, options);
                 }
                 else {
@@ -35,6 +39,7 @@ class ReactiveObject<T extends Object> {
                 }
 
                 defineProperty(this, key, {
+                    enumerable: true,
                     get() {
                         node.track();
 
@@ -43,9 +48,10 @@ 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,
                     get() {
                         return read(node);
                     },

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';
 
 
@@ -286,17 +286,22 @@ const dispose = <T extends { dispose: () => void }>(dispose?: T[] | T) => {
 };
 
 const effect = <T>(fn: Effect<T>['fn'], options: Omit<Options, 'value'> = {}) => {
-    if (!scope) {
+    let node = new Signal(undefined as any, DIRTY, EFFECT, options);
+
+    if (scope !== null) {
+        node.root = scope;
+    }
+    else if (observer !== null && observer.type === EFFECT) {
+        node.root = observer.root;
+    }
+    else {
         throw new Error('Reactivity: `effects` cannot be created without a reactive root');
     }
 
-    let node = new Signal(undefined as any, DIRTY, EFFECT, options);
-
     node.fn = fn;
-    node.root = scope;
     node.task = () => read(node);
 
-    node.root.scheduler(node.task);
+    read(node);
 
     return node as Effect<void>;
 };
@@ -306,8 +311,8 @@ const read = <T>(node: Signal<T>): typeof node['value'] => {
         return node.value;
     }
 
-    if (observer) {
-        if (!observers) {
+    if (observer !== null) {
+        if (observers === null) {
             if (observer.sources !== null && observer.sources[index] == node) {
                 index++;
             }
@@ -320,7 +325,7 @@ const read = <T>(node: Signal<T>): typeof node['value'] => {
         }
     }
 
-    if (node.fn) {
+    if (node.fn !== null) {
         sync(node);
     }
 
@@ -342,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 };