@esportsplus/reactivity 0.4.7 → 0.5.0

package/.github/dependabot.yml

@@ -4,11 +4,13 @@
 # https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
 
 version: 2
+
 registries:
   npm-npmjs:
     token: ${{secrets.NPM_TOKEN}}
     type: npm-registry
     url: https://registry.npmjs.org
+
 updates:
   - package-ecosystem: "npm"
     directory: "/"

package/.github/workflows/bump.yml

@@ -1,7 +1,9 @@
 name: bump
+
 on:
   push:
     branches: '**' # only trigger on branches, not on tags
+
 jobs:
   bump:
     uses: esportsplus/workflows/.github/workflows/bump.yml@main

package/.github/workflows/dependabot.yml

@@ -0,0 +1,12 @@
+name: dependabot automerge
+
+on:
+  pull_request:
+    types: [opened, synchronize, labeled]
+  workflow_dispatch:
+
+jobs:
+  automerge:
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/workflows/.github/workflows/dependabot.yml@main

package/.github/workflows/publish.yml

@@ -1,4 +1,5 @@
 name: publish to npm
+
 on:
   release:
     types: [published]
@@ -7,6 +8,7 @@ on:
     workflows: [bump]
     types:
       - completed
+
 jobs:
   publish:
     secrets:

package/build/constants.d.ts

