@gct-paas/core 0.1.4-dev.6 → 0.1.4-dev.8

package/es/utils/tools/tools.mjs

@@ -1,11 +1,12 @@
 import { getCookie, setCookie, clearCookie } from 'qx-util';
 import { mergeWith, cloneDeep, unionWith, isEqual } from 'lodash-es';
-import '../../constants/index.mjs';
-import '../../enums/index.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 +27,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 +50,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,117 @@
+/**
+ * 节点判断函数类型
+ */
+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[];
+}
+export {};

package/es/utils/treeHelper/treeHelper.mjs

@@ -0,0 +1,220 @@
+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;
+    });
+  }
+}
+
+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/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;

package/es/utils/value-helper/value-helper.mjs

@@ -0,0 +1,109 @@
+import { isRef, computed, ref, watch } from 'vue';
+
+function afterValueSet(value, afterSet) {
+  const newVal = computed({
+    get: () => value.value,
+    set: (v) => {
+      value.value = v;
+      afterSet(v);
+    }
+  });
+  return newVal;
+}
+function afterFieldSet(object, afterSet) {
+  const keys = Object.keys(isRef(object) ? object.value : object);
+  const result = {};
+  keys.forEach((key) => {
+    result[key] = computed({
+      get: () => {
+        return (isRef(object) ? object.value : object)[key];
+      },
+      set(v) {
+        (isRef(object) ? object.value : object)[key] = v;
+        afterSet(key, v);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  });
+  return result;
+}
+function emitFieldSet(object, emitSet) {
+  const keys = Object.keys(isRef(object) ? object.value : object);
+  const result = {};
+  let cacheData = {};
+  keys.forEach((key) => {
+    result[key] = computed({
+      get: () => {
+        cacheData = {};
+        return (isRef(object) ? object.value : object)[key];
+      },
+      set(v) {
+        const objVal = isRef(object) ? object.value : object;
+        cacheData[key] = v;
+        const newObj = { ...objVal, ...cacheData };
+        emitSet(key, v, newObj);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  });
+  return result;
+}
+function parseValueUnit(str) {
+  if (str === "nullpx") {
+    return {
+      value: 0,
+      unit: "px"
+    };
+  }
+  const regex = /^(\d+\.?\d*)([a-zA-Z%]+)$/;
+  const match = str.match(regex);
+  if (match) {
+    return {
+      value: parseFloat(match[1]),
+      unit: match[2]
+    };
+  }
+  throw new Error("Invalid value");
+}
+function computedEx(opts) {
+  const result = ref();
+  let clear;
+  const watchDeep = () => {
+    if (!opts.deep) {
+      return;
+    }
+    clear = watch(
+      () => result.value,
+      (v) => {
+        opts.set(v);
+      },
+      { deep: true }
+    );
+  };
+  watch(
+    () => opts.get(),
+    (v) => {
+      if (clear) {
+        clear();
+      }
+      result.value = v;
+      watchDeep();
+    },
+    { immediate: true }
+  );
+  return result;
+}
+function cacheFnReturn(cb) {
+  const cacheReturn = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = JSON.stringify(args);
+    if (cacheReturn.has(key)) {
+      return cacheReturn.get(key);
+    }
+    const result = cb(...args);
+    cacheReturn.set(key, result);
+    return result;
+  };
+}
+
+export { afterFieldSet, afterValueSet, cacheFnReturn, computedEx, emitFieldSet, parseValueUnit };

package/es/utils/width-install/width-install.mjs

@@ -1,7 +1,5 @@
-import '../../constants/index.mjs';
 import { EditorRegisterConst } from '../../constants/editor-register/editor-register.mjs';
 
-"use strict";
 function widthEditorInstall(providerTag, provider, com, comName) {
   return {
     install(app) {