@esportsplus/reactivity 0.1.18 → 0.1.20

package/src/reactive/array.ts

@@ -1,215 +1,213 @@
-import { dispose, signal } from '~/signal';
-import { Listener, Object, Options, Signal } from '~/types';
-import { ReactiveObject } from './object';
-
-
-type Events<T> = {
-    fill: { value: T };
-    pop: { item: T };
-    push: { items: T[] };
-    reverse: undefined;
-    shift: { item: T };
-    sort: undefined;
-    splice: { deleteCount: number, items: T[], start: number };
-    unshift: { items: T[] };
-};
-
-type Node<T extends Object> = ReactiveObject<T>;
-
-
-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) );
-    }
-
-    return signals;
-}
-
-function unsupported(method: string): never {
-    throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
-}
-
-
-// TODO:
-// - patch method ( diff )
-class ReactiveArray<T> extends Array<T> {
-    #signal: Signal<boolean>;
-
-
-    constructor(data: T[]) {
-        super(...data);
-        this.#signal = signal(false);
-    }
-
-
-    set length(n: number) {
-        if (n > this.length) {
-            return;
-        }
-
-        this.splice(n);
-    }
-
-
-    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);
-    }
-
-    dispose() {
-        this.#signal.dispose();
-    }
-
-    fill(value: T, start?: number, end?: number) {
-        super.fill(value, start, end);
-
-        this.dispatch('fill', { value });
-        this.trigger();
-
-        return this;
-    }
-
-    on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
-        this.#signal.on(event, listener);
-    }
-
-    once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
-        this.#signal.once(event, listener);
-    }
-
-    pop() {
-        let item = super.pop();
-
-        if (item !== undefined) {
-            this.dispatch('pop', { item });
-            this.trigger();
-        }
-
-        return item;
-    }
-
-    push(...items: T[]) {
-        let n = super.push(...items);
-
-        this.dispatch('push', { items });
-        this.trigger();
-
-        return n;
-    }
-
-    reverse() {
-        super.reverse();
-
-        this.dispatch('reverse');
-        this.trigger();
-
-        return this;
-    }
-
-    shift() {
-        let item = super.shift();
-
-        if (item !== undefined) {
-            this.dispatch('shift', { item });
-            this.trigger();
-        }
-
-        return item;
-    }
-
-    sort() {
-        super.sort();
-
-        this.dispatch('sort');
-        this.trigger();
-
-        return this;
-    }
-
-    splice(start: number, deleteCount: number = super.length, ...items: T[]) {
-        let removed = super.splice(start, deleteCount, ...items);
-
-        if (items.length > 0 || removed.length > 0) {
-            this.dispatch('splice', {
-                deleteCount,
-                items,
-                start
-            });
-            this.trigger();
-        }
-
-        return removed;
-    }
-
-    track() {
-        this.#signal.get();
-    }
-
-    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 nodes
-class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
-    #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 Node<T> | undefined;
-    }
-
-    // @ts-ignore
-    push(...values: T[]) {
-        return super.push(...factory(values, this.#options));
-    }
-
-    shift() {
-        return dispose(super.shift()) as Node<T> | undefined;
-    }
-
-    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));
-    }
-}
-
-
+import { dispose, signal } from '~/signal';
+import { Listener, Object, Options, Signal } from '~/types';
+import { ReactiveObject } from './object';
+
+
+type Events<T> = {
+    fill: { value: T };
+    pop: { item: T };
+    push: { items: T[] };
+    reverse: undefined;
+    shift: { item: T };
+    sort: undefined;
+    splice: { deleteCount: number, items: T[], start: number };
+    unshift: { items: T[] };
+};
+
+type Node<T extends Object> = ReactiveObject<T>;
+
+
+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) );
+    }
+
+    return signals;
+}
+
+function unsupported(method: string): never {
+    throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
+}
+
+
+class ReactiveArray<T> extends Array<T> {
+    #signal: Signal<boolean>;
+
+
+    constructor(data: T[]) {
+        super(...data);
+        this.#signal = signal(false);
+    }
+
+
+    set length(n: number) {
+        if (n > this.length) {
+            return;
+        }
+
+        this.splice(n);
+    }
+
+
+    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);
+    }
+
+    dispose() {
+        this.#signal.dispose();
+    }
+
+    fill(value: T, start?: number, end?: number) {
+        super.fill(value, start, end);
+
+        this.dispatch('fill', { value });
+        this.trigger();
+
+        return this;
+    }
+
+    on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
+        this.#signal.on(event, listener);
+    }
+
+    once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
+        this.#signal.once(event, listener);
+    }
+
+    pop() {
+        let item = super.pop();
+
+        if (item !== undefined) {
+            this.dispatch('pop', { item });
+            this.trigger();
+        }
+
+        return item;
+    }
+
+    push(...items: T[]) {
+        let n = super.push(...items);
+
+        this.dispatch('push', { items });
+        this.trigger();
+
+        return n;
+    }
+
+    reverse() {
+        super.reverse();
+
+        this.dispatch('reverse');
+        this.trigger();
+
+        return this;
+    }
+
+    shift() {
+        let item = super.shift();
+
+        if (item !== undefined) {
+            this.dispatch('shift', { item });
+            this.trigger();
+        }
+
+        return item;
+    }
+
+    sort() {
+        super.sort();
+
+        this.dispatch('sort');
+        this.trigger();
+
+        return this;
+    }
+
+    splice(start: number, deleteCount: number = super.length, ...items: T[]) {
+        let removed = super.splice(start, deleteCount, ...items);
+
+        if (items.length > 0 || removed.length > 0) {
+            this.dispatch('splice', {
+                deleteCount,
+                items,
+                start
+            });
+            this.trigger();
+        }
+
+        return removed;
+    }
+
+    track() {
+        this.#signal.get();
+    }
+
+    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 nodes
+class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
+    #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 Node<T> | undefined;
+    }
+
+    // @ts-ignore
+    push(...values: T[]) {
+        return super.push(...factory(values, this.#options));
+    }
+
+    shift() {
+        return dispose(super.shift()) as Node<T> | undefined;
+    }
+
+    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));
+    }
+}
+
+
 export { ReactiveArray, ReactiveObjectArray };

package/src/reactive/index.ts

@@ -1,38 +1,38 @@
-import { Computed, Object, Options, Prettify, 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]>> }
-        : 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
-                ? { [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]> };
-
-
-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> }
-    >;
+import { Computed, Object, Options, Prettify, 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]>> }
+        : 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
+                ? { [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]> };
+
+
+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> }
+    >;
 };

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 };