@esportsplus/reactivity 0.16.6 → 0.17.0

package/build/reactive/array.d.ts

@@ -1,12 +1,4 @@
-import { Prettify } from '@esportsplus/utilities';
-type ReactiveArray<T> = Prettify<T[] & {
-    clear: () => void;
-    dispose: () => void;
-    dispatch: <K extends keyof Events<T>, V>(event: K, value?: V) => void;
-    map: <R>(fn: (this: ReactiveArray<T>, value: T, i: number) => R) => R[];
-    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;
-}>;
+import { REACTIVE_ARRAY } from '../constants.js';
 type Events<T> = {
     clear: undefined;
     pop: {
@@ -37,150 +29,22 @@ type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
-declare const _default: <T>(data: T[]) => {
-    [x: number]: T;
-    length: number;
-    toString: () => string;
-    toLocaleString: {
-        (): string;
-        (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
-    };
-    pop: () => T | undefined;
-    push: (...items: T[]) => number;
-    concat: {
-        (...items: ConcatArray<T>[]): T[];
-        (...items: (T | ConcatArray<T>)[]): T[];
-    };
-    join: (separator?: string) => string;
-    reverse: () => T[];
-    shift: () => T | undefined;
-    slice: (start?: number, end?: number) => T[];
-    sort: (compareFn?: ((a: T, b: T) => number) | undefined) => T[] & {
-        clear: () => void;
-        dispose: () => void;
-        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
-        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    };
-    splice: {
-        (start: number, deleteCount?: number): T[];
-        (start: number, deleteCount: number, ...items: T[]): T[];
-    };
-    unshift: (...items: T[]) => number;
-    indexOf: (searchElement: T, fromIndex?: number) => number;
-    lastIndexOf: (searchElement: T, fromIndex?: number) => number;
-    every: {
-        <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
-        (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
-    };
-    some: (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any) => boolean;
-    forEach: (callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any) => void;
-    map: (<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]) & (<R>(fn: (this: any, value: T, i: number) => R) => R[]);
-    filter: {
-        <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
-        (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
-    };
-    reduce: {
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-        <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    };
-    reduceRight: {
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
-        (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-        <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    };
-    find: {
-        <S extends T>(predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
-        (predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
-    };
-    findIndex: (predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any) => number;
-    fill: (value: T, start?: number, end?: number) => T[] & {
-        clear: () => void;
-        dispose: () => void;
-        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
-        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    };
-    copyWithin: (target: number, start: number, end?: number) => T[] & {
-        clear: () => void;
-        dispose: () => void;
-        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
-        map: <R>(fn: (this: any, value: T, i: number) => R) => R[];
-        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    };
-    entries: () => ArrayIterator<[number, T]>;
-    keys: () => ArrayIterator<number>;
-    values: () => ArrayIterator<T>;
-    includes: (searchElement: T, fromIndex?: number) => boolean;
-    flatMap: <U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | readonly U[], thisArg?: This | undefined) => U[];
-    flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
-    at: (index: number) => T | undefined;
-    findLast: {
-        <S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S | undefined;
-        (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined;
-    };
-    findLastIndex: (predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any) => number;
-    toReversed: () => T[];
-    toSorted: (compareFn?: ((a: T, b: T) => number) | undefined) => T[];
-    toSpliced: {
-        (start: number, deleteCount: number, ...items: T[]): T[];
-        (start: number, deleteCount?: number): T[];
-    };
-    with: (index: number, value: T) => T[];
-    [Symbol.iterator]: () => ArrayIterator<T>;
-    readonly [Symbol.unscopables]: {
-        [x: number]: boolean | undefined;
-        length?: boolean | undefined;
-        toString?: boolean | undefined;
-        toLocaleString?: boolean | undefined;
-        pop?: boolean | undefined;
-        push?: boolean | undefined;
-        concat?: boolean | undefined;
-        join?: boolean | undefined;
-        reverse?: boolean | undefined;
-        shift?: boolean | undefined;
-        slice?: boolean | undefined;
-        sort?: boolean | undefined;
-        splice?: boolean | undefined;
-        unshift?: boolean | undefined;
-        indexOf?: boolean | undefined;
-        lastIndexOf?: boolean | undefined;
-        every?: boolean | undefined;
-        some?: boolean | undefined;
-        forEach?: boolean | undefined;
-        map?: boolean | undefined;
-        filter?: boolean | undefined;
-        reduce?: boolean | undefined;
-        reduceRight?: boolean | undefined;
-        find?: boolean | undefined;
-        findIndex?: boolean | undefined;
-        fill?: boolean | undefined;
-        copyWithin?: boolean | undefined;
-        entries?: boolean | undefined;
-        keys?: boolean | undefined;
-        values?: boolean | undefined;
-        includes?: boolean | undefined;
-        flatMap?: boolean | undefined;
-        flat?: boolean | undefined;
-        at?: boolean | undefined;
-        findLast?: boolean | undefined;
-        findLastIndex?: boolean | undefined;
-        toReversed?: boolean | undefined;
-        toSorted?: boolean | undefined;
-        toSpliced?: boolean | undefined;
-        with?: boolean | undefined;
-        [Symbol.iterator]?: boolean | undefined;
-        readonly [Symbol.unscopables]?: boolean | undefined;
-    };
-    clear: () => void;
-    dispose: () => void;
-    dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
-    on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T>[K]>) => void;
-};
-export default _default;
-export type { ReactiveArray };
+type Listeners = Record<string, (Listener<any> | null)[]>;
+declare class ReactiveArray<T> extends Array<T> {
+    [REACTIVE_ARRAY]: boolean;
+    listeners: Listeners;
+    constructor(...items: T[]);
+    clear(): void;
+    dispatch<K extends keyof Events<T>, V>(event: K, value?: V): void;
+    dispose(): 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(): T | undefined;
+    push(...items: T[]): number;
+    reverse(): this;
+    shift(): T | undefined;
+    sort(fn: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+}
+export { ReactiveArray };

package/build/reactive/array.js

@@ -1,194 +1,119 @@
-import { isNumber } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '../constants.js';
 import { isReactiveObject } from './object.js';
-function cleanup(item) {
-    if (isReactiveObject(item)) {
-        item.dispose();
+class ReactiveArray extends Array {
+    [REACTIVE_ARRAY] = true;
+    listeners = {};
+    constructor(...items) {
+        super(...items);
     }
-}
-function clear(data, listeners) {
-    dispose(data);
-    dispatch(listeners, 'clear');
-}
-function dispatch(listeners, event, value) {
-    if (listeners === null || listeners[event] === undefined) {
-        return;
+    clear() {
+        this.dispose();
+        this.dispatch('clear');
     }
-    let bucket = listeners[event];
-    for (let i = 0, n = bucket.length; i < n; i++) {
-        let listener = bucket[i];
-        if (listener === null) {
-            continue;
+    dispatch(event, value) {
+        let listeners = this.listeners[event];
+        if (!listeners) {
+            return;
         }
-        try {
-            listener(value);
-            if (listener.once !== undefined) {
-                bucket[i] = null;
+        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;
             }
-        }
-        catch {
-            bucket[i] = null;
         }
     }
-}
-function dispose(data) {
-    let item;
-    while (item = data.pop()) {
-        cleanup(item);
+    dispose() {
+        let item;
+        while (item = super.pop()) {
+            if (isReactiveObject(item)) {
+                item.dispose();
+            }
+        }
     }
-}
-function map(data, proxy, fn) {
-    let n = data.length, values = new Array(n);
-    for (let i = 0; i < n; i++) {
-        values[i] = fn.call(proxy, data[i], i);
+    on(event, listener) {
+        let listeners = this.listeners[event];
+        if (listeners === undefined) {
+            this.listeners[event] = [listener];
+        }
+        else {
+            let hole = listeners.length;
+            for (let i = 0, n = hole; i < n; i++) {
+                let l = listeners[i];
+                if (l === listener) {
+                    return;
+                }
+                else if (l === null && hole === n) {
+                    hole = i;
+                }
+            }
+            listeners[hole] = listener;
+        }
     }
-    return values;
-}
-function on(listeners, event, listener) {
-    let bucket = listeners[event];
-    if (bucket === undefined) {
-        listeners[event] = [listener];
+    once(event, listener) {
+        listener.once = true;
+        this.on(event, listener);
     }
-    else {
-        let hole = bucket.length;
-        for (let i = 0, n = hole; i < n; i++) {
-            let l = bucket[i];
-            if (l === listener) {
-                return;
-            }
-            else if (l === null && hole === n) {
-                hole = i;
+    pop() {
+        let item = super.pop();
+        if (item !== undefined) {
+            if (isReactiveObject(item)) {
+                item.dispose();
             }
+            this.dispatch('pop', { item });
         }
-        bucket[hole] = listener;
+        return item;
     }
-}
-function once(listeners, event, listener) {
-    listener.once = true;
-    on(listeners, event, listener);
-}
-function pop(data, listeners) {
-    let item = data.pop();
-    if (item !== undefined) {
-        cleanup(item);
-        dispatch(listeners, 'pop', { item });
+    push(...items) {
+        let length = super.push(...items);
+        this.dispatch('push', { items });
+        return length;
     }
-    return item;
-}
-function push(data, listeners, items) {
-    let n = data.push(...items);
-    dispatch(listeners, 'push', { items });
-    return n;
-}
-function reverse(data, listeners) {
-    data.reverse();
-    dispatch(listeners, 'reverse');
-}
-function shift(data, listeners) {
-    let item = data.shift();
-    if (item !== undefined) {
-        cleanup(item);
-        dispatch(listeners, 'shift', { item });
+    reverse() {
+        super.reverse();
+        this.dispatch('reverse');
+        return this;
     }
-    return item;
-}
-function sort(data, listeners, fn) {
-    data.sort((a, b) => fn(a, b));
-    dispatch(listeners, 'sort');
-}
-function splice(data, listeners, start, deleteCount = data.length, items = []) {
-    let removed = data.splice(start, deleteCount, ...items);
-    if (items.length > 0 || removed.length > 0) {
-        for (let i = 0, n = removed.length; i < n; i++) {
-            cleanup(removed[i]);
+    shift() {
+        let item = super.shift();
+        if (item !== undefined) {
+            if (isReactiveObject(item)) {
+                item.dispose();
+            }
+            this.dispatch('shift', { item });
         }
-        dispatch(listeners, 'splice', {
-            deleteCount,
-            items,
-            start
-        });
+        return item;
     }
-    return removed;
-}
-function unshift(data, listeners, items) {
-    let length = data.unshift(...items);
-    dispatch(listeners, 'unshift', { items });
-    return length;
-}
-export default (data) => {
-    let listeners = {}, proxy = new Proxy({}, {
-        get(_, key) {
-            if (isNumber(key)) {
-                return data[key];
-            }
-            else if (key in wrapper) {
-                return wrapper[key];
-            }
-            else if (key === 'length') {
-                return data.length;
-            }
-            return data[key];
-        },
-        set(_, key, value) {
-            if (isNumber(key)) {
-                splice(data, listeners, key, 1, value);
-            }
-            else if (key === 'length') {
-                if (value >= data.length) {
-                }
-                else if (value === 0) {
-                    clear(data, listeners);
-                }
-                else {
-                    splice(data, listeners, value);
+    sort(fn) {
+        super.sort(fn);
+        this.dispatch('sort');
+        return this;
+    }
+    splice(start, deleteCount = this.length, ...items) {
+        let removed = super.splice(start, deleteCount, ...items);
+        if (items.length > 0 || removed.length > 0) {
+            for (let i = 0, n = removed.length; i < n; i++) {
+                let item = removed[i];
+                if (isReactiveObject(item)) {
+                    item.dispose();
                 }
             }
-            else {
-                return false;
-            }
-            return true;
+            this.dispatch('splice', { deleteCount, items, start });
         }
-    }), wrapper = {
-        [REACTIVE_ARRAY]: true,
-        at: (i) => data[i],
-        clear: () => {
-            clear(data, listeners);
-            return proxy;
-        },
-        dispatch: (event, value) => {
-            dispatch(listeners, event, value);
-            return proxy;
-        },
-        dispose: () => {
-            dispose(data);
-            return proxy;
-        },
-        map: (fn) => {
-            return map(data, proxy, fn);
-        },
-        on: (event, listener) => {
-            on(listeners, event, listener);
-            return proxy;
-        },
-        once: (event, listener) => {
-            once(listeners, event, listener);
-            return proxy;
-        },
-        pop: () => pop(data, listeners),
-        push: (...items) => push(data, listeners, items),
-        reverse: () => {
-            reverse(data, listeners);
-            return proxy;
-        },
-        shift: () => shift(data, listeners),
-        sort: (fn) => {
-            sort(data, listeners, fn);
-            return proxy;
-        },
-        splice: (start, deleteCount, ...items) => {
-            return splice(data, listeners, start, deleteCount, items);
-        },
-        unshift: (...items) => unshift(data, listeners, items),
-    };
-    return proxy;
-};
+        return removed;
+    }
+    unshift(...items) {
+        let length = super.unshift(...items);
+        this.dispatch('unshift', { items });
+        return length;
+    }
+}
+export { ReactiveArray };

package/build/reactive/index.d.ts

@@ -1,9 +1,18 @@
+import { Prettify } from '@esportsplus/utilities';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
-type API<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends (infer U)[] ? ReactiveArray<U> : never;
-declare const _default: <T extends Record<PropertyKey, any> | unknown[]>(input: T extends {
+type API<T> = T extends Record<PropertyKey, unknown> ? Prettify<{
+    [K in keyof T]: Infer<T[K]>;
+} & {
+    dispose: VoidFunction;
+}> : T extends (infer U)[] ? ReactiveArray<U> : never;
+type Guard<T> = T extends {
     dispose: any;
 } ? {
-    never: "[ dispose ] are reserved keys";
-} : T) => API<T>;
+    never: '[ dispose ] are reserved keys';
+} : T;
+type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: T[K];
+} : T;
+declare const _default: <T extends Record<PropertyKey, any> | unknown[]>(input: Guard<T>) => API<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,15 +1,15 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { onCleanup, root } from '../system.js';
-import array from './array.js';
-import object from './object.js';
+import { ReactiveArray } from './array.js';
+import { ReactiveObject } from './object.js';
 export default (input) => {
     let dispose = false, value = root(() => {
         let response;
-        if (isArray(input)) {
-            response = array(input);
+        if (isObject(input)) {
+            response = new ReactiveObject(input);
         }
-        else if (isObject(input)) {
-            response = object(input);
+        else if (isArray(input)) {
+            response = new ReactiveArray(...input);
         }
         if (response) {
             if (root.disposables) {

package/build/reactive/object.d.ts

@@ -1,14 +1,4 @@
-import { Prettify } from '@esportsplus/utilities';
 import { REACTIVE_OBJECT } from '../constants.js';
-import { ReactiveArray } from './array.js';
-type API<T> = Prettify<{
-    [K in keyof T]: Infer<T[K]>;
-} & {
-    dispose: VoidFunction;
-}>;
-type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends unknown[] ? ReactiveArray<T> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: T[K];
-} : T;
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT]: boolean;
     private disposers;
@@ -16,7 +6,4 @@ declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     dispose(): void;
 }
 declare const isReactiveObject: (value: any) => value is ReactiveObject<any>;
-declare const _default: <T extends Record<PropertyKey, unknown>>(input: T) => API<T>;
-export default _default;
-export { isReactiveObject };
-export type { API as ReactiveObject };
+export { isReactiveObject, ReactiveObject };

package/build/reactive/object.js

@@ -1,7 +1,7 @@
-import { defineProperty, isArray, isFunction, isObject, isPromise } from '@esportsplus/utilities';
+import { defineProperty, isArray, isObject, isPromise } from '@esportsplus/utilities';
 import { computed, dispose, effect, read, root, set, signal } from '../system.js';
 import { REACTIVE_OBJECT } from '../constants.js';
-import array from './array.js';
+import { ReactiveArray } from './array.js';
 class ReactiveObject {
     [REACTIVE_OBJECT] = true;
     disposers = null;
@@ -9,15 +9,8 @@ class ReactiveObject {
         let keys = Object.keys(data);
         for (let i = 0, n = keys.length; i < n; i++) {
             let key = keys[i], value = data[key];
-            if (isArray(value)) {
-                let node = array(value);
-                (this.disposers ??= []).push(() => node.dispose());
-                defineProperty(this, key, {
-                    enumerable: true,
-                    value: node
-                });
-            }
-            else if (isFunction(value)) {
+            let type = typeof value;
+            if (type === 'function') {
                 let node;
                 defineProperty(this, key, {
                     enumerable: true,
@@ -46,19 +39,29 @@ class ReactiveObject {
                         return read(node);
                     }
                 });
+                continue;
             }
-            else {
-                let node = signal(value);
+            if (value == null || type !== 'object') {
+            }
+            else if (isArray(value)) {
+                let node = new ReactiveArray(value);
+                (this.disposers ??= []).push(() => node.dispose());
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        return read(node);
-                    },
-                    set(v) {
-                        set(node, v);
-                    }
+                    value: node
                 });
+                continue;
             }
+            let node = signal(value);
+            defineProperty(this, key, {
+                enumerable: true,
+                get() {
+                    return read(node);
+                },
+                set(v) {
+                    set(node, v);
+                }
+            });
         }
     }
     dispose() {
@@ -74,7 +77,4 @@ class ReactiveObject {
 const isReactiveObject = (value) => {
     return isObject(value) && REACTIVE_OBJECT in value;
 };
-export default (input) => {
-    return new ReactiveObject(input);
-};
-export { isReactiveObject };
+export { isReactiveObject, ReactiveObject };