@@ -1,9 +1,7 @@
-declare const CLEAN = 0;
-declare const CHECK = 1;
-declare const DIRTY = 2;
-declare const DISPOSED = 3;
-declare const COMPUTED = 0;
-declare const EFFECT = 1;
-declare const ROOT = 2;
-declare const SIGNAL = 3;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };
+declare const REACTIVE: unique symbol;
+declare const STATE_NONE = 0;
+declare const STATE_CHECK: number;
+declare const STATE_DIRTY: number;
+declare const STATE_RECOMPUTING: number;
+declare const STATE_IN_HEAP: number;
+export { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/constants.js

@@ -1,9 +1,7 @@
-const CLEAN = 0;
-const CHECK = 1;
-const DIRTY = 2;
-const DISPOSED = 3;
-const COMPUTED = 0;
-const EFFECT = 1;
-const ROOT = 2;
-const SIGNAL = 3;
-export { CHECK, CLEAN, COMPUTED, DIRTY, DISPOSED, EFFECT, ROOT, SIGNAL };
+const REACTIVE = Symbol('reactive');
+const STATE_NONE = 0;
+const STATE_CHECK = 1 << 0;
+const STATE_DIRTY = 1 << 1;
+const STATE_RECOMPUTING = 1 << 2;
+const STATE_IN_HEAP = 1 << 3;
+export { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/index.d.ts

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

package/build/index.js

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

package/build/reactive/array.d.ts

@@ -1,5 +1,6 @@
-import { Infer } from '../types.js';
-import { Listener, Options, ReactiveObject, Signal } from '../types.js';
+import { Computed, Infer } from '../types.js';
+import { ReactiveObject } from './object.js';
+import { Disposable } from './disposable.js';
 type API<T> = Infer<T>[] & ReactiveArray<T>;
 type Events<T> = {
     pop: {
@@ -26,30 +27,32 @@ type Events<T> = {
         items: Item<T>[];
     };
 };
-type Item<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : Signal<T>;
-declare class ReactiveArray<T> {
+type Item<T> = Computed<T> | ReactiveArray<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;
+declare class ReactiveArray<T> extends Disposable {
     private data;
-    private options;
+    private listeners;
     private proxy;
-    private signal;
-    constructor(data: Item<T>[], proxy: API<T>, options?: Options);
+    constructor(data: Item<T>[], proxy: API<T>);
     get length(): number;
     set length(n: number);
-    at(i: number): any;
-    dispatch<E extends keyof Events<unknown>>(event: E, data?: Events<T>[E]): void;
+    at(i: number): ReactiveArray<T> | T | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
+    dispatch<D>(event: keyof Events<T>, value?: D): void;
     dispose(): void;
-    indexOf(value: T, fromIndex?: number): number;
-    map<U>(fn: (this: API<T>, value: T, i: number) => U, i?: number, n?: number): U[];
-    on<E extends keyof Events<unknown>>(event: E, listener: Listener<Events<T>[E]>): void;
-    once<E extends keyof Events<unknown>>(event: E, listener: Listener<Events<T>[E]>): 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;
     pop(): Item<T> | undefined;
     push(...input: T[]): number;
     reverse(): this;
     shift(): Item<T> | undefined;
-    sort(fn: (a: T, b: T) => number): this;
+    sort(fn: (a: Value<T>, b: Value<T>) => number): this;
     splice(start: number, deleteCount?: number, ...input: T[]): Item<T>[];
     unshift(...input: T[]): number;
 }
-declare const _default: <T>(input: T[], options?: Options) => API<T>;
-export default _default;
-export type { API as ReactiveArray };
+export default function array<T>(input: T[]): API<T>;
+export { ReactiveArray };

package/build/reactive/array.js

@@ -1,16 +1,15 @@
-import { isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { dispose, signal, Reactive } from '../signal.js';
+import { isArray, isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
+import { computed, dispose, isComputed, read } from '../signal.js';
 import object from './object.js';
-class ReactiveArray {
+import { Disposable } from './disposable.js';
+class ReactiveArray extends Disposable {
     data;
-    options;
+    listeners = null;
     proxy;
-    signal;
-    constructor(data, proxy, options = {}) {
+    constructor(data, proxy) {
+        super();
         this.data = data;
-        this.options = options;
         this.proxy = proxy;
-        this.signal = signal(false);
     }
     get length() {
         return this.data.length;
@@ -23,26 +22,44 @@ class ReactiveArray {
     }
     at(i) {
         let value = this.data[i];
-        if (isInstanceOf(value, Reactive)) {
-            return value.get();
+        if (isComputed(value)) {
+            return read(value);
         }
         return value;
     }
-    dispatch(event, data) {
-        this.signal.dispatch(event, data);
+    dispatch(event, value) {
+        if (this.listeners === null || this.listeners[event] === undefined) {
+            return;
+        }
+        let listeners = this.listeners[event];
+        for (let i = 0, n = listeners.length; i < n; i++) {
+            let listener = listeners[i];
+            if (listener === null) {
+                continue;
+            }
+            try {
+                listener(value);
+                if (listener.once !== undefined) {
+                    listeners[i] = null;
+                }
+            }
+            catch {
+                listeners[i] = null;
+            }
+        }
     }
     dispose() {
-        this.signal.dispose();
-        dispose(this.data);
-    }
-    indexOf(value, fromIndex) {
         let data = this.data;
-        for (let i = fromIndex ?? 0, n = data.length; i < n; i++) {
-            if (data[i].value === value) {
-                return i;
+        for (let i = 0, n = data.length; i < n; i++) {
+            let value = data[i];
+            if (isInstanceOf(value, Disposable)) {
+                value.dispose();
+            }
+            else if (isComputed(value)) {
+                dispose(value);
             }
         }
-        return -1;
+        this.listeners = null;
     }
     map(fn, i, n) {
         let { data, proxy } = this, values = [];
@@ -55,52 +72,79 @@ class ReactiveArray {
         n = Math.min(n, data.length);
         for (; i < n; i++) {
             let item = data[i];
-            values.push(fn.call(proxy, isInstanceOf(item, Reactive) ? item.value : item, i));
+            values.push(fn.call(proxy, (isComputed(item) ? item.value : item), i));
         }
         return values;
     }
     on(event, listener) {
-        this.signal.on(event, listener);
+        if (this.listeners === null) {
+            this.listeners = { [event]: [listener] };
+        }
+        else {
+            let listeners = this.listeners[event];
+            if (listeners === undefined) {
+                this.listeners[event] = [listener];
+            }
+            else if (listeners.indexOf(listener) === -1) {
+                let i = listeners.indexOf(null);
+                if (i === -1) {
+                    listeners.push(listener);
+                }
+                else {
+                    listeners[i] = listener;
+                }
+            }
+        }
     }
     once(event, listener) {
-        this.signal.once(event, listener);
+        listener.once = true;
+        this.on(event, listener);
     }
     pop() {
         let item = this.data.pop();
         if (item !== undefined) {
-            dispose(item);
-            this.signal.dispatch('pop', { item });
+            if (isComputed(item)) {
+                dispose(item);
+            }
+            this.dispatch('pop', { item });
         }
         return item;
     }
     push(...input) {
-        let items = factory(input, this.options), n = this.data.push(...items);
-        this.signal.dispatch('push', { items });
+        let items = factory(input), n = this.data.push(...items);
+        this.dispatch('push', { items });
         return n;
     }
     reverse() {
         this.data.reverse();
-        this.signal.dispatch('reverse');
+        this.dispatch('reverse');
         return this;
     }
     shift() {
         let item = this.data.shift();
         if (item !== undefined) {
-            dispose(item);
-            this.signal.dispatch('shift', { item });
+            if (isComputed(item)) {
+                dispose(item);
+            }
+            this.dispatch('shift', { item });
         }
         return item;
     }
     sort(fn) {
-        this.data.sort((a, b) => fn(isInstanceOf(a, Reactive) ? a.value : a, isInstanceOf(b, Reactive) ? b.value : b));
-        this.signal.dispatch('sort');
+        this.data.sort((a, b) => fn((isComputed(a) ? a.value : a), (isComputed(b) ? b.value : b)));
+        this.dispatch('sort');
         return this;
     }
     splice(start, deleteCount = this.data.length, ...input) {
-        let items = factory(input, this.options), removed = this.data.splice(start, deleteCount, ...items);
+        let items = factory(input), removed = this.data.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
-            dispose(removed);
-            this.signal.dispatch('splice', {
+            for (let i = 0, n = removed.length; i < n; i++) {
+                let item = removed[i];
+                if (isComputed(item)) {
+                    dispose(item);
+                }
+            }
+            this.dispatch('splice', {
                 deleteCount,
                 items,
                 start
@@ -109,31 +153,37 @@ class ReactiveArray {
         return removed;
     }
     unshift(...input) {
-        let items = factory(input, this.options), length = this.data.unshift(...items);
-        this.signal.dispatch('unshift', { items });
+        let items = factory(input), length = this.data.unshift(...items);
+        this.dispatch('unshift', { items });
         return length;
     }
 }
-function factory(input, options = {}) {
+function factory(input) {
     let items = [];
     for (let i = 0, n = input.length; i < n; i++) {
         let value = input[i];
-        if (isObject(value)) {
-            items[i] = object(value, options);
+        if (isArray(value)) {
+            items[i] = array(value);
+        }
+        else if (isFunction(value)) {
+            items[i] = computed(value);
+        }
+        else if (isObject(value)) {
+            items[i] = object(value);
         }
         else {
-            items[i] = signal(value);
+            items[i] = value;
         }
     }
     return items;
 }
-export default (input, options = {}) => {
-    let wrapped = factory(input, options), proxy = new Proxy({}, {
+export default function array(input) {
+    let proxy = new Proxy({}, {
         get(_, key) {
             if (isNumber(key)) {
                 let value = wrapped[key];
-                if (isInstanceOf(value, Reactive)) {
-                    return value.get();
+                if (isComputed(value)) {
+                    return read(value);
                 }
                 return value;
             }
@@ -145,11 +195,8 @@ export default (input, options = {}) => {
         set(_, key, value) {
             if (isNumber(key)) {
                 let host = wrapped[key];
-                if (host === undefined) {
-                    wrapped[key] = factory([value], options)[0];
-                }
-                else if (isInstanceOf(host, Reactive)) {
-                    host.set(value);
+                if (host === undefined || !isComputed(host)) {
+                    wrapped[key] = factory([value])[0];
                 }
                 else {
                     return false;
@@ -161,7 +208,9 @@ export default (input, options = {}) => {
             }
             return false;
         }
-    });
+    }), wrapped = factory(input);
     let a = new ReactiveArray(wrapped, proxy);
     return proxy;
-};
+}
+;
+export { ReactiveArray };

package/build/reactive/disposable.d.ts

@@ -0,0 +1,4 @@
+declare class Disposable {
+    dispose(): void;
+}
+export { Disposable };

package/build/reactive/disposable.js

@@ -0,0 +1,6 @@
+class Disposable {
+    dispose() {
+        throw new Error('@esportsplus/reactivity: Disposable should not be instantiated directly.');
+    }
+}
+export { Disposable };

package/build/reactive/index.d.ts

@@ -1,4 +1,4 @@
-import { Options, Reactive } from '../types.js';
+import { Reactive } from '../types.js';
 type Guard<T> = T extends {
     dispose: any;
 } | {
@@ -6,5 +6,5 @@ type Guard<T> = T extends {
 } ? {
     never: '[ dispose, signals ] are reserved keys';
 } : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
-declare const _default: <T>(data: Guard<T>, options?: Options) => Reactive<T>;
+declare const _default: <T>(data: Guard<T>) => Reactive<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,13 +1,13 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { default as array } from './array.js';
 import { default as object } from './object.js';
-export default (data, options = {}) => {
+export default (data) => {
     let value;
     if (isArray(data)) {
-        value = array(data, options);
+        value = array(data);
     }
     else if (isObject(data)) {
-        value = object(data, options);
+        value = object(data);
     }
     else {
         throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);

package/build/reactive/object.d.ts

@@ -1,8 +1,13 @@
-import { Infer, Options, Prettify } from '../types.js';
-type API<T> = Prettify<{
+import { Prettify } from '@esportsplus/utilities';
+import { Infer } from '../types.js';
+import { Disposable } from './disposable.js';
+type API<T extends Record<PropertyKey, unknown>> = Prettify<{
     [K in keyof T]: Infer<T[K]>;
-} & {
-    dispose: VoidFunction;
-}>;
-export default function object<T extends Record<PropertyKey, unknown>>(input: T, options?: Options): API<T>;
-export type { API as ReactiveObject };
+}> & ReactiveObject<T>;
+declare class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable {
+    private signals;
+    constructor(data: T);
+    dispose(): void;
+}
+export default function object<T extends Record<PropertyKey, unknown>>(input: T): API<T>;
+export { ReactiveObject };

package/build/reactive/object.js

@@ -1,61 +1,84 @@
-import { defineProperty, isArray, isFunction, isObject } from '@esportsplus/utilities';
-import { computed, signal } from '../signal.js';
-import { default as array } from './array.js';
-class ReactiveObject {
+import { defineProperty, isArray, isFunction, isInstanceOf, isObject } from '@esportsplus/utilities';
+import array from './array.js';
+import { computed, dispose, isComputed, read, signal } from '../signal.js';
+import { Disposable } from './disposable.js';
+let { set } = signal;
+class ReactiveObject extends Disposable {
     signals = {};
-    constructor(data, options = {}) {
-        let signals = this.signals;
+    constructor(data) {
+        super();
+        let signals = this.signals, triggers = {};
         for (let key in data) {
             let value = data[key];
             if (isArray(value)) {
-                let s = signals[key] = array(value, options);
+                let s = signals[key] = array(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
+                        read(t);
                         return s;
+                    },
+                    set(v) {
+                        set(t, !!t.value);
+                        s = signals[key] = array(v);
                     }
                 });
             }
             else if (isFunction(value)) {
-                let s = signals[key] = computed(value, options);
+                let s = signals[key] = computed(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        return read(s);
                     }
                 });
             }
             else if (isObject(value)) {
-                let s = signals[key] = new ReactiveObject(value, options);
+                let s = signals[key] = new ReactiveObject(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
+                        read(t);
                         return s;
+                    },
+                    set(v) {
+                        set(t, !!t.value);
+                        s = signals[key] = new ReactiveObject(v);
                     }
                 });
             }
             else {
-                let s = signals[key] = signal(value, options);
+                let s = signals[key] = signal(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        if (s === undefined) {
+                            s = signals[key] = signal(value);
+                        }
+                        return read(s);
                     },
-                    set(value) {
-                        s.set(value);
+                    set(v) {
+                        set(s, v);
                     }
                 });
             }
         }
     }
     dispose() {
-        let signals = this.signals;
-        for (let key in signals) {
-            signals[key].dispose();
+        for (let key in this.signals) {
+            let value = this.signals[key];
+            if (isInstanceOf(value, Disposable)) {
+                value.dispose();
+            }
+            else if (isComputed(value)) {
+                dispose(value);
+            }
         }
+        this.signals = {};
     }
 }
-export default function object(input, options = {}) {
-    return new ReactiveObject(input, options);
+export default function object(input) {
+    return new ReactiveObject(input);
 }
 ;
+export { ReactiveObject };

package/build/signal.d.ts

@@ -1,31 +1,15 @@
-import { Computed, Changed, Effect, Event, Function, Listener, NeverAsync, Options, Root, Scheduler, Signal, State, Type } from './types.js';
-declare class Reactive<T> {
-    changed: Changed | null;
-    fn: Computed<T>['fn'] | Effect['fn'] | null;
-    listeners: Record<Event, (Listener<any> | null)[]> | null;
-    observers: Reactive<any>[] | null;
-    root: Root | null;
-    scheduler: Scheduler | null;
-    sources: Reactive<any>[] | null;
-    state: State;
-    task: Function | null;
-    tracking: boolean | null;
-    type: Type;
-    value: T;
-    constructor(state: State, type: Type, value: T);
-    dispatch<D>(event: Event, data?: D): void;
-    dispose(): void;
-    get(): T;
-    on<T>(event: Event, listener: Listener<T>): void;
-    once<T>(event: Event, listener: Listener<T>): void;
-    set(value: T): T;
-}
-declare const computed: <T>(fn: Computed<T>["fn"], options?: Options) => Computed<T>;
-declare const dispose: <T extends {
-    dispose: VoidFunction;
-}>(dispose?: T[] | T | null) => T | T[] | null | undefined;
-declare const effect: (fn: Effect["fn"]) => Effect;
-declare const root: <T>(fn: NeverAsync<(instance: Root) => T>, scheduler?: Scheduler) => T;
-declare const signal: <T>(value: T, options?: Options) => Signal<T>;
-export { computed, dispose, effect, root, signal };
-export { Reactive };
+import { Computed, Signal } from './types.js';
+declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
+declare const dispose: (el: Computed<unknown>) => void;
+declare const isComputed: (value: unknown) => value is Computed<unknown>;
+declare const isReactive: (value: unknown) => value is Computed<unknown> | Signal<unknown>;
+declare const isSignal: (value: unknown) => value is Signal<unknown>;
+declare const oncleanup: (fn: VoidFunction) => typeof fn;
+declare const read: <T>(el: Signal<T> | Computed<T>) => T;
+declare const root: <T>(fn: () => T) => T;
+declare const signal: {
+    <T>(value: T): Signal<T>;
+    set(el: Signal<unknown>, v: unknown): void;
+};
+declare const stabilize: () => void;
+export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };