baja-lite 1.0.7 → 1.0.16

package/src/fn.ts

@@ -219,49 +219,57 @@ export function excuteSplit<T = any, R = any, E = any>(
   const list = arraySplit(datas, ps);
   if (sync === ExcuteSplitMode.AsyncTrust) {
     return new Promise<R[]>(async (resolve, reject) => {
-      const reasons: R[] = [];
-      if (settled) {
-        const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
-        for (const item of result) {
-          if (item.status === 'rejected') {
-            reject(item.reason);
-          } else {
-            reasons.push(item.value);
+      try {
+        const reasons: R[] = [];
+        if (settled) {
+          const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
+          for (const item of result) {
+            if (item.status === 'rejected') {
+              reject(item.reason);
+            } else {
+              reasons.push(item.value);
+            }
+          }
+        } else {
+          for (let i = 0; i < list.length; i++) {
+            const startIndex = (i - 1) * ps.everyLength;
+            const endIndex = startIndex + list[i]!.length - 1;
+            reasons.push(await fn(list[i]!, i, list.length, extendParams[i], startIndex, endIndex));
           }
         }
-      } else {
-        for (let i = 0; i < list.length; i++) {
-          const startIndex = (i - 1) * ps.everyLength;
-          const endIndex = startIndex + list[i]!.length - 1;
-          reasons.push(await fn(list[i]!, i, list.length, extendParams[i], startIndex, endIndex));
-        }
+        resolve(reasons);
+      } catch (error) {
+        reject(error);
       }
-      resolve(reasons);
     });
   } else if (sync === ExcuteSplitMode.AsyncNoTrust) {
     return new Promise<{ result: R[]; error: string[]; }>(async (resolve, reject) => {
-      const reasons: { result: R[]; error: string[]; } = { result: [], error: [] };
-      if (settled) {
-        const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
-        for (const item of result) {
-          if (item.status === 'rejected') {
-            reasons.error.push(item.reason);
-          } else {
-            reasons.result.push(item.value);
+      try {
+        const reasons: { result: R[]; error: string[]; } = { result: [], error: [] };
+        if (settled) {
+          const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
+          for (const item of result) {
+            if (item.status === 'rejected') {
+              reasons.error.push(item.reason);
+            } else {
+              reasons.result.push(item.value);
+            }
           }
-        }
-      } else {
-        for (let i = 0; i < list.length; i++) {
-          const startIndex = (i - 1) * ps.everyLength;
-          const endIndex = startIndex + list[i]!.length - 1;
-          try {
-            reasons.result.push(await fn(list[i]!, i, list.length, extendParams[i], startIndex, endIndex));
-          } catch (error) {
-            reasons.error.push(error as string);
+        } else {
+          for (let i = 0; i < list.length; i++) {
+            const startIndex = (i - 1) * ps.everyLength;
+            const endIndex = startIndex + list[i]!.length - 1;
+            try {
+              reasons.result.push(await fn(list[i]!, i, list.length, extendParams[i], startIndex, endIndex));
+            } catch (error) {
+              reasons.error.push(error as string);
+            }
           }
         }
+        resolve(reasons);
+      } catch (error) {
+        reject(error);
       }
-      resolve(reasons);
     });
   } else if (sync === ExcuteSplitMode.SyncTrust) {
     const reasons: R[] = [];

package/src/list.ts

@@ -1,3 +1,4 @@
+
 export class ArrayList<T> extends Array<T> {
     constructor(array?: Array<T> | T | undefined) {
         super();
@@ -28,4 +29,29 @@ export class ArrayList<T> extends Array<T> {
     remove(index: number) {
         this.splice(index, 1);
     }
-}
+}
+
+// export class ArrayMap<T> extends Array<T> {
+//     private _map: Map<string, T> = new Map();
+//     private key: keyof T;
+//     constructor(key: keyof T, array?: Array<T> | T | undefined) {
+//         super();
+//         this.key = key;
+//         if (array instanceof Array) {
+//             super.push(...array);
+//         } else if (typeof array !== 'undefined') {
+//             super.push(array);
+//         }
+//     }
+//     override push(...items: T[]): number {
+//         for (const item of items) {
+//             const key = item[this.key] as string;
+//             if (!this._map.has(key)) {
+//                 super.push(item);
+//                 this._map.set(key, item);
+//             }
+//         }
+//         return this.length;
+//     }
+//     override
+// }

package/src/math.ts

@@ -134,7 +134,7 @@ export const round = (number: any, numDigits: number, upOrDown = 0): number => {
 /** =value.xx,其中xx=number,如number=99，表示修正数字为value.99 */
 export const merge = function (value: any, number: any) {
   if (isNum(value) && isNum(number)) {
-    return new Decimal(value).floor().add(`0.${ number }`).toNumber();
+    return new Decimal(value).floor().add(`0.${number}`).toNumber();
   } else if (isNum(value)) {
     return value;
   } else {
@@ -181,7 +181,7 @@ const IF = function () {
 export class Bus {
   private result: number;
   private ifit = true;
-  constructor (result: any) {
+  constructor(result: any) {
     this.result = num(result);
   }
   @IF()
@@ -364,4 +364,42 @@ export const getGeo = (p1: Point, p2: Point) => {
                 Math.cos(p1.lat), Math.cos(p2.lat), Math.pow(Math.sin(div(sub(p1.long, p2.long), 2)), 2)
               ))
           )), 2, 6378.137, 10000))).div(10000).round(2).over();
-};
+};
+
+const ZM = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+/**
+ * 十进制转换自定义进制
+ * @param from 数字
+ * @param to 自定义进制的字符
+ * @returns 
+ */
+export function ten2Any(from: number, to = ZM) {
+  let result = '';
+  const length = to.length;
+  while (from > 0) {
+    from--;
+    let remainder = from % length;
+    result = to.charAt(remainder) + result;
+    from = Math.floor(from / length);
+  }
+  return result;
+}
+/**
+ * 自定义进制转换十进制
+ * @param from
+ * @param to 
+ * @returns 
+ */
+export function any2Ten(from: string, to = ZM) {
+  let decimal = 0;
+  from = from.toUpperCase();
+  for (let i = 0; i < from.length; i++) {
+    const char = from[from.length - 1 - i]!.toUpperCase();
+    const index = to.indexOf(char);
+    if (index > -1) {
+      const value = to.indexOf(char) + 1;
+      decimal += value * Math.pow(26, i);
+    }
+  }
+  return decimal;
+}

package/src/set-ex.ts

@@ -1,3 +1,5 @@
+import iterate from "iterare";
+
 export class SetEx<T> extends Set {
   private _key: keyof T;
   private _onExist1?: (oldData: T, newData: T) => void | null;
@@ -6,6 +8,7 @@ export class SetEx<T> extends Set {
   private _onExist2?: (oldData: T, newData: T) => void | null;
   private _onNotExist2?: (newData: T) => void | null;
   private _replaceIfExits2: boolean;
+  private _map: Map<string, T> = new Map();
   /**
    * @param key 识别是否存在的对象的属性名
    * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
@@ -52,21 +55,22 @@ export class SetEx<T> extends Set {
    */
   override add(value: T): this {
     let flag = false;
-    this.forEach((item: T): any => {
-      if (item[this._key] === value[this._key]) {
-        flag = true;
-        if (this._onExist1) {
-          this._onExist1(item, value);
-        }
-        if (this._replaceIfExits1 === true) {
-          super.delete(item);
-          flag = false;
-        }
-        return false;
+    const key = value[this._key] as string;
+    const item = this._map.get(key);
+    if (item) {
+      flag = true;
+      if (this._onExist1) {
+        this._onExist1(item, value);
       }
-    });
+      if (this._replaceIfExits1 === true) {
+        super.delete(item);
+        this._map.delete(key);
+        flag = false;
+      }
+    }
     if (flag === false) {
       super.add(value);
+      this._map.set(key, value);
       if (this._onNotExist1) {
         this._onNotExist1(value);
       }
@@ -92,24 +96,25 @@ export class SetEx<T> extends Set {
    */
   add2(value: T): T {
     let flag = false;
+    const key = value[this._key] as string;
+    const item = this._map.get(key);
     let tmp = value;
-    this.forEach((item: T): any => {
-      if (item[this._key] === value[this._key]) {
-        flag = true;
-        if (this._onExist2) {
-          this._onExist2(item, value);
-        }
-        if (this._replaceIfExits2 === true) {
-          super.delete(value);
-          flag = false;
-        } else {
-          tmp = item;
-        }
-        return false;
+    if (item) {
+      flag = true;
+      if (this._onExist2) {
+        this._onExist2(item, value);
       }
-    });
+      if (this._replaceIfExits2 === true) {
+        super.delete(value);
+        this._map.delete(key);
+        flag = false;
+      } else {
+        tmp = item;
+      }
+    }
     if (flag === false) {
       super.add(value);
+      this._map.set(key, value);
       if (this._onNotExist2) {
         this._onNotExist2(value);
       }
@@ -131,30 +136,19 @@ export class SetEx<T> extends Set {
   }
   /**
    * 用key找到匹配的第一个对象
-   * @param {*} value 这是对象的关键属性,而非对象
+   * @param {*} key 这是对象的关键属性,而非对象
    * @returns {(T | null)}
    */
-  find(value: T[keyof T]): T | null {
-    for (const item of this) {
-      if (item[this._key] === value) {
-        return item;
-      }
-    }
-    return null;
+  find(key: T[keyof T]): T | null {
+    return this._map.get(key as string) ?? null;
   }
   /**
    * 用key找到匹配的所有对象
-   * @param {*} value 这是对象的关键属性,而非对象
+   * @param {*} key 这是对象的关键属性,而非对象
    * @returns {T[]}
    */
-  findAll(value: T[keyof T]): T[] {
-    const res = new Array<T>();
-    this.forEach((item) => {
-      if (item[this._key] === value) {
-        res.push(item);
-      }
-    });
-    return res;
+  findAll(key: T[keyof T]): T[] {
+    return iterate(key as string[]).map(k => this._map.get(k)).filter(v => v !== undefined).toArray() as T[];
   }
   /**
    *
@@ -191,13 +185,8 @@ export class SetEx<T> extends Set {
    * @param {*} value 这是对象的关键属性,而非对象
    * @returns {boolean}
    */
-  override has(value: T[keyof T] ): boolean {
-    for (const item of this) {
-      if (item[this._key] === value) {
-        return true;
-      }
-    }
-    return false;
+  override has(key: T[keyof T]): boolean {
+    return this._map.has(key as string);
   }
   /**
    * 转为数组
@@ -235,15 +224,16 @@ export class SetEx<T> extends Set {
   /**
    *
    * 删除key对应的对象
-   * @param {*} value 这是对象的关键属性,而非对象
+   * @param {*} _key 这是对象的关键属性,而非对象
    * @returns {boolean}
    */
-  override delete(value: T[keyof T]): boolean {
-    for (const item of this) {
-      if (item[this._key] === value) {
-        super.delete(item);
-        return true;
-      }
+  override delete(_key: T[keyof T]): boolean {
+    const key = _key as string;
+    const item = this._map.get(key);
+    if (item) {
+      super.delete(item);
+      this._map.delete(key);
+      return true;
     }
     return false;
   }
@@ -271,6 +261,7 @@ export class SetEx<T> extends Set {
     values?: ReadonlyArray<T> | null;
   }): this {
     this.clear();
+    this._map.clear();
     if (option.key) { this._key = option.key; }
     if (option.onExist1) { this._onExist1 = option.onExist1; }
     if (option.onNotExist1) { this._onNotExist1 = option.onNotExist1; }
@@ -380,4 +371,4 @@ export class SetEx<T> extends Set {
   set key(key: keyof T) {
     this._key = key;
   }
-}
+}