@esportsplus/reactivity 0.12.4 → 0.13.1

package/build/reactive/array.d.ts

@@ -1,62 +1,8 @@
-import { REACTIVE_ARRAY } from '../constants.js';
-import { Computed, Infer } from '../types.js';
-import { ReactiveObject } from './object.js';
-type API<T> = Infer<T>[] & ReactiveArray<T>;
-type Events<T> = {
-    pop: {
-        item: Item<T>;
-    };
-    push: {
-        items: Item<T>[];
-    };
-    reverse: undefined;
-    set: {
-        index: number;
-        item: Item<T>;
-    };
-    shift: {
-        item: Item<T>;
-    };
-    sort: undefined;
-    splice: {
-        deleteCount: number;
-        items: Item<T>[];
-        start: number;
-    };
-    unshift: {
-        items: Item<T>[];
-    };
+import { Infer } from '../types.js';
+type API<T> = Infer<T[]> & {
+    clear: () => void;
+    dispose: () => void;
 };
-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;
-declare class ReactiveArray<T> {
-    [REACTIVE_ARRAY]: boolean;
-    disposables: number;
-    private data;
-    private listeners;
-    private proxy;
-    constructor(data: Item<T>[], proxy: API<T>);
-    get length(): number;
-    set length(n: number);
-    private cleanup;
-    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<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;
-    shift(): Item<T> | undefined;
-    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[]) => API<T>;
+declare const _default: <T>(data: T[]) => API<T>;
 export default _default;
 export type { API as ReactiveArray };

package/build/reactive/array.js

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

package/build/reactive/index.d.ts

@@ -3,7 +3,8 @@ import object from './object.js';
 type API<T> = T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
 type Input<T> = T extends {
     dispose: any;
-} ? never : T extends Record<PropertyKey, unknown> ? T : T extends unknown[] ? Input<T[number]>[] : never;
-declare const _default: <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>) => API<T>;
+} ? {
+    never: '[ dispose, signals ] are reserved keys';
+} : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
+declare const _default: <T>(input: Input<T>) => API<T>;
 export default _default;
-export type { Input };

package/build/reactive/object.d.ts

@@ -1,9 +1,11 @@
 import { Prettify } from '@esportsplus/utilities';
 import { Infer } from '../types.js';
 import { REACTIVE_OBJECT } from '../constants.js';
-type API<T extends Record<PropertyKey, unknown>> = Prettify<{
+type API<T> = Prettify<{
     [K in keyof T]: Infer<T[K]>;
-}> & ReactiveObject<T>;
+} & {
+    dispose: VoidFunction;
+}>;
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT]: boolean;
     private disposers;

package/build/reactive/object.js

@@ -62,11 +62,12 @@ class ReactiveObject {
         }
     }
     dispose() {
-        let disposers = this.disposers;
-        if (disposers) {
-            for (let i = 0, n = disposers.length; i < n; i++) {
-                disposers[i]();
-            }
+        let disposers = this.disposers, disposer;
+        if (!disposers) {
+            return;
+        }
+        while (disposer = disposers.pop()) {
+            disposer();
         }
     }
 }

package/build/types.d.ts

@@ -15,7 +15,7 @@ interface Computed<T> {
     subsTail: Link | null;
     value: 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> ? {
+type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? Infer<U>[] : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K];
 } : T;
 interface Link {
@@ -26,11 +26,10 @@ interface Link {
     prevSub: Link | null;
     version: number;
 }
-type Reactive<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : ReactiveArray<T>;
 type Signal<T> = {
     [SIGNAL]: true;
     subs: Link | null;
     subsTail: Link | null;
     value: T;
 };
-export type { Computed, Infer, Link, Signal, Reactive, ReactiveArray, ReactiveObject };
+export type { Computed, Infer, Link, Signal, ReactiveArray, ReactiveObject };

package/package.json

@@ -2,7 +2,7 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/custom-function": "^0.0.13",
-    "@esportsplus/utilities": "^0.21.1"
+    "@esportsplus/utilities": "^0.22.1"
   },
   "devDependencies": {
     "@esportsplus/typescript": "^0.9.2"
@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.12.4",
+  "version": "0.13.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/array.ts

@@ -1,307 +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;
-
-
-class ReactiveArray<T> {
-    [REACTIVE_ARRAY] = true;
-    disposables: number = 0;
-
-    private data: Item<T>[];
-
-    private listeners: Record<string, (Listener<any> | null)[]> | null = null;
+type Listeners = Record<string, (Listener<any> | 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];
-
-        if (isComputed(value)) {
-            return read(value);
-        }
-
-        return value;
-    }
+    for (let i = 0, n = bucket.length; i < n; i++) {
+        let listener = bucket[i];
 
-    dispatch<K extends keyof Events<T>, V>(event: K, value?: V) {
-        if (this.listeners === null || this.listeners[event] === undefined) {
-            return;
+        if (listener === null) {
+            continue;
         }
 
-        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);
+        try {
+            listener(value);
 
-                if (listener.once !== undefined) {
-                    listeners[i] = null;
-                }
-            }
-            catch {
-                listeners[i] = null;
+            if (listener.once !== undefined) {
+                bucket[i] = null;
             }
         }
-    }
-
-    dispose() {
-        for (let i = 0, n = this.data.length; i < n; i++) {
-            this.cleanup(this.data[i]);
+        catch {
+            bucket[i] = null;
         }
     }
+}
 
-    map<R>(
-        fn: (this: API<T>, value: Value<T>, i: number) => R,
-        i?: number,
-        n?: number
-    ) {
-        let { data, proxy } = this;
+function dispose<T>(data: T[]) {
+    let item;
 
-        if (i === undefined) {
-            i = 0;
-        }
+    while (item = data.pop()) {
+        cleanup(item);
+    }
+}
 
-        if (n === undefined) {
-            n = data.length;
-        }
+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;
+    }
 
-        n = Math.min(n, data.length);
+    if (n === undefined) {
+        n = data.length;
+    }
 
-        let values: R[] = new Array(n - i);
+    n = Math.min(n, data.length);
 
-        for (; i < n; i++) {
-            let item = data[i];
+    let values: R[] = new Array(n - i);
 
-            values[i] = fn.call(
-                proxy,
-                (isComputed(item) ? item.value : item) as Value<T>,
-                i
-            );
-        }
+    for (; i < n; i++) {
+        let item = data[i];
 
-        return values;
+        values[i] = fn.call(
+            proxy,
+            (isComputed(item) ? item.value : item) as T,
+            i
+        );
     }
 
-    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];
+    return values;
+}
 
