@esportsplus/reactivity 0.13.2 → 0.14.1

package/build/reactive/array.d.ts

@@ -1,12 +1,13 @@
+import { Prettify } from '@esportsplus/utilities';
 import { Infer } from '../types.js';
-type API<T> = Infer<T[]> & {
+type API<T extends unknown[]> = Prettify<Infer<T> & {
     clear: () => void;
     dispose: () => void;
-    dispatch: <T, K extends keyof Events<T>, V>(event: K, value?: V) => void;
-    map: <T, R>(this: API<T>, fn: (this: API<T>, value: T, i: number) => R, i?: number, n?: number) => R[];
-    on: <T, K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    once: <T, K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
-};
+    dispatch: <K extends keyof Events<T>, V>(event: K, value?: V) => void;
+    map: <R>(this: API<T>, fn: (this: API<T>, value: T, i: number) => R, i?: number, n?: number) => R[];
+    on: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
+    once: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
+}>;
 type Events<T> = {
     clear: undefined;
     pop: {
@@ -37,6 +38,20 @@ type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
-declare const _default: <T>(data: T[]) => API<T>;
+declare const _default: <T extends unknown[]>(data: T) => Infer<T> & {
+    clear: () => void;
+    dispose: () => void;
+    dispatch: <K_1 extends keyof Events<T_2>, V>(event: K_1, value?: V | undefined) => void;
+    map: <R>(this: any, fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+    on: <K_1 extends keyof Events<T_2>>(event: K_1, listener: Listener<Events<T>[K_1]>) => void;
+    once: <K_1 extends keyof Events<T_2>>(event: K_1, listener: Listener<Events<T>[K_1]>) => void;
+} extends infer T_1 ? { [K in keyof T_1]: (Infer<T> & {
+    clear: () => void;
+    dispose: () => void;
+    dispatch: <K_1 extends keyof Events<T_2>, V>(event: K_1, value?: V | undefined) => void;
+    map: <R>(this: any, fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+    on: <K_1 extends keyof Events<T_2>>(event: K_1, listener: Listener<Events<T>[K_1]>) => void;
+    once: <K_1 extends keyof Events<T_2>>(event: K_1, listener: Listener<Events<T>[K_1]>) => void;
+})[K]; } : never;
 export default _default;
 export type { API as ReactiveArray };

package/build/reactive/array.js

@@ -1,21 +1,10 @@
 import { isNumber } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '../constants.js';
-import { dispose as d, isComputed, read } from '../system.js';
 import { isReactiveObject } from './object.js';
-function at(data, i) {
-    let value = data[i];
-    if (isComputed(value)) {
-        return read(value);
-    }
-    return value;
-}
 function cleanup(item) {
     if (isReactiveObject(item)) {
         item.dispose();
     }
-    else if (isComputed(item)) {
-        d(item);
-    }
 }
 function clear(data, listeners) {
     dispose(data);
@@ -58,8 +47,7 @@ function map(data, proxy, fn, i, n) {
     n = Math.min(n, data.length);
     let values = new Array(n - i);
     for (; i < n; i++) {
-        let item = data[i];
-        values[i] = fn.call(proxy, (isComputed(item) ? item.value : item), i);
+        values[i] = fn.call(proxy, data[i], i);
     }
     return values;
 }
@@ -112,7 +100,7 @@ function shift(data, listeners) {
     return item;
 }
 function sort(data, listeners, fn) {
-    data.sort((a, b) => fn((isComputed(a) ? a.value : a), (isComputed(b) ? b.value : b)));
+    data.sort((a, b) => fn(a, b));
     dispatch(listeners, 'sort');
 }
 function splice(data, listeners, start, deleteCount = data.length, items = []) {
@@ -138,11 +126,7 @@ export default (data) => {
     let listeners = {}, proxy = new Proxy({}, {
         get(_, key) {
             if (isNumber(key)) {
-                let value = data[key];
-                if (isComputed(value)) {
-                    return read(value);
-                }
-                return value;
+                return data[key];
             }
             else if (key in wrapper) {
                 return wrapper[key];
@@ -173,7 +157,7 @@ export default (data) => {
         }
     }), wrapper = {
         [REACTIVE_ARRAY]: true,
-        at: (i) => at(data, i),
+        at: (i) => data[i],
         clear: () => {
             clear(data, listeners);
             return proxy;

package/package.json

@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/array.ts

@@ -1,18 +1,19 @@
-import { isNumber } from '@esportsplus/utilities';
+import { isNumber, Prettify } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '~/constants';
-import { dispose as d, isComputed, read } from '~/system';
 import { Infer } from '~/types';
 import { isReactiveObject } from './object';
 
 
-type API<T> = Infer<T[]> & {
-    clear: () => void;
-    dispose: () => void;
-    dispatch: <T, K extends keyof Events<T>, V>(event: K, value?: V) => void;
-    map: <T, R>(this: API<T>, fn: (this: API<T>, value: T, i: number) => R, i?: number, n?: number) => R[];
-    on: <T, K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
-    once: <T, K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
-};
+type API<T extends unknown[]> = Prettify<
+    Infer<T> & {
+        clear: () => void;
+        dispose: () => void;
+        dispatch: <K extends keyof Events<T>, V>(event: K, value?: V) => void;
+        map: <R>(this: API<T>, fn: (this: API<T>, value: T, i: number) => R, i?: number, n?: number) => R[];
+        on: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
+        once: <K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) => void;
+    }
+>;
 
 type Events<T> = {
     clear: undefined,
@@ -49,23 +50,10 @@ type Listener<V> = {
 type Listeners = Record<string, (Listener<any> | null)[]>;
 
 
-function at<T>(data: T[], i: number) {
-    let value = data[i];
-
-    if (isComputed(value)) {
-        return read(value);
-    }
-
-    return value;
-}
-
 function cleanup<T>(item: T) {
     if (isReactiveObject(item)) {
         item.dispose();
     }
-    else if (isComputed(item)) {
-        d(item);
-    }
 }
 
 function clear<T>(data: T[], listeners: Listeners) {
@@ -108,10 +96,10 @@ function dispose<T>(data: T[]) {
     }
 }
 
-function map<T, R>(
-    data: T[],
+function map<T extends unknown[], R>(
+    data: T,
     proxy: API<T>,
-    fn: (this: API<T>, value: T, i: number) => R,
+    fn: (this: API<T>, value: T[number], i: number) => R,
     i?: number,
     n?: number
 ) {
@@ -128,13 +116,7 @@ function map<T, R>(
     let values: R[] = new Array(n - i);
 
     for (; i < n; i++) {
-        let item = data[i];
-
-        values[i] = fn.call(
-            proxy,
-            (isComputed(item) ? item.value : item) as T,
-            i
-        );
+        values[i] = fn.call(proxy, data[i], i);
     }
 
     return values;
@@ -204,15 +186,12 @@ function shift<T>(data: T[], listeners: Listeners) {
     return item;
 }
 
-function sort<T>(data: T[], listeners: Listeners, fn: (a: T, b: T) => number) {
-    data.sort((a, b) => fn(
-        (isComputed(a) ? a.value : a) as T,
-        (isComputed(b) ? b.value : b) as T
-    ));
+function sort<T extends unknown[]>(data: T, listeners: Listeners, fn: (a: T[number], b: T[number]) => number) {
+    data.sort((a, b) => fn(a, b));
     dispatch(listeners, 'sort');
 }
 
-function splice<T>(data: T[], listeners: Listeners, start: number, deleteCount: number = data.length, items: T[] = []) {
+function splice<T extends unknown[]>(data: T, listeners: Listeners, start: number, deleteCount: number = data.length, items: T[] = []) {
     let removed = data.splice(start, deleteCount, ...items);
 
     if (items.length > 0 || removed.length > 0) {
@@ -239,18 +218,12 @@ function unshift<T>(data: T[], listeners: Listeners, items: T[]) {
 }
 
 
-export default <T>(data: T[]) => {
+export default <T extends unknown[]>(data: T) => {
     let listeners: Listeners = {},
         proxy = new Proxy({}, {
             get(_, key: any) {
                 if (isNumber(key)) {
-                    let value = data[key];
-
-                    if (isComputed(value)) {
-                        return read(value);
-                    }
-
-                    return value;
+                    return data[key];
                 }
                 else if (key in wrapper) {
                     return wrapper[key as keyof typeof wrapper];
@@ -284,7 +257,7 @@ export default <T>(data: T[]) => {
         }) as API<T>,
         wrapper = {
             [REACTIVE_ARRAY]: true,
-            at: (i: number) => at(data, i),
+            at: (i: number) => data[i],
             clear: () => {
                 clear(data, listeners);
                 return proxy;
@@ -298,7 +271,7 @@ export default <T>(data: T[]) => {
                 return proxy;
             },
             map: <R>(
-                fn: (this: API<T>, value: T, i: number) => R,
+                fn: (this: API<T>, value: T[number], i: number) => R,
                 i?: number,
                 n?: number
             ) => {
@@ -319,7 +292,7 @@ export default <T>(data: T[]) => {
                 return proxy;
             },
             shift: () => shift(data, listeners),
-            sort: (fn: (a: T, b: T) => number) => {
+            sort: (fn: (a: T[number], b: T[number]) => number) => {
                 sort(data, listeners, fn);
                 return proxy;
             },