@esportsplus/reactivity 0.1.28 → 0.1.30

package/build/reactive/array.d.ts

@@ -24,15 +24,14 @@ type Events<T> = {
         items: T[];
     };
 };
-type Node<T extends Object> = ReactiveObject<T>;
 declare class ReactiveArray<T> extends Array<T> {
     private signal;
     constructor(data: T[]);
     set length(n: number);
-    private trigger;
     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[];
     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;
@@ -41,19 +40,20 @@ declare class ReactiveArray<T> extends Array<T> {
     shift(): T | undefined;
     sort(): this;
     splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    track(): void;
+    track(index?: number): T | undefined;
+    trigger(): void;
     unshift(...items: T[]): number;
 }
-declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<Node<T>> {
+declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<ReactiveObject<T>> {
     private options;
     constructor(data: T[], options?: Options);
     fill(): never;
     reverse(): never;
-    pop(): Node<T> | undefined;
+    pop(): ReactiveObject<T> | undefined;
     push(...values: T[]): number;
-    shift(): Node<T> | undefined;
+    shift(): ReactiveObject<T> | undefined;
     sort(): never;
-    splice(start: number, deleteCount?: number, ...values: T[]): Node<T> | Node<T>[] | null | undefined;
+    splice(start: number, deleteCount?: number, ...values: T[]): ReactiveObject<T> | ReactiveObject<T>[] | null | undefined;
     unshift(...values: T[]): number;
 }
 export { ReactiveArray, ReactiveObjectArray };

package/build/reactive/array.js

@@ -22,9 +22,6 @@ class ReactiveArray extends Array {
         }
         this.splice(n);
     }
-    trigger() {
-        this.signal.set(!this.signal.value);
-    }
     dispatch(event, data) {
         this.signal.dispatch(event, data);
     }
@@ -37,6 +34,13 @@ class ReactiveArray extends Array {
         this.trigger();
         return this;
     }
+    map(fn) {
+        let values = [];
+        for (let i = 0, n = this.length; i < n; i++) {
+            values.push(fn.call(this, this[i], i, this));
+        }
+        return values;
+    }
     on(event, listener) {
         this.signal.on(event, listener);
     }
@@ -89,8 +93,12 @@ class ReactiveArray extends Array {
         }
         return removed;
     }
-    track() {
+    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);

package/build/reactive/index.d.ts

@@ -4,15 +4,15 @@ import { ReactiveObject } from './object';
 type Guard<T> = T extends Object ? {
     [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[] ? Infer<T[number]>[] : T extends Object ? {
+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 ? {
     [K in keyof T]: T[K];
 } : T;
 type Never<K, V> = K extends keyof ReactiveObject<Object> ? never : V;
-type Node<T> = T extends (...args: unknown[]) => unknown ? Computed<T> : T extends unknown[] ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T> : Signal<T>;
-type Nodes<T extends Object> = {
-    [K in keyof T]: Node<T[K]>;
+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>, "nodes"> & {
-    nodes: Nodes<T>;
+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>;
 }>;
 export default _default;

package/build/reactive/object.d.ts

@@ -2,7 +2,7 @@ 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> {
-    nodes: Record<PropertyKey, Node>;
+    signals: Record<PropertyKey, Node>;
     constructor(data: T, options?: Options);
     dispose(): void;
 }

package/build/reactive/object.js

@@ -2,54 +2,54 @@ import { computed, signal } from '../signal';
 import { defineProperty, isArray } from '../utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 class ReactiveObject {
-    nodes = {};
+    signals = {};
     constructor(data, options = {}) {
-        let nodes = this.nodes;
+        let signals = this.signals;
         for (let key in data) {
             let input = data[key];
             if (typeof input === 'function') {
-                let node = nodes[key] = computed(input, options);
+                let s = signals[key] = computed(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return node.get();
+                        return s.get();
                     }
                 });
             }
             else if (isArray(input)) {
-                let node, test = input[0];
+                let s, test = input[0];
                 if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
-                    node = nodes[key] = new ReactiveObjectArray(input, options);
+                    s = signals[key] = new ReactiveObjectArray(input, options);
                 }
                 else {
-                    node = nodes[key] = new ReactiveArray(input);
+                    s = signals[key] = new ReactiveArray(input);
                 }
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        node.track();
-                        return node;
+                        s.track();
+                        return s;
                     }
                 });
             }
             else {
-                let node = nodes[key] = signal(input, options);
+                let s = signals[key] = signal(input, options);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return node.get();
+                        return s.get();
                     },
                     set(value) {
-                        node.set(value);
+                        s.set(value);
                     }
                 });
             }
         }
     }
     dispose() {
-        let nodes = this.nodes;
-        for (let key in nodes) {
-            nodes[key].dispose();
+        let signals = this.signals;
+        for (let key in signals) {
+            signals[key].dispose();
         }
     }
 }

package/package.json

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

package/src/reactive/array.ts

@@ -14,8 +14,6 @@ type Events<T> = {
     unshift: { items: T[] };
 };
 
