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

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/uploader/uploader.d.ts

@@ -0,0 +1,20 @@
+export declare class Uploader {
+    static getFiles({ multiple, acceptList, }: {
+        multiple: boolean;
+        acceptList?: string;
+    }): Promise<File[]>;
+    static beforeUploadFun(file: File, { maxSize, acceptList, beforeUpload, }: {
+        maxSize: number;
+        acceptList: string[];
+        beforeUpload?: (file: File) => Promise<unknown>;
+    }): Promise<undefined>;
+    static uploadByFile(file: File, isApp?: boolean, modelKey?: string): Promise<string>;
+    static toBase64(file: File): Promise<unknown>;
+    /**
+     * 图片压缩转Base64
+     */
+    static compressToBase64(file: File, { quality, scale }?: {
+        quality?: number | undefined;
+        scale?: number | undefined;
+    }): Promise<unknown>;
+}

package/es/utils/uploader/uploader.mjs

@@ -0,0 +1,120 @@
+class Uploader {
+  static getFiles({
+    multiple,
+    acceptList
+  }) {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.multiple = !!multiple;
+    input.accept = acceptList || "*";
+    input.click();
+    return new Promise((resolve, reject) => {
+      input.onchange = async () => {
+        const filelist = input.files || [];
+        resolve(Object.values(filelist));
+      };
+      input.onerror = async () => {
+        reject();
+      };
+    });
+  }
+  static async beforeUploadFun(file, {
+    maxSize = 5,
+    acceptList = [],
+    beforeUpload
+  }) {
+    if (file.name.indexOf(",") > -1) {
+      return Promise.reject(`文件名不能有逗号`);
+    }
+    if (beforeUpload) {
+      await beforeUpload(file);
+    }
+    const fileSize = file.size / 1024 / 1024;
+    if (fileSize > maxSize) {
+      return Promise.reject(`【${file.name}】文件大小不能超过 ${maxSize}MB`);
+    }
+    if (acceptList.length) {
+      const filename = file?.name?.replaceAll(" ", "")?.match(/\.([A-Za-z0-9]+)$/)?.at(-1);
+      if (!acceptList.includes(`.${filename?.toLocaleLowerCase()}`)) {
+        return Promise.reject(
+          `【${file.name}】支持的扩展名为${acceptList.join(" ")}`
+        );
+      }
+    }
+  }
+  static async uploadByFile(file, isApp = false, modelKey) {
+    const formData = new FormData();
+    formData.append("file", file, file.name);
+    const http = isApp ? appUploadapis : passUploadapis;
+    const path = await http(formData, modelKey);
+    return "/" + path;
+  }
+  static toBase64(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = () => reject("转换失败");
+      if (file) {
+        reader.readAsDataURL(file);
+      }
+    });
+  }
+  /**
+   * 图片压缩转Base64
+   */
+  static compressToBase64(file, { quality = 0.8, scale = 0.8 } = {}) {
+    return new Promise((resolve, reject) => {
+      if (!file.type.startsWith("image/")) {
+        reject("请选择图片文件");
+        return;
+      }
+      if (typeof scale !== "number" || scale <= 0 || scale > 1) {
+        reject("缩放比例必须在0-1之间");
+        return;
+      }
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const img = new Image();
+        img.onload = () => {
+          const width = Math.floor(img.width * scale);
+          const height = Math.floor(img.height * scale);
+          const canvas = document.createElement("canvas");
+          canvas.width = width;
+          canvas.height = height;
+          const ctx = canvas.getContext("2d");
+          ctx.imageSmoothingEnabled = true;
+          ctx.imageSmoothingQuality = "high";
+          ctx.drawImage(img, 0, 0, width, height);
+          resolve(canvas.toDataURL(file.type, quality));
+        };
+        img.onerror = () => reject("图片加载失败");
+        img.src = e.target?.result;
+      };
+      reader.onerror = () => reject("文件读取失败");
+      reader.readAsDataURL(file);
+    });
+  }
+}
+async function appUploadapis(formData, modelKey) {
+  return _api.apaas.fileResource.postUpload(
+    { ...modelKey ? { modelKey } : {} },
+    formData,
+    {
+      headers: { "Content-Type": "multipart/form-data;charset=UTF-8" }
+    }
+  );
+}
+async function passUploadapis(formData) {
+  return _api.apaas.file.postUploadImage(
+    // TODO: 待修改
+    { bucket: "IMAGE" },
+    formData,
+    {
+      headers: { "Content-Type": "multipart/form-data;charset=UTF-8" }
+    }
+  );
+}
+
+export { Uploader };

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/validate.d.ts

@@ -0,0 +1,5 @@
+export declare const validateEmoji: (value: string) => boolean;
+export declare const hasEmojiAndSpecStr: (value: string) => boolean;
+export declare const hasEmojiAndSpecStr1: (value: string) => boolean;
+export declare const validateModelName: (_rule: unknown, value: string) => Promise<void>;
+export declare const validateIsModelName: (_rule: unknown, value: string) => Promise<void>;

package/es/utils/validate.mjs

@@ -0,0 +1,25 @@
+import { t } from './i18n/index.mjs';
+
+const validateEmoji = (value) => {
+  const reg = /[\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]/gu;
+  const reg2 = /\u{1F91D}\u{1F3FB}-\u{1F3FF}/u;
+  return reg.test(value) || reg2.test(value);
+};
+const hasEmojiAndSpecStr = (value) => {
+  return validateEmoji(value) || /[*?？:：,，[\]【】#]/.test(value);
+};
+const hasEmojiAndSpecStr1 = (value) => {
+  return validateEmoji(value) || /[*?？:：,，[\]\\/【】#]/.test(value);
+};
+const validateModelName = (_rule, value) => {
+  if (hasEmojiAndSpecStr(value))
+    return Promise.reject(t("sys.model.modelNameError"));
+  return Promise.resolve();
+};
+const validateIsModelName = (_rule, value) => {
+  if (hasEmojiAndSpecStr1(value))
+    return Promise.reject(t("sys.model.notModelNameError"));
+  return Promise.resolve();
+};
+
+export { hasEmojiAndSpecStr, hasEmojiAndSpecStr1, validateEmoji, validateIsModelName, validateModelName };