@gct-paas/core 0.1.4-dev.1 → 0.1.4-dev.10

package/es/utils/treeHelper/treeHelper.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 节点判断函数类型
+ */
+type Fn<T> = (node: T, parent?: T) => boolean | unknown;
+/**
+ * 树结构辅助配置接口
+ */
+interface ITreeHelperConfig {
+    /** 节点 ID 字段名 */
+    id: string;
+    /** 子节点字段名 */
+    children: string;
+    /** 父节点 ID 字段名 */
+    pid: string;
+    /** 是否深度遍历 */
+    deep: boolean;
+}
+/**
+ * 树结构数据处理工具类
+ * 提供树形数据与列表数据的相互转换、节点查找、路径查找等功能
+ */
+export declare class TreeHelper {
+    /**
+     * 默认配置
+     */
+    private static readonly _DEFAULT_CONFIG;
+    /**
+     * 获取合并后的配置
+     * @param config 用户配置
+     * @returns 合并后的完整配置
+     */
+    private static _getConfig;
+    /**
+     * 将列表数据转换为树形结构
+     * @param list 列表数据
+     * @param config 配置项
+     * @param callBack 节点转换回调函数
+     * @returns 树形结构数据
+     */
+    static listToTree<T extends IObject = IObject, R = T>(list: T[], config: Partial<ITreeHelperConfig> | undefined, callBack: (node: T) => R): R[];
+    /**
+     * 将树形结构转换为列表数据
+     * @param tree 树形结构数据
+     * @param config 配置项
+     * @returns 列表数据
+     */
+    static treeToList<T extends IObject = IObject>(tree: T[], config?: Partial<ITreeHelperConfig>): T[];
+    /**
+     * 在树中查找单个节点
+     * @param tree 树形结构数据
+     * @param func 查找条件函数
+     * @param config 配置项
+     * @returns 找到的节点或 null
+     */
+    static findNode<T extends IObject = IObject>(tree: T[], func: Fn<T>, config?: Partial<ITreeHelperConfig>): T | null;
+    /**
+     * 在树中查找所有匹配的节点
+     * @param tree 树形结构数据
+     * @param func 查找条件函数
+     * @param config 配置项
+     * @returns 所有匹配的节点数组
+     */
+    static findNodeAll<T extends IObject = IObject>(tree: T[], func: Fn<T>, config?: Partial<ITreeHelperConfig>): T[];
+    /**
+     * 查找节点的路径
+     * @param tree 树形结构数据
+     * @param func 查找条件函数
+     * @param config 配置项
+     * @returns 从根节点到目标节点的路径数组,未找到返回 null
+     */
+    static findPath<T extends IObject = IObject>(tree: T[], func: Fn<T>, config?: Partial<ITreeHelperConfig>): T[] | null;
+    /**
+     * 查找最近的符合条件的父节点
+     * @param tree 树形结构数据
+     * @param startId 起始节点 ID
+     * @param func 查找条件函数
+     * @param config 配置项
+     * @returns 找到的父节点或 undefined
+     */
+    static findClosestParent<T extends IObject = IObject>(tree: T[], startId: string | number, func: Fn<T>, config?: Partial<ITreeHelperConfig>): T | undefined;
+    /**
+     * 将具有 id 和 parentId 的列表转换为树形结构
+     * @param list 列表数据,需要包含 id 和 parentId 字段
+     * @param callBack 节点转换回调函数
+     * @returns 树形结构数据
+     */
+    static list_to_tree<T extends {
+        id?: string;
+        parentId?: string;
+    }, R = T>(list: T[], callBack: (n: IObject) => R): R[];
+    /**
+     * 获取所有父级路径
+     * @param treeData 树形结构数据
+     * @param path 目标路径
+     * @returns 从根节点到目标节点的所有路径数组
+     */
+    static getAllParentPath(treeData: (IObject & {
+        path: string;
+    })[], path: string): string[];
+    /**
+     * 递归遍历树并且根据callback返回新数据再拼装成一个新树
+     *
+     * @static
+     * @param {IObject[]} treeData
+     * @param {Function} callback
+     * @param {Partial<ITreeHelperConfig>} [config={}]
+     * @return {*}
+     */
+    static traverseAndBuildTree(treeData: IObject[], callback: (node: IObject) => IObject | unknown, config?: Partial<ITreeHelperConfig>): IObject[];
+    /**
+     * 递归遍历树结构
+     * @param treeData 树形结构数据
+     * @param callBack 回调函数
+     * @param parentNode 父节点
+     */
+    static eachTree<T extends IObject = IObject>(treeData: T[], callBack: (node: T, parentNode?: T) => any, parentNode?: any): void;
+}
+export {};

