@esportsplus/reactivity 0.6.1 → 0.7.0

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive/index.js';
 export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
+export { default as scheduler } from './scheduler.js';
 export * from './types.js';

package/build/index.js

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive/index.js';
 export { computed, dispose, oncleanup, root, signal, stabilize } from './signal.js';
+export { default as scheduler } from './scheduler.js';
 export * from './types.js';

package/build/reactive/array.d.ts

@@ -27,12 +27,12 @@ type Events<T> = {
         items: Item<T>[];
     };
 };
-type Item<T> = Computed<T> | ReactiveArray<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
+type Item<T> = Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
 type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
-type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? ReactiveArray<U> : T;
+type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? API<U> : T;
 declare class ReactiveArray<T> extends Disposable {
     private data;
     private listeners;
@@ -40,12 +40,12 @@ declare class ReactiveArray<T> extends Disposable {
     constructor(data: Item<T>[], proxy: API<T>);
     get length(): number;
     set length(n: number);
-    at(i: number): ReactiveArray<T> | T | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
-    dispatch<D>(event: keyof Events<T>, value?: D): void;
+    at(i: number): T | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
+    dispatch<K extends keyof Events<T>, V>(event: K, value?: V): void;
     dispose(): void;
     map<R>(fn: (this: API<T>, value: Value<T>, i: number) => R, i?: number, n?: number): R[];
-    on<T>(event: keyof Events<T>, listener: Listener<T>): void;
-    once<T>(event: keyof Events<T>, listener: Listener<T>): void;
+    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
+    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
     pop(): Item<T> | undefined;
     push(...input: T[]): number;
     reverse(): this;
@@ -55,4 +55,4 @@ declare class ReactiveArray<T> extends Disposable {
     unshift(...input: T[]): number;
 }
 export default function array<T>(input: T[]): API<T>;
-export { ReactiveArray };
+export type { API as ReactiveArray };

package/build/reactive/array.js

@@ -213,4 +213,3 @@ export default function array(input) {
     return proxy;
 }
 ;
-export { ReactiveArray };

package/build/reactive/object.d.ts

@@ -10,4 +10,4 @@ declare class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Dis
     dispose(): void;
 }
 export default function object<T extends Record<PropertyKey, unknown>>(input: T): API<T>;
-export { ReactiveObject };
+export type { API as ReactiveObject };

package/build/reactive/object.js

@@ -91,4 +91,3 @@ export default function object(input) {
     return new ReactiveObject(input);
 }
 ;
-export { ReactiveObject };

package/build/scheduler.d.ts

@@ -0,0 +1,4 @@
+declare const scheduler: (schedule: (task: VoidFunction) => void) => void;
+declare const state: import("./types.js").Signal<number>;
+export default scheduler;
+export { state };

package/build/scheduler.js

@@ -0,0 +1,17 @@
+import { STATE_DIRTY, STATE_NONE } from './constants.js';
+import { computed, dispose, read, signal, stabilize } from './signal.js';
+let c = null;
+const scheduler = (schedule) => {
+    if (c) {
+        dispose(c);
+    }
+    c = computed(() => {
+        if (read(state) !== STATE_DIRTY) {
+            return;
+        }
+        schedule(stabilize);
+    });
+};
+const state = signal(STATE_NONE);
+export default scheduler;
+export { state };

package/build/signal.js

@@ -1,5 +1,6 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
+import { state } from './scheduler.js';
 let dirtyHeap = new Array(2000), maxDirty = 0, markedHeap = false, minDirty = 0, observer = null;
 function cleanup(node) {
     if (!node.cleanup) {
@@ -159,6 +160,9 @@ function recompute(el, del) {
             insertIntoHeap(o);
         }
     }
+    if (state.value === STATE_NONE) {
+        root(() => signal.set(state, STATE_DIRTY));
+    }
 }
 function unlink(link) {
     let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
@@ -305,14 +309,17 @@ signal.set = (el, v) => {
     }
 };
 const stabilize = () => {
-    for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
-        let el = dirtyHeap[minDirty];
-        dirtyHeap[minDirty] = undefined;
-        while (el !== undefined) {
-            let next = el.nextHeap;
-            recompute(el, false);
-            el = next;
+    root(() => {
+        for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
+            let el = dirtyHeap[minDirty];
+            dirtyHeap[minDirty] = undefined;
+            while (el !== undefined) {
+                let next = el.nextHeap;
+                recompute(el, false);
+                el = next;
+            }
         }
-    }
+        signal.set(state, STATE_NONE);
+    });
 };
 export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };

package/package.json

@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/constants.ts

