xjs-common 12.0.0-alpha.1 → 12.0.0-alpha.2

package/build/const/types.d.ts

@@ -1,7 +1,7 @@
 export type IndexSignature = string | number | symbol;
 export type NormalRecord<T = any> = Record<IndexSignature, T>;
 export type MaybeArray<T = any> = T | T[];
-export type MaybePromise<T = void> = T | Promise<T>;
+export type MaybePromise<T = any> = T | Promise<T>;
 export type Loggable = {
     log: (msg: any) => void;
     warn: (msg: any) => void;
@@ -14,6 +14,42 @@ export type IdName<T = number> = {
     name: string;
 } & Unique<T>;
 export type Any = string | number | bigint | boolean | symbol | object | undefined | null;
+export interface AlmostArray<E = any> extends ArrayLike<E> {
+    /** {@link Array.copyWithin()} */
+    copyWithin(target: number, start: number, end?: number): this;
+    /** {@link Array.every()} */
+    every(predicate: (value: E, index: number, array: this) => unknown, thisArg?: any): boolean;
+    /** {@link Array.fill()} */
+    fill(value: E, start?: number, end?: number): this;
+    /** {@link Array.filter()} */
+    filter(predicate: (value: E, index: number, array: this) => any, thisArg?: any): this;
+    /** {@link Array.find()} */
+    find(predicate: (value: E, index: number, obj: this) => boolean, thisArg?: any): E | undefined;
+    /** {@link Array.findIndex()} */
+    findIndex(predicate: (value: E, index: number, obj: this) => boolean, thisArg?: any): number;
+    /** {@link Array.forEach()} */
+    forEach(callbackfn: (value: E, index: number, array: this) => void, thisArg?: any): void;
+    /** {@link Array.indexOf()} */
+    indexOf(searchElement: E, fromIndex?: number): number;
+    /** {@link Array.join()} */
+    join(separator?: string): string;
+    /** {@link Array.lastIndexOf()} */
+    lastIndexOf(searchElement: E, fromIndex?: number): number;
+    /** {@link Array.map()} */
+    map(callbackfn: (value: E, index: number, array: this) => number, thisArg?: any): this;
+    /** {@link Array.reduce()} */
+    reduce<U = E>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue?: U): U;
+    /** {@link Array.reduceRight()} */
+    reduceRight<U = E>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue?: U): U;
+    /** {@link Array.reverse()} */
+    reverse(): this;
+    /** {@link Array.slice()} */
+    slice(start?: number, end?: number): this;
+    /** {@link Array.some()} */
+    some(predicate: (value: E, index: number, array: this) => unknown, thisArg?: any): boolean;
+    /** {@link Array.sort()} */
+    sort(compareFn?: (a: E, b: E) => number): this;
+}
 export declare enum Type {
     string = "string",
     number = "number",

package/build/func/u-array.d.ts

@@ -1,24 +1,18 @@
+import { AlmostArray } from "../const/types";
 export declare namespace UArray {
     /**
      * compares two arrays to valuate equality.
      * if one side is null or undefined, it returns true when other side is the same.
+     * this function has compatibility to `AlmostArray` like `Uint8Array` etc.
      * @param v1 it uses equal operator for comparing elements, so applying object element is not recommended.
      * @param v2 same as v1.
-     * @param sort it uses {@link Array#sort} on v1 and v2 if true. default is true.
-     * @param useStrictEqual it uses `===` operator for compareing elements if true, otherwise using `==` operator. default is true.
+     * @param sort it uses {@link Array.sort()} on v1 and v2 if true. default is true.
+     * @param useStrictEqual check equality whether `Array` or not and it uses `===` operator for compareing elements if true, otherwise using `==` operator. default is true.
      */
-    function eq(v1: any[], v2: any[], op: {
+    function eq(v1: any[] | AlmostArray, v2: any[] | AlmostArray, op?: {
         sort?: boolean;
-        useStrictEqual: false;
+        useStrictEqual?: boolean;
     }): boolean;
-    function eq<T>(v1: T[], v2: T[], op: {
-        sort?: boolean;
-        useStrictEqual: true;
-    }): boolean;
-    function eq<T>(v1: T[], v2: T[], op: {
-        sort?: boolean;
-    }): boolean;
-    function eq<T>(v1: T[], v2: T[]): boolean;
     /**
      * returns array which is removed duplicate of elements.
      * this doesn't mutate the param.
@@ -32,7 +26,12 @@ export declare namespace UArray {
         predicate: (v1: T, v2: T) => boolean;
         takeLast?: boolean;
     }): T[];
-    function chop<T>(array: T[], len: number): T[][];
+    /**
+     * chop array to partial arrays which have specified length. the remainder is added to end of a result.
+     * this function has compatibility to `AlmostArray` like `Uint8Array` etc.
+     */
+    function chop<E>(array: E[], len: number): E[][];
+    function chop<T extends AlmostArray>(array: T, len: number): T[];
     function remove<T>(array: T[], v: T): void;
     function randomPick<T>(array: T[], takeout?: boolean): T;
     function shuffle<T>(array: T[]): T[];

package/build/func/u-array.js

@@ -1,6 +1,15 @@
 import { array2map, int2array } from "./u";
 export var UArray;
 (function (UArray) {
+    /**
+     * compares two arrays to valuate equality.
+     * if one side is null or undefined, it returns true when other side is the same.
+     * this function has compatibility to `AlmostArray` like `Uint8Array` etc.
+     * @param v1 it uses equal operator for comparing elements, so applying object element is not recommended.
+     * @param v2 same as v1.
+     * @param sort it uses {@link Array.sort()} on v1 and v2 if true. default is true.
+     * @param useStrictEqual check equality whether `Array` or not and it uses `===` operator for compareing elements if true, otherwise using `==` operator. default is true.
+     */
     function eq(v1, v2, op = {}) {
         const { sort, useStrictEqual } = Object.assign({ sort: true, useStrictEqual: true }, op);
         if (v1 && !v2 || !v1 && v2)
@@ -9,7 +18,9 @@ export var UArray;
             return true;
         if (v1.length !== v2.length)
             return false;
-        const a = sort ? [...v1].sort() : v1, b = sort ? [...v2].sort() : v2;
+        if (useStrictEqual && v1 instanceof Array !== v2 instanceof Array)
+            return false;
+        const a = sort ? v1.slice().sort() : v1, b = sort ? v2.slice().sort() : v2;
         return a.every((v, i) => useStrictEqual ? v === b[i] : v == b[i]);
     }
     UArray.eq = eq;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xjs-common",
-  "version": "12.0.0-alpha.1",
+  "version": "12.0.0-alpha.2",
   "description": "library modules for typescript that bundled general-purpose implementations.",
   "repository": {
     "type": "git",