package/es/utils/treeHelper/treeHelper.mjs

@@ -0,0 +1,234 @@
+class TreeHelper {
+  /**
+   * 默认配置
+   */
+  static _DEFAULT_CONFIG = {
+    id: "id",
+    children: "children",
+    pid: "pid",
+    deep: true
+  };
+  /**
+   * 获取合并后的配置
+   * @param config 用户配置
+   * @returns 合并后的完整配置
+   */
+  static _getConfig(config) {
+    return Object.assign({}, TreeHelper._DEFAULT_CONFIG, config);
+  }
+  /**
+   * 将列表数据转换为树形结构
+   * @param list 列表数据
+   * @param config 配置项
+   * @param callBack 节点转换回调函数
+   * @returns 树形结构数据
+   */
+  static listToTree(list, config = {}, callBack) {
+    const conf = TreeHelper._getConfig(config);
+    const nodeMap = /* @__PURE__ */ new Map();
+    const result = [];
+    const { id, children, pid, deep } = conf;
+    for (const node of list) {
+      const record = node;
+      if (!deep) {
+        record[children] = record[pid] === "ROOT" ? record[children] ?? [] : [];
+      } else {
+        record[children] = record[children] ?? void 0;
+      }
+      nodeMap.set(record[id], callBack(node));
+    }
+    for (const node of list) {
+      const record = node;
+      const parent = nodeMap.get(record[pid]);
+      if (parent) {
+        const parentRecord = parent;
+        if (!parentRecord[children]) {
+          parentRecord[children] = [];
+        }
+        parentRecord[children].push(callBack(node));
+      } else {
+        result.push(callBack(node));
+      }
+    }
+    return result;
+  }
+  /**
+   * 将树形结构转换为列表数据
+   * @param tree 树形结构数据
+   * @param config 配置项
+   * @returns 列表数据
+   */
+  static treeToList(tree, config = {}) {
+    const { children } = TreeHelper._getConfig(config);
+    const result = [...tree];
+    for (let i = 0; i < result.length; i++) {
+      const record = result[i];
+      const child = record[children];
+      if (!Array.isArray(child)) continue;
+      result.splice(i + 1, 0, ...child);
+    }
+    return result;
+  }
+  /**
+   * 在树中查找单个节点
+   * @param tree 树形结构数据
+   * @param func 查找条件函数
+   * @param config 配置项
+   * @returns 找到的节点或 null
+   */
+  static findNode(tree, func, config = {}) {
+    const { children } = TreeHelper._getConfig(config);
+    const list = tree ? [...tree] : [];
+    for (const node of list) {
+      if (func(node)) return node;
+      const record = node;
+      const child = record[children];
+      if (Array.isArray(child)) {
+        list.push(...child);
+      }
+    }
+    return null;
+  }
+  /**
+   * 在树中查找所有匹配的节点
+   * @param tree 树形结构数据
+   * @param func 查找条件函数
+   * @param config 配置项
+   * @returns 所有匹配的节点数组
+   */
+  static findNodeAll(tree, func, config = {}) {
+    const { children } = TreeHelper._getConfig(config);
+    const list = tree ? [...tree] : [];
+    const result = [];
+    for (const node of list) {
+      if (func(node)) result.push(node);
+      const record = node;
+      const child = record[children];
+      if (Array.isArray(child)) {
+        list.push(...child);
+      }
+    }
+    return result;
+  }
+  /**
+   * 查找节点的路径
+   * @param tree 树形结构数据
+   * @param func 查找条件函数
+   * @param config 配置项
+   * @returns 从根节点到目标节点的路径数组,未找到返回 null
+   */
+  static findPath(tree, func, config = {}) {
+    const { children } = TreeHelper._getConfig(config);
+    const path = [];
+    const list = tree ? [...tree] : [];
+    const visitedSet = /* @__PURE__ */ new Set();
+    while (list.length) {
+      const node = list[0];
+      if (visitedSet.has(node)) {
+        path.pop();
+        list.shift();
+      } else {
+        visitedSet.add(node);
+        const record = node;
+        const child = record[children];
+        if (Array.isArray(child)) {
+          list.unshift(...child);
+        }
+        path.push(node);
+        if (func(node)) return path;
+      }
+    }
+    return null;
+  }
+  /**
+   * 查找最近的符合条件的父节点
+   * @param tree 树形结构数据
+   * @param startId 起始节点 ID
+   * @param func 查找条件函数
+   * @param config 配置项
+   * @returns 找到的父节点或 undefined
+   */
+  static findClosestParent(tree, startId, func, config = {}) {
+    const { id } = TreeHelper._getConfig(config);
+    const path = TreeHelper.findPath(
+      tree,
+      (node) => node[id] === startId,
+      config
+    );
+    return path?.reverse().find((n) => func(n));
+  }
+  /**
+   * 将具有 id 和 parentId 的列表转换为树形结构
+   * @param list 列表数据,需要包含 id 和 parentId 字段
+   * @param callBack 节点转换回调函数
+   * @returns 树形结构数据
+   */
+  static list_to_tree(list, callBack) {
+    const map = {};
+    const roots = [];
+    for (let i = 0; i < list.length; i++) {
+      const node = list[i];
+      map[node.id] = i;
+      node.children = [];
+    }
+    for (const node of list) {
+      if (node.parentId === "ROOT" || !node.parentId) {
+        roots.push(callBack(node));
+      } else {
+        const current = node;
+        const parentIndex = map[node.parentId];
+        if (parentIndex !== void 0) {
+          const parent = list[parentIndex];
+          parent.children?.push(callBack(current));
+        }
+      }
+    }
+    return roots;
+  }
+  /**
+   * 获取所有父级路径
+   * @param treeData 树形结构数据
+   * @param path 目标路径
+   * @returns 从根节点到目标节点的所有路径数组
+   */
+  static getAllParentPath(treeData, path) {
+    const menuList = TreeHelper.findPath(treeData, (n) => n.path === path);
+    return (menuList || []).map((item) => item.path);
+  }
+  /**
+   * 递归遍历树并且根据callback返回新数据再拼装成一个新树
+   *
+   * @static
+   * @param {IObject[]} treeData
+   * @param {Function} callback
+   * @param {Partial<ITreeHelperConfig>} [config={}]
+   * @return {*}
+   */
+  static traverseAndBuildTree(treeData, callback, config = {}) {
+    config = this._getConfig(config);
+    const { children } = config;
+    return treeData.map((node) => {
+      const newNode = callback(node) || node;
+      if (children && node[children] && node[children].length > 0) {
+        newNode[children] = this.traverseAndBuildTree(node.children, callback);
+      }
+      return newNode;
+    });
+  }
+  /**
+   * 递归遍历树结构
+   * @param treeData 树形结构数据
+   * @param callBack 回调函数
+   * @param parentNode 父节点
+   */
+  static eachTree(treeData, callBack, parentNode = {}) {
+    treeData.forEach((element) => {
+      const newNode = callBack(element, parentNode) || element;
+      if (element.children) {
+        TreeHelper.eachTree(element.children, callBack, newNode);
+      }
+    });
+  }
+}
+
+export { TreeHelper };