@@ -11,4 +11,11 @@ const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
 
 
-export { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+export {
+    REACTIVE,
+    STATE_CHECK,
+    STATE_DIRTY,
+    STATE_IN_HEAP,
+    STATE_NONE,
+    STATE_RECOMPUTING
+};

package/src/index.ts

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive';
 export { computed, dispose, oncleanup, root, signal, stabilize } from './signal';
+export { default as scheduler } from './scheduler';
 export * from './types';

package/src/reactive/array.ts

@@ -33,7 +33,7 @@ type Events<T> = {
     };
 };
 
-type Item<T> = Computed<T> | ReactiveArray<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
+type Item<T> = Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
 
 type Listener<V> = {
     once?: boolean;
@@ -44,7 +44,7 @@ type Value<T> =
     T extends Record<PropertyKey, unknown>
         ? ReactiveObject<T>
         : T extends Array<infer U>
-            ? ReactiveArray<U>
+            ? API<U>
             : T;
 
 
@@ -85,7 +85,7 @@ class ReactiveArray<T> extends Disposable {
         return value;
     }
 
-    dispatch<D>(event: keyof Events<T>, value?: D) {
+    dispatch<K extends keyof Events<T>, V>(event: K, value?: V) {
         if (this.listeners === null || this.listeners[event] === undefined) {
             return;
         }
@@ -162,7 +162,7 @@ class ReactiveArray<T> extends Disposable {
         return values;
     }
 
-    on<T>(event: keyof Events<T>, listener: Listener<T>) {
+    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
         if (this.listeners === null) {
             this.listeners = { [event]: [listener] };
         }
@@ -185,7 +185,7 @@ class ReactiveArray<T> extends Disposable {
         }
     }
 
-    once<T>(event: keyof Events<T>, listener: Listener<T>) {
+    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
         listener.once = true;
         this.on(event, listener);
     }
@@ -291,7 +291,7 @@ function factory<T>(input: T[]) {
             items[i] = computed(value as Computed<T>['fn']);
         }
         else if (isObject(value)) {
-            items[i] = object(value);
+            items[i] = object(value) as Item<T>;
         }
         else {
             items[i] = value;
@@ -346,4 +346,4 @@ export default function array<T>(input: T[]) {
 
     return proxy;
 };
-export { ReactiveArray };
+export type { API as ReactiveArray };

package/src/reactive/object.ts

@@ -121,4 +121,4 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
 export default function object<T extends Record<PropertyKey, unknown>>(input: T) {
     return new ReactiveObject(input) as API<T>;
 };
-export { ReactiveObject };
+export type { API as ReactiveObject };

package/src/scheduler.ts

@@ -0,0 +1,27 @@
+import { STATE_DIRTY, STATE_NONE } from './constants';
+import { computed, dispose, read, signal, stabilize } from './signal';
+import { Computed } from './types';
+
+
+let c: Computed<void> | null = null;
+
+
+const scheduler = (schedule: (task: VoidFunction) => void) => {
+    if (c) {
+        dispose(c);
+    }
+
+    c = computed(() => {
+        if (read(state) !== STATE_DIRTY) {
+            return;
+        }
+
+        schedule(stabilize);
+    });
+};
+
+const state = signal(STATE_NONE);
+
+
+export default scheduler;
+export { state };

package/src/signal.ts

@@ -1,6 +1,7 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
 import { Computed, Link, Signal, } from './types';
+import { state } from './scheduler';
 
 
 let dirtyHeap: (Computed<unknown> | undefined)[] = new Array(2000),
@@ -226,6 +227,10 @@ function recompute<T>(el: Computed<T>, del: boolean) {
             insertIntoHeap(o);
         }
     }
+
+    if (state.value === STATE_NONE) {
+        root(() => signal.set(state, STATE_DIRTY));
+    }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
@@ -421,19 +426,23 @@ signal.set = <T>(el: Signal<T>, v: T) => {
 };
 
 const stabilize = () => {
-    for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
-        let el = dirtyHeap[minDirty];
+    root(() => {
+        for (minDirty = 0; minDirty <= maxDirty; minDirty++) {
+            let el = dirtyHeap[minDirty];
 
-        dirtyHeap[minDirty] = undefined;
+            dirtyHeap[minDirty] = undefined;
 
-        while (el !== undefined) {
-            let next = el.nextHeap;
+            while (el !== undefined) {
+                let next = el.nextHeap;
 
-            recompute(el, false);
+                recompute(el, false);
 
-            el = next;
+                el = next;
+            }
         }
-    }
+
+        signal.set(state, STATE_NONE);
+    });
 };