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

package/es/utils/style/index.mjs

@@ -0,0 +1,141 @@
+const calcStyle = (data, ignoringStyle = []) => {
+  const style = {};
+  const padding = data.padding;
+  if (padding) {
+    if (padding.top != null && padding.top != "" && !ignoringStyle.includes("paddingTop"))
+      style["padding-top"] = padding.top;
+    if (padding.right != null && padding.right != "" && !ignoringStyle.includes("paddingRight"))
+      style["padding-right"] = padding.right;
+    if (padding.bottom != null && padding.bottom != "" && !ignoringStyle.includes("paddingBottom"))
+      style["padding-bottom"] = padding.bottom;
+    if (padding.left != null && padding.left != "" && !ignoringStyle.includes("paddingLeft"))
+      style["padding-left"] = padding.left;
+  }
+  const margin = data.margin;
+  if (margin) {
+    if (margin.top != null && margin.top != "" && !ignoringStyle.includes("marginTop"))
+      style["margin-top"] = margin.top;
+    if (margin.right != null && margin.right != "" && !ignoringStyle.includes("marginRight"))
+      style["margin-right"] = margin.right;
+    if (margin.bottom != null && margin.bottom != "" && !ignoringStyle.includes("marginBottom"))
+      style["margin-bottom"] = margin.bottom;
+    if (margin.left != null && margin.left != "" && !ignoringStyle.includes("marginLeft"))
+      style["margin-left"] = margin.left;
+  }
+  if (data.background != null && data.background != "" && !ignoringStyle.includes("backgroundColor")) {
+    style["background-color"] = data.background;
+  }
+  if (data.width != null && data.width != "" && !ignoringStyle.includes("width")) {
+    style.width = data.width;
+  }
+  if (data.height != null && data.height != "" && !ignoringStyle.includes("height")) {
+    style.height = data.height;
+    style.overflowX = "hidden";
+    style.overflowY = "auto";
+  }
+  const position = data.position;
+  if (position) {
+    if (position.position != null && position.position != "" && !ignoringStyle.includes("zIndex")) {
+      style.position = position.position;
+      style["z-index"] = 1;
+    }
+    if (position.top != null && position.top != "" && !ignoringStyle.includes("top"))
+      style.top = `${position.top}px`;
+    if (position.right != null && position.right != "" && !ignoringStyle.includes("right"))
+      style.right = `${position.right}px`;
+    if (position.bottom != null && position.bottom != "" && !ignoringStyle.includes("bottom"))
+      style.bottom = `${position.bottom}px`;
+    if (position.left != null && position.left != "" && !ignoringStyle.includes("left"))
+      style.left = `${position.left}px`;
+  }
+  const border = data.border;
+  if (border) {
+    if (border.topLeftRadius != null && border.topLeftRadius != "" && !ignoringStyle.includes("borderTopLeftRadius")) {
+      style["border-top-left-radius"] = border.topLeftRadius;
+    }
+    if (border.topRightRadius != null && border.topRightRadius != "" && !ignoringStyle.includes("borderTopRightRadius")) {
+      style["border-top-right-radius"] = border.topRightRadius;
+    }
+    if (border.bottomLeftRadius != null && border.bottomLeftRadius != "" && !ignoringStyle.includes("borderBottomLeftRadius")) {
+      style["border-bottom-left-radius"] = border.bottomLeftRadius;
+    }
+    if (border.bottomRightRadius != null && border.bottomRightRadius != "" && !ignoringStyle.includes("borderBottomRightRadius")) {
+      style["border-bottom-right-radius"] = border.bottomRightRadius;
+    }
+    if (border.top) {
+      if (border.top.color != null && border.top.color != "" && !ignoringStyle.includes("borderTopColor")) {
+        style["border-top-color"] = border.top.color;
+      }
+      if (border.top.width != null && border.top.width != "" && !ignoringStyle.includes("borderTopWidth")) {
+        style["border-top-width"] = border.top.width;
+      }
+      if (border.top.style && !ignoringStyle.includes("borderTopStyle")) {
+        style["border-top-style"] = border.top.style;
+      }
+    }
+    if (border.right) {
+      if (border.right.color != null && border.right.color != "" && !ignoringStyle.includes("borderRightColor")) {
+        style["border-right-color"] = border.right.color;
+      }
+      if (border.right.width != null && border.right.width != "" && !ignoringStyle.includes("borderRightWidth")) {
+        style["border-right-width"] = border.right.width;
+      }
+      if (border.right.style && !ignoringStyle.includes("borderRightStyle")) {
+        style["border-right-style"] = border.right.style;
+      }
+    }
+    if (border.bottom) {
+      if (border.bottom.color != null && border.bottom.color != "" && !ignoringStyle.includes("borderBottomColor")) {
+        style["border-bottom-color"] = border.bottom.color;
+      }
+      if (border.bottom.width != null && border.bottom.width != "" && !ignoringStyle.includes("borderBottomWidth")) {
+        style["border-bottom-width"] = border.bottom.width;
+      }
+      if (border.bottom.style && !ignoringStyle.includes("borderBottomStyle")) {
+        style["border-bottom-style"] = border.bottom.style;
+      }
+    }
+    if (border.left) {
+      if (border.left.color != null && border.left.color != "" && !ignoringStyle.includes("borderLeftColor")) {
+        style["border-left-color"] = border.left.color;
+      }
+      if (border.left.width != null && border.left.width != "" && !ignoringStyle.includes("borderLeftWidth")) {
+        style["border-left-width"] = border.left.width;
+      }
+      if (border.left.style && !ignoringStyle.includes("borderLeftStyle")) {
+        style["border-left-style"] = border.left.style;
+      }
+    }
+  }
+  if (data.border_radius) {
+    style["border-radius"] = `${data.border_radius}px`;
+  }
+  return style;
+};
+const calcFontStyle = (data, ignoringStyle = []) => {
+  const style = {};
+  const labelFont = data.labelFont;
+  if (labelFont) {
+    if (labelFont.color != null && labelFont.color != "" && !ignoringStyle.includes("color"))
+      style.color = labelFont.color;
+    if (labelFont.fontSize != null && labelFont.fontSize != "" && !ignoringStyle.includes("fontSize")) {
+      style["font-size"] = labelFont.fontSize;
+    }
+    if (labelFont.align && !ignoringStyle.includes("textAlign")) {
+      style["text-align"] = labelFont.align;
+      style["text-align-last"] = labelFont.align;
+    }
+    if (labelFont.bold === true && !ignoringStyle.includes("fontWeight")) {
+      style["font-weight"] = "bold";
+    }
+    if (labelFont.italic === true && !ignoringStyle.includes("fontStyle")) {
+      style["font-style"] = "italic";
+    }
+    if (labelFont.textDecoration && !ignoringStyle.includes("textDecoration")) {
+      style["text-decoration"] = labelFont.textDecoration;
+    }
+  }
+  return style;
+};
+
+export { calcFontStyle, calcStyle };

