@esportsplus/reactivity 0.13.1 → 0.14.0

package/build/reactive/array.d.ts

@@ -2,6 +2,40 @@ import { Infer } from '../types.js';
 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 Events<T> = {
+    clear: undefined;
+    pop: {
+        item: T;
+    };
+    push: {
+        items: T[];
+    };
+    reverse: undefined;
+    set: {
+        index: number;
+        item: T;
+    };
+    shift: {
+        item: T;
+    };
+    sort: undefined;
+    splice: {
+        deleteCount: number;
+        items: T[];
+        start: number;
+    };
+    unshift: {
+        items: T[];
+    };
+};
+type Listener<V> = {
+    once?: boolean;
+    (value: V): void;
 };
 declare const _default: <T>(data: T[]) => API<T>;
 export default _default;

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.1",
+  "version": "0.14.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/array.ts

@@ -1,6 +1,5 @@
 import { isNumber } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '~/constants';
-import { dispose as d, isComputed, read } from '~/system';
 import { Infer } from '~/types';
 import { isReactiveObject } from './object';
 
@@ -8,6 +7,10 @@ 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 Events<T> = {
@@ -45,23 +48,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) {
@@ -124,13 +114,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;
@@ -201,10 +185,7 @@ function shift<T>(data: T[], listeners: Listeners) {
 }
 
 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
-    ));
+    data.sort((a, b) => fn(a, b));
     dispatch(listeners, 'sort');
 }
 
@@ -240,13 +221,7 @@ export default <T>(data: T[]) => {
         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];
@@ -280,7 +255,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;