@esportsplus/reactivity 0.1.30 → 0.2.0

package/build/macro.d.ts

@@ -1,10 +1,9 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { Computed, Options } from './types';
-type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
+import { Options } from './types';
 declare class Macro<A extends unknown[], R> extends CustomFunction {
     private factory;
-    constructor(fn: Function<A, R>, options?: Options);
+    constructor(fn: Macro<A, R>['factory']['fn'], options?: Options);
     dispose(): void;
 }
-declare const _default: <A extends unknown[], R>(fn: Function<A, R>, options?: Options) => Macro<A, R>;
+declare const _default: <A extends unknown[], R>(fn: Macro<A, R>["factory"]["fn"], options?: Options) => Macro<A, R>;
 export default _default;

package/build/reactive/array.d.ts

@@ -1,59 +1,49 @@
-import { Listener, Object, Options } from '../types';
+import { Listener, Options, Signal } from '../types';
 import { ReactiveObject } from './object';
 type Events<T> = {
-    fill: {
-        value: T;
-    };
     pop: {
-        item: T;
+        item: R<T>;
     };
     push: {
-        items: T[];
+        items: R<T>[];
     };
     reverse: undefined;
     shift: {
-        item: T;
+        item: R<T>;
     };
     sort: undefined;
     splice: {
         deleteCount: number;
-        items: T[];
+        items: R<T>[];
         start: number;
     };
     unshift: {
-        items: T[];
+        items: R<T>[];
     };
 };
-declare class ReactiveArray<T> extends Array<T> {
+type R<T> = Signal<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: T[K];
+} : never>;
+declare class ReactiveArray<T> extends Array<R<T>> {
+    private options;
+    private self;
     private signal;
-    constructor(data: T[]);
+    constructor(data: R<T>[], options?: Options);
     set length(n: number);
+    at(index: number): any;
     dispatch<E extends keyof Events<T>>(event: E, data?: Events<T>[E]): void;
     dispose(): void;
-    fill(value: T, start?: number, end?: number): this;
-    map<U>(fn: (this: ReactiveArray<T>, value: T, i: number, values: this) => U): U[];
+    map<U>(fn: (this: T[], value: T, i: number) => U): U[];
     on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>): void;
     once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>): void;
-    pop(): T | undefined;
-    push(...items: T[]): number;
+    pop(): R<T> | undefined;
+    push(...input: T[]): number;
     reverse(): this;
-    shift(): T | undefined;
+    shift(): R<T> | undefined;
     sort(): this;
-    splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    track(index?: number): T | undefined;
-    trigger(): void;
-    unshift(...items: T[]): number;
-}
-declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<ReactiveObject<T>> {
-    private options;
-    constructor(data: T[], options?: Options);
-    fill(): never;
-    reverse(): never;
-    pop(): ReactiveObject<T> | undefined;
-    push(...values: T[]): number;
-    shift(): ReactiveObject<T> | undefined;
-    sort(): never;
-    splice(start: number, deleteCount?: number, ...values: T[]): ReactiveObject<T> | ReactiveObject<T>[] | null | undefined;
-    unshift(...values: T[]): number;
+    splice(start: number, deleteCount?: number, ...input: T[]): R<T>[];
+    unshift(...input: T[]): number;
 }
-export { ReactiveArray, ReactiveObjectArray };
+declare const _default: <T>(input: T[], options?: Options) => any;
+export default _default;
+export { ReactiveArray };

package/build/reactive/array.js

@@ -1,19 +1,63 @@
-import { dispose, signal } from '../signal';
+import { dispose, signal, Reactive } from '../signal';
+import { isInstanceOf, isNumber, isObject } from '../utilities';
 import { ReactiveObject } from './object';