package/es/utils/tools/tools.d.ts

@@ -1,14 +1,4 @@
-/**
- * 递归合并两个对象
- *
- * @export
- * @template T
- * @template U
- * @param {T} target 目标对象，合并后结果存放于此。The target object to merge into.
- * @param {U} source 要合并的源对象。The source object to merge from.
- * @returns {*}  {(T & U)} 合并后的对象。The merged object.
- */
-export declare function deepMerge<T extends object | null | undefined, U extends object | null | undefined>(target: T, source: U): T & U;
+import { default as qs } from 'qs';
 /**
  * 获取认证令牌
  *
@@ -37,16 +27,6 @@ export declare function getTenant(): string | null;
  * @param {string} tenant
  */
 export declare function setTenant(tenant: string): void;
-/**
- * 获取路径参数
- *
- * @export
- * @returns {*}  {{ aid: string; pid: string }}
- */
-export declare function getPathQuery(): {
-    aid: string;
-    pid: string;
-};
 /**
  * 是否为移动端设备
  */
@@ -58,3 +38,25 @@ export declare const isMobile: boolean;
  * @returns {*}
  */
 export declare function getTimezone(): string;
+/**
+ * 递归合并两个对象
+ *
+ * @template T
+ * @template U
+ * @param {T} target 目标对象，合并后结果存放于此
+ * @param {U} source 要合并的源对象
+ * @returns {(T & U)} 合并后的对象
+ */
+export declare function deepMerge<T extends object | null | undefined, U extends object | null | undefined>(target: T, source: U): T & U;
+/**
+ * 对象 → 矩阵参数（stringify）
+ * @param {*} params
+ * @returns
+ */
+export declare function stringifyMatrixParams(params: Record<string, string | number | null | undefined>): string;
+/**
+ * 矩阵参数 → 对象（parse）
+ * @param {*} path
+ * @returns
+ */
+export declare function parseMatrixParams(path: string): qs.ParsedQs;

