@esportsplus/reactivity 0.1.19 → 0.1.21

package/src/reactive/object.ts

@@ -1,77 +1,77 @@
-import { computed, signal } from '~/signal';
-import { Computed, Object, Options, Signal } from '~/types';
-import { defineProperty, isArray } from '~/utilities';
-import { ReactiveArray, ReactiveObjectArray } from './array';
-
-
-type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
-
-
-class ReactiveObject<T extends Object> {
-    nodes: Record<PropertyKey, Node> = {};
-
-
-    constructor(data: T, options: Options = {}) {
-        let nodes = this.nodes;
-
-        for (let key in data) {
-            let input = data[key];
-
-            if (typeof input === 'function') {
-                let node = nodes[key] = computed(input as Computed<T>['fn'], options);
-
-                defineProperty(this, key, {
-                    enumerable: true,
-                    get() {
-                        return node.get();
-                    }
-                });
-            }
-            else if (isArray(input)) {
-                let node: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
-                    test = input[0];
-
-                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
-                    node = nodes[key] = new ReactiveObjectArray(input, options);
-                }
-                else {
-                    node = nodes[key] = new ReactiveArray(input);
-                }
-
-                defineProperty(this, key, {
-                    enumerable: true,
-                    get() {
-                        node.track();
-
-                        return node;
-                    }
-                });
-            }
-            else {
-                let node = nodes[key] = signal(input, options);
-
-                defineProperty(this, key, {
-                    enumerable: true,
-                    get() {
-                        return node.get();
-                    },
-                    set(value) {
-                        node.set(value);
-                    }
-                });
-            }
-        }
-    }
-
-
-    dispose() {
-        let nodes = this.nodes;
-
-        for (let key in nodes) {
-            nodes[key].dispose();
-        }
-    }
-}
-
-
+import { computed, signal } from '~/signal';
+import { Computed, Object, Options, Signal } from '~/types';
+import { defineProperty, isArray } from '~/utilities';
+import { ReactiveArray, ReactiveObjectArray } from './array';
+
+
+type Node = Computed<any> | ReactiveArray<any> | ReactiveObjectArray<Object> | Signal<any>;
+
+
+class ReactiveObject<T extends Object> {
+    nodes: Record<PropertyKey, Node> = {};
+
+
+    constructor(data: T, options: Options = {}) {
+        let nodes = this.nodes;
+
+        for (let key in data) {
+            let input = data[key];
+
+            if (typeof input === 'function') {
+                let node = nodes[key] = computed(input as Computed<T>['fn'], options);
+
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        return node.get();
+                    }
+                });
+            }
+            else if (isArray(input)) {
+                let node: ReactiveArray<unknown> | ReactiveObjectArray<Object>,
+                    test = input[0];
+
+                if (typeof test === 'object' && test !== null && test?.constructor?.name === 'Object') {
+                    node = nodes[key] = new ReactiveObjectArray(input, options);
+                }
+                else {
+                    node = nodes[key] = new ReactiveArray(input);
+                }
+
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        node.track();
+
+                        return node;
+                    }
+                });
+            }
+            else {
+                let node = nodes[key] = signal(input, options);
+
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        return node.get();
+                    },
+                    set(value) {
+                        node.set(value);
+                    }
+                });
+            }
+        }
+    }
+
+
+    dispose() {
+        let nodes = this.nodes;
+
+        for (let key in nodes) {
+            nodes[key].dispose();
+        }
+    }
+}
+
+
 export { ReactiveObject };

package/src/resource.ts

@@ -1,71 +1,71 @@
-import CustomFunction from '@esportsplus/custom-function';
-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 {
-    #data: Signal<Awaited<R>>;
-    #input: Signal<A | null>;
-    #ok: Signal<boolean | null>;
-
-    stop: boolean | null = null;
-
-
-    constructor(fn: Function<A,R>, options: Options = {}) {
-        super((...args: A) => {
-            this.stop = null;
-
-            this.#input.set(args);
-            this.#ok.set(null);
-
-            fn(...args)
-                .then((value) => {
-                    if (this.stop === true) {
-                        return;
-                    }
-
-                    this.#data.set(value as Awaited<R>);
-                    this.#ok.set(true);
-                })
-                .catch(() => {
-                    if (this.stop === true) {
-                        return;
-                    }
-
-                    this.#data.set(undefined as Awaited<R>);
-                    this.#ok.set(false);
-                });
-        });
-        this.#data = signal(undefined as Awaited<R>, options);
-        this.#input = signal<A | null>(null, options);
-        this.#ok = signal<boolean | null>(null, options);
-    }
-
-
-    get data() {
-        return this.#data.get();
-    }
-
-    get input() {
-        return this.#input.get();
-    }
-
-    get ok() {
-        return this.#ok.get();
-    }
-
-
-    dispose() {
-        this.#data.dispose();
-        this.#input.dispose();
-        this.#ok.dispose();
-    }
-}
-
-
-export default <A extends unknown[], R extends Promise<unknown>>(fn: Function<A,R>, options: Options = {}) => {
-    return new Resource(fn, options);
+import CustomFunction from '@esportsplus/custom-function';
+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 {
+    #data: Signal<Awaited<R>>;
+    #input: Signal<A | null>;
+    #ok: Signal<boolean | null>;
+
+    stop: boolean | null = null;
+
+
+    constructor(fn: Function<A,R>, options: Options = {}) {
+        super((...args: A) => {
+            this.stop = null;
+
+            this.#input.set(args);
+            this.#ok.set(null);
+
+            fn(...args)
+                .then((value) => {
+                    if (this.stop === true) {
+                        return;
+                    }
+
+                    this.#data.set(value as Awaited<R>);
+                    this.#ok.set(true);
+                })
+                .catch(() => {
+                    if (this.stop === true) {
+                        return;
+                    }
+
+                    this.#data.set(undefined as Awaited<R>);
+                    this.#ok.set(false);
+                });
+        });
+        this.#data = signal(undefined as Awaited<R>, options);
+        this.#input = signal<A | null>(null, options);
+        this.#ok = signal<boolean | null>(null, options);
+    }
+
+
+    get data() {
+        return this.#data.get();
+    }
+
+    get input() {
+        return this.#input.get();
+    }
+
+    get ok() {
+        return this.#ok.get();
+    }
+
+
+    dispose() {
+        this.#data.dispose();
+        this.#input.dispose();
+        this.#ok.dispose();
+    }
+}
+
+
+export default <A extends unknown[], R extends Promise<unknown>>(fn: Function<A,R>, options: Options = {}) => {
+    return new Resource(fn, options);
 };