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

package/es/utils/model-loader/model-loader.mjs

@@ -0,0 +1,326 @@
+import { cloneDeep } from 'lodash-es';
+import { EntityModelCategoryEnum } from '../../enums/app-designer/index.mjs';
+import '../../enums/page-designer/designer.mjs';
+import '../../enums/breakpointEnum.mjs';
+
+class ModelLoader {
+  // 缓存过期时间（毫秒），默认10分钟
+  CACHE_EXPIRATION_TIME = 10 * 60 * 1e3;
+  modelCache = /* @__PURE__ */ new Map();
+  modelLoadingCache = /* @__PURE__ */ new Map();
+  modelsLoadingCache = /* @__PURE__ */ new Map();
+  enumCache = /* @__PURE__ */ new Map();
+  enumLoadingCache = /* @__PURE__ */ new Map();
+  queryRefDataCache = /* @__PURE__ */ new Map();
+  queryRefDataLoadingCache = /* @__PURE__ */ new Map();
+  /**
+   * 检查缓存条目是否过期
+   *
+   * @param {CacheEntry<any>} entry
+   * @returns {*}  {boolean}
+   */
+  isExpired(entry) {
+    return Date.now() > entry.expiresAt;
+  }
+  /**
+   * 创建缓存条目
+   *
+   * @param {T} data
+   * @returns {*}  {CacheEntry<T>}
+   */
+  createCacheEntry(data) {
+    return {
+      data,
+      expiresAt: Date.now() + this.CACHE_EXPIRATION_TIME
+    };
+  }
+  /**
+   * 加载模型信息，具有缓存和请求去重功能
+   *
+   * @author chitanda
+   * @date 2025-06-20 16:06:05
+   * @param {string} modelKey
+   * @returns {*}  {Promise<ModelMetaDTO>}
+   */
+  async loadModel(modelKey) {
+    if (this.modelCache.has(modelKey)) {
+      const cacheEntry = this.modelCache.get(modelKey);
+      if (!this.isExpired(cacheEntry)) {
+        return cacheEntry.data;
+      }
+      this.modelCache.delete(modelKey);
+    }
+    if (this.modelLoadingCache.has(modelKey)) {
+      return this.modelLoadingCache.get(modelKey);
+    }
+    const loadPromise = (async () => {
+      try {
+        const data = await _api.apaas.modelMeta.getDetail({ modelKey });
+        if (data) {
+          this.modelCache.set(modelKey, this.createCacheEntry(data));
+          return data;
+        }
+        return {};
+      } finally {
+        this.modelLoadingCache.delete(modelKey);
+      }
+    })();
+    this.modelLoadingCache.set(modelKey, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * 加载多个模型信息
+   *
+   * @author chitanda
+   * @date 2025-06-22 15:06:54
+   * @param {string[]} modelKeys
+   * @returns {*}  {Promise<ModelMetaDTO[]>}
+   */
+  async loadModels(modelKeys) {
+    const cacheKey = modelKeys.join(",");
+    const allCached = modelKeys.every((key) => {
+      const entry = this.modelCache.get(key);
+      return entry && !this.isExpired(entry);
+    });
+    if (allCached) {
+      return modelKeys.map((key) => this.modelCache.get(key).data);
+    }
+    modelKeys.forEach((key) => {
+      const entry = this.modelCache.get(key);
+      if (entry && this.isExpired(entry)) {
+        this.modelCache.delete(key);
+      }
+    });
+    if (this.modelsLoadingCache.has(cacheKey)) {
+      return this.modelsLoadingCache.get(cacheKey);
+    }
+    const loadPromise = (async () => {
+      try {
+        const pendingKeys = modelKeys.filter((key) => !this.modelCache.has(key));
+        if (pendingKeys.length > 0) {
+          const data = await _api.apaas.modelMeta.getByKeys({
+            modelKeys: pendingKeys.join(",")
+          });
+          if (data && data.length > 0) {
+            data.forEach((model) => {
+              this.modelCache.set(model.key, this.createCacheEntry(model));
+              model.fieldMetaList = model.fieldMetas || [];
+            });
+          }
+        }
+        return modelKeys.map((key) => {
+          const entry = this.modelCache.get(key);
+          return entry.data;
+        });
+      } finally {
+        this.modelsLoadingCache.delete(cacheKey);
+      }
+    })();
+    this.modelsLoadingCache.set(cacheKey, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * 加载指定模型的字段信息
+   *
+   * @author chitanda
+   * @date 2025-06-22 14:06:37
+   * @param {string} modelKey
+   * @param {string} fieldKey
+   * @returns {*}  {(Promise<FieldMetaDTO | undefined>)}
+   */
+  async loadField(modelKey, fieldKey) {
+    const model = await this.loadModel(modelKey);
+    if (model?.fieldMetaList) {
+      return model.fieldMetaList.find((field) => field.key === fieldKey);
+    }
+    return void 0;
+  }
+  /**
+   * 加载指定模型的字段路径信息
+   *
+   * @author chitanda
+   * @date 2025-06-22 14:06:11
+   * @param {string} modelKey
+   * @param {string} fieldKey
+   * @returns {*}  {Promise<string[]>}
+   */
+  async loadFieldPaths(modelKey, fieldKey, fieldCodeChain) {
+    if (!fieldCodeChain) {
+      return [];
+    }
+    const list = [];
+    const isFieldModel = !!fieldCodeChain.bindFieldKey;
+    const modelKeys = isFieldModel ? fieldCodeChain.modelLink || [
+      fieldCodeChain.belongModelKey,
+      fieldCodeChain.bindModelKey
+    ] : [fieldCodeChain.modelKey];
+    const models = await this.loadModels(modelKeys);
+    if (isFieldModel) {
+      list.push(...models.map((model2) => model2.name));
+    } else {
+      const model2 = await this.loadModel(fieldCodeChain.modelKey);
+      if (model2) {
+        list.push(model2.name);
+      }
+    }
+    const model = await this.loadModel(modelKey);
+    if (model?.fieldMetaList) {
+      const field = model.fieldMetaList.find((field2) => field2.key === fieldKey);
+      if (field) {
+        list.push(field.name);
+      }
+    }
+    return list;
+  }
+  /**
+   * 加载指定模型的枚举列表
+   *
+   * @param {string} modelKey
+   * @param {string} fieldKey
+   * @param {string} [modelCategory=EntityModelCategoryEnum.ENTITY]
+   * @returns {*}  {Promise<IObject[]>}
+   */
+  async loadEnumList(modelKey, fieldKey, modelCategory = EntityModelCategoryEnum.ENTITY) {
+    const cacheKey = `${modelCategory}:${modelKey}:${fieldKey}`;
+    if (this.enumCache.has(cacheKey)) {
+      const cacheEntry = this.enumCache.get(cacheKey);
+      if (!this.isExpired(cacheEntry)) {
+        return cloneDeep(cacheEntry.data);
+      }
+      this.enumCache.delete(cacheKey);
+      this.enumLoadingCache.delete(cacheKey);
+    }
+    if (this.enumLoadingCache.has(cacheKey)) {
+      return this.enumLoadingCache.get(cacheKey);
+    }
+    const loadPromise = (async () => {
+      try {
+        return [];
+      } finally {
+        this.enumLoadingCache.delete(cacheKey);
+      }
+    })();
+    this.enumLoadingCache.set(cacheKey, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * 加载关联数据查询（QueryRef）
+   *
+   * @param {QueryRefDataRequest} request
+   * @returns {*}  {Promise<ModelPageableRow>}
+   */
+  async loadQueryRefData(request) {
+    if (!request || !request.modelKey) {
+      throw new Error(`queryRefData 参数缺失`);
+    }
+    const cacheKey = JSON.stringify(request);
+    if (this.queryRefDataCache.has(cacheKey)) {
+      const cacheEntry = this.queryRefDataCache.get(cacheKey);
+      if (!this.isExpired(cacheEntry)) {
+        return cloneDeep(cacheEntry.data);
+      }
+      this.queryRefDataCache.delete(cacheKey);
+      this.queryRefDataLoadingCache.delete(cacheKey);
+    }
+    if (this.queryRefDataLoadingCache.has(cacheKey)) {
+      return this.queryRefDataLoadingCache.get(cacheKey);
+    }
+    const loadPromise = (async () => {
+      try {
+        const data = await _api.apaas.modelData.postQueryRefData(request);
+        if (data) {
+          this.queryRefDataCache.set(cacheKey, this.createCacheEntry(data));
+          return cloneDeep(data);
+        }
+        return {};
+      } finally {
+        this.queryRefDataLoadingCache.delete(cacheKey);
+      }
+    })();
+    this.queryRefDataLoadingCache.set(cacheKey, loadPromise);
+    return loadPromise;
+  }
+  /**
+   * 获取已缓存的模型
+   * @param modelKey 模型键
+   * @returns ModelMetaDTO | undefined
+   */
+  getCachedModel(modelKey) {
+    const entry = this.modelCache.get(modelKey);
+    if (entry && !this.isExpired(entry)) {
+      return entry.data;
+    }
+    if (entry && this.isExpired(entry)) {
+      this.modelCache.delete(modelKey);
+    }
+    return void 0;
+  }
+  /**
+   * 清除指定模型的缓存
+   *
+   * @author chitanda
+   * @date 2025-06-20 16:06:41
+   * @param {string} modelKey
+   */
+  clear(modelKey) {
+    this.modelCache.delete(modelKey);
+    this.modelLoadingCache.delete(modelKey);
+    const keysToDelete = [];
+    this.modelsLoadingCache.forEach((_, cacheKey) => {
+      if (cacheKey.includes(modelKey)) {
+        keysToDelete.push(cacheKey);
+      }
+    });
+    keysToDelete.forEach((key) => {
+      this.modelsLoadingCache.delete(key);
+    });
+    const enumKeysToDelete = [];
+    this.enumCache.forEach((_, cacheKey) => {
+      if (cacheKey.includes(modelKey)) {
+        enumKeysToDelete.push(cacheKey);
+      }
+    });
+    enumKeysToDelete.forEach((key) => {
+      this.enumCache.delete(key);
+      this.enumLoadingCache.delete(key);
+    });
+    const queryRefKeysToDelete = [];
+    this.queryRefDataCache.forEach((_, cacheKey) => {
+      if (cacheKey.includes(`"modelKey":"${modelKey}"`)) {
+        queryRefKeysToDelete.push(cacheKey);
+      }
+    });
+    queryRefKeysToDelete.forEach((key) => {
+      this.queryRefDataCache.delete(key);
+      this.queryRefDataLoadingCache.delete(key);
+    });
+  }
+  /**
+   * 清除所有模型缓存
+   *
+   * @author chitanda
+   * @date 2025-06-20 16:06:35
+   */
+  clearAll() {
+    this.modelCache.clear();
+    this.modelLoadingCache.clear();
+    this.modelsLoadingCache.clear();
+    this.enumCache.clear();
+    this.enumLoadingCache.clear();
+    this.queryRefDataCache.clear();
+    this.queryRefDataLoadingCache.clear();
+  }
+  /**
+   * 获取所有已缓存的模型键
+   *
+   * @author chitanda
+   * @date 2025-06-20 16:06:55
+   * @returns {*}  {string[]}
+   */
+  keys() {
+    return Array.from(this.modelCache.keys());
+  }
+}
+const modelLoader = new ModelLoader();
+
+export { modelLoader };

package/es/utils/namespace/namespace.mjs

@@ -1,6 +1,5 @@
 import { STYLE_NAMESPACE_TAG } from '../../constants/index.mjs';
 
-"use strict";
 const statePrefix = "is-";
 function _bem(namespace, block, blockSuffix, element, modifier) {
   let cls = `${namespace}-${block}`;

package/es/utils/plugin-static-resource/plugin-static-resource.mjs

@@ -1,6 +1,5 @@
 import path from 'path-browserify';
 
-"use strict";
 class PluginStaticResource {
   /**
    * 插件静态资源工具类.

package/es/utils/props/gct-form-item/gct-form-item.props.d.ts

@@ -0,0 +1,63 @@
+import { PropType } from 'vue';
+import { IEditorBasic, IFormEditItem, IFormItemController } from '../../../interface';
+/**
+ * 标准的表单项输入属性
+ *
+ * @author chitanda
+ * @date 2025-06-22 13:06:34
+ * @export
+ * @template T
+ * @template M
+ * @template C
+ * @returns {*}
+ */
+export declare function gctFormItemEditorProps<T = IObject, M extends IEditorBasic = IEditorBasic, C extends IContext = IContext>(): {
+    context: {
+        type: PropType<C>;
+        default: () => {};
+    };
+    value: {
+        type: PropType<T>;
+    };
+    model: {
+        type: PropType<M>;
+        required: boolean;
+    };
+    c: {
+        type: PropType<IFormItemController>;
+        required: boolean;
+    };
+    itemModel: {
+        type: PropType<IFormEditItem>;
+    };
+    data: {
+        type: ObjectConstructor;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keepalive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"small" | "medium" | "large">;
+    };
+    count: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isEmptyText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};

package/es/utils/props/gct-form-item/gct-form-item.props.mjs

@@ -0,0 +1,66 @@
+/**
+ * 标准的表单项输入属性
+ *
+ * @author chitanda
+ * @date 2025-06-22 13:06:34
+ * @export
+ * @template T
+ * @template M
+ * @template C
+ * @returns {*}
+ */
+function gctFormItemEditorProps() {
+  return {
+    context: {
+      type: Object,
+      default: () => ({})
+    },
+    value: {
+      type: Object
+    },
+    model: {
+      type: Object,
+      required: true
+    },
+    c: {
+      type: Object,
+      required: true
+    },
+    itemModel: {
+      type: Object
+    },
+    data: {
+      type: Object
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    readonly: {
+      type: Boolean,
+      default: false
+    },
+    keepalive: {
+      type: Boolean,
+      default: false
+    },
+    visible: {
+      type: Boolean,
+      default: true
+    },
+    size: {
+      type: String
+    },
+    count: {
+      type: Number,
+      default: 0
+    },
+    // 空数据时是否显示提示文本
+    isEmptyText: {
+      type: Boolean,
+      default: false
+    }
+  };
+}
+
+export { gctFormItemEditorProps };

package/es/utils/props/index.d.ts

@@ -0,0 +1 @@
+export { gctFormItemEditorProps } from './gct-form-item/gct-form-item.props';

package/es/utils/style/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 计算配置样式
+ *
+ * @param data
+ * @param ignoringStyle 忽略计算的样式
+ * @returns
+ */
+export declare const calcStyle: (data: IData, ignoringStyle?: string[]) => IObject;
+/**
+ * 计算字体样式
+ *
+ * @param data
+ * @param ignoringStyle 忽略的样式
+ * @returns
+ */
+export declare const calcFontStyle: (data: IData, ignoringStyle?: string[]) => IObject;

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;