@esportsplus/reactivity 0.12.3 → 0.13.0

package/src/reactive/array.ts

@@ -1,304 +1,246 @@
-import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { isNumber } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '~/constants';
-import { computed, dispose, isComputed, read } from '~/system';
-import { Computed, Infer } from '~/types';
-import object, { isReactiveObject, ReactiveObject } from './object';
+import { dispose as d, isComputed, read } from '~/system';
+import { Infer } from '~/types';
+import { isReactiveObject } from './object';
 
 
-type API<T> = Infer<T>[] & ReactiveArray<T>;
+type API<T> = Infer<T[]> & {
+    clear: () => void;
+    dispose: () => void;
+};
 
 type Events<T> = {
+    clear: undefined,
     pop: {
-        item: Item<T>;
+        item: T;
     };
     push: {
-        items: Item<T>[];
+        items: T[];
     };
     reverse: undefined;
     set: {
         index: number;
-        item: Item<T>;
+        item: T;
     };
     shift: {
-        item: Item<T>;
+        item: T;
     };
     sort: undefined;
     splice: {
         deleteCount: number;
-        items: Item<T>[];
+        items: T[];
         start: number;
     };
     unshift: {
-        items: Item<T>[];
+        items: T[];
     };
 };
 
-type Item<T> = T | Computed<T> | API<T> | ReactiveObject< T extends Record<PropertyKey, unknown> ? T : never >;
-
 type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
 
-type Value<T> =
-    T extends Record<PropertyKey, unknown>
-        ? ReactiveObject<T>
-        : T extends Array<infer U>
-            ? API<U>
-            : T;
-
+type Listeners = Record<string, (Listener<any> | null)[]>;
 
