@gct-paas/core 0.1.4-dev.7 → 0.1.4-dev.9

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,3 +1,4 @@
+import { default as qs } from 'qs';
 /**
  * 获取认证令牌
  *
@@ -26,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;
-};
 /**
  * 是否为移动端设备
  */
@@ -57,3 +48,15 @@ export declare function getTimezone(): string;
  * @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,11 +1,16 @@
 import { getCookie, setCookie, clearCookie } from 'qx-util';
 import { mergeWith, cloneDeep, unionWith, isEqual } from 'lodash-es';
-import '../../constants/index.mjs';
-import '../../enums/index.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 getToken() {
   return getCookie(CoreConst.TOKEN);
 }
@@ -26,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/;
@@ -56,5 +54,19 @@ function deepMerge(target, source) {
     }
   });
 }
+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,124 @@
+/**
+ * 节点判断函数类型
+ */
+type Fn<T> = (node: T, parent?: T) => boolean | unknown;
+/**
+ * 树结构辅助配置接口
+ */
+interface ITreeHelperConfig {
+    /** 节点 ID 字段名 */
+    id: string;
+    /** 子节点字段名 */
+    children: string;
+    /** 父节点 ID 字段名 */
+    pid: string;
+    /** 是否深度遍历 */
+    deep: boolean;
+}
+/**
+ * 带子节点的对象接口
+ */
+interface IWithChildren<R> {
+    children?: R[];
+}
+/**
+ * 树结构数据处理工具类
+ * 提供树形数据与列表数据的相互转换、节点查找、路径查找等功能
+ */
+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: T & IWithChildren<R>) => R): R[];
+    /**
+     * 获取所有父级路径
+     * @param treeData 树形结构数据
+     * @param path 目标路径
+     * @returns 从根节点到目标节点的所有路径数组
+     */
+    static getAllParentPath(treeData: object & {
+        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 = (n) => n) {
+    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/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;