@esportsplus/reactivity 0.1.19 → 0.1.20

package/src/index.ts

@@ -1,6 +1,6 @@
-export { default as macro } from './macro';
-export { default as resource } from './resource';
-export { default as reactive } from './reactive';
-export { computed, dispose, effect, root, signal } from './signal';
-export * from './constants';
+export { default as macro } from './macro';
+export { default as resource } from './resource';
+export { default as reactive } from './reactive';
+export { computed, dispose, effect, root, signal } from './signal';
+export * from './constants';
 export * from './types';

package/src/macro.ts

@@ -1,29 +1,29 @@
-import CustomFunction from '@esportsplus/custom-function';
-import { computed } from './signal';
-import { Computed, Options } from './types';
-
-
-type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
-
-
-class Macro<A extends unknown[], R> extends CustomFunction {
-    #factory: Computed<(...args: A) => R>;
-
-
-    constructor(fn: Function<A,R>, options: Options = {}) {
-        super((...args: A) => {
-            return this.#factory.get()(...args);
-        });
-        this.#factory = computed(fn, options);
-    }
-
-
-    dispose() {
-        this.#factory.dispose();
-    }
-}
-
-
-export default <A extends unknown[], R>(fn: Function<A,R>, options: Options = {}) => {
-    return new Macro(fn, options);
+import CustomFunction from '@esportsplus/custom-function';
+import { computed } from './signal';
+import { Computed, Options } from './types';
+
+
+type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
+
+
+class Macro<A extends unknown[], R> extends CustomFunction {
+    #factory: Computed<(...args: A) => R>;
+
+
+    constructor(fn: Function<A,R>, options: Options = {}) {
+        super((...args: A) => {
+            return this.#factory.get()(...args);
+        });
+        this.#factory = computed(fn, options);
+    }
+
+
+    dispose() {
+        this.#factory.dispose();
+    }
+}
+
+
+export default <A extends unknown[], R>(fn: Function<A,R>, options: Options = {}) => {
+    return new Macro(fn, options);
 };

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