package/es/utils/useUUid.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+interface IRandomUUidOpts {
+    /** 是否需要拼接前缀（默认不需要） */
+    needPrefix?: boolean;
+    /** 随机串只能是字符串 */
+    isString?: boolean;
+    /** 前缀，默认前缀u_ */
+    prefix?: string;
+    /** 即将生成的uuid位数（不包含前缀, 默认8位） */
+    length?: number;
+    /** 类型 */
+    chars?: string;
+    /** 是否数字打头 */
+    numPref?: boolean;
+}
+/**
+ * 生成随机串
+ * @param uuids 不可用的uuid
+ * @param opts
+ * @param opts.needPrefix 是否需要拼接前缀（默认不需要）
+ * @param opts.isString 随机串只能是字符串
+ * @param opts.prefix 前缀，默认前缀u_
+ * @param opts.length 即将生成的uuid位数（不包含前缀, 默认8位）
+ * @param opts.chars 类型
+ * @param opts.numPref 数字打头
+ */
+export declare const randomUUID: {
+    (uuids?: string[], opts?: IRandomUUidOpts): string;
+    Generate(uuids?: string[], opts?: IRandomUUidOpts): {
+        next: () => string;
+    };
+};
+export declare function useUUid(tableData: Ref<IObject[]>, keyAttr: Ref<string>, opts?: IRandomUUidOpts): {
+    oldUUids: import('vue').ComputedRef<any[]>;
+    flatTableData: import('vue').ComputedRef<IObject[]>;
+    getUuid: (uuidsProp?: string[], optsProp?: IRandomUUidOpts) => string;
+    getUuidGenerate: (uuidsProp?: string[], optsProp?: IRandomUUidOpts) => {
+        next: () => string;
+    };
+};
+export {};

