@esportsplus/reactivity 0.14.0 → 0.14.2

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 ReactiveArray<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>(fn: (this: ReactiveArray<T>, value: T[number], 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,150 @@ type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
-declare const _default: <T>(data: T[]) => API<T>;
+declare const _default: <T>(data: T[]) => {
+    [x: number]: Infer<T>;
+    length: number;
+    toString: () => string;
+    toLocaleString: {
+        (): string;
+        (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+    };
+    pop: () => Infer<T> | undefined;
+    push: (...items: Infer<T>[]) => number;
+    concat: {
+        (...items: ConcatArray<Infer<T>>[]): Infer<T>[];
+        (...items: (Infer<T> | ConcatArray<Infer<T>>)[]): Infer<T>[];
+    };
+    join: (separator?: string) => string;
+    reverse: () => Infer<T>[];
+    shift: () => Infer<T> | undefined;
+    slice: (start?: number, end?: number) => Infer<T>[];
+    sort: (compareFn?: ((a: Infer<T>, b: Infer<T>) => number) | undefined) => Infer<T>[] & {
+        clear: () => void;
+        dispose: () => void;
+        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
+        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+    };
+    splice: {
+        (start: number, deleteCount?: number): Infer<T>[];
+        (start: number, deleteCount: number, ...items: Infer<T>[]): Infer<T>[];
+    };
+    unshift: (...items: Infer<T>[]) => number;
+    indexOf: (searchElement: Infer<T>, fromIndex?: number) => number;
+    lastIndexOf: (searchElement: Infer<T>, fromIndex?: number) => number;
+    every: {
+        <S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): this is S[];
+        (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): boolean;
+    };
+    some: (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any) => boolean;
+    forEach: (callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => void, thisArg?: any) => void;
+    map: (<U>(callbackfn: (value: Infer<T>, index: number, array: Infer<T>[]) => U, thisArg?: any) => U[]) & (<R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[]);
+    filter: {
+        <S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): S[];
+        (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): Infer<T>[];
+    };
+    reduce: {
+        (callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>): Infer<T>;
+        (callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>, initialValue: Infer<T>): Infer<T>;
+        <U>(callbackfn: (previousValue: U, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => U, initialValue: U): U;
+    };
+    reduceRight: {
+        (callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>): Infer<T>;
+        (callbackfn: (previousValue: Infer<T>, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => Infer<T>, initialValue: Infer<T>): Infer<T>;
+        <U>(callbackfn: (previousValue: U, currentValue: Infer<T>, currentIndex: number, array: Infer<T>[]) => U, initialValue: U): U;
+    };
+    find: {
+        <S extends Infer<T>>(predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => value is S, thisArg?: any): S | undefined;
+        (predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => unknown, thisArg?: any): Infer<T> | undefined;
+    };
+    findIndex: (predicate: (value: Infer<T>, index: number, obj: Infer<T>[]) => unknown, thisArg?: any) => number;
+    fill: (value: Infer<T>, start?: number, end?: number) => Infer<T>[] & {
+        clear: () => void;
+        dispose: () => void;
+        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
+        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+    };
+    copyWithin: (target: number, start: number, end?: number) => Infer<T>[] & {
+        clear: () => void;
+        dispose: () => void;
+        dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
+        map: <R>(fn: (this: any, value: T, i: number) => R, i?: number, n?: number) => R[];
+        on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+        once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+    };
+    entries: () => ArrayIterator<[number, Infer<T>]>;
+    keys: () => ArrayIterator<number>;
+    values: () => ArrayIterator<Infer<T>>;
+    includes: (searchElement: Infer<T>, fromIndex?: number) => boolean;
+    flatMap: <U, This = undefined>(callback: (this: This, value: Infer<T>, index: number, array: Infer<T>[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+    flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
+    at: (index: number) => Infer<T> | undefined;
+    findLast: {
+        <S extends Infer<T>>(predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => value is S, thisArg?: any): S | undefined;
+        (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any): Infer<T> | undefined;
+    };
+    findLastIndex: (predicate: (value: Infer<T>, index: number, array: Infer<T>[]) => unknown, thisArg?: any) => number;
+    toReversed: () => Infer<T>[];
+    toSorted: (compareFn?: ((a: Infer<T>, b: Infer<T>) => number) | undefined) => Infer<T>[];
+    toSpliced: {
+        (start: number, deleteCount: number, ...items: Infer<T>[]): Infer<T>[];
+        (start: number, deleteCount?: number): Infer<T>[];
+    };
+    with: (index: number, value: Infer<T>) => Infer<T>[];
+    [Symbol.iterator]: () => ArrayIterator<Infer<T>>;
+    readonly [Symbol.unscopables]: {
+        [x: number]: boolean | undefined;
+        length?: boolean | undefined;
+        toString?: boolean | undefined;
+        toLocaleString?: boolean | undefined;
+        pop?: boolean | undefined;
+        push?: boolean | undefined;
+        concat?: boolean | undefined;
+        join?: boolean | undefined;
+        reverse?: boolean | undefined;
+        shift?: boolean | undefined;
+        slice?: boolean | undefined;
+        sort?: boolean | undefined;
+        splice?: boolean | undefined;
+        unshift?: boolean | undefined;
+        indexOf?: boolean | undefined;
+        lastIndexOf?: boolean | undefined;
+        every?: boolean | undefined;
+        some?: boolean | undefined;
+        forEach?: boolean | undefined;
+        map?: boolean | undefined;
+        filter?: boolean | undefined;
+        reduce?: boolean | undefined;
+        reduceRight?: boolean | undefined;
+        find?: boolean | undefined;
+        findIndex?: boolean | undefined;
+        fill?: boolean | undefined;
+        copyWithin?: boolean | undefined;
+        entries?: boolean | undefined;
+        keys?: boolean | undefined;
+        values?: boolean | undefined;
+        includes?: boolean | undefined;
+        flatMap?: boolean | undefined;
+        flat?: boolean | undefined;
+        at?: boolean | undefined;
+        findLast?: boolean | undefined;
+        findLastIndex?: boolean | undefined;
+        toReversed?: boolean | undefined;
+        toSorted?: boolean | undefined;
+        toSpliced?: boolean | undefined;
+        with?: boolean | undefined;
+        [Symbol.iterator]?: boolean | undefined;
+        readonly [Symbol.unscopables]?: boolean | undefined;
+    };
+    clear: () => void;
+    dispose: () => void;
+    dispatch: <K extends keyof Events<T_1>, V>(event: K, value?: V | undefined) => void;
+    on: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+    once: <K extends keyof Events<T_1>>(event: K, listener: Listener<Events<T[]>[K]>) => void;
+};
 export default _default;
-export type { API as ReactiveArray };
+export type { ReactiveArray };

package/package.json

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

package/src/reactive/array.ts

@@ -1,17 +1,19 @@
-import { isNumber } from '@esportsplus/utilities';
+import { isNumber, Prettify } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '~/constants';
 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 ReactiveArray<T extends unknown[]> = Prettify<
+    Infer<T> & {
+        clear: () => void;
+        dispose: () => void;
+        dispatch: <K extends keyof Events<T>, V>(event: K, value?: V) => void;
+        map: <R>(fn: (this: ReactiveArray<T>, value: T[number], 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,
@@ -96,8 +98,8 @@ function dispose<T>(data: T[]) {
 
 function map<T, R>(
     data: T[],
-    proxy: API<T>,
-    fn: (this: API<T>, value: T, i: number) => R,
+    proxy: ReactiveArray<typeof data>,
+    fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R,
     i?: number,
     n?: number
 ) {
@@ -252,7 +254,7 @@ export default <T>(data: T[]) => {
 
                 return true;
             }
-        }) as API<T>,
+        }) as ReactiveArray<typeof data>,
         wrapper = {
             [REACTIVE_ARRAY]: true,
             at: (i: number) => data[i],
@@ -269,7 +271,7 @@ export default <T>(data: T[]) => {
                 return proxy;
             },
             map: <R>(
-                fn: (this: API<T>, value: T, i: number) => R,
+                fn: (this: ReactiveArray<typeof data>, value: T, i: number) => R,
                 i?: number,
                 n?: number
             ) => {
@@ -302,4 +304,4 @@ export default <T>(data: T[]) => {
 
     return proxy;
 };
-export type { API as ReactiveArray };
+export type { ReactiveArray };