-function factory(data, options = {}) {
-    let signals = [];
-    for (let i = 0, n = data.length; i < n; i++) {
-        signals.push(new ReactiveObject(data[i], options));
+let handler = {
+    get(target, prop) {
+        let value = target[prop];
+        if (value === undefined) {
+            return value;
+        }
+        if (isInstanceOf(value, Reactive)) {
+            return value.get();
+        }
+        else if (supported.has(prop)) {
+            return value;
+        }
+        throw new Error(`Reactivity: '${prop}' is not supported on reactive arrays`);
+    },
+    set(target, prop, value) {
+        if (isNumber(prop)) {
+            let host = target[prop];
+            if (isInstanceOf(host, Reactive)) {
+                host.set(value);
+                return true;
+            }
+            return false;
+        }
+        return target[prop] = value;
+    }
+}, supported = new Set([
+    'at',
+    'dispatch', 'dispose',
+    'length',
+    'map',
+    'on', 'once',
+    'pop', 'push',
+    'reverse',
+    'self', 'shift', 'sort', 'splice',
+    'unshift'
+]);
+function factory(input, options = {}) {
+    let items = [];
+    for (let i = 0, n = input.length; i < n; i++) {
+        let value = input[i];
+        if (isObject(value)) {
+            items[i] = new ReactiveObject(value, options);
+        }
+        else {
+            items[i] = signal(value);
+        }
     }
-    return signals;
-}
-function unsupported(method) {
-    throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
+    return items;
 }
 class ReactiveArray extends Array {
+    options;
+    self;
     signal;
-    constructor(data) {
+    constructor(data, options = {}) {
         super(...data);
+        this.options = options;
+        this.self = this;
         this.signal = signal(false);
     }
     set length(n) {
@@ -22,22 +66,24 @@ class ReactiveArray extends Array {
         }
         this.splice(n);
     }
+    at(index) {
+        let value = super.at(index);
+        if (isInstanceOf(value, Reactive)) {
+            return value.get();
+        }
+        return value;
+    }
     dispatch(event, data) {
         this.signal.dispatch(event, data);
     }
     dispose() {
         this.signal.dispose();
-    }
-    fill(value, start, end) {
-        super.fill(value, start, end);
-        this.dispatch('fill', { value });
-        this.trigger();
-        return this;
+        dispose(this.self);
     }
     map(fn) {
-        let values = [];
-        for (let i = 0, n = this.length; i < n; i++) {
-            values.push(fn.call(this, this[i], i, this));
+        let self = this.self, values = [];
+        for (let i = 0, n = self.length; i < n; i++) {
+            values.push(fn.call(this, self[i].value, i));
         }
         return values;
     }
@@ -50,92 +96,53 @@ class ReactiveArray extends Array {
     pop() {
         let item = super.pop();
         if (item !== undefined) {
-            this.dispatch('pop', { item });
-            this.trigger();
+            dispose(item);
+            this.signal.dispatch('pop', { item });
         }
         return item;
     }
-    push(...items) {
-        let n = super.push(...items);
-        this.dispatch('push', { items });
-        this.trigger();
+    push(...input) {
+        let items = factory(input, this.options), n = super.push(...items);
+        this.signal.dispatch('push', { items });
         return n;
     }
     reverse() {
         super.reverse();
-        this.dispatch('reverse');
-        this.trigger();
+        this.signal.dispatch('reverse');
         return this;
     }
     shift() {
         let item = super.shift();
         if (item !== undefined) {
-            this.dispatch('shift', { item });
-            this.trigger();
+            dispose(item);
+            this.signal.dispatch('shift', { item });
         }
         return item;
     }
     sort() {
         super.sort();
-        this.dispatch('sort');
-        this.trigger();
+        this.signal.dispatch('sort');
         return this;
     }
-    splice(start, deleteCount = super.length, ...items) {
-        let removed = super.splice(start, deleteCount, ...items);
+    splice(start, deleteCount = super.length, ...input) {
+        let items = factory(input, this.options), removed = super.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
-            this.dispatch('splice', {
+            dispose(removed);
+            this.signal.dispatch('splice', {
                 deleteCount,
                 items,
                 start
             });
-            this.trigger();
         }
         return removed;
     }
-    track(index) {
-        this.signal.get();
-        return index === undefined ? undefined : this[index];
-    }
-    trigger() {
-        this.signal.set(!this.signal.value);
-    }
-    unshift(...items) {
-        let length = super.unshift(...items);
-        this.dispatch('unshift', { items });
-        this.trigger();
+    unshift(...input) {
+        let items = factory(input, this.options), length = super.unshift(...items);
+        this.signal.dispatch('unshift', { items });
         return length;
     }
 }
-class ReactiveObjectArray extends ReactiveArray {
-    options;
-    constructor(data, options = {}) {
-        super(factory(data, options));
-        this.options = options;
-    }
-    fill() {
-        return unsupported('fill');
-    }
-    reverse() {
-        return unsupported('reverse');
-    }
-    pop() {
-        return dispose(super.pop());
-    }
-    push(...values) {
-        return super.push(...factory(values, this.options));
-    }
-    shift() {
-        return dispose(super.shift());
-    }
-    sort() {
-        return unsupported('sort');
-    }
-    splice(start, deleteCount = super.length, ...values) {
-        return dispose(super.splice(start, deleteCount, ...factory(values, this.options)));
-    }
-    unshift(...values) {
-        return super.unshift(...factory(values, this.options));
-    }
-}
-export { ReactiveArray, ReactiveObjectArray };
+export default (input, options = {}) => {
+    return new Proxy(new ReactiveArray(factory(input, options)), handler);
+};
+export { ReactiveArray };

package/build/reactive/index.d.ts

@@ -1,18 +1,13 @@
-import { Computed, Object, Options, Prettify, Signal } from '../types';
-import { ReactiveArray, ReactiveObjectArray } from './array';
+import { Prettify } from '@esportsplus/typescript';
+import { Options } from '../types';
+import { ReactiveArray } from './array';
 import { ReactiveObject } from './object';
-type Guard<T> = T extends Object ? {
+type Guard<T> = T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: Never<K, Guard<T[K]>>;
-} : T extends unknown[] ? Guard<T[number]>[] : T;
-type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends unknown[] ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]> : T extends Object ? {
+} : T extends unknown[] ? T : never;
+type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends (infer U)[] ? Prettify<Omit<U[], 'map'> & Pick<ReactiveArray<U>, 'dispatch' | 'dispose' | 'map' | 'on' | 'once'>> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K];
 } : T;
-type Never<K, V> = K extends keyof ReactiveObject<Object> ? never : V;
-type Nodes<T> = T extends (...args: unknown[]) => unknown ? Computed<T> : T extends unknown[] ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]> : Signal<T>;
-type Signals<T extends Object> = {
-    [K in keyof T]: Nodes<T[K]>;
-};
-declare const _default: <T extends Object>(data: Guard<T>, options?: Options) => Prettify<{ [K in keyof T]: Infer<T[K]>; } & Omit<ReactiveObject<T>, "signals"> & {
-    signals: Signals<T>;
-}>;
+type Never<K, V> = K extends keyof ReactiveObject<Record<PropertyKey, unknown>> ? never : V;
+declare const _default: <T>(data: Guard<T>, options?: Options) => T extends Record<PropertyKey, unknown> ? { [K in keyof T]: Infer<T[K]>; } : Infer<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,4 +1,16 @@
-import { ReactiveObject } from './object';
-export default (data, options) => {
-    return new ReactiveObject(data, options);
+import { default as array } from './array';
+import { default as object } from './object';
+import { isArray, isObject } from '../utilities';
+export default (data, options = {}) => {
+    let value;
+    if (isArray(data)) {
+        value = array(data, options);
+    }
+    else if (isObject(data)) {
+        value = object(data, options);
+    }
+    else {
+        throw new Error('Reactivity: received invalid input for `reactive()`', data);
+    }
+    return value;
 };

package/build/reactive/object.d.ts

@@ -1,9 +1,11 @@
-import { Computed, Object, Options, Signal } from '../types';
-import { ReactiveArray, ReactiveObjectArray } from './array';
-type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
-declare class ReactiveObject<T extends Object> {
-    signals: Record<PropertyKey, Node>;
+import { Computed, Options, Signal } from '../types';
+import { ReactiveArray } from './array';
+declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
+    signals: Record<PropertyKey, Computed<any> | ReactiveArray<any> | Signal<any>>;
     constructor(data: T, options?: Options);
+    get value(): this;
     dispose(): void;
 }
+declare const _default: <T extends Record<PropertyKey, unknown>>(input: T, options?: Options) => ReactiveObject<T>;
+export default _default;
 export { ReactiveObject };

package/build/reactive/object.js

@@ -1,34 +1,27 @@
 import { computed, signal } from '../signal';
-import { defineProperty, isArray } from '../utilities';
-import { ReactiveArray, ReactiveObjectArray } from './array';
+import { defineProperty, isArray, isFunction } from '../utilities';
+import { default as array } from './array';
 class ReactiveObject {
     signals = {};
     constructor(data, options = {}) {
         let signals = this.signals;
         for (let key in data) {
             let input = data[key];
-            if (typeof input === 'function') {
-                let s = signals[key] = computed(input, options);
+            if (isArray(input)) {
+                let s = signals[key] = array(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        return s;
                     }
                 });
             }
-            else if (isArray(input)) {
-                let s, test = input[0];
-                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
-                    s = signals[key] = new ReactiveObjectArray(input, options);
-                }
-                else {
-                    s = signals[key] = new ReactiveArray(input);
-                }
+            else if (isFunction(input)) {
+                let s = signals[key] = computed(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        s.track();
-                        return s;
+                        return s.get();
                     }
                 });
             }
@@ -46,6 +39,9 @@ class ReactiveObject {
             }
         }
     }
+    get value() {
+        return this;
+    }
     dispose() {
         let signals = this.signals;
         for (let key in signals) {
@@ -53,4 +49,7 @@ class ReactiveObject {
         }
     }
 }
+export default (input, options = {}) => {
+    return new ReactiveObject(input, options);
+};
 export { ReactiveObject };

package/build/resource.d.ts

@@ -1,16 +1,15 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { Options } from './types';
-type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
 declare class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
     private arguments;
     private okay;
     private response;
     stop: boolean | null;
-    constructor(fn: Function<A, R>, options?: Options);
+    constructor(fn: (...args: A) => R, options?: Options);
     get data(): Awaited<R>;
     get input(): A | null;
     get ok(): boolean | null;
     dispose(): void;
 }
-declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: Function<A, R>, options?: Options) => Resource<A, R>;
+declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R, options?: Options) => Resource<A, R>;
 export default _default;

package/build/types.d.ts

@@ -21,7 +21,6 @@ type Listener<D> = {
         value: V;
     }): void;
 };