package/es/utils/useUUid.mjs

@@ -0,0 +1,93 @@
+import { computed, unref } from 'vue';
+
+const randomUUID = (uuids = [], opts) => {
+  const {
+    needPrefix = false,
+    isString = true,
+    prefix = "u_",
+    length = 8,
+    chars = "",
+    numPref = false
+  } = opts || {};
+  let characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  if (chars === "capital&number") {
+    characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  } else if (chars === "lowercase&number") {
+    characters = "abcdefghijklmnopqrstuvwxyz0123456789";
+  } else if (chars === "lowercase") {
+    characters = "abcdefghijklmnopqrstuvwxyz";
+  }
+  let uuid;
+  while (!uuid) {
+    let id = "";
+    if (isString) {
+      if (numPref) {
+        id += Math.floor(Math.random() * 9) + 1;
+      }
+      for (let i = 0; i < length; i++) {
+        id += characters.charAt(Math.floor(Math.random() * characters.length));
+      }
+    } else {
+      id = `${needPrefix ? prefix : ""}${numPref ? Math.floor(Math.random() * 9) + 1 : ""}${Math.random().toString(36).substr(2, length)}`;
+    }
+    if (!uuids.includes(id)) {
+      uuid = id;
+    }
+  }
+  return uuid;
+};
+randomUUID.Generate = (uuids, opts) => {
+  const cloneUUids = Array.isArray(uuids) ? uuids.concat() : [];
+  return {
+    next: () => {
+      const id = randomUUID(cloneUUids, opts);
+      cloneUUids.push(id);
+      return id;
+    }
+  };
+};
+function useUUid(tableData, keyAttr, opts) {
+  const f_children = "children";
+  const f_key = "key";
+  const flatTableData = computed(() => {
+    return tableData.value.reduce((list, item) => {
+      list.push(item);
+      const nodes = item[f_children].map((ele) => {
+        return {
+          ...ele,
+          _pid_: item.id
+        };
+      });
+      list.push(...nodes);
+      return list;
+    }, []);
+  });
+  const oldUUids = computed(() => {
+    return flatTableData.value.map((data) => {
+      if (data._pid_) {
+        return data[f_key].replace(new RegExp(`^${unref(keyAttr)}_*`), "");
+      }
+      return null;
+    }).filter((i) => i);
+  });
+  function getUuid(uuidsProp, optsProp) {
+    return randomUUID([...unref(oldUUids), ...uuidsProp ?? []], {
+      ...opts,
+      ...optsProp
+    });
+  }
+  function getUuidGenerate(uuidsProp, optsProp) {
+    return randomUUID.Generate([...unref(oldUUids), ...uuidsProp ?? []], {
+      ...opts,
+      ...optsProp
+    });
+  }
+  return {
+    oldUUids,
+    flatTableData,
+    getUuid,
+    getUuidGenerate
+  };
+}
+
+export { randomUUID, useUUid };