-            if (listeners === undefined) {
-                this.listeners[event] = [listener];
-            }
-            else {
-                let hole = listeners.length;
+function on<T, K extends keyof Events<T>>(listeners: Listeners, event: K, listener: Listener<Events<T>[K]>) {
+    let bucket = listeners[event];
 
-                for (let i = 0, n = hole; i < n; i++) {
-                    let l = listeners[i];
+    if (bucket === undefined) {
+        listeners[event] = [listener];
+    }
+    else {
+        let hole = bucket.length;
 
-                    if (l === listener) {
-                        return;
-                    }
-                    else if (l === null && hole === n) {
-                        hole = i;
-                    }
-                }
+        for (let i = 0, n = hole; i < n; i++) {
+            let l = bucket[i];
 
-                listeners[hole] = listener;
+            if (l === listener) {
+                return;
+            }
+            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 this;
-    }
+    return n;
+}
 
-    shift() {
-        let item = this.data.shift();
+function reverse<T>(data: T[], listeners: Listeners) {
+    data.reverse();
+    dispatch(listeners, 'reverse');
+}
 
-        if (item !== undefined) {
-            this.cleanup(item);
-            this.dispatch('shift', { item });
-        }
+function shift<T>(data: T[], listeners: Listeners) {
+    let item = data.shift();
 
-        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 this;
-    }
+    return item;
+}
 
-    splice(start: number, deleteCount: number = this.data.length, ...input: T[]) {
-        let items = factory(input),
-            removed = this.data.splice(start, deleteCount, ...items);
+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');
+}
 
-        if (items.length > 0 || removed.length > 0) {
-            for (let i = 0, n = removed.length; i < n; i++) {
-                this.cleanup(removed[i]);
-            }
+function splice<T>(data: T[], listeners: Listeners, start: number, deleteCount: number = data.length, items: T[] = []) {
+    let removed = data.splice(start, deleteCount, ...items);
 
-            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 n = input.length,
-        output: Item<T>[] = new Array(n);
+    dispatch(listeners, 'unshift', { items });
 
-    for (let i = 0; i < n; i++) {
-        let value = input[i];
-
-        if (isFunction(value)) {
-            output[i] = computed(value as Computed<T>['fn']);
-        }
-        else if (isObject(value)) {
-            output[i] = object(value) as Item<T>;
-        }
-        else {
-            output[i] = value;
-        }
-    }
-
-    return output;
+    return length;
 }
 
 
-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);
@@ -309,29 +248,83 @@ 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') {
-                    array.length = value;
-                    return true;
+                    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 type { API as ReactiveArray };
+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(() => {
@@ -42,5 +40,4 @@ export default <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input
 
         throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
     });
-};
-export type { Input };
+};

package/src/reactive/object.ts

@@ -5,7 +5,7 @@ import { REACTIVE_OBJECT } from '~/constants';
 import array from './array';
 
 
-type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
+type API<T> = Prettify<{ [K in keyof T]: Infer<T[K]> } & { dispose: VoidFunction } >;
 
 
 class ReactiveObject<T extends Record<PropertyKey, unknown>> {
@@ -90,12 +90,15 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
 
 
     dispose() {
-        let disposers = this.disposers;
+        let disposers = this.disposers,
+            disposer;
 
-        if (disposers) {
-            for (let i = 0, n = disposers.length; i < n; i++) {
-                disposers[i]();
-            }
+        if (!disposers) {
+            return;
+        }
+
+        while (disposer = disposers.pop()) {
+            disposer();
         }
     }
 }

package/src/types.ts

@@ -29,7 +29,7 @@ type Infer<T> =
         : T extends (...args: any[]) => infer R
             ? R
             : T extends (infer U)[]
-                ? ReactiveArray<U>
+                ? Infer<U>[]
                 : T extends ReactiveObject<any>
                     ? T
                     : T extends Record<PropertyKey, unknown>
@@ -45,10 +45,6 @@ interface Link {
     version: number;
 }
 
-type Reactive<T> = T extends Record<PropertyKey, unknown>
-    ? ReactiveObject<T>
-    : ReactiveArray<T>;
-
 type Signal<T> = {
     [SIGNAL]: true;
     subs: Link | null;
@@ -62,5 +58,5 @@ export type {
     Infer,
     Link,
     Signal,
-    Reactive, ReactiveArray, ReactiveObject
+    ReactiveArray, ReactiveObject
 };