-type Object = Record<PropertyKey, unknown>;
 type Options = {
     changed?: Changed;
 };
@@ -38,4 +37,4 @@ type Signal<T> = {
 } & Base<T>;
 type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
-export type { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };
+export type { Changed, Computed, Effect, Event, Function, Listener, NeverAsync, Options, Prettify, Root, Scheduler, Signal, State, Type };

package/build/utilities.d.ts

@@ -1,3 +1,8 @@
-declare const isArray: (arg: any) => arg is any[];
 declare const defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
-export { defineProperty, isArray };
+declare const isArray: (arg: any) => arg is any[];
+declare const isFunction: (value: unknown) => value is Function;
+declare const isInstanceOf: <T>(instance: unknown, match: new (...args: any) => T) => instance is T;
+declare const isNumber: (value: any) => value is number;
+declare const isObject: (value: unknown) => value is Record<PropertyKey, unknown>;
+declare const isString: (value: unknown) => value is string;
+export { defineProperty, isArray, isFunction, isInstanceOf, isNumber, isObject, isString };

package/build/utilities.js

@@ -1,3 +1,18 @@
-const { isArray } = Array;
 const { defineProperty } = Object;
-export { defineProperty, isArray };
+const { isArray } = Array;
+const isFunction = (value) => {
+    return typeof value === 'function';
+};
+const isInstanceOf = (instance, match) => {
+    return typeof instance === 'object' && instance !== null && instance.constructor === match;
+};
+const isNumber = (value) => {
+    return !isNaN(value);
+};
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null && value.constructor === Object;
+};
+const isString = (value) => {
+    return typeof value === 'string';
+};
+export { defineProperty, isArray, isFunction, isInstanceOf, isNumber, isObject, isString };

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.30"
+    "version": "0.2.0"
 }

