@esportsplus/reactivity 0.1.27 → 0.1.29

package/build/reactive/array.d.ts

@@ -24,7 +24,6 @@ type Events<T> = {
         items: T[];
     };
 };
-type Node<T extends Object> = ReactiveObject<T>;
 declare class ReactiveArray<T> extends Array<T> {
     private signal;
     constructor(data: T[]);
@@ -33,6 +32,7 @@ declare class ReactiveArray<T> extends Array<T> {
     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: (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;
@@ -44,16 +44,16 @@ declare class ReactiveArray<T> extends Array<T> {
     track(): 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

@@ -13,7 +13,7 @@ function unsupported(method) {
 class ReactiveArray extends Array {
     signal;
     constructor(data) {
-        super(...data);
+        super(data);
         this.signal = signal(false);
     }
     set length(n) {
@@ -37,6 +37,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(this[i], i, this));
+        }
+        return values;
+    }
     on(event, listener) {
         this.signal.on(event, listener);
     }

package/build/reactive/index.d.ts

@@ -8,11 +8,11 @@ type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T ex
     [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> : 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

@@ -1,7 +1,7 @@
 {
     "author": "ICJR",
     "dependencies": {
-        "@esportsplus/custom-function": "^0.0.6"
+        "@esportsplus/custom-function": "^0.0.7"
     },
     "devDependencies": {
         "@esportsplus/typescript": "^0.4.9"
@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.27"
+    "version": "0.1.29"
 }

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 = [];
@@ -37,7 +35,8 @@ class ReactiveArray<T> extends Array<T> {
 
 
     constructor(data: T[]) {
-        super(...data);
+        // @ts-ignore
+        super(data);
         this.signal = signal(false);
     }
 
@@ -73,6 +72,16 @@ class ReactiveArray<T> extends Array<T> {
         return this;
     }
 
+    map<U>(fn: (value: T, i: number, values: this) => U) {
+        let values: U[] = [];
+
+        for (let i = 0, n = this.length; i < n; i++) {
+            values.push( fn(this[i], i, this) );
+        }
+
+        return values;
+    }
+
     on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
         this.signal.on(event, listener);
     }
@@ -162,8 +171,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 +191,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 +200,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

@@ -21,18 +21,20 @@ type Infer<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>
             : 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();
         }
     }
 }