package/es/utils/util.d.ts

@@ -0,0 +1,39 @@
+import { IOpenWindowOptions } from '../interface';
+/**
+ * 替换url中的参数，格式为xxx/{aid}/xxx/{pid}/{bid?}
+ *
+ * @export
+ * @param {string} url - 原始 URL 字符串
+ * @param {IObject} data - 用于替换占位符的数据对象
+ * @return {string} 处理后的 URL 字符串
+ */
+export declare function genUrl(url: string, data: IObject): string;
+/**
+ * 打开新窗口
+ *
+ * @export
+ * @param {string} url - 要打开的 URL
+ * @param {IOpenWindowOptions} [options] - 窗口配置选项
+ * @return {Window | null} 新打开的窗口对象，如果打开失败则返回 null
+ *
+ * @example
+ * ```typescript
+ * // 简单打开新窗口
+ * openWindow('https://example.com');
+ *
+ * // 使用 URL 参数替换
+ * openWindow('/user/{id}/profile', {
+ *   genUrlData: { id: '123' }
+ * });
+ *
+ * // 完整配置
+ * openWindow('https://example.com', {
+ *   target: '_blank',
+ *   noopener: true,
+ *   noreferrer: true,
+ *   routePath: '/dashboard',
+ *   optionStr: 'width=800,height=600'
+ * });
+ * ```
+ */
+export declare function openWindow(url: string, options?: IOpenWindowOptions): Window | null;

package/es/utils/util.mjs

@@ -0,0 +1,40 @@
+function genUrl(url, data) {
+  let result = url;
+  Object.keys(data).forEach((key) => {
+    result = result.replace(`{${key}}`, data[key] ?? "");
+    result = result.replace(`{${key}?}`, data[key] ?? "");
+  });
+  result = result.replace(/\/\{[a-z]+\?\}/g, "");
+  return result;
+}
+function openWindow(url, options) {
+  const {
+    target = "_blank",
+    noopener = true,
+    noreferrer = true,
+    genUrlData,
+    routePath = "",
+    optionStr = ""
+  } = options || {};
+  const features = [];
+  if (noopener) {
+    features.push("noopener=yes");
+  }
+  if (noreferrer) {
+    features.push("noreferrer=yes");
+  }
+  let finalUrl = url;
+  if (genUrlData) {
+    finalUrl = genUrl(finalUrl, genUrlData);
+  }
+  if (routePath) {
+    finalUrl += routePath;
+  }
+  let featuresStr = features.join(",");
+  if (optionStr) {
+    featuresStr = featuresStr ? `${featuresStr},${optionStr}` : optionStr;
+  }
+  return window.open(finalUrl, target, featuresStr);
+}
+
+export { genUrl, openWindow };

package/es/utils/uuid/uuid.d.ts

@@ -0,0 +1,3 @@
+export declare function buildUUID(): string;
+export declare function buildShortUUID(prefix?: string): string;
+export declare const uuid2: (len: number, radix?: number) => string;

