@yelon/util 13.4.2 → 13.5.2-beta.0

package/browser/cookie.service.d.ts

@@ -49,7 +49,7 @@ export declare class CookieService {
      *
      * 设置指定 Cookie 键的值
      */
-    put(key: string, value: string | undefined, options?: CookieOptions): void;
+    put(key: string, value: string, options?: CookieOptions): void;
     /**
      * Remove given cookie
      *

package/browser/copy.d.ts

@@ -3,4 +3,4 @@
  *
  * 复制字符串文档至剪贴板
  */
-export declare function copy(value: string): Promise<void>;
+export declare function copy(value: string): Promise<string>;

package/config/abc/media.type.d.ts

@@ -1,4 +1,4 @@
-import type { NzSafeAny } from 'ng-zorro-antd/core/types';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
 export interface YunzaiMediaConfig {
     /**
      * Plyr library path, default: `["https://cdn.bootcdn.net/ajax/libs/plyr/3.5.10/plyr.min.js", "https://cdn.bootcdn.net/ajax/libs/plyr/3.5.10/plyr.css"]`

package/config/abc/st.type.d.ts

@@ -424,4 +424,21 @@ export interface YunzaiSTConfig {
          */
         mode?: 'full' | 'icon' | 'text';
     };
+    /**
+     * Max button option can be showed, and the extra part are auto generated under `more`
+     *
+     * 配置最多显示多少个按钮，多余部分自动生成至 `更多` 下面
+     *
+     * > 注意：若在 `buttons` 下配置过按钮组会导致其失效
+     */
+    maxMultipleButton?: {
+        /**
+         * 更多按钮文本，默认：`更多`
+         */
+        text?: string;
+        /**
+         * 超出数量自动合并，默认：`2`
+         */
+        count?: number;
+    };
 }

package/config/sf/sf.type.d.ts

@@ -124,4 +124,10 @@ export interface YunzaiSFConfig {
      * 指定 `format: 'email'` 的默认Email后缀，默认：`['qq.com', '163.com', 'gmail.com', '126.com', 'aliyun.com']`
      */
     uiEmailSuffixes?: string[];
+    /**
+     * Whether to delay rendering, should be manually call `refreshSchema()`
+     *
+     * 是否延迟渲染，需要手动调用 `refreshSchema()`
+     */
+    delay?: boolean;
 }

package/esm2020/array/array.service.mjs

@@ -269,10 +269,10 @@ export class ArrayService {
             .values());
     }
 }
-ArrayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ArrayService, deps: [{ token: i1.YunzaiConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
-ArrayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ArrayService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ArrayService, decorators: [{
+ArrayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ArrayService, deps: [{ token: i1.YunzaiConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+ArrayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ArrayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ArrayService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.YunzaiConfigService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.service.js","sourceRoot":"","sources":["../../../../../packages/util/array/array.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from '@angular/core';\n\nimport { YunzaiConfigService, YunzaiUtilArrayConfig } from '@yelon/util/config';\nimport { NzTreeNode } from 'ng-zorro-antd/core/tree';\n\nimport {\n  ArrayServiceArrToTreeNodeOptions,\n  ArrayServiceArrToTreeOptions,\n  ArrayServiceGetKeysByTreeNodeOptions,\n  ArrayServiceGroupByResult,\n  ArrayServiceTreeToArrOptions\n} from './array-type.service';\n\n@Injectable({ providedIn: 'root' })\nexport class ArrayService {\n  private c: YunzaiUtilArrayConfig;\n\n  constructor(cog: YunzaiConfigService) {\n    this.c = cog.merge('utilArray', {\n      deepMapName: 'deep',\n      parentMapName: 'parent',\n      idMapName: 'id',\n      parentIdMapName: 'parent_id',\n      childrenMapName: 'children',\n      titleMapName: 'title',\n      checkedMapname: 'checked',\n      selectedMapname: 'selected',\n      expandedMapname: 'expanded',\n      disabledMapname: 'disabled'\n    })!;\n  }\n\n  /**\n   * Convert tree structure to array structure\n   *\n   * 将树结构转换成数组结构\n   */\n  treeToArr<T extends object = any>(tree: readonly T[], options?: ArrayServiceTreeToArrOptions<T>): T[] {\n    const opt = {\n      deepMapName: this.c.deepMapName,\n      parentMapName: this.c.parentMapName,\n      childrenMapName: this.c.childrenMapName,\n      clearChildren: true,\n      cb: null,\n      ...options\n    } as ArrayServiceTreeToArrOptions;\n    const result: Array<{ [key: string]: any }> = [];\n    const inFn = (list: ReadonlyArray<{ [key: string]: any }>, parent: T | null, deep: number = 0): void => {\n      for (const i of list) {\n        i[opt.deepMapName!] = deep;\n        i[opt.parentMapName!] = parent;\n        if (opt.cb) {\n          opt.cb(i, parent, deep);\n        }\n        result.push(i);\n        const children = i[opt.childrenMapName!];\n        if (children != null && Array.isArray(children) && children.length > 0) {\n          inFn(children, i as T, deep + 1);\n        }\n        if (opt.clearChildren) {\n          delete i[opt.childrenMapName!];\n        }\n      }\n    };\n    inFn(tree, null);\n    return result as T[];\n  }\n\n  /**\n   * Convert array structure to tree structure\n   *\n   * 数组转换成树数据\n   */\n  arrToTree<T extends object = any>(arr: readonly T[], options?: ArrayServiceArrToTreeOptions<T>): T[] {\n    if (!Array.isArray(arr) || arr.length === 0) {\n      return [];\n    }\n\n    const opt = {\n      idMapName: this.c.idMapName,\n      parentIdMapName: this.c.parentIdMapName,\n      childrenMapName: this.c.childrenMapName,\n      cb: null,\n      ...options\n    } as ArrayServiceArrToTreeOptions<T>;\n    const tree: T[] = [];\n    const childrenOf: { [key: string]: T[] } = {};\n    let rootPid = opt.rootParentIdValue;\n    const arrType = arr as ReadonlyArray<{ [key: string]: any }>;\n    if (!rootPid) {\n      const pids = arrType.map(i => i[opt.parentIdMapName!]);\n      const emptyPid = pids.findIndex(w => w == null);\n      rootPid = emptyPid !== -1 ? pids[emptyPid] : pids.sort()[0];\n    }\n    for (const item of arrType) {\n      const id = item[opt.idMapName!];\n      const pid = item[opt.parentIdMapName!];\n      childrenOf[id] = childrenOf[id] || [];\n      item[opt.childrenMapName!] = childrenOf[id];\n      if (opt.cb) {\n        opt.cb(item as T);\n      }\n      if (pid !== rootPid) {\n        childrenOf[pid] = childrenOf[pid] || [];\n        childrenOf[pid].push(item as T);\n      } else {\n        tree.push(item as T);\n      }\n    }\n    return tree;\n  }\n\n  /**\n   * 数组转换成 `nz-tree` 数据源，通过 `options` 转化项名，也可以使用 `options.cb` 更高级决定数据项\n   */\n  arrToTreeNode<T extends object = any>(arr: readonly T[], options?: ArrayServiceArrToTreeNodeOptions): NzTreeNode[] {\n    const opt = {\n      idMapName: this.c.idMapName,\n      parentIdMapName: this.c.parentIdMapName,\n      titleMapName: this.c.titleMapName,\n      isLeafMapName: 'isLeaf',\n      checkedMapname: this.c.checkedMapname,\n      selectedMapname: this.c.selectedMapname,\n      expandedMapname: this.c.expandedMapname,\n      disabledMapname: this.c.disabledMapname,\n      cb: null,\n      ...options\n    } as ArrayServiceArrToTreeNodeOptions<T>;\n    const tree = this.arrToTree<T>(arr, {\n      idMapName: opt.idMapName,\n      parentIdMapName: opt.parentIdMapName,\n      childrenMapName: 'children'\n    });\n    this.visitTree<T>(tree, (item: { [key: string]: any }, parent, deep) => {\n      item.key = item[opt.idMapName!];\n      item.title = item[opt.titleMapName!];\n      item.checked = item[opt.checkedMapname!];\n      item.selected = item[opt.selectedMapname!];\n      item.expanded = item[opt.expandedMapname!];\n      item.disabled = item[opt.disabledMapname!];\n      if (item[opt.isLeafMapName!] == null) {\n        item.isLeaf = item.children.length === 0;\n      } else {\n        item.isLeaf = item[opt.isLeafMapName!];\n      }\n      if (opt.cb) {\n        opt.cb(item as any, parent, deep);\n      }\n    });\n    return tree.map(node => new NzTreeNode(node as any));\n  }\n\n  /**\n   * 递归访问整个树\n   */\n  visitTree<T extends object = any>(\n    tree: readonly T[],\n    cb: (item: T, parent: T | null, deep: number) => void,\n    options?: {\n      /** 子项名，默认：`'children'` */\n      childrenMapName?: string;\n    }\n  ): void {\n    options = {\n      childrenMapName: this.c.childrenMapName,\n      ...options\n    };\n    const inFn = (data: readonly T[], parent: T | null, deep: number): void => {\n      for (const item of data) {\n        cb(item, parent, deep);\n        const childrenVal = (item as { [key: string]: any })[options!.childrenMapName!];\n        if (Array.isArray(childrenVal) && childrenVal.length > 0) {\n          inFn(childrenVal, item, deep + 1);\n        }\n      }\n    };\n    inFn(tree, null, 1);\n  }\n\n  /**\n   * Return the value of the first tree value in the tree where predicate is true, and `undefined` otherwise\n   *\n   * 根据条件返回树的第一个值，否则返回 `undefined`\n   */\n  findTree<T extends object = any>(\n    tree: readonly T[],\n    predicate: (item: T) => boolean,\n    options?: {\n      /** 子项名，默认：`'children'` */\n      childrenMapName?: string;\n    }\n  ): T | undefined {\n    let res: T | undefined;\n    this.visitTree<T>(\n      tree,\n      item => {\n        if (res === undefined && predicate(item)) {\n          res = item;\n        }\n      },\n      options\n    );\n    return res;\n  }\n\n  /**\n   * 获取所有已经选中的 `key` 值\n   */\n  getKeysByTreeNode(tree: NzTreeNode[], options?: ArrayServiceGetKeysByTreeNodeOptions): any[] {\n    const opt = {\n      includeHalfChecked: true,\n      ...options\n    } as ArrayServiceGetKeysByTreeNodeOptions;\n    const keys: any[] = [];\n    this.visitTree<NzTreeNode>(tree, (item, parent, deep) => {\n      if (item.isChecked || (opt.includeHalfChecked && item.isHalfChecked)) {\n        keys.push(opt.cb ? opt.cb(item, parent, deep) : opt.keyMapName ? item.origin[opt.keyMapName] : item.key);\n      }\n    });\n    return keys;\n  }\n  private baseFlat(array: any[], depth: number, result: any[] = []): any[] {\n    let index = -1;\n    while (++index < array.length) {\n      const value = array[index];\n      if (depth > 0 && Array.isArray(value)) {\n        if (depth > 1) {\n          this.baseFlat(value, depth - 1, result);\n        } else {\n          let pushIndex = -1;\n          const offset = result.length;\n\n          while (++pushIndex < value.length) {\n            result[offset + pushIndex] = value[pushIndex];\n          }\n        }\n      } else {\n        result[result.length] = value;\n      }\n    }\n    return result;\n  }\n  /**\n   * Recursively flattens array\n   *\n   * 递归扁平数组\n   * ```ts\n   * srv.flat([1, [2, 3, [4, 5, [6]]]]) => [1,2,3,4,5,6]\n   * srv.flat([1, [2, 3, [4, 5, [6]]]], 1) => [1,2,3,[4, 5, [6]]]\n   * ```\n   */\n  flat<T>(array: readonly T[], depth: number = 1 / 0): T[] {\n    return Array.isArray(array) ? this.baseFlat(array as any[], depth) : (array as T[]);\n  }\n  /**\n   * Group the array\n   *\n   * 对数组进行分组\n   * ```ts\n   * srv.groupBy([6.1, 4.2, 6.3], Math.floor) => {\"4\":[4.2],\"6\":[6.1,6.3]}\n   * srv.groupBy(['one', 'two', 'three'], v => v.length) => {\"3\":[\"one\",\"two\"],\"5\":[\"three\"]}\n   * ```\n   */\n  groupBy<T>(array: readonly T[], iteratee: (value: T) => string | number): ArrayServiceGroupByResult {\n    if (!Array.isArray(array)) {\n      return {};\n    }\n    return array.reduce((result, value) => {\n      const key = iteratee(value);\n      if (Object.prototype.hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        result[key] = [value];\n      }\n      return result;\n    }, {} as ArrayServiceGroupByResult);\n  }\n  /**\n   * Creates a duplicate-free version of an array\n   *\n   * 创建去重后的数组\n   * ```ts\n   * uniq([1, 2, 2, 3, 1]) => [1,2,3]\n   * uniq([{ a: 1 }, { a: 1 }, { a: 2 }], 'a') => [{\"a\":1},{\"a\":2}]\n   * uniq([{ a: 1 }, { a: 1 }, { a: 2 }], i => (i.a === 1 ? 'a' : 'b')) => [{\"a\":1},{\"a\":2}]\n   * ```\n   */\n  uniq<T>(array: readonly T[], predicate?: string | ((value: T) => string | number | boolean)): T[] {\n    return Array.from(\n      array\n        .reduce((map, value) => {\n          const key = predicate\n            ? typeof predicate === 'string'\n              ? (value as any)[predicate]\n              : predicate!(value)\n            : value;\n          if (!map.has(key)) {\n            map.set(key, value);\n          }\n          return map;\n        }, new Map<string | number | boolean, T>())\n        .values()\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.service.js","sourceRoot":"","sources":["../../../../../packages/util/array/array.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from '@angular/core';\n\nimport { YunzaiConfigService, YunzaiUtilArrayConfig } from '@yelon/util/config';\nimport { NzTreeNode } from 'ng-zorro-antd/core/tree';\n\nimport {\n  ArrayServiceArrToTreeNodeOptions,\n  ArrayServiceArrToTreeOptions,\n  ArrayServiceGetKeysByTreeNodeOptions,\n  ArrayServiceGroupByResult,\n  ArrayServiceTreeToArrOptions\n} from './array-type.service';\n\n@Injectable({ providedIn: 'root' })\nexport class ArrayService {\n  private c: YunzaiUtilArrayConfig;\n\n  constructor(cog: YunzaiConfigService) {\n    this.c = cog.merge('utilArray', {\n      deepMapName: 'deep',\n      parentMapName: 'parent',\n      idMapName: 'id',\n      parentIdMapName: 'parent_id',\n      childrenMapName: 'children',\n      titleMapName: 'title',\n      checkedMapname: 'checked',\n      selectedMapname: 'selected',\n      expandedMapname: 'expanded',\n      disabledMapname: 'disabled'\n    })!;\n  }\n\n  /**\n   * Convert tree structure to array structure\n   *\n   * 将树结构转换成数组结构\n   */\n  treeToArr<T extends object = any>(tree: readonly T[], options?: ArrayServiceTreeToArrOptions<T>): T[] {\n    const opt = {\n      deepMapName: this.c.deepMapName,\n      parentMapName: this.c.parentMapName,\n      childrenMapName: this.c.childrenMapName,\n      clearChildren: true,\n      cb: null,\n      ...options\n    } as ArrayServiceTreeToArrOptions;\n    const result: Array<{ [key: string]: any }> = [];\n    const inFn = (list: ReadonlyArray<{ [key: string]: any }>, parent: T | null, deep: number = 0): void => {\n      for (const i of list) {\n        i[opt.deepMapName!] = deep;\n        i[opt.parentMapName!] = parent;\n        if (opt.cb) {\n          opt.cb(i, parent, deep);\n        }\n        result.push(i);\n        const children = i[opt.childrenMapName!];\n        if (children != null && Array.isArray(children) && children.length > 0) {\n          inFn(children, i as T, deep + 1);\n        }\n        if (opt.clearChildren) {\n          delete i[opt.childrenMapName!];\n        }\n      }\n    };\n    inFn(tree, null);\n    return result as T[];\n  }\n\n  /**\n   * Convert array structure to tree structure\n   *\n   * 数组转换成树数据\n   */\n  arrToTree<T extends object = any>(arr: readonly T[], options?: ArrayServiceArrToTreeOptions<T>): T[] {\n    if (!Array.isArray(arr) || arr.length === 0) {\n      return [];\n    }\n\n    const opt = {\n      idMapName: this.c.idMapName,\n      parentIdMapName: this.c.parentIdMapName,\n      childrenMapName: this.c.childrenMapName,\n      cb: null,\n      ...options\n    } as ArrayServiceArrToTreeOptions<T>;\n    const tree: T[] = [];\n    const childrenOf: { [key: string]: T[] } = {};\n    let rootPid = opt.rootParentIdValue;\n    const arrType = arr as ReadonlyArray<{ [key: string]: any }>;\n    if (!rootPid) {\n      const pids = arrType.map(i => i[opt.parentIdMapName!]);\n      const emptyPid = pids.findIndex(w => w == null);\n      rootPid = emptyPid !== -1 ? pids[emptyPid] : pids.sort()[0];\n    }\n    for (const item of arrType) {\n      const id = item[opt.idMapName!];\n      const pid = item[opt.parentIdMapName!];\n      childrenOf[id] = childrenOf[id] || [];\n      item[opt.childrenMapName!] = childrenOf[id];\n      if (opt.cb) {\n        opt.cb(item as T);\n      }\n      if (pid !== rootPid) {\n        childrenOf[pid] = childrenOf[pid] || [];\n        childrenOf[pid].push(item as T);\n      } else {\n        tree.push(item as T);\n      }\n    }\n    return tree;\n  }\n\n  /**\n   * 数组转换成 `nz-tree` 数据源，通过 `options` 转化项名，也可以使用 `options.cb` 更高级决定数据项\n   */\n  arrToTreeNode<T extends object = any>(arr: readonly T[], options?: ArrayServiceArrToTreeNodeOptions): NzTreeNode[] {\n    const opt = {\n      idMapName: this.c.idMapName,\n      parentIdMapName: this.c.parentIdMapName,\n      titleMapName: this.c.titleMapName,\n      isLeafMapName: 'isLeaf',\n      checkedMapname: this.c.checkedMapname,\n      selectedMapname: this.c.selectedMapname,\n      expandedMapname: this.c.expandedMapname,\n      disabledMapname: this.c.disabledMapname,\n      cb: null,\n      ...options\n    } as ArrayServiceArrToTreeNodeOptions<T>;\n    const tree = this.arrToTree<T>(arr, {\n      idMapName: opt.idMapName,\n      parentIdMapName: opt.parentIdMapName,\n      childrenMapName: 'children'\n    });\n    this.visitTree<T>(tree, (item: { [key: string]: any }, parent, deep) => {\n      item.key = item[opt.idMapName!];\n      item.title = item[opt.titleMapName!];\n      item.checked = item[opt.checkedMapname!];\n      item.selected = item[opt.selectedMapname!];\n      item.expanded = item[opt.expandedMapname!];\n      item.disabled = item[opt.disabledMapname!];\n      if (item[opt.isLeafMapName!] == null) {\n        item.isLeaf = item.children.length === 0;\n      } else {\n        item.isLeaf = item[opt.isLeafMapName!];\n      }\n      if (opt.cb) {\n        opt.cb(item as any, parent, deep);\n      }\n    });\n    return tree.map(node => new NzTreeNode(node as any));\n  }\n\n  /**\n   * 递归访问整个树\n   */\n  visitTree<T extends object = any>(\n    tree: readonly T[],\n    cb: (item: T, parent: T | null, deep: number) => void,\n    options?: {\n      /** 子项名，默认：`'children'` */\n      childrenMapName?: string;\n    }\n  ): void {\n    options = {\n      childrenMapName: this.c.childrenMapName,\n      ...options\n    };\n    const inFn = (data: readonly T[], parent: T | null, deep: number): void => {\n      for (const item of data) {\n        cb(item, parent, deep);\n        const childrenVal = (item as { [key: string]: any })[options!.childrenMapName!];\n        if (Array.isArray(childrenVal) && childrenVal.length > 0) {\n          inFn(childrenVal, item, deep + 1);\n        }\n      }\n    };\n    inFn(tree, null, 1);\n  }\n\n  /**\n   * Return the value of the first tree value in the tree where predicate is true, and `undefined` otherwise\n   *\n   * 根据条件返回树的第一个值，否则返回 `undefined`\n   */\n  findTree<T extends object = any>(\n    tree: readonly T[],\n    predicate: (item: T) => boolean,\n    options?: {\n      /** 子项名，默认：`'children'` */\n      childrenMapName?: string;\n    }\n  ): T | undefined {\n    let res: T | undefined;\n    this.visitTree<T>(\n      tree,\n      item => {\n        if (res === undefined && predicate(item)) {\n          res = item;\n        }\n      },\n      options\n    );\n    return res;\n  }\n\n  /**\n   * 获取所有已经选中的 `key` 值\n   */\n  getKeysByTreeNode(tree: NzTreeNode[], options?: ArrayServiceGetKeysByTreeNodeOptions): any[] {\n    const opt = {\n      includeHalfChecked: true,\n      ...options\n    } as ArrayServiceGetKeysByTreeNodeOptions;\n    const keys: any[] = [];\n    this.visitTree<NzTreeNode>(tree, (item, parent, deep) => {\n      if (item.isChecked || (opt.includeHalfChecked && item.isHalfChecked)) {\n        keys.push(opt.cb ? opt.cb(item, parent, deep) : opt.keyMapName ? item.origin[opt.keyMapName] : item.key);\n      }\n    });\n    return keys;\n  }\n  private baseFlat(array: any[], depth: number, result: any[] = []): any[] {\n    let index = -1;\n    while (++index < array.length) {\n      const value = array[index];\n      if (depth > 0 && Array.isArray(value)) {\n        if (depth > 1) {\n          this.baseFlat(value, depth - 1, result);\n        } else {\n          let pushIndex = -1;\n          const offset = result.length;\n\n          while (++pushIndex < value.length) {\n            result[offset + pushIndex] = value[pushIndex];\n          }\n        }\n      } else {\n        result[result.length] = value;\n      }\n    }\n    return result;\n  }\n  /**\n   * Recursively flattens array\n   *\n   * 递归扁平数组\n   * ```ts\n   * srv.flat([1, [2, 3, [4, 5, [6]]]]) => [1,2,3,4,5,6]\n   * srv.flat([1, [2, 3, [4, 5, [6]]]], 1) => [1,2,3,[4, 5, [6]]]\n   * ```\n   */\n  flat<T>(array: readonly T[], depth: number = 1 / 0): T[] {\n    return Array.isArray(array) ? this.baseFlat(array as any[], depth) : (array as T[]);\n  }\n  /**\n   * Group the array\n   *\n   * 对数组进行分组\n   * ```ts\n   * srv.groupBy([6.1, 4.2, 6.3], Math.floor) => {\"4\":[4.2],\"6\":[6.1,6.3]}\n   * srv.groupBy(['one', 'two', 'three'], v => v.length) => {\"3\":[\"one\",\"two\"],\"5\":[\"three\"]}\n   * ```\n   */\n  groupBy<T>(array: readonly T[], iteratee: (value: T) => string | number): ArrayServiceGroupByResult {\n    if (!Array.isArray(array)) {\n      return {};\n    }\n    return array.reduce((result, value) => {\n      const key = iteratee(value);\n      if (Object.prototype.hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        result[key] = [value];\n      }\n      return result;\n    }, {} as ArrayServiceGroupByResult);\n  }\n  /**\n   * Creates a duplicate-free version of an array\n   *\n   * 创建去重后的数组\n   * ```ts\n   * uniq([1, 2, 2, 3, 1]) => [1,2,3]\n   * uniq([{ a: 1 }, { a: 1 }, { a: 2 }], 'a') => [{\"a\":1},{\"a\":2}]\n   * uniq([{ a: 1 }, { a: 1 }, { a: 2 }], i => (i.a === 1 ? 'a' : 'b')) => [{\"a\":1},{\"a\":2}]\n   * ```\n   */\n  uniq<T>(array: readonly T[], predicate?: string | ((value: T) => string | number | boolean)): T[] {\n    return Array.from(\n      array\n        .reduce((map, value) => {\n          const key = predicate\n            ? typeof predicate === 'string'\n              ? (value as any)[predicate]\n              : predicate!(value)\n            : value;\n          if (!map.has(key)) {\n            map.set(key, value);\n          }\n          return map;\n        }, new Map<string | number | boolean, T>())\n        .values()\n    );\n  }\n}\n"]}

package/esm2020/browser/cookie.service.mjs

@@ -80,7 +80,7 @@ export class CookieService {
      * 移除指定 Cookie
      */
     remove(key, options) {
-        this.put(key, undefined, options);
+        this.put(key, '', options);
     }
     /**
      * Remove all cookies
@@ -91,13 +91,13 @@ export class CookieService {
         this.doc.cookie = '';
     }
 }
-CookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CookieService, deps: [{ token: DOCUMENT }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
-CookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CookieService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CookieService, decorators: [{
+CookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CookieService, deps: [{ token: DOCUMENT }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+CookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CookieService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CookieService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [DOCUMENT]
                 }] }, { type: i1.Platform }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/browser/copy.mjs

@@ -4,6 +4,25 @@
  * 复制字符串文档至剪贴板
  */
 export function copy(value) {
-    return navigator.clipboard.writeText(value);
+    return new Promise((resolve) => {
+        let copyTextArea = null;
+        try {
+            copyTextArea = document.createElement('textarea');
+            copyTextArea.style.height = '0px';
+            copyTextArea.style.opacity = '0';
+            copyTextArea.style.width = '0px';
+            document.body.appendChild(copyTextArea);
+            copyTextArea.value = value;
+            copyTextArea.select();
+            // eslint-disable-next-line deprecation/deprecation
+            document.execCommand('copy');
+            resolve(value);
+        }
+        finally {
+            if (copyTextArea && copyTextArea.parentNode) {
+                copyTextArea.parentNode.removeChild(copyTextArea);
+            }
+        }
+    });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29weS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3V0aWwvYnJvd3Nlci9jb3B5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDRixNQUFNLFVBQVUsSUFBSSxDQUFDLEtBQWE7SUFDakMsT0FBTyxTQUFTLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUM5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5IHRleHQgdG8gY2xpcGJvYXJkXG4gKlxuICog5aSN5Yi25a2X56ym5Liy5paH5qGj6Iez5Ymq6LS05p2/XG4gKi9cbiBleHBvcnQgZnVuY3Rpb24gY29weSh2YWx1ZTogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gIHJldHVybiBuYXZpZ2F0b3IuY2xpcGJvYXJkLndyaXRlVGV4dCh2YWx1ZSk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/browser/scroll.service.mjs

@@ -76,13 +76,13 @@ export class ScrollService {
         this.scrollToElement(this._getDoc().body, topOffset);
     }
 }
-ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, deps: [{ token: DOCUMENT }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
-ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ScrollService, decorators: [{
+ScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ScrollService, deps: [{ token: DOCUMENT }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ScrollService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ScrollService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [DOCUMENT]
                 }] }, { type: i1.Platform }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/config/abc/media.type.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWEudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3V0aWwvY29uZmlnL2FiYy9tZWRpYS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE56U2FmZUFueSB9IGZyb20gJ25nLXpvcnJvLWFudGQvY29yZS90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgWXVuemFpTWVkaWFDb25maWcge1xuICAvKipcbiAgICogUGx5ciBsaWJyYXJ5IHBhdGgsIGRlZmF1bHQ6IGBbXCJodHRwczovL2Nkbi5ib290Y2RuLm5ldC9hamF4L2xpYnMvcGx5ci8zLjUuMTAvcGx5ci5taW4uanNcIiwgXCJodHRwczovL2Nkbi5ib290Y2RuLm5ldC9hamF4L2xpYnMvcGx5ci8zLjUuMTAvcGx5ci5jc3NcIl1gXG4gICAqL1xuICB1cmxzPzogc3RyaW5nW107XG4gIC8qKlxuICAgKiBQbGVhc2UgcmVmZXIgdG8gW3BseXIgb3B0aW9uc10oaHR0cHM6Ly9naXRodWIuY29tL3NhbXBvdHRzL3BseXIjb3B0aW9ucylcbiAgICovXG4gIG9wdGlvbnM/OiBOelNhZmVBbnk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWEudHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3V0aWwvY29uZmlnL2FiYy9tZWRpYS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOelNhZmVBbnkgfSBmcm9tICduZy16b3Jyby1hbnRkL2NvcmUvdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFl1bnphaU1lZGlhQ29uZmlnIHtcbiAgLyoqXG4gICAqIFBseXIgbGlicmFyeSBwYXRoLCBkZWZhdWx0OiBgW1wiaHR0cHM6Ly9jZG4uYm9vdGNkbi5uZXQvYWpheC9saWJzL3BseXIvMy41LjEwL3BseXIubWluLmpzXCIsIFwiaHR0cHM6Ly9jZG4uYm9vdGNkbi5uZXQvYWpheC9saWJzL3BseXIvMy41LjEwL3BseXIuY3NzXCJdYFxuICAgKi9cbiAgdXJscz86IHN0cmluZ1tdO1xuICAvKipcbiAgICogUGxlYXNlIHJlZmVyIHRvIFtwbHlyIG9wdGlvbnNdKGh0dHBzOi8vZ2l0aHViLmNvbS9zYW1wb3R0cy9wbHlyI29wdGlvbnMpXG4gICAqL1xuICBvcHRpb25zPzogTnpTYWZlQW55O1xufVxuIl19

package/esm2020/config/abc/st.type.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st.type.js","sourceRoot":"","sources":["../../../../../../packages/util/config/abc/st.type.ts"],"names":[],"mappings":"","sourcesContent":["import { HttpHeaders, HttpParams } from '@angular/common/http';\nimport { TemplateRef, TrackByFunction } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\nimport { NzDrawerOptions } from 'ng-zorro-antd/drawer';\nimport { ModalOptions } from 'ng-zorro-antd/modal';\nimport { PaginationItemRenderContext } from 'ng-zorro-antd/pagination';\n\nexport interface YunzaiSTConfig {\n  /**\n   * 起始页码，默认为：`1`\n   */\n  pi?: number;\n  /**\n   * 每页数量，默认：`10`\n   */\n  ps?: number;\n  /**\n   * 是否显示边框，默认：`false`\n   */\n  bordered?: boolean;\n  /**\n   * table大小，默认：`default`\n   */\n  size?: 'small' | 'middle' | 'default';\n  /**\n   * 是否开启响应式，默认：`true`\n   */\n  responsive?: boolean;\n  /**\n   * 是否在小屏幕下才显示顶部与底部，默认：`false`\n   */\n  responsiveHideHeaderFooter?: boolean;\n  /** 请求体配置 */\n  req?: {\n    /**\n     * 分页类型，默认：`page`\n     * - `page` 使用 `pi`，`ps` 组合\n     * - `skip` 使用 `skip`，`limit` 组合\n     */\n    type?: 'page' | 'skip';\n    /** 请求方法，默认：`GET` */\n    method?: string;\n    /** 请求体 `Header` */\n    headers?: NzSafeAny;\n    /**\n     * 重命名参数 `pi`、`ps`，默认：`{ pi: 'pi', ps: 'ps', skip: 'skip', limit: 'limit' }`\n     * - `{ pi: 'Page' }` => `pi` 会被替换成 Page\n     */\n    reName?: {\n      pi?: string;\n      ps?: string;\n      skip?: string;\n      limit?: string;\n    };\n    /**\n     * 是否将请求所有参数数据都放入 `body` 当中（`url` 地址本身参数除外），仅当 `method: 'POST'` 时有效，默认：`false`\n     */\n    allInBody?: boolean;\n    /**\n     * 是否延迟加载数据，即渲染结束后不会主动发起请求，默认：`false`\n     */\n    lazyLoad?: boolean;\n    /**\n     * 请求前数据处理\n     */\n    process?: (requestOptions: NzSafeAny) => NzSafeAny;\n  };\n  /** 返回体配置 */\n  res?: {\n    /**\n     * 重命名返回参数 `total`、`list`，默认：`{ list: ['list'], total: ['total'] }`\n     * - `{ total: 'Total' }` => Total 会被当作 `total`\n     */\n    reName?: {\n      total?: string | string[];\n      list?: string | string[];\n    };\n    /**\n     * 数据预处理\n     */\n    process?: (data: NzSafeAny[], rawData?: NzSafeAny) => NzSafeAny[];\n  };\n  /** 返回体配置 */\n  page?: {\n    /**\n     * 前端分页，当 `data` 为`any[]` 或 `Observable<any[]>` 有效，默认：`true`\n     * - `true` 由 `st` 根据 `data` 长度受控分页，包括：排序、过滤等\n     * - `false` 由用户通过 `total` 和 `data` 参数受控分页，并维护 `(change)` 当分页变更时重新加载数据\n     */\n    front?: boolean;\n    /**\n     * 后端分页是否采用`0`基索引，只在`data`类型为`string`时有效，默认：`false`\n     */\n    zeroIndexed?: boolean;\n    /**\n     * 指定分页显示的位置，默认：`bottom`\n     */\n    position?: 'top' | 'bottom' | 'both';\n    /**\n     * 指定分页分页方向，默认：`right`\n     */\n    placement?: 'left' | 'center' | 'right';\n    /**\n     * 是否显示分页器，默认：`true`\n     */\n    show?: boolean;\n    /**\n     * 是否显示分页器中改变页数，默认：`false`\n     */\n    showSize?: boolean;\n    /**\n     * 分页器中每页显示条目数下拉框值，默认：`[10, 20, 30, 40, 50]`\n     */\n    pageSizes?: number[];\n    /**\n     * 是否显示分页器中快速跳转，默认：`false`\n     */\n    showQuickJumper?: boolean;\n    /**\n     * 是否显示总数据量，默认：`true`\n     * - `boolean` 类型显示与否，默认模板：`共 {{total}} 条`\n     * - `string` 自定义模板，模板变量：\n     *  - `{{total}}` 表示数据总量\n     *  - `{{range[0]}}` 表示当前页开始数量值\n     *  - `{{range[1]}}` 表示当前页结束数量值\n     */\n    total?: string | boolean;\n    /**\n     * 用于自定义页码的结构，用法参照 Pagination 组件\n     */\n    itemRender?: TemplateRef<PaginationItemRenderContext> | null;\n    /**\n     * 当添加该属性时，显示为简单分页，默认：`false`\n     */\n    simple?: boolean;\n    /**\n     * 切换分页时返回顶部，默认：`true`\n     */\n    toTop?: boolean;\n    /**\n     * 返回顶部偏移值，默认：`100`\n     */\n    toTopOffset?: number;\n  };\n  /**\n   * 重命名排序值，`columns` 的重命名高于属性\n   */\n  sortReName?: { ascend?: string; descend?: string };\n  /**\n   * 单排序规则\n   * - 若不指定，则返回：`columnName=ascend|descend`\n   * - 若指定，则返回：`sort=columnName.(ascend|descend)`\n   */\n  singleSort?: {\n    /** 请求参数名，默认：`sort` */\n    key?: string;\n    /** 列名与状态间分隔符，默认：`.` */\n    nameSeparator?: string;\n  };\n  /**\n   * 是否多排序，当 `sort` 多个相同值时自动合并，建议后端支持时使用\n   */\n  multiSort?: {\n    /** 请求参数名，默认：`sort` */\n    key?: string;\n    /** 不同属性间分隔符，默认：`-` */\n    separator?: string;\n    /** 列名与状态间分隔符，默认：`.` */\n    nameSeparator?: string;\n    /**\n     * 是否以数组的形式传递参数\n     * - `true` 表示使用 `url?sort=name.asc&sort=age.desc` 形式\n     * - `false` 表示使用 `url?sort=name.asc-age.desc` 形式\n     */\n    arrayParam?: boolean;\n    /**\n     * 是否全局多排序模式，默认：`true`\n     * - `true` 表示所有 `st` 默认为多排序\n     * - `false` 表示需要为每个 `st` 添加 `multiSort` 才会视为多排序模式\n     */\n    global?: boolean;\n    /**\n     * 是否保持空值的键名，默认：`true`\n     * - `true` 表示不管是否有排序都会发送 `key` 键名\n     * - `false` 表示无排序动作时不会发送 `key` 键名\n     */\n    keepEmptyKey?: boolean;\n  };\n  /**\n   * 按钮模态框配置\n   */\n  modal?: {\n    /**\n     * 指定模态框目标组件的接收参数名，默认：`record`\n     */\n    paramsName?: string;\n    /** 大小；例如：lg、600，默认：`lg` */\n    size?: 'sm' | 'md' | 'lg' | 'xl' | '' | number;\n    /** 对话框 [ModalOptions](https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/components/modal/modal-types.ts) 参数 */\n    modalOptions?: ModalOptions;\n    /** 是否精准（默认：`true`），若返回值非空值（`null`或`undefined`）视为成功，否则视为错误 */\n    exact?: boolean;\n  };\n  /**\n   * 按钮抽屉配置\n   */\n  drawer?: {\n    /**\n     * 抽屉目标组件的接收参数名，默认：`record`\n     */\n    paramsName?: string;\n    /**\n     * 大小；例如：lg、600，默认：`md`\n     *\n     * | 类型 | 默认大小 |\n     * | --- | ------ |\n     * | `sm` | `300` |\n     * | `md` | `600` |\n     * | `lg` | `900` |\n     * | `xl` | `1200` |\n     *\n     * > 以上值，可通过覆盖相应的LESS参数自行调整\n     */\n    size?: 'sm' | 'md' | 'lg' | 'xl' | number;\n    /**\n     * 是否包含底部工具条，默认：`true`\n     */\n    footer?: boolean;\n    /**\n     * 底部工具条高度，默认：`55`\n     */\n    footerHeight?: number;\n    /** 抽屉 [NzDrawerOptions](https://ng.ant.design/components/drawer/zh#nzdraweroptions) 参数 */\n    drawerOptions?: NzDrawerOptions;\n  };\n  /**\n   * 气泡参数\n   */\n  pop?: {\n    /**\n     * Title of the popover, default: `确认删除吗？`\n     */\n    title?: string;\n\n    /**\n     * Popover trigger mode, default: `click`\n     */\n    trigger?: 'click' | 'focus' | 'hover';\n\n    /**\n     * The position of the popover relative to the target, default: `top`\n     */\n    placement?:\n      | 'top'\n      | 'left'\n      | 'right'\n      | 'bottom'\n      | 'topLeft'\n      | 'topRight'\n      | 'bottomLeft'\n      | 'bottomRight'\n      | 'leftTop'\n      | 'leftBottom'\n      | 'rightTop'\n      | 'rightBottom';\n\n    /**\n     * Class name of the popover card\n     */\n    overlayClassName?: string;\n\n    /**\n     * Style of the popover card\n     */\n    overlayStyle?: { [key: string]: string };\n\n    /**\n     * Text of the Cancel button\n     */\n    cancelText?: string;\n\n    /**\n     * Text of the Confirm button\n     */\n    okText?: string;\n\n    /**\n     * Button `type` of the Confirm button\n     */\n    okType?: 'primary' | 'ghost' | 'dashed' | 'danger' | 'default';\n\n    /**\n     * Customize icon of confirmation\n     */\n    icon?: string;\n  };\n  /**\n   * 过滤按钮确认文本\n   */\n  filterConfirmText?: string;\n  /**\n   * 过滤按钮重置文本\n   */\n  filterClearText?: string;\n  /**\n   * 按钮图标\n   */\n  btnIcon?: {\n    /** 图标主题风格，默认：`outline` */\n    theme?: 'outline' | 'twotone' | 'fill';\n    /** 是否有旋转动画，默认：`false` */\n    spin?: boolean;\n    /** 仅适用双色图标，设置双色图标的主要颜色，仅对当前 icon 生效 */\n    twoToneColor?: string;\n    /** 指定来自 IconFont 的图标类型 */\n    iconfont?: string;\n  };\n  /**\n   * 行号索引，默认：`1`\n   * - 计算规则为：`index + noIndex`\n   */\n  noIndex?: number;\n  /**\n   * 表格行的类名\n   */\n  rowClassName?: (record: NzSafeAny, index: number) => string;\n  /**\n   * 通过点击行来展开子行，Default: `false`\n   */\n  expandRowByClick?: boolean;\n  /**\n   * 手风琴模式，Default: `false`\n   */\n  expandAccordion?: boolean;\n  /**\n   * 指定 `width` 模式\n   */\n  widthMode?: {\n    /**\n     * 宽度类型，默认：`default`\n     * - `default` 默认行为\n     * - `strict` 严格模式，即强制按 `width` 指定的宽度呈现，并根据 `strictBehavior` 类型处理\n     */\n    type?: 'strict' | 'default';\n    /**\n     * 严格模式的处理行为，默认：`truncate`\n     * - `wrap` 强制换行\n     * - `truncate` 截短\n     */\n    strictBehavior?: 'wrap' | 'truncate';\n  };\n  /**\n   * Default: `54`\n   */\n  virtualItemSize?: number;\n  /**\n   * Default: `200`\n   */\n  virtualMaxBufferPx?: number;\n  /**\n   * Default: `100`\n   */\n  virtualMinBufferPx?: number;\n  /**\n   * The TrackByFunction to use for tracking changes\n   */\n  virtualForTrackBy?: TrackByFunction<unknown>;\n  /**\n   * Conditional expression rendering behavior, can be set to `hide` (default) or `disabled`, Default: `hide`\n   */\n  iifBehavior?: 'hide' | 'disabled';\n  /**\n   * The spinning indicator\n   */\n  loadingIndicator?: TemplateRef<void>;\n  /**\n   * Specifies a delay in milliseconds for loading state (prevent flush)\n   */\n  loadingDelay?: number;\n  /**\n   * Custom no result content\n   */\n  noResult?: string | TemplateRef<void>;\n  /**\n   * Safe rendering type, default: `safeHtml`\n   *\n   * 安全渲染方式，默认：`safeHtml`\n   */\n  safeType?: 'text' | 'html' | 'safeHtml';\n  /**\n   * Override the default request behavior, you can customize your own request implementation, for example: Graphql\n   *\n   * 覆盖默认的请求行为，可以自定义自己的请求实现，例如：Graphql\n   */\n  customRequest?: (options: {\n    method: string;\n    url: string;\n    options: {\n      body?: unknown;\n      headers?:\n        | HttpHeaders\n        | {\n            [header: string]: string | string[];\n          };\n      params?:\n        | HttpParams\n        | {\n            [param: string]: string | string[];\n          };\n    };\n  }) => Observable<NzSafeAny>;\n  /**\n   * Date format\n   *\n   * 日期格式化\n   */\n  date?: {\n    /**\n     * Format string, default: `yyyy-MM-dd HH:mm`\n     *\n     * 格式化字符串，默认：`yyyy-MM-dd HH:mm`\n     */\n    format: string;\n  };\n  yn?: {\n    /**\n     * 真值条件，（默认：`true`）\n     */\n    truth?: unknown;\n    /**\n     * 徽章 `true` 时文本，（默认：`是`）\n     */\n    yes?: string;\n    /**\n     * 徽章 `false` 时文本，（默认：`否`）\n     */\n    no?: string;\n    /**\n     * 徽章显示风格，默认：`icon`\n     * - `full` 图标和文本\n     * - `icon` 图标\n     * - `text` 文本\n     */\n    mode?: 'full' | 'icon' | 'text';\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st.type.js","sourceRoot":"","sources":["../../../../../../packages/util/config/abc/st.type.ts"],"names":[],"mappings":"","sourcesContent":["import { HttpHeaders, HttpParams } from '@angular/common/http';\nimport { TemplateRef, TrackByFunction } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\nimport { NzDrawerOptions } from 'ng-zorro-antd/drawer';\nimport { ModalOptions } from 'ng-zorro-antd/modal';\nimport { PaginationItemRenderContext } from 'ng-zorro-antd/pagination';\n\nexport interface YunzaiSTConfig {\n  /**\n   * 起始页码，默认为：`1`\n   */\n  pi?: number;\n  /**\n   * 每页数量，默认：`10`\n   */\n  ps?: number;\n  /**\n   * 是否显示边框，默认：`false`\n   */\n  bordered?: boolean;\n  /**\n   * table大小，默认：`default`\n   */\n  size?: 'small' | 'middle' | 'default';\n  /**\n   * 是否开启响应式，默认：`true`\n   */\n  responsive?: boolean;\n  /**\n   * 是否在小屏幕下才显示顶部与底部，默认：`false`\n   */\n  responsiveHideHeaderFooter?: boolean;\n  /** 请求体配置 */\n  req?: {\n    /**\n     * 分页类型，默认：`page`\n     * - `page` 使用 `pi`，`ps` 组合\n     * - `skip` 使用 `skip`，`limit` 组合\n     */\n    type?: 'page' | 'skip';\n    /** 请求方法，默认：`GET` */\n    method?: string;\n    /** 请求体 `Header` */\n    headers?: NzSafeAny;\n    /**\n     * 重命名参数 `pi`、`ps`，默认：`{ pi: 'pi', ps: 'ps', skip: 'skip', limit: 'limit' }`\n     * - `{ pi: 'Page' }` => `pi` 会被替换成 Page\n     */\n    reName?: {\n      pi?: string;\n      ps?: string;\n      skip?: string;\n      limit?: string;\n    };\n    /**\n     * 是否将请求所有参数数据都放入 `body` 当中（`url` 地址本身参数除外），仅当 `method: 'POST'` 时有效，默认：`false`\n     */\n    allInBody?: boolean;\n    /**\n     * 是否延迟加载数据，即渲染结束后不会主动发起请求，默认：`false`\n     */\n    lazyLoad?: boolean;\n    /**\n     * 请求前数据处理\n     */\n    process?: (requestOptions: NzSafeAny) => NzSafeAny;\n  };\n  /** 返回体配置 */\n  res?: {\n    /**\n     * 重命名返回参数 `total`、`list`，默认：`{ list: ['list'], total: ['total'] }`\n     * - `{ total: 'Total' }` => Total 会被当作 `total`\n     */\n    reName?: {\n      total?: string | string[];\n      list?: string | string[];\n    };\n    /**\n     * 数据预处理\n     */\n    process?: (data: NzSafeAny[], rawData?: NzSafeAny) => NzSafeAny[];\n  };\n  /** 返回体配置 */\n  page?: {\n    /**\n     * 前端分页，当 `data` 为`any[]` 或 `Observable<any[]>` 有效，默认：`true`\n     * - `true` 由 `st` 根据 `data` 长度受控分页，包括：排序、过滤等\n     * - `false` 由用户通过 `total` 和 `data` 参数受控分页，并维护 `(change)` 当分页变更时重新加载数据\n     */\n    front?: boolean;\n    /**\n     * 后端分页是否采用`0`基索引，只在`data`类型为`string`时有效，默认：`false`\n     */\n    zeroIndexed?: boolean;\n    /**\n     * 指定分页显示的位置，默认：`bottom`\n     */\n    position?: 'top' | 'bottom' | 'both';\n    /**\n     * 指定分页分页方向，默认：`right`\n     */\n    placement?: 'left' | 'center' | 'right';\n    /**\n     * 是否显示分页器，默认：`true`\n     */\n    show?: boolean;\n    /**\n     * 是否显示分页器中改变页数，默认：`false`\n     */\n    showSize?: boolean;\n    /**\n     * 分页器中每页显示条目数下拉框值，默认：`[10, 20, 30, 40, 50]`\n     */\n    pageSizes?: number[];\n    /**\n     * 是否显示分页器中快速跳转，默认：`false`\n     */\n    showQuickJumper?: boolean;\n    /**\n     * 是否显示总数据量，默认：`true`\n     * - `boolean` 类型显示与否，默认模板：`共 {{total}} 条`\n     * - `string` 自定义模板，模板变量：\n     *  - `{{total}}` 表示数据总量\n     *  - `{{range[0]}}` 表示当前页开始数量值\n     *  - `{{range[1]}}` 表示当前页结束数量值\n     */\n    total?: string | boolean;\n    /**\n     * 用于自定义页码的结构，用法参照 Pagination 组件\n     */\n    itemRender?: TemplateRef<PaginationItemRenderContext> | null;\n    /**\n     * 当添加该属性时，显示为简单分页，默认：`false`\n     */\n    simple?: boolean;\n    /**\n     * 切换分页时返回顶部，默认：`true`\n     */\n    toTop?: boolean;\n    /**\n     * 返回顶部偏移值，默认：`100`\n     */\n    toTopOffset?: number;\n  };\n  /**\n   * 重命名排序值，`columns` 的重命名高于属性\n   */\n  sortReName?: { ascend?: string; descend?: string };\n  /**\n   * 单排序规则\n   * - 若不指定，则返回：`columnName=ascend|descend`\n   * - 若指定，则返回：`sort=columnName.(ascend|descend)`\n   */\n  singleSort?: {\n    /** 请求参数名，默认：`sort` */\n    key?: string;\n    /** 列名与状态间分隔符，默认：`.` */\n    nameSeparator?: string;\n  };\n  /**\n   * 是否多排序，当 `sort` 多个相同值时自动合并，建议后端支持时使用\n   */\n  multiSort?: {\n    /** 请求参数名，默认：`sort` */\n    key?: string;\n    /** 不同属性间分隔符，默认：`-` */\n    separator?: string;\n    /** 列名与状态间分隔符，默认：`.` */\n    nameSeparator?: string;\n    /**\n     * 是否以数组的形式传递参数\n     * - `true` 表示使用 `url?sort=name.asc&sort=age.desc` 形式\n     * - `false` 表示使用 `url?sort=name.asc-age.desc` 形式\n     */\n    arrayParam?: boolean;\n    /**\n     * 是否全局多排序模式，默认：`true`\n     * - `true` 表示所有 `st` 默认为多排序\n     * - `false` 表示需要为每个 `st` 添加 `multiSort` 才会视为多排序模式\n     */\n    global?: boolean;\n    /**\n     * 是否保持空值的键名，默认：`true`\n     * - `true` 表示不管是否有排序都会发送 `key` 键名\n     * - `false` 表示无排序动作时不会发送 `key` 键名\n     */\n    keepEmptyKey?: boolean;\n  };\n  /**\n   * 按钮模态框配置\n   */\n  modal?: {\n    /**\n     * 指定模态框目标组件的接收参数名，默认：`record`\n     */\n    paramsName?: string;\n    /** 大小；例如：lg、600，默认：`lg` */\n    size?: 'sm' | 'md' | 'lg' | 'xl' | '' | number;\n    /** 对话框 [ModalOptions](https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/components/modal/modal-types.ts) 参数 */\n    modalOptions?: ModalOptions;\n    /** 是否精准（默认：`true`），若返回值非空值（`null`或`undefined`）视为成功，否则视为错误 */\n    exact?: boolean;\n  };\n  /**\n   * 按钮抽屉配置\n   */\n  drawer?: {\n    /**\n     * 抽屉目标组件的接收参数名，默认：`record`\n     */\n    paramsName?: string;\n    /**\n     * 大小；例如：lg、600，默认：`md`\n     *\n     * | 类型 | 默认大小 |\n     * | --- | ------ |\n     * | `sm` | `300` |\n     * | `md` | `600` |\n     * | `lg` | `900` |\n     * | `xl` | `1200` |\n     *\n     * > 以上值，可通过覆盖相应的LESS参数自行调整\n     */\n    size?: 'sm' | 'md' | 'lg' | 'xl' | number;\n    /**\n     * 是否包含底部工具条，默认：`true`\n     */\n    footer?: boolean;\n    /**\n     * 底部工具条高度，默认：`55`\n     */\n    footerHeight?: number;\n    /** 抽屉 [NzDrawerOptions](https://ng.ant.design/components/drawer/zh#nzdraweroptions) 参数 */\n    drawerOptions?: NzDrawerOptions;\n  };\n  /**\n   * 气泡参数\n   */\n  pop?: {\n    /**\n     * Title of the popover, default: `确认删除吗？`\n     */\n    title?: string;\n\n    /**\n     * Popover trigger mode, default: `click`\n     */\n    trigger?: 'click' | 'focus' | 'hover';\n\n    /**\n     * The position of the popover relative to the target, default: `top`\n     */\n    placement?:\n      | 'top'\n      | 'left'\n      | 'right'\n      | 'bottom'\n      | 'topLeft'\n      | 'topRight'\n      | 'bottomLeft'\n      | 'bottomRight'\n      | 'leftTop'\n      | 'leftBottom'\n      | 'rightTop'\n      | 'rightBottom';\n\n    /**\n     * Class name of the popover card\n     */\n    overlayClassName?: string;\n\n    /**\n     * Style of the popover card\n     */\n    overlayStyle?: { [key: string]: string };\n\n    /**\n     * Text of the Cancel button\n     */\n    cancelText?: string;\n\n    /**\n     * Text of the Confirm button\n     */\n    okText?: string;\n\n    /**\n     * Button `type` of the Confirm button\n     */\n    okType?: 'primary' | 'ghost' | 'dashed' | 'danger' | 'default';\n\n    /**\n     * Customize icon of confirmation\n     */\n    icon?: string;\n  };\n  /**\n   * 过滤按钮确认文本\n   */\n  filterConfirmText?: string;\n  /**\n   * 过滤按钮重置文本\n   */\n  filterClearText?: string;\n  /**\n   * 按钮图标\n   */\n  btnIcon?: {\n    /** 图标主题风格，默认：`outline` */\n    theme?: 'outline' | 'twotone' | 'fill';\n    /** 是否有旋转动画，默认：`false` */\n    spin?: boolean;\n    /** 仅适用双色图标，设置双色图标的主要颜色，仅对当前 icon 生效 */\n    twoToneColor?: string;\n    /** 指定来自 IconFont 的图标类型 */\n    iconfont?: string;\n  };\n  /**\n   * 行号索引，默认：`1`\n   * - 计算规则为：`index + noIndex`\n   */\n  noIndex?: number;\n  /**\n   * 表格行的类名\n   */\n  rowClassName?: (record: NzSafeAny, index: number) => string;\n  /**\n   * 通过点击行来展开子行，Default: `false`\n   */\n  expandRowByClick?: boolean;\n  /**\n   * 手风琴模式，Default: `false`\n   */\n  expandAccordion?: boolean;\n  /**\n   * 指定 `width` 模式\n   */\n  widthMode?: {\n    /**\n     * 宽度类型，默认：`default`\n     * - `default` 默认行为\n     * - `strict` 严格模式，即强制按 `width` 指定的宽度呈现，并根据 `strictBehavior` 类型处理\n     */\n    type?: 'strict' | 'default';\n    /**\n     * 严格模式的处理行为，默认：`truncate`\n     * - `wrap` 强制换行\n     * - `truncate` 截短\n     */\n    strictBehavior?: 'wrap' | 'truncate';\n  };\n  /**\n   * Default: `54`\n   */\n  virtualItemSize?: number;\n  /**\n   * Default: `200`\n   */\n  virtualMaxBufferPx?: number;\n  /**\n   * Default: `100`\n   */\n  virtualMinBufferPx?: number;\n  /**\n   * The TrackByFunction to use for tracking changes\n   */\n  virtualForTrackBy?: TrackByFunction<unknown>;\n  /**\n   * Conditional expression rendering behavior, can be set to `hide` (default) or `disabled`, Default: `hide`\n   */\n  iifBehavior?: 'hide' | 'disabled';\n  /**\n   * The spinning indicator\n   */\n  loadingIndicator?: TemplateRef<void>;\n  /**\n   * Specifies a delay in milliseconds for loading state (prevent flush)\n   */\n  loadingDelay?: number;\n  /**\n   * Custom no result content\n   */\n  noResult?: string | TemplateRef<void>;\n  /**\n   * Safe rendering type, default: `safeHtml`\n   *\n   * 安全渲染方式，默认：`safeHtml`\n   */\n  safeType?: 'text' | 'html' | 'safeHtml';\n  /**\n   * Override the default request behavior, you can customize your own request implementation, for example: Graphql\n   *\n   * 覆盖默认的请求行为，可以自定义自己的请求实现，例如：Graphql\n   */\n  customRequest?: (options: {\n    method: string;\n    url: string;\n    options: {\n      body?: unknown;\n      headers?:\n        | HttpHeaders\n        | {\n            [header: string]: string | string[];\n          };\n      params?:\n        | HttpParams\n        | {\n            [param: string]: string | string[];\n          };\n    };\n  }) => Observable<NzSafeAny>;\n  /**\n   * Date format\n   *\n   * 日期格式化\n   */\n  date?: {\n    /**\n     * Format string, default: `yyyy-MM-dd HH:mm`\n     *\n     * 格式化字符串，默认：`yyyy-MM-dd HH:mm`\n     */\n    format: string;\n  };\n  yn?: {\n    /**\n     * 真值条件，（默认：`true`）\n     */\n    truth?: unknown;\n    /**\n     * 徽章 `true` 时文本，（默认：`是`）\n     */\n    yes?: string;\n    /**\n     * 徽章 `false` 时文本，（默认：`否`）\n     */\n    no?: string;\n    /**\n     * 徽章显示风格，默认：`icon`\n     * - `full` 图标和文本\n     * - `icon` 图标\n     * - `text` 文本\n     */\n    mode?: 'full' | 'icon' | 'text';\n  };\n  /**\n   * Max button option can be showed, and the extra part are auto generated under `more`\n   *\n   * 配置最多显示多少个按钮，多余部分自动生成至 `更多` 下面\n   *\n   * > 注意：若在 `buttons` 下配置过按钮组会导致其失效\n   */\n  maxMultipleButton?: {\n    /**\n     * 更多按钮文本，默认：`更多`\n     */\n    text?: string;\n\n    /**\n     * 超出数量自动合并，默认：`2`\n     */\n    count?: number;\n  };\n}\n"]}

package/esm2020/config/config.service.mjs

@@ -23,9 +23,9 @@ export class YunzaiConfigService {
         this.config[componentName] = { ...this.config[componentName], ...value };
     }
 }
-YunzaiConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: YunzaiConfigService, deps: [{ token: YUNZAI_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-YunzaiConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: YunzaiConfigService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: YunzaiConfigService, decorators: [{
+YunzaiConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: YunzaiConfigService, deps: [{ token: YUNZAI_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+YunzaiConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: YunzaiConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: YunzaiConfigService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
@@ -34,4 +34,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImpor
                     type: Inject,
                     args: [YUNZAI_CONFIG]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/config/sf/sf.type.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/format/currency.service.mjs

@@ -223,9 +223,9 @@ export class CurrencyService {
         return ret;
     }
 }
-CurrencyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CurrencyService, deps: [{ token: i1.YunzaiConfigService }, { token: LOCALE_ID }, { token: DEFAULT_CURRENCY_CODE }], target: i0.ɵɵFactoryTarget.Injectable });
-CurrencyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CurrencyService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: CurrencyService, decorators: [{
+CurrencyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CurrencyService, deps: [{ token: i1.YunzaiConfigService }, { token: LOCALE_ID }, { token: DEFAULT_CURRENCY_CODE }], target: i0.ɵɵFactoryTarget.Injectable });
+CurrencyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CurrencyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CurrencyService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.YunzaiConfigService }, { type: undefined, decorators: [{
@@ -235,4 +235,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImpor
                     type: Inject,
                     args: [DEFAULT_CURRENCY_CODE]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency.service.js","sourceRoot":"","sources":["../../../../../packages/util/format/currency.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe, formatNumber } from '@angular/common';\nimport { DEFAULT_CURRENCY_CODE, Inject, Injectable, LOCALE_ID } from '@angular/core';\n\nimport { YunzaiConfigService, YunzaiUtilCurrencyConfig } from '@yelon/util/config';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport {\n  CurrencyCNYOptions,\n  CurrencyFormatOptions,\n  CurrencyMegaOptions,\n  CurrencyMegaResult,\n  CurrencyMega_Powers\n} from './currency.types';\n\n@Injectable({ providedIn: 'root' })\nexport class CurrencyService {\n  private c: YunzaiUtilCurrencyConfig;\n  private readonly currencyPipe: CurrencyPipe;\n\n  constructor(\n    cog: YunzaiConfigService,\n    @Inject(LOCALE_ID) private locale: string,\n    @Inject(DEFAULT_CURRENCY_CODE) _defaultCurrencyCode: string = 'USD'\n  ) {\n    this.currencyPipe = new CurrencyPipe(locale, _defaultCurrencyCode);\n    this.c = cog.merge('utilCurrency', {\n      startingUnit: 'yuan',\n      megaUnit: { Q: '京', T: '兆', B: '亿', M: '万', K: '千' },\n      precision: 2,\n      ignoreZeroPrecision: true\n    })!;\n  }\n\n  /**\n   * Format a number with commas as thousands separators\n   *\n   * 格式化货币，用逗号将数字格式化为千位分隔符\n   * ```ts\n   * 10000 => `10,000`\n   * 10000.567 => `10,000.57`\n   * ```\n   */\n  format(value: number | string, options?: CurrencyFormatOptions): string {\n    options = {\n      startingUnit: this.c.startingUnit,\n      precision: this.c.precision,\n      ignoreZeroPrecision: this.c.ignoreZeroPrecision,\n      ngCurrency: this.c.ngCurrency,\n      ...options\n    };\n    let truthValue = Number(value);\n    if (value == null || isNaN(truthValue)) {\n      return '';\n    }\n    if (options.startingUnit === 'cent') {\n      truthValue = truthValue / 100;\n    }\n    if (options.ngCurrency != null) {\n      const cur = options.ngCurrency!;\n      return this.currencyPipe.transform(\n        truthValue,\n        cur.currencyCode,\n        cur.display,\n        cur.digitsInfo,\n        cur.locale || this.locale\n      )!;\n    }\n    const res = formatNumber(\n      truthValue,\n      this.locale,\n      `.${options.ignoreZeroPrecision ? 1 : options.precision}-${options.precision}`\n    );\n    return options.ignoreZeroPrecision ? res.replace(/(?:\\.[0]+)$/g, '') : res;\n  }\n\n  /**\n   * Large number format filter\n   *\n   * 大数据格式化\n   * ```ts\n   * 1000 => { value: '1', unit: 'K', unitI18n: '千' }\n   * 12456 => { value: '12.46', unit: 'K', unitI18n: '千' }\n   * ```\n   */\n  mega(value: number | string, options?: CurrencyMegaOptions): CurrencyMegaResult {\n    options = { precision: this.c.precision, unitI18n: this.c.megaUnit, startingUnit: this.c.startingUnit, ...options };\n    let num = Number(value);\n    const res: CurrencyMegaResult = { raw: value, value: '', unit: '', unitI18n: '' };\n    if (isNaN(num) || num === 0) {\n      res.value = value.toString();\n      return res;\n    }\n    if (options.startingUnit === 'cent') {\n      num = num / 100;\n    }\n    let abs = Math.abs(+num);\n    const rounder = Math.pow(10, options.precision!);\n    const isNegative = num < 0;\n    for (const p of CurrencyMega_Powers) {\n      let reduced = abs / p.value;\n\n      reduced = Math.round(reduced * rounder) / rounder;\n\n      if (reduced >= 1) {\n        abs = reduced;\n        res.unit = p.unit;\n        break;\n      }\n    }\n\n    res.value = (isNegative ? '-' : '') + abs;\n    res.unitI18n = (options.unitI18n as { [key: string]: NzSafeAny })[res.unit];\n    return res;\n  }\n\n  /**\n   * Converted into RMB notation.\n   *\n   * 转化成人民币表示法\n   */\n  cny(value: number | string, options?: CurrencyCNYOptions): string {\n    options = {\n      inWords: true,\n      minusSymbol: '负',\n      startingUnit: this.c.startingUnit,\n      ...options\n    };\n\n    value = Number(value);\n    if (isNaN(value)) {\n      return '';\n    }\n    if (options.startingUnit === 'cent') {\n      value = value / 100;\n    }\n    value = value.toString();\n    let integer: number | string;\n    let decimal: number | string | null;\n    [integer, decimal] = value.split('.');\n    let symbol = '';\n    if (integer.startsWith('-')) {\n      symbol = options.minusSymbol!;\n      integer = integer.substring(1);\n    }\n    if (/^-?\\d+$/.test(value)) {\n      decimal = null;\n    }\n    integer = (+integer).toString();\n    const inWords = options.inWords;\n    const unit: { [key: string]: string[] } = {\n      num: inWords\n        ? ['', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖', '点']\n        : ['', '一', '二', '三', '四', '五', '六', '七', '八', '九', '点'],\n      radice: inWords\n        ? [\n            '',\n            '拾',\n            '佰',\n            '仟',\n            '万',\n            '拾',\n            '佰',\n            '仟',\n            '亿',\n            '拾',\n            '佰',\n            '仟',\n            '万亿',\n            '拾',\n            '佰',\n            '仟',\n            '兆',\n            '拾',\n            '佰',\n            '仟'\n          ]\n        : [\n            '',\n            '十',\n            '百',\n            '千',\n            '万',\n            '十',\n            '百',\n            '千',\n            '亿',\n            '十',\n            '百',\n            '千',\n            '万亿',\n            '十',\n            '百',\n            '千',\n            '兆',\n            '十',\n            '百',\n            '千'\n          ],\n      dec: ['角', '分', '厘', '毫']\n    };\n    if (inWords) {\n      value = (+value).toFixed(5).toString();\n    }\n    let integerRes = '';\n    const integerCount = integer.length;\n    if (integer === '0' || integerCount === 0) {\n      integerRes = '零';\n    } else {\n      let cnDesc = '';\n      for (let i = 0; i < integerCount; i++) {\n        const n = +integer[i];\n        const j = integerCount - i - 1;\n        const isZero = i > 1 && n !== 0 && integer[i - 1] === '0';\n        const cnZero = isZero ? '零' : '';\n        const isEmpptyUnit = (n === 0 && j % 4 !== 0) || integer.substring(i - 3, i - 3 + 4) === '0000';\n        const descMark = cnDesc;\n        let cnNum = unit.num[n];\n\n        cnDesc = isEmpptyUnit ? '' : unit.radice[j];\n        // 第一位是一十\n        if (i === 0 && cnNum === '一' && cnDesc === '十') cnNum = '';\n        const isChangeEr =\n          n > 1 &&\n          cnNum === '二' && // 去除首位\n          ['', '十', '百'].indexOf(cnDesc) === -1 && // 不读两\\两十\\两百\n          descMark !== '十'; // 不读十两\n        if (isChangeEr) cnNum = '两';\n        integerRes += cnZero + cnNum + cnDesc;\n      }\n    }\n\n    // 小数部分拼接\n    let decimalRes = '';\n    const decimalCount = decimal ? decimal.toString().length : 0;\n    if (decimal === null) {\n      decimalRes = inWords ? '整' : '';\n    } else if (decimal === '0') {\n      decimalRes = '零';\n    } else {\n      for (let i = 0; i < decimalCount; i++) {\n        if (inWords && i > unit.dec.length - 1) break;\n        const n = decimal[i];\n        const cnZero = n === '0' ? '零' : '';\n        const cnNum = unit.num[+n];\n        const cnDesc = inWords ? unit.dec[i] : '';\n        decimalRes += cnZero + cnNum + cnDesc;\n      }\n    }\n    const ret =\n      symbol +\n      (inWords\n        ? integerRes + (decimalRes === '零' ? '元整' : `元${decimalRes}`)\n        : integerRes + (decimalRes === '' ? '' : `点${decimalRes}`));\n    return ret;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency.service.js","sourceRoot":"","sources":["../../../../../packages/util/format/currency.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe, formatNumber } from '@angular/common';\nimport { DEFAULT_CURRENCY_CODE, Inject, Injectable, LOCALE_ID } from '@angular/core';\n\nimport { YunzaiConfigService, YunzaiUtilCurrencyConfig } from '@yelon/util/config';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport {\n  CurrencyCNYOptions,\n  CurrencyFormatOptions,\n  CurrencyMegaOptions,\n  CurrencyMegaResult,\n  CurrencyMega_Powers\n} from './currency.types';\n\n@Injectable({ providedIn: 'root' })\nexport class CurrencyService {\n  private c: YunzaiUtilCurrencyConfig;\n  private readonly currencyPipe: CurrencyPipe;\n\n  constructor(\n    cog: YunzaiConfigService,\n    @Inject(LOCALE_ID) private locale: string,\n    @Inject(DEFAULT_CURRENCY_CODE) _defaultCurrencyCode: string = 'USD'\n  ) {\n    this.currencyPipe = new CurrencyPipe(locale, _defaultCurrencyCode);\n    this.c = cog.merge('utilCurrency', {\n      startingUnit: 'yuan',\n      megaUnit: { Q: '京', T: '兆', B: '亿', M: '万', K: '千' },\n      precision: 2,\n      ignoreZeroPrecision: true\n    })!;\n  }\n\n  /**\n   * Format a number with commas as thousands separators\n   *\n   * 格式化货币，用逗号将数字格式化为千位分隔符\n   * ```ts\n   * 10000 => `10,000`\n   * 10000.567 => `10,000.57`\n   * ```\n   */\n  format(value: number | string, options?: CurrencyFormatOptions): string {\n    options = {\n      startingUnit: this.c.startingUnit,\n      precision: this.c.precision,\n      ignoreZeroPrecision: this.c.ignoreZeroPrecision,\n      ngCurrency: this.c.ngCurrency,\n      ...options\n    };\n    let truthValue = Number(value);\n    if (value == null || isNaN(truthValue)) {\n      return '';\n    }\n    if (options.startingUnit === 'cent') {\n      truthValue = truthValue / 100;\n    }\n    if (options.ngCurrency != null) {\n      const cur = options.ngCurrency!;\n      return this.currencyPipe.transform(\n        truthValue,\n        cur.currencyCode,\n        cur.display,\n        cur.digitsInfo,\n        cur.locale || this.locale\n      )!;\n    }\n    const res = formatNumber(\n      truthValue,\n      this.locale,\n      `.${options.ignoreZeroPrecision ? 1 : options.precision}-${options.precision}`\n    );\n    return options.ignoreZeroPrecision ? res.replace(/(?:\\.[0]+)$/g, '') : res;\n  }\n\n  /**\n   * Large number format filter\n   *\n   * 大数据格式化\n   * ```ts\n   * 1000 => { value: '1', unit: 'K', unitI18n: '千' }\n   * 12456 => { value: '12.46', unit: 'K', unitI18n: '千' }\n   * ```\n   */\n  mega(value: number | string, options?: CurrencyMegaOptions): CurrencyMegaResult {\n    options = { precision: this.c.precision, unitI18n: this.c.megaUnit, startingUnit: this.c.startingUnit, ...options };\n    let num = Number(value);\n    const res: CurrencyMegaResult = { raw: value, value: '', unit: '', unitI18n: '' };\n    if (isNaN(num) || num === 0) {\n      res.value = value.toString();\n      return res;\n    }\n    if (options.startingUnit === 'cent') {\n      num = num / 100;\n    }\n    let abs = Math.abs(+num);\n    const rounder = Math.pow(10, options.precision!);\n    const isNegative = num < 0;\n    for (const p of CurrencyMega_Powers) {\n      let reduced = abs / p.value;\n\n      reduced = Math.round(reduced * rounder) / rounder;\n\n      if (reduced >= 1) {\n        abs = reduced;\n        res.unit = p.unit;\n        break;\n      }\n    }\n\n    res.value = (isNegative ? '-' : '') + abs;\n    res.unitI18n = (options.unitI18n as { [key: string]: NzSafeAny })[res.unit];\n    return res;\n  }\n\n  /**\n   * Converted into RMB notation.\n   *\n   * 转化成人民币表示法\n   */\n  cny(value: number | string, options?: CurrencyCNYOptions): string {\n    options = {\n      inWords: true,\n      minusSymbol: '负',\n      startingUnit: this.c.startingUnit,\n      ...options\n    };\n\n    value = Number(value);\n    if (isNaN(value)) {\n      return '';\n    }\n    if (options.startingUnit === 'cent') {\n      value = value / 100;\n    }\n    value = value.toString();\n    let integer: number | string;\n    let decimal: number | string | null;\n    [integer, decimal] = value.split('.');\n    let symbol = '';\n    if (integer.startsWith('-')) {\n      symbol = options.minusSymbol!;\n      integer = integer.substring(1);\n    }\n    if (/^-?\\d+$/.test(value)) {\n      decimal = null;\n    }\n    integer = (+integer).toString();\n    const inWords = options.inWords;\n    const unit: { [key: string]: string[] } = {\n      num: inWords\n        ? ['', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖', '点']\n        : ['', '一', '二', '三', '四', '五', '六', '七', '八', '九', '点'],\n      radice: inWords\n        ? [\n            '',\n            '拾',\n            '佰',\n            '仟',\n            '万',\n            '拾',\n            '佰',\n            '仟',\n            '亿',\n            '拾',\n            '佰',\n            '仟',\n            '万亿',\n            '拾',\n            '佰',\n            '仟',\n            '兆',\n            '拾',\n            '佰',\n            '仟'\n          ]\n        : [\n            '',\n            '十',\n            '百',\n            '千',\n            '万',\n            '十',\n            '百',\n            '千',\n            '亿',\n            '十',\n            '百',\n            '千',\n            '万亿',\n            '十',\n            '百',\n            '千',\n            '兆',\n            '十',\n            '百',\n            '千'\n          ],\n      dec: ['角', '分', '厘', '毫']\n    };\n    if (inWords) {\n      value = (+value).toFixed(5).toString();\n    }\n    let integerRes = '';\n    const integerCount = integer.length;\n    if (integer === '0' || integerCount === 0) {\n      integerRes = '零';\n    } else {\n      let cnDesc = '';\n      for (let i = 0; i < integerCount; i++) {\n        const n = +integer[i];\n        const j = integerCount - i - 1;\n        const isZero = i > 1 && n !== 0 && integer[i - 1] === '0';\n        const cnZero = isZero ? '零' : '';\n        const isEmpptyUnit = (n === 0 && j % 4 !== 0) || integer.substring(i - 3, i - 3 + 4) === '0000';\n        const descMark = cnDesc;\n        let cnNum = unit.num[n];\n\n        cnDesc = isEmpptyUnit ? '' : unit.radice[j];\n        // 第一位是一十\n        if (i === 0 && cnNum === '一' && cnDesc === '十') cnNum = '';\n        const isChangeEr =\n          n > 1 &&\n          cnNum === '二' && // 去除首位\n          ['', '十', '百'].indexOf(cnDesc) === -1 && // 不读两\\两十\\两百\n          descMark !== '十'; // 不读十两\n        if (isChangeEr) cnNum = '两';\n        integerRes += cnZero + cnNum + cnDesc;\n      }\n    }\n\n    // 小数部分拼接\n    let decimalRes = '';\n    const decimalCount = decimal ? decimal.toString().length : 0;\n    if (decimal === null) {\n      decimalRes = inWords ? '整' : '';\n    } else if (decimal === '0') {\n      decimalRes = '零';\n    } else {\n      for (let i = 0; i < decimalCount; i++) {\n        if (inWords && i > unit.dec.length - 1) break;\n        const n = decimal[i];\n        const cnZero = n === '0' ? '零' : '';\n        const cnNum = unit.num[+n];\n        const cnDesc = inWords ? unit.dec[i] : '';\n        decimalRes += cnZero + cnNum + cnDesc;\n      }\n    }\n    const ret =\n      symbol +\n      (inWords\n        ? integerRes + (decimalRes === '零' ? '元整' : `元${decimalRes}`)\n        : integerRes + (decimalRes === '' ? '' : `点${decimalRes}`));\n    return ret;\n  }\n}\n"]}