package/src/macro.ts

@@ -3,14 +3,11 @@ import { computed } from './signal';
 import { Computed, Options } from './types';
 
 
-type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
-
-
 class Macro<A extends unknown[], R> extends CustomFunction {
     private factory: Computed<(...args: A) => R>;
 
 
-    constructor(fn: Function<A,R>, options: Options = {}) {
+    constructor(fn: Macro<A,R>['factory']['fn'], options: Options = {}) {
         super((...args: A) => {
             return this.factory.get()(...args);
         });
@@ -24,6 +21,6 @@ class Macro<A extends unknown[], R> extends CustomFunction {
 }
 
 
-export default <A extends unknown[], R>(fn: Function<A,R>, options: Options = {}) => {
+export default <A extends unknown[], R>(fn: Macro<A,R>['factory']['fn'], options: Options = {}) => {
     return new Macro(fn, options);
 };

package/src/reactive/array.ts

@@ -1,41 +1,112 @@
-import { dispose, signal } from '~/signal';
-import { Listener, Object, Options, Signal } from '~/types';
+import { dispose, signal, Reactive } from '~/signal';
+import { Listener, Options, Signal } from '~/types';
+import { isInstanceOf, isNumber, isObject } from '~/utilities';
 import { ReactiveObject } from './object';
 
 
 type Events<T> = {
-    fill: { value: T };
-    pop: { item: T };
-    push: { items: T[] };
+    pop: {
+        item: R<T>;
+    };
+    push: {
+        items: R<T>[];
+    };
     reverse: undefined;
-    shift: { item: T };
+    shift: {
+        item: R<T>;
+    };
     sort: undefined;
-    splice: { deleteCount: number, items: T[], start: number };
-    unshift: { items: T[] };
+    splice: {
+        deleteCount: number;
+        items: R<T>[];
+        start: number;
+    };
+    unshift: {
+        items: R<T>[];
+    };
 };
 
+type R<T> = Signal<T> | ReactiveObject< T extends Record<PropertyKey, unknown> ? { [K in keyof T]: T[K] } : never >;
 
-function factory<T extends Object>(data: T[], options: Options = {}) {
-    let signals = [];
 
-    for (let i = 0, n = data.length; i < n; i++) {
-        signals.push( new ReactiveObject(data[i], options) );
-    }
+let handler = {
+        get(target: any, prop: any) {
+            let value = target[prop];
 
-    return signals;
-}
+            if (value === undefined) {
+                return value;
+            }
+
+            if (isInstanceOf(value, Reactive)) {
+                return value.get();
+            }
+            else if (supported.has(prop)) {
+                return value;
+            }
+
+            throw new Error(`Reactivity: '${prop}' is not supported on reactive arrays`);
+        },
+        set(target: any, prop: any, value: any) {
+            if (isNumber(prop)) {
+                let host = target[prop];
+
+                if (isInstanceOf(host, Reactive)) {
+                    host.set(value);
+                    return true;
+                }
+
+                return false;
+            }
+
+            return target[prop] = value;
+        }
+    },
+    supported = new Set([
+        'at',
+        'dispatch', 'dispose',
+        'length',
+        'map',
+        'on', 'once',
+        'pop', 'push',
+        'reverse',
+        'self', 'shift', 'sort', 'splice',
+        'unshift'
+    ]);
+
+
+function factory<T>(input: T[], options: Options = {}) {
+    let items: R<T>[] = [];
+
+    for (let i = 0, n = input.length; i < n; i++) {
+        let value = input[i];
+
+        if (isObject(value)) {
+            items[i] = new ReactiveObject(value, options);
+        }
+        else {
+            items[i] = signal(value);
+        }
+    }
 
-function unsupported(method: string): never {
-    throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
+    return items;
 }
 
 
-class ReactiveArray<T> extends Array<T> {
+// REMINDER:
+// - @ts-ignore flags are supressing type mismatch error
+// - Input values are being transformed by this class into reactive values and back during get
+class ReactiveArray<T> extends Array<R<T>> {
+    private options: Options;
+    // - Proxy binds itself to methods on get
+    // - Use 'self' to avoid going through proxy for internal loops
+    private self: ReactiveArray<T>;
     private signal: Signal<boolean>;
 
 
-    constructor(data: T[]) {
+    constructor(data: R<T>[], options: Options = {}) {
         super(...data);
+        this.options = options;
+        this.self = this;
         this.signal = signal(false);
     }
 
@@ -49,28 +120,33 @@ class ReactiveArray<T> extends Array<T> {
     }
 
 
+    at(index: number) {
+        let value = super.at(index);
+
+        if (isInstanceOf(value, Reactive)) {
+            return value.get();
+        }
+
+        return value;
+    }
+
     dispatch<E extends keyof Events<T>>(event: E, data?: Events<T>[E]) {
         this.signal.dispatch(event, data);
     }
 
     dispose() {
         this.signal.dispose();
+        dispose(this.self as any);
     }
 
-    fill(value: T, start?: number, end?: number) {
-        super.fill(value, start, end);
-
-        this.dispatch('fill', { value });
-        this.trigger();
-
-        return this;
-    }
-
-    map<U>(fn: (this: ReactiveArray<T>, value: T, i: number, values: this) => U) {
-        let values: U[] = [];
+    // @ts-ignore
+    map<U>(fn: (this: T[], value: T, i: number) => U) {
+        let self = this.self,
+            values: U[] = [];
 
-        for (let i = 0, n = this.length; i < n; i++) {
-            values.push( fn.call(this, this[i], i, this) );
+        for (let i = 0, n = self.length; i < n; i++) {
+            // @ts-ignore
+            values.push( fn.call(this, self[i].value, i) );
         }
 
         return values;
@@ -88,27 +164,27 @@ class ReactiveArray<T> extends Array<T> {
         let item = super.pop();
 
         if (item !== undefined) {
-            this.dispatch('pop', { item });
-            this.trigger();
+            dispose(item);
+            this.signal.dispatch('pop', { item });
         }
 
         return item;
     }
 
-    push(...items: T[]) {
-        let n = super.push(...items);
+    // @ts-ignore
+    push(...input: T[]) {
+        let items = factory(input, this.options),
+            n = super.push(...items);
 
-        this.dispatch('push', { items });
-        this.trigger();
+        this.signal.dispatch('push', { items });
 
         return n;
     }
 
+    // @ts-ignore
     reverse() {
         super.reverse();
-
-        this.dispatch('reverse');
-        this.trigger();
+        this.signal.dispatch('reverse');
 
         return this;
     }
@@ -117,8 +193,8 @@ class ReactiveArray<T> extends Array<T> {
         let item = super.shift();
 
         if (item !== undefined) {
-            this.dispatch('shift', { item });
-            this.trigger();
+            dispose(item);
+            this.signal.dispatch('shift', { item });
         }
 
         return item;
@@ -126,96 +202,41 @@ class ReactiveArray<T> extends Array<T> {
 
     sort() {
         super.sort();
-
-        this.dispatch('sort');
-        this.trigger();
+        this.signal.dispatch('sort');
 
         return this;
     }
 
-    splice(start: number, deleteCount: number = super.length, ...items: T[]) {
-        let removed = super.splice(start, deleteCount, ...items);
+    // @ts-ignore
+    splice(start: number, deleteCount: number = super.length, ...input: T[]) {
+        let items = factory(input, this.options),
+            removed = super.splice(start, deleteCount, ...items);
 
         if (items.length > 0 || removed.length > 0) {
-            this.dispatch('splice', {
+            dispose(removed);
+            this.signal.dispatch('splice', {
                 deleteCount,
                 items,
                 start
             });
-            this.trigger();
         }
 
         return removed;
     }
 
-    track(index?: number) {
-        this.signal.get();
-        return index === undefined ? undefined : this[index];
-    }
-
-    trigger() {
-        this.signal.set(!this.signal.value);
-    }
-
-    unshift(...items: T[]) {
-        let length = super.unshift(...items);
-
-        this.dispatch('unshift', { items });
-        this.trigger();
-
-        return length;
-    }
-}
-
-
-// REMINDER:
-// - @ts-ignore flags are supressing a type mismatch error
-// - Input values are being transformed by this class into signals
-class ReactiveObjectArray<T extends Object>  extends ReactiveArray<ReactiveObject<T>> {
-    private options: Options;
-
-
-    constructor(data: T[], options: Options = {}) {
-        super( factory(data, options) );
-        this.options = options;
-    }
-
-
-    fill() {
-        return unsupported('fill');
-    }
-
-    reverse() {
-        return unsupported('reverse');
-    }
-
-    pop() {
-        return dispose(super.pop()) as ReactiveObject<T>| undefined;
-    }
-
     // @ts-ignore
-    push(...values: T[]) {
-        return super.push(...factory(values, this.options));
-    }
+    unshift(...input: T[]) {
+        let items = factory(input, this.options),
+            length = super.unshift(...items);
 
-    shift() {
-        return dispose(super.shift()) as ReactiveObject<T> | undefined;
-    }
+        this.signal.dispatch('unshift', { items });
 
-    sort() {
-        return unsupported('sort');
-    }
-
-    // @ts-ignore
-    splice(start: number, deleteCount: number = super.length, ...values: T[]) {
-        return dispose( super.splice(start, deleteCount, ...factory(values, this.options)) );
-    }
-
-    // @ts-ignore
-    unshift(...values: T[]) {
-        return super.unshift(...factory(values, this.options));
+        return length;
     }
 }
 
 
-export { ReactiveArray, ReactiveObjectArray };
+export default <T>(input: T[], options: Options = {}) => {
+    return new Proxy(new ReactiveArray(factory(input, options)), handler);
+};
+export { ReactiveArray };

package/src/reactive/index.ts

@@ -1,40 +1,41 @@
-import { Computed, Object, Options, Prettify, Signal } from '~/types';
-import { ReactiveArray, ReactiveObjectArray } from './array';
-import { ReactiveObject } from './object';
+import { Prettify } from '@esportsplus/typescript';
+import { Options } from '~/types';
+import { default as array, ReactiveArray } from './array';
+import { default as object, ReactiveObject } from './object';
+import { isArray, isObject } from '~/utilities';
 
 
 type Guard<T> =
-    T extends Object
+    T extends Record<PropertyKey, unknown>
         ? { [K in keyof T]: Never<K, Guard<T[K]>> }
         : T extends unknown[]
-            ? Guard<T[number]>[]
-            : T;
+            ? T
+            : never;
 
 type Infer<T> =
     T extends (...args: unknown[]) => unknown
         ? ReturnType<T>
-        : T extends unknown[]
-            ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]>
-            : T extends Object
+        : T extends (infer U)[]
+            ? Prettify< Omit<U[], 'map'> & Pick<ReactiveArray<U>, 'dispatch' | 'dispose' | 'map' | 'on' | 'once'> >
+            : T extends Record<PropertyKey, unknown>
                 ? { [K in keyof T]: T[K] }
                 : T;
 
-type Never<K,V> = K extends keyof ReactiveObject<Object> ? never : V;
+type Never<K,V> = K extends keyof ReactiveObject<Record<PropertyKey, unknown>> ? never : V;
 
-type Nodes<T> =
-    T extends (...args: unknown[]) => unknown
-        ? Computed<T>
-        : T extends unknown[]
-            ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]>
-            : Signal<T>;
 
-type Signals<T extends Object> = {
-    [K in keyof T]: Nodes<T[K]>
-};
+export default <T>(data: Guard<T>, options: Options = {}) => {
+    let value;
 
+    if (isArray(data)) {
+        value = array(data, options);
+    }
+    else if (isObject(data)) {
+        value = object(data as { [K in keyof T]: T[K] }, options);
+    }
+    else {
+        throw new Error('Reactivity: received invalid input for `reactive()`', data);
+    }
 
-export default <T extends Object>(data: Guard<T>, options?: Options) => {
-    return new ReactiveObject(data, options) as any as Prettify<
-        { [K in keyof T]: Infer<T[K]> } & Omit<ReactiveObject<T>, 'signals'> & { signals: Signals<T> }
-    >;
+    return value as T extends Record<PropertyKey, unknown> ? { [K in keyof T]: Infer<T[K]> } : Infer<T>;
 };

package/src/reactive/object.ts

@@ -1,14 +1,11 @@
 import { computed, signal } from '~/signal';
-import { Computed, Object, Options, Signal } from '~/types';
-import { defineProperty, isArray } from '~/utilities';
-import { ReactiveArray, ReactiveObjectArray } from './array';
+import { Computed, Options, Signal } from '~/types';
+import { defineProperty, isArray, isFunction } from '~/utilities';
+import { default as array, ReactiveArray } from './array';
 
 
-type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
-
-
-class ReactiveObject<T extends Object> {
-    signals: Record<PropertyKey, Node> = {};
+class ReactiveObject<T extends Record<PropertyKey, unknown>> {
+    signals: Record<PropertyKey, Computed<any> | ReactiveArray<any> | Signal<any>> = {};
 
 
     constructor(data: T, options: Options = {}) {
@@ -17,33 +14,23 @@ class ReactiveObject<T extends Object> {
         for (let key in data) {
             let input = data[key];
 
-            if (typeof input === 'function') {
-                let s = signals[key] = computed(input as Computed<T>['fn'], options);
+            if (isArray(input)) {
+                let s = signals[key] = array(input, options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return s.get();
+                        return s;
                     }
                 });
             }
-            else if (isArray(input)) {
-                let s: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
-                    test = input[0];
-
-                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
-                    s = signals[key] = new ReactiveObjectArray(input, options);
-                }
-                else {
-                    s = signals[key] = new ReactiveArray(input);
-                }
+            else if (isFunction(input)) {
+                let s = signals[key] = computed(input as Computed<T>['fn'], options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        s.track();
-
-                        return s;
+                        return s.get();
                     }
                 });
             }
@@ -64,6 +51,11 @@ class ReactiveObject<T extends Object> {
     }
 
 
+    get value() {
+        return this;
+    }
+
+
     dispose() {
         let signals = this.signals;
 
@@ -74,4 +66,7 @@ class ReactiveObject<T extends Object> {
 }
 
 
+export default <T extends Record<PropertyKey, unknown>>(input: T, options: Options = {}) => {
+    return new ReactiveObject(input, options);
+};
 export { ReactiveObject };

package/src/resource.ts

@@ -3,9 +3,6 @@ import { signal } from './signal';
 import { Options, Signal } from './types';
 
 
-type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
-
-
 class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
     private arguments: Signal<A | null>;
     private okay: Signal<boolean | null>;
@@ -14,7 +11,7 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
     stop: boolean | null = null;
 
 
-    constructor(fn: Function<A,R>, options: Options = {}) {
+    constructor(fn: (...args: A) => R, options: Options = {}) {
         super((...args: A) => {
             this.stop = null;
 
@@ -66,6 +63,6 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
 }
 
 
-export default <A extends unknown[], R extends Promise<unknown>>(fn: Function<A,R>, options: Options = {}) => {
+export default <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R, options: Options = {}) => {
     return new Resource(fn, options);
 };

package/src/types.ts

@@ -27,8 +27,6 @@ type Listener<D> = {
     <V>(event: { data?: D, value: V }): void;
 };
 
-type Object = Record<PropertyKey, unknown>;
-
 type Options = {
     changed?: Changed;
 };
@@ -52,4 +50,15 @@ type State = typeof CHECK | typeof CLEAN | typeof DIRTY | typeof DISPOSED;
 type Type = typeof COMPUTED | typeof EFFECT | typeof ROOT | typeof SIGNAL;
 
 
-export type { Changed, Computed, Effect, Event, Function, Listener, Object, Options, NeverAsync, Prettify, Root, Scheduler, Signal, State, Type };
+export type {
+    Changed, Computed,
+    Effect, Event,
+    Function,
+    Listener,
+    NeverAsync,
+    Options,
+    Prettify,
+    Root,
+    Scheduler, Signal, State,
+    Type
+};

package/src/utilities.ts

@@ -1,6 +1,26 @@
+const { defineProperty } = Object;
+
 const { isArray } = Array;
 
-const { defineProperty } = Object;
+const isFunction = (value: unknown): value is Function => {
+    return typeof value === 'function';
+};
+
+const isInstanceOf = <T>(instance: unknown, match: new (...args: any) => T): instance is T => {
+    return typeof instance === 'object' && instance !== null && instance.constructor === match;
+};
+
+const isNumber = (value: any): value is number => {
+    return !isNaN(value);
+};
+
+const isObject = (value: unknown): value is Record<PropertyKey, unknown> => {
+    return typeof value === 'object' && value !== null && value.constructor === Object;
+};
+
+const isString = (value: unknown): value is string => {
+    return typeof value === 'string';
+};
 
 
-export { defineProperty, isArray };
+export { defineProperty, isArray, isFunction, isInstanceOf, isNumber, isObject, isString };