-type Node<T extends Object> = ReactiveObject<T>;
-
 
 function factory<T extends Object>(data: T[], options: Options = {}) {
     let signals = [];
@@ -51,11 +49,6 @@ class ReactiveArray<T> extends Array<T> {
     }
 
 
-    private trigger() {
-        this.signal.set(!this.signal.value);
-    }
-
-
     dispatch<E extends keyof Events<T>>(event: E, data?: Events<T>[E]) {
         this.signal.dispatch(event, data);
     }
@@ -73,6 +66,16 @@ class ReactiveArray<T> extends Array<T> {
         return this;
     }
 
+    map<U>(fn: (this: ReactiveArray<T>, value: T, i: number, values: this) => U) {
+        let values: U[] = [];
+
+        for (let i = 0, n = this.length; i < n; i++) {
+            values.push( fn.call(this, this[i], i, this) );
+        }
+
+        return values;
+    }
+
     on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
         this.signal.on(event, listener);
     }
@@ -145,8 +148,13 @@ class ReactiveArray<T> extends Array<T> {
         return removed;
     }
 
-    track() {
+    track(index?: number) {
         this.signal.get();
+        return index === undefined ? undefined : this[index];
+    }
+
+    trigger() {
+        this.signal.set(!this.signal.value);
     }
 
     unshift(...items: T[]) {
@@ -162,8 +170,8 @@ class ReactiveArray<T> extends Array<T> {
 
 // REMINDER:
 // - @ts-ignore flags are supressing a type mismatch error
-// - Input values are being transformed by this class into nodes
-class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
+// - Input values are being transformed by this class into signals
+class ReactiveObjectArray<T extends Object>  extends ReactiveArray<ReactiveObject<T>> {
     private options: Options;
 
 
@@ -182,7 +190,7 @@ class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
     }
 
     pop() {
-        return dispose(super.pop()) as Node<T> | undefined;
+        return dispose(super.pop()) as ReactiveObject<T>| undefined;
     }
 
     // @ts-ignore
@@ -191,7 +199,7 @@ class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
     }
 
     shift() {
-        return dispose(super.shift()) as Node<T> | undefined;
+        return dispose(super.shift()) as ReactiveObject<T> | undefined;
     }
 
     sort() {

package/src/reactive/index.ts

@@ -14,25 +14,27 @@ type Infer<T> =
     T extends (...args: unknown[]) => unknown
         ? ReturnType<T>
         : T extends unknown[]
-            ? Infer<T[number]>[]
+            ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]>
             : T extends Object
                 ? { [K in keyof T]: T[K] }
                 : T;
 
 type Never<K,V> = K extends keyof ReactiveObject<Object> ? never : V;
 
-type Node<T> =
+type Nodes<T> =
     T extends (...args: unknown[]) => unknown
         ? Computed<T>
         : T extends unknown[]
-            ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T>
+            ? T extends Object[] ? ReactiveObjectArray<T[0]> : ReactiveArray<T[0]>
             : Signal<T>;
 
-type Nodes<T extends Object> = { [K in keyof T]: Node<T[K]> };
+type Signals<T extends Object> = {
+    [K in keyof T]: Nodes<T[K]>
+};
 
 
 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>, 'nodes'> & { nodes: Nodes<T> }
+        { [K in keyof T]: Infer<T[K]> } & Omit<ReactiveObject<T>, 'signals'> & { signals: Signals<T> }
     >;
 };

package/src/reactive/object.ts

@@ -8,55 +8,55 @@ type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | S
 
 
 class ReactiveObject<T extends Object> {
-    nodes: Record<PropertyKey, Node> = {};
+    signals: Record<PropertyKey, Node> = {};
 
 
     constructor(data: T, options: Options = {}) {
-        let nodes = this.nodes;
+        let signals = this.signals;
 
         for (let key in data) {
             let input = data[key];
 
             if (typeof input === 'function') {
-                let node = nodes[key] = computed(input as Computed<T>['fn'], options);
+                let s = signals[key] = computed(input as Computed<T>['fn'], options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return node.get();
+                        return s.get();
                     }
                 });
             }
             else if (isArray(input)) {
-                let node: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
+                let s: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
                     test = input[0];
 
                 if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
-                    node = nodes[key] = new ReactiveObjectArray(input, options);
+                    s = signals[key] = new ReactiveObjectArray(input, options);
                 }
                 else {
-                    node = nodes[key] = new ReactiveArray(input);
+                    s = signals[key] = new ReactiveArray(input);
                 }
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        node.track();
+                        s.track();
 
-                        return node;
+                        return s;
                     }
                 });
             }
             else {
-                let node = nodes[key] = signal(input, options);
+                let s = signals[key] = signal(input, options);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return node.get();
+                        return s.get();
                     },
                     set(value) {
-                        node.set(value);
+                        s.set(value);
                     }
                 });
             }
@@ -65,10 +65,10 @@ class ReactiveObject<T extends Object> {
 
 
     dispose() {
-        let nodes = this.nodes;
+        let signals = this.signals;
 
-        for (let key in nodes) {
-            nodes[key].dispose();
+        for (let key in signals) {
+            signals[key].dispose();
         }
     }
 }