-class ReactiveArray<T> {
-    [REACTIVE_ARRAY] = true;
-    disposables: number = 0;
 
-    private data: Item<T>[];
-    private listeners: Record<string, (Listener<any> | null)[]> | null = null;
-    private proxy: API<T>;
+function at<T>(data: T[], i: number) {
+    let value = data[i];
 
-
-    constructor(data: Item<T>[], proxy: API<T>) {
-        this.data = data;
-        this.proxy = proxy;
+    if (isComputed(value)) {
+        return read(value);
     }
 
+    return value;
+}
 
-    get length(): number {
-        return this.data.length;
+function cleanup<T>(item: T) {
+    if (isReactiveObject(item)) {
+        item.dispose();
     }
-
-    set length(n: number) {
-        if (n > this.data.length) {
-            return;
-        }
-
-        this.splice(n);
+    else if (isComputed(item)) {
+        d(item);
     }
+}
 
+function clear<T>(data: T[], listeners: Listeners) {
+    dispose(data);
+    dispatch(listeners, 'clear');
+}
 
-    private cleanup(item: Item<T>) {
-        if (isReactiveObject(item)) {
-            item.dispose();
-        }
-        else if (isComputed(item)) {
-            dispose(item);
-        }
+function dispatch<T, K extends keyof Events<T>, V>(listeners: Listeners, event: K, value?: V) {
+    if (listeners === null || listeners[event] === undefined) {
+        return;
     }
 
+    let bucket = listeners[event];
 
-    at(i: number) {
-        let value = this.data[i];
+    for (let i = 0, n = bucket.length; i < n; i++) {
+        let listener = bucket[i];
 
-        if (isComputed(value)) {
-            return read(value);
+        if (listener === null) {
+            continue;
         }
 
-        return value;
-    }
+        try {
+            listener(value);
 
-    dispatch<K extends keyof Events<T>, V>(event: K, value?: V) {
-        if (this.listeners === null || this.listeners[event] === undefined) {
-            return;
+            if (listener.once !== undefined) {
+                bucket[i] = null;
+            }
         }
+        catch {
+            bucket[i] = null;
+        }
+    }
+}
 
-        let listeners = this.listeners[event];
-
-        for (let i = 0, n = listeners.length; i < n; i++) {
-            let listener = listeners[i];
-
-            if (listener === null) {
-                continue;
-            }
+function dispose<T>(data: T[]) {
+    let item;
 
-            try {
-                listener(value);
+    while (item = data.pop()) {
+        cleanup(item);
+    }
+}
 
-                if (listener.once !== undefined) {
-                    listeners[i] = null;
-                }
-            }
-            catch {
-                listeners[i] = null;
-            }
-        }
+function map<T, R>(
+    data: T[],
+    proxy: API<T>,
+    fn: (this: API<T>, value: T, i: number) => R,
+    i?: number,
+    n?: number
+) {
+    if (i === undefined) {
+        i = 0;
     }
 
-    dispose() {
-        for (let i = 0, n = this.data.length; i < n; i++) {
-            this.cleanup(this.data[i]);
-        }
+    if (n === undefined) {
+        n = data.length;
     }
 
-    map<R>(
-        fn: (this: API<T>, value: Value<T>, i: number) => R,
-        i?: number,
-        n?: number
-    ) {
-        let { data, proxy } = this,
-            values: R[] = [];
+    n = Math.min(n, data.length);
 
-        if (i === undefined) {
-            i = 0;
-        }
+    let values: R[] = new Array(n - i);
 
-        if (n === undefined) {
-            n = data.length;
-        }
+    for (; i < n; i++) {
+        let item = data[i];
 
-        n = Math.min(n, data.length);
+        values[i] = fn.call(
+            proxy,
+            (isComputed(item) ? item.value : item) as T,
+            i
+        );
+    }
 
-        for (; i < n; i++) {
-            let item = data[i];
+    return values;
+}
 
-            values.push(
-                fn.call(
-                    proxy,
-                    (isComputed(item) ? item.value : item) as Value<T>,
-                    i
-                )
-            );
-        }
+function on<T, K extends keyof Events<T>>(listeners: Listeners, event: K, listener: Listener<Events<T>[K]>) {
+    let bucket = listeners[event];
 
-        return values;
+    if (bucket === undefined) {
+        listeners[event] = [listener];
     }
+    else {
+        let hole = bucket.length;
 
-    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
-        if (this.listeners === null) {
-            this.listeners = { [event]: [listener] };
-        }
-        else {
-            let listeners = this.listeners[event];
+        for (let i = 0, n = hole; i < n; i++) {
+            let l = bucket[i];
 
-            if (listeners === undefined) {
-                this.listeners[event] = [listener];
+            if (l === listener) {
+                return;
             }
-            else if (listeners.indexOf(listener) === -1) {
-                let i = listeners.indexOf(null);
-
-                if (i === -1) {
-                    listeners.push(listener);
-                }
-                else {
-                    listeners[i] = listener;
-                }
+            else if (l === null && hole === n) {
+                hole = i;
             }
         }
-    }
 
-    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
-        listener.once = true;
-        this.on(event, listener);
+        bucket[hole] = listener;
     }
+}
 
-    pop() {
-        let item = this.data.pop();
+function once<T, K extends keyof Events<T>>(listeners: Listeners, event: K, listener: Listener<Events<T>[K]>) {
+    listener.once = true;
+    on(listeners, event, listener);
+}
 
-        if (item !== undefined) {
-            this.cleanup(item);
-            this.dispatch('pop', { item });
-        }
+function pop<T>(data: T[], listeners: Listeners) {
+    let item = data.pop();
 
-        return item;
+    if (item !== undefined) {
+        cleanup(item);
+        dispatch(listeners, 'pop', { item });
     }
 
-    push(...input: T[]) {
-        let items = factory(input),
-            n = this.data.push(...items);
+    return item;
+}
 
-        this.dispatch('push', { items });
+function push<T>(data: T[], listeners: Listeners, items: T[]) {
+    let n = data.push(...items);
 
-        return n;
-    }
+    dispatch(listeners, 'push', { items });
 
-    reverse() {
-        this.data.reverse();
-        this.dispatch('reverse');
+    return n;
+}
 
-        return this;
-    }
+function reverse<T>(data: T[], listeners: Listeners) {
+    data.reverse();
+    dispatch(listeners, 'reverse');
+}
 
-    shift() {
-        let item = this.data.shift();
+function shift<T>(data: T[], listeners: Listeners) {
+    let item = data.shift();
 
-        if (item !== undefined) {
-            this.cleanup(item);
-            this.dispatch('shift', { item });
-        }
-
-        return item;
+    if (item !== undefined) {
+        cleanup(item);
+        dispatch(listeners, 'shift', { item });
     }
 
-    sort(fn: (a: Value<T>, b: Value<T>) => number) {
-        this.data.sort((a, b) => fn(
-            (isComputed(a) ? a.value : a) as Value<T>,
-            (isComputed(b) ? b.value : b) as Value<T>
-        ));
-        this.dispatch('sort');
+    return item;
+}
 
-        return this;
-    }
+function sort<T>(data: T[], listeners: Listeners, fn: (a: T, b: T) => number) {
+    data.sort((a, b) => fn(
+        (isComputed(a) ? a.value : a) as T,
+        (isComputed(b) ? b.value : b) as T
+    ));
+    dispatch(listeners, 'sort');
+}
 
-    splice(start: number, deleteCount: number = this.data.length, ...input: T[]) {
-        let items = factory(input),
-            removed = this.data.splice(start, deleteCount, ...items);
+function splice<T>(data: T[], listeners: Listeners, start: number, deleteCount: number = data.length, items: T[] = []) {
+    let removed = data.splice(start, deleteCount, ...items);
 
-        if (items.length > 0 || removed.length > 0) {
-            for (let i = 0, n = removed.length; i < n; i++) {
-                this.cleanup(removed[i]);
-            }
-
-            this.dispatch('splice', {
-                deleteCount,
-                items,
-                start
-            });
+    if (items.length > 0 || removed.length > 0) {
+        for (let i = 0, n = removed.length; i < n; i++) {
+            cleanup(removed[i]);
         }
 
-        return removed;
+        dispatch(listeners, 'splice', {
+            deleteCount,
+            items,
+            start
+        });
     }
 
-    unshift(...input: T[]) {
-        let items = factory(input),
-            length = this.data.unshift(...items);
-
-        this.dispatch('unshift', { items });
-
-        return length;
-    }
+    return removed;
 }
 
+function unshift<T>(data: T[], listeners: Listeners, items: T[]) {
+    let length = data.unshift(...items);
 
-function factory<T>(input: T[]) {
-    let items: Item<T>[] = [];
-
-    for (let i = 0, n = input.length; i < n; i++) {
-        let value = input[i];
-
-        if (isFunction(value)) {
-            items[i] = computed(value as Computed<T>['fn']);
-        }
-        else if (isObject(value)) {
-            items[i] = object(value) as Item<T>;
-        }
-        else {
-            items[i] = value;
-        }
-    }
+    dispatch(listeners, 'unshift', { items });
 
-    return items;
+    return length;
 }
 
 
-const isReactiveArray = (value: any): value is ReactiveArray<any> => {
-    return isObject(value) && REACTIVE_ARRAY in value;
-};
-
-
-export default <T>(input: T[]) => {
-    let proxy = new Proxy({}, {
-            get(_: any, key: any) {
+export default <T>(data: T[]) => {
+    let listeners: Listeners = {},
+        proxy = new Proxy({}, {
+            get(_, key: any) {
                 if (isNumber(key)) {
-                    let value = wrapped[key];
+                    let value = data[key];
 
                     if (isComputed(value)) {
                         return read(value);
@@ -306,29 +248,82 @@ export default <T>(input: T[]) => {
 
                     return value;
                 }
-                else if (key in array) {
-                    return array[key as keyof typeof array];
+                else if (key in wrapper) {
+                    return wrapper[key as keyof typeof wrapper];
+                }
+                else if (key === 'length') {
+                    return data.length;
                 }
 
-                return wrapped[key];
+                return data[key];
             },
-            set(_: any, key: any, value: any) {
+            set(_, key: any, value: any) {
                 if (isNumber(key)) {
-                    array.splice(key, 1, value);
-                    return true;
+                    splice(data, listeners, key, 1, value);
                 }
                 else if (key === 'length') {
-                    return array.length = value;
+                    if (value >= data.length) {
+                    }
+                    else if (value === 0) {
+                        clear(data, listeners);
+                    }
+                    else {
+                        splice(data, listeners, value);
+                    }
+                }
+                else {
+                    return false;
                 }
 
-                return false;
+                return true;
             }
         }) as API<T>,
-        wrapped = factory(input);
-
-    let array = new ReactiveArray(wrapped, proxy);
+        wrapper = {
+            [REACTIVE_ARRAY]: true,
+            at: (i: number) => at(data, i),
+            clear: () => {
+                clear(data, listeners);
+                return proxy;
+            },
+            dispatch: <K extends keyof Events<T>, V>(event: K, value?: V) => {
+                dispatch(listeners, event, value);
+                return proxy;
+            },
+            dispose: () => {
+                dispose(data);
+                return proxy;
+            },
+            map: <R>(
+                fn: (this: API<T>, value: T, i: number) => R,
+                i?: number,
+                n?: number
+            ) => {
+                return map(data, proxy, fn, i, n);
+            },
+            on: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => {
+                on(listeners, event, listener);
+                return proxy;
+            },
+            once: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => {
+                once(listeners, event, listener);
+                return proxy;
+            },
+            pop: () => pop(data, listeners),
+            push: (...items: T[]) => push(data, listeners, items),
+            reverse: () => {
+                reverse(data, listeners);
+                return proxy;
+            },
+            shift: () => shift(data, listeners),
+            sort: (fn: (a: T, b: T) => number) => {
+                sort(data, listeners, fn);
+                return proxy;
+            },
+            splice: (start: number, deleteCount?: number, ...items: T[]) => {
+                return splice(data, listeners, start, deleteCount, items);
+            },
+            unshift: (...items: T[]) => unshift(data, listeners, items),
+        };
 
     return proxy;
 };
-export { isReactiveArray };
-export type { API as ReactiveArray };

package/src/reactive/index.ts

@@ -13,15 +13,13 @@ type API<T> =
 
 type Input<T> =
     T extends { dispose: any }
-        ? never
-        : T extends Record<PropertyKey, unknown>
+        ? { never: '[ dispose, signals ] are reserved keys' }
+        : T extends Record<PropertyKey, unknown> | unknown[]
             ? T
-            : T extends unknown[]
-                ? Input<T[number]>[]
-                : never;
+            : never;
 
 
-export default <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>): API<T> => {
+export default <T>(input: Input<T>): API<T> => {
     let value: API<T> | undefined;
 
     return root(() => {