@esportsplus/reactivity 0.1.0 → 0.1.1

package/build/reactive/array.d.ts

@@ -1,4 +1,4 @@
-import { Listener, Options } from '../types';
+import { Listener, Object, Options } from '../types';
 import { ReactiveObject } from './object';
 type Events<T> = {
     fill: {
@@ -24,7 +24,7 @@ type Events<T> = {
         items: T[];
     };
 };
-type Node<T extends Record<PropertyKey, unknown>> = ReactiveObject<T>;
+type Node<T extends Object> = ReactiveObject<T>;
 declare class ReactiveArray<T> extends Array<T> {
     #private;
     constructor(data: T[]);
@@ -45,7 +45,7 @@ declare class ReactiveArray<T> extends Array<T> {
     track(): void;
     unshift(...items: T[]): number;
 }
-declare class ReactiveObjectArray<T extends Record<PropertyKey, unknown>> extends ReactiveArray<Node<T>> {
+declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<Node<T>> {
     #private;
     constructor(data: T[], options?: Options);
     fill(): never;

package/build/reactive/index.d.ts

@@ -1,4 +1,5 @@
-import { Object, Options } from '../types';
+import { Computed, Object, Options, Signal } from '../types';
+import { ReactiveArray, ReactiveObjectArray } from './array';
 import { ReactiveObject } from './object';
 type Guard<T> = T extends Object ? {
     [K in keyof T]: Never<K, Guard<T[K]>>;
@@ -7,5 +8,13 @@ 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;
-declare const _default: <T extends Object>(data: Guard<T>, options?: Options) => { [K_1 in keyof T]: Infer<T[K_1]>; } & ReactiveObject<T> extends infer T_1 ? { [K in keyof T_1]: ({ [K_1 in keyof T]: Infer<T[K_1]>; } & ReactiveObject<T>)[K]; } : never;
+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]>;
+};
+declare const _default: <T extends Object>(data: Guard<T>, options?: Options) => { [K_1 in keyof T]: Infer<T[K_1]>; } & Omit<ReactiveObject<T>, "nodes"> & {
+    nodes: Nodes<T>;
+} extends infer T_1 ? { [K in keyof T_1]: ({ [K_1 in keyof T]: Infer<T[K_1]>; } & Omit<ReactiveObject<T>, "nodes"> & {
+    nodes: Nodes<T>;
+})[K]; } : never;
 export default _default;

package/build/reactive/object.d.ts

@@ -1,12 +1,7 @@
-import { Computed, Options, Signal } from '../types';
+import { Computed, Object, Options, Signal } from '../types';
 import { ReactiveArray, ReactiveObjectArray } from './array';
-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 Object = Record<PropertyKey, unknown>;
 declare class ReactiveObject<T extends Object> {
-    nodes: Nodes<T>;
+    nodes: Record<PropertyKey, Computed<unknown> | ReactiveObjectArray<Object> | ReactiveArray<unknown> | Signal<unknown>>;
     constructor(data: T, options?: Options);
     dispose(): void;
     reset(): void;

package/build/reactive/object.js

@@ -2,9 +2,9 @@ import { computed, read, signal, write } from '../signal';
 import { defineProperty, isArray } from '../utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 class ReactiveObject {
-    nodes;
+    nodes = {};
     constructor(data, options = {}) {
-        let nodes = {};
+        let nodes = this.nodes;
         for (let key in data) {
             let input = data[key];
             if (typeof input === 'function') {
@@ -42,7 +42,6 @@ class ReactiveObject {
                 });
             }
         }
-        this.nodes = nodes;
     }
     dispose() {
         let nodes = this.nodes;

package/package.json

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

package/src/reactive/array.ts

@@ -1,5 +1,5 @@
 import { dispose, read, signal, write } from '~/signal';
-import { Listener, Options, Signal } from '~/types';
+import { Listener, Object, Options, Signal } from '~/types';
 import { ReactiveObject } from './object';
 
 
@@ -14,10 +14,10 @@ type Events<T> = {
     unshift: { items: T[] };
 };
 
-type Node<T extends Record<PropertyKey, unknown>> = ReactiveObject<T>;
+type Node<T extends Object> = ReactiveObject<T>;
 
 
-function factory<T extends Record<PropertyKey, unknown>>(data: T[], options: Options = {}) {
+function factory<T extends Object>(data: T[], options: Options = {}) {
     let signals = [];
 
     for (let i = 0, n = data.length; i < n; i++) {
@@ -169,7 +169,7 @@ 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 Record<PropertyKey, unknown>>  extends ReactiveArray<Node<T>> {
+class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
     #options: Options;
 
 

package/src/reactive/index.ts

@@ -1,4 +1,5 @@
-import { Object, Options, Prettify } from '~/types';
+import { Computed, Object, Options, Prettify, Signal } from '~/types';
+import { ReactiveArray, ReactiveObjectArray } from './array';
 import { ReactiveObject } from './object';
 
 
@@ -20,7 +21,18 @@ type Infer<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]> };
+
 
 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]> } & ReactiveObject<T> >;
+    return new ReactiveObject(data, options) as any as Prettify<
+        { [K in keyof T]: Infer<T[K]> } & Omit<ReactiveObject<T>, 'nodes'> & { nodes: Nodes<T> }
+    >;
 };

package/src/reactive/object.ts

@@ -1,27 +1,15 @@
 import { computed, read, signal, write } from '~/signal';
-import { Computed, Options, Signal } from '~/types';
+import { Computed, Object, Options, Signal } from '~/types';
 import { defineProperty, isArray } from '~/utilities';
 import { ReactiveArray, ReactiveObjectArray } from './array';
 
 
-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 Object = Record<PropertyKey, unknown>;
-
-
 class ReactiveObject<T extends Object> {
-    nodes: Nodes<T>;
+    nodes: Record<PropertyKey, Computed<unknown> | ReactiveObjectArray<Object> | ReactiveArray<unknown> | Signal<unknown>> = {};
 
 
     constructor(data: T, options: Options = {}) {
-        let nodes: Object = {};
+        let nodes = this.nodes;
 
         for (let key in data) {
             let input = data[key];
@@ -67,8 +55,6 @@ class ReactiveObject<T extends Object> {
                 });
             }
         }
-
-        this.nodes = nodes as typeof this.nodes;
     }