package/es/utils/uuid/uuid.mjs

@@ -0,0 +1,48 @@
+const hexList = [];
+for (let i = 0; i <= 15; i++) {
+  hexList[i] = i.toString(16);
+}
+function buildUUID() {
+  let uuid = "";
+  for (let i = 1; i <= 36; i++) {
+    if (i === 9 || i === 14 || i === 19 || i === 24) {
+      uuid += "-";
+    } else if (i === 15) {
+      uuid += 4;
+    } else if (i === 20) {
+      uuid += hexList[Math.random() * 4 | 8];
+    } else {
+      uuid += hexList[Math.random() * 16 | 0];
+    }
+  }
+  return uuid.replace(/-/g, "");
+}
+let unique = 0;
+function buildShortUUID(prefix = "") {
+  prefix = prefix.replaceAll("-", "");
+  const random = Math.floor(Math.random() * 1e9);
+  unique++;
+  return prefix + "_" + random + unique;
+}
+const uuid2 = (len, radix) => {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+  const uuid = [];
+  let i;
+  radix = radix || chars.length;
+  if (len) {
+    for (i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix];
+  } else {
+    let r;
+    uuid[8] = uuid[13] = uuid[18] = uuid[23] = "-";
+    uuid[14] = "4";
+    for (i = 0; i < 36; i++) {
+      if (!uuid[i]) {
+        r = 0 | Math.random() * 16;
+        uuid[i] = chars[i == 19 ? r & 3 | 8 : r];
+      }
+    }
+  }
+  return uuid.join("");
+};
+
+export { buildShortUUID, buildUUID, uuid2 };

package/es/utils/value-helper/value-helper.d.ts

@@ -0,0 +1,49 @@
+import { Ref, ToRefs, ComputedGetter, ComputedSetter } from 'vue';
+export declare function afterValueSet<U>(value: Ref<U>, afterSet: (i: U) => void): Ref<U>;
+export declare function afterFieldSet<T extends object>(object: T | Ref<T>, afterSet: <F extends keyof T>(field: F, v: T[F]) => void): ToRefs<T>;
+/**
+ * 属性修改的时候不修改并抛出事件
+ * @author lingxiaoming
+ * @date 2024-07-17 03:30:44
+ * @export
+ * @template T
+ * @param {(T | Ref<T>)} object (对象必须有该属性,即使是undefined,否则无法监控)
+ * @param {<F extends keyof T>(field: F, v: T[F], newObj: T) => void} emitSet newObj是将要修改成的完整数据
+ * @return {*}  {ToRefs<T>}
+ */
+export declare function emitFieldSet<T extends object>(object: T | Ref<T>, emitSet: <F extends keyof T>(field: F, v: T[F], newObj: T) => void): ToRefs<T>;
+/**
+ * 解析数值和单位
+ * @author lingxiaoming
+ * @date 2024-07-15 06:06:41
+ * @param {string} str
+ * @return {*}  {({ value: number; unit: string } | null)}
+ */
+export declare function parseValueUnit(str: string): {
+    value: number;
+    unit: string;
+};
+/**
+ * 增强computed，当属性变更时，自动调用set方法
+ * @author lingxiaoming
+ * @date 2024-08-26 10:19:01
+ * @export
+ * @param {{
+ *   get: ComputedGetter<T>;
+ *   set: ComputedSetter<T>;
+ *   deep: boolean; //为true时，深层属性变更也会触发set
+ * }} opts
+ */
+export declare function computedEx<T>(opts: {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+    deep?: boolean;
+}): Ref<T, T>;
+/**
+ * 缓存函数返回值，下次相同参数调用时直接返回缓存值
+ * @export
+ * @template T
+ * @param cb
+ * @return {*}
+ */
+export declare function cacheFnReturn<T extends Function>(cb: T): T;