package/es/utils/tools/tools.mjs

@@ -1,26 +1,16 @@
+import { getCookie, setCookie, clearCookie } from 'qx-util';
 import { mergeWith, cloneDeep, unionWith, isEqual } from 'lodash-es';
-import '../../node_modules/.pnpm/qx-util@0.4.8/node_modules/qx-util/out/index.mjs';
-import '../../constants/index.mjs';
-import '../../enums/index.mjs';
-import { isObject, isArray } from '../../node_modules/.pnpm/qx-util@0.4.8/node_modules/qx-util/out/utils/type-util/type-util.mjs';
-import { getCookie, setCookie, clearCookie } from '../../node_modules/.pnpm/qx-util@0.4.8/node_modules/qx-util/out/utils/util/util.mjs';
+import '../../constants/expression-type/modeCfg.mjs';
+import '../../constants/expression-type/BuiltOperators.mjs';
+import '../../constants/expression-type/function.mjs';
+import '../../constants/expression-type/variable.mjs';
 import { CoreConst } from '../../constants/core.mjs';
+import '../../enums/app-designer/index.mjs';
+import '../../enums/page-designer/designer.mjs';
+import '../../enums/breakpointEnum.mjs';
 import { TIMEZONE_KEY } from '../../enums/cacheEnum.mjs';
+import qs from 'qs';
 
-"use strict";
-function deepMerge(target, source) {
-  return mergeWith(cloneDeep(target), source, (objValue, srcValue) => {
-    if (isObject(objValue) && isObject(srcValue)) {
-      return mergeWith(
-        cloneDeep(objValue),
-        srcValue,
-        (prevValue, nextValue) => {
-          return isArray(prevValue) ? unionWith(prevValue, nextValue, isEqual) : void 0;
-        }
-      );
-    }
-  });
-}
 function getToken() {
   return getCookie(CoreConst.TOKEN);
 }
@@ -41,13 +31,6 @@ function setTenant(tenant) {
     clearCookie(CoreConst.TENANT, true);
   }
 }
-function getPathQuery() {
-  const params = location.pathname.replace("/src/projects", "").split("/");
-  return {
-    aid: params[2],
-    pid: params[3]
-  };
-}
 const isMobile = (() => {
   const ua = navigator.userAgent;
   const mobileRegex = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/;
@@ -58,5 +41,32 @@ const isMobile = (() => {
 function getTimezone() {
   return localStorage.getItem(TIMEZONE_KEY) || "UTC+08:00";
 }
+function deepMerge(target, source) {
+  return mergeWith(cloneDeep(target), source, (objValue, srcValue) => {
+    if (typeof objValue === "object" && typeof srcValue === "object") {
+      return mergeWith(
+        cloneDeep(objValue),
+        srcValue,
+        (prevValue, nextValue) => {
+          return Array.isArray(prevValue) ? unionWith(prevValue, nextValue, isEqual) : void 0;
+        }
+      );
+    }
+  });
+}
+function stringifyMatrixParams(params) {
+  const str = qs.stringify(params, {
+    encode: true,
+    delimiter: ";"
+  });
+  return str ? `;${str}` : "";
+}
+function parseMatrixParams(path) {
+  const idx = path.indexOf(";");
+  if (idx === -1) return {};
+  return qs.parse(path, {
+    delimiter: ";"
+  });
+}
 
-export { deepMerge, getPathQuery, getTenant, getTimezone, getToken, isMobile, setTenant, setToken };
+export { deepMerge, getTenant, getTimezone, getToken, isMobile, parseMatrixParams, setTenant, setToken, stringifyMatrixParams };

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 {};