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

package/es/utils/linked-list/linked-list.mjs

@@ -0,0 +1,119 @@
+import { LinkedNode } from '../linked-node/linked-node.mjs';
+
+class LinkedList {
+  /**
+   * 当前激活节点
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 15:07:02
+   * @type {(LinkedNode<T> | null)}
+   */
+  active = null;
+  /**
+   * 新增节点
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 15:07:45
+   * @param {T} data
+   */
+  add(data) {
+    if (!this.active) {
+      this.active = new LinkedNode(data);
+    } else {
+      if (this.active.next) {
+        let next = this.active.next;
+        while (next) {
+          next = next.next;
+          if (next) {
+            next.clear();
+          }
+        }
+      }
+      const node = new LinkedNode(data, null, this.active);
+      this.active.next = node;
+      this.active = node;
+    }
+  }
+  /**
+   * 删除节点
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 15:07:11
+   * @param {LinkedNode<T>} node
+   */
+  delete(node) {
+    const { prev, next } = node;
+    if (prev) {
+      prev.next = next;
+    }
+    if (next) {
+      next.prev = prev;
+    }
+    node.clear();
+  }
+  /**
+   * 上一个节点
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 16:07:41
+   */
+  prev() {
+    if (this.active && this.active.prev) {
+      this.active = this.active.prev;
+    }
+  }
+  /**
+   * 下一个节点
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 16:07:57
+   */
+  next() {
+    if (this.active && this.active.next) {
+      this.active = this.active.next;
+    }
+  }
+  /**
+   * 清理所有缓存
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 16:07:43
+   */
+  clearAll() {
+    if (this.active) {
+      let prev = this.active.prev;
+      let next = this.active.next;
+      while (prev) {
+        prev.clear();
+        prev = prev.prev;
+      }
+      while (next) {
+        next.clear();
+        next = next.next;
+      }
+      this.active.clear();
+    }
+  }
+  /**
+   * 是否可以撤销
+   *
+   * @author zhanghanrui
+   * @date 2024-08-21 15:08:57
+   * @return {*}  {boolean}
+   */
+  canUndo() {
+    return !!this.active && !!this.active.prev;
+  }
+  /**
+   * 是否可以重做
+   *
+   * @author zhanghanrui
+   * @date 2024-08-21 15:08:33
+   * @return {*}  {boolean}
+   */
+  canRedo() {
+    return !!this.active && !!this.active.next;
+  }
+}
+
+export { LinkedList };

package/es/utils/linked-node/linked-node.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 链表节点
+ *
+ * @author zhanghanrui
+ * @date 2024-07-31 15:07:21
+ * @export
+ * @class LinkedNode
+ * @template T
+ */
+export declare class LinkedNode<T = any> {
+    data: T;
+    next: LinkedNode | null;
+    prev: LinkedNode | null;
+    /**
+     * Creates an instance of LinkedNode.
+     *
+     * @author zhanghanrui
+     * @date 2024-07-31 15:07:43
+     * @param {T} data 当前节点数据
+     * @param {(LinkedNode | null)} [next=null] 下一个节点
+     * @param {(LinkedNode | null)} [prev=null] 上一个节点
+     */
+    constructor(data: T, next?: LinkedNode | null, prev?: LinkedNode | null);
+    /**
+     * 清理链表，避免内存泄漏
+     *
+     * @author zhanghanrui
+     * @date 2024-07-31 15:07:34
+     */
+    clear(): void;
+}

package/es/utils/linked-node/linked-node.mjs

@@ -0,0 +1,32 @@
+class LinkedNode {
+  data;
+  next;
+  prev;
+  /**
+   * Creates an instance of LinkedNode.
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 15:07:43
+   * @param {T} data 当前节点数据
+   * @param {(LinkedNode | null)} [next=null] 下一个节点
+   * @param {(LinkedNode | null)} [prev=null] 上一个节点
+   */
+  constructor(data, next = null, prev = null) {
+    this.data = data;
+    this.next = next;
+    this.prev = prev;
+  }
+  /**
+   * 清理链表，避免内存泄漏
+   *
+   * @author zhanghanrui
+   * @date 2024-07-31 15:07:34
+   */
+  clear() {
+    this.data = null;
+    this.next = null;
+    this.prev = null;
+  }
+}
+
+export { LinkedNode };

package/es/utils/lowcode/utils.d.ts

@@ -0,0 +1 @@
+export declare const insertCustomCssToHead: (cssCode: string, modalId?: string) => void;

package/es/utils/lowcode/utils.mjs

@@ -0,0 +1,20 @@
+import { isEmpty } from 'lodash-es';
+
+const insertCustomCssToHead = function(cssCode, modalId = "") {
+  const head = document.getElementsByTagName("head")[0];
+  const oldStyle = document.getElementById("gct-custom-css" + modalId);
+  if (oldStyle) {
+    head.removeChild(oldStyle);
+  }
+  const newStyle = document.createElement("style");
+  newStyle.id = "gct-custom-css" + modalId;
+  newStyle.type = "text/css";
+  if (isEmpty(modalId)) {
+    newStyle.innerHTML = cssCode;
+  } else {
+    newStyle.innerHTML = `#${modalId}{${cssCode}}`;
+  }
+  head.appendChild(newStyle);
+};
+
+export { insertCustomCssToHead };

package/es/utils/lowcode/validate.d.ts

@@ -0,0 +1,13 @@
+interface Validation {
+    required?: boolean;
+    reg?: string | RegExp;
+    regHint?: string;
+    validateFn?: any;
+}
+interface Rule {
+    required?: boolean;
+    message?: string;
+    validator?: any;
+}
+export declare function buildItemRules(validation: Validation): Rule[];
+export {};

package/es/utils/lowcode/validate.mjs

@@ -0,0 +1,29 @@
+import { t } from '../i18n/index.mjs';
+
+function buildItemRules(validation) {
+  const rules = [];
+  if (validation.required) {
+    rules.push({
+      required: true,
+      message: t("sys.notNull")
+    });
+  }
+  if (validation.reg) {
+    const { reg, regHint } = validation;
+    const regExg = new RegExp(reg);
+    const validator = (val) => regExg.test(val);
+    rules.push({
+      validator,
+      message: regHint ?? t("sys.regError")
+    });
+  }
+  const validateEvent = validation.validateFn;
+  if (validateEvent) {
+    rules.push({
+      validator: validateEvent
+    });
+  }
+  return rules;
+}
+
+export { buildItemRules };

package/es/utils/mitt/mitt.d.ts

@@ -0,0 +1 @@
+export declare const mitt: import('mitt').Emitter<Record<import('mitt').EventType, unknown>>;

package/es/utils/mitt/mitt.mjs

@@ -0,0 +1,5 @@
+import Mitt from 'mitt';
+
+const mitt = Mitt();
+
+export { mitt };

package/es/utils/model-loader/model-loader.d.ts

@@ -0,0 +1,118 @@
+import { IFieldCodeChain } from '../../interface';
+import { FieldMetaDTO, ModelMetaDTO, ModelPageableRow, QueryRefDataRequest } from '@gct-paas/api/apaas';
+/**
+ * 模型加载器，提供模型缓存和请求去重功能
+ *
+ * @author chitanda
+ * @date 2025-06-20 16:06:12
+ * @class ModelLoader
+ */
+declare class ModelLoader {
+    private readonly CACHE_EXPIRATION_TIME;
+    private modelCache;
+    private modelLoadingCache;
+    private modelsLoadingCache;
+    private enumCache;
+    private enumLoadingCache;
+    private queryRefDataCache;
+    private queryRefDataLoadingCache;
+    /**
+     * 检查缓存条目是否过期
+     *
+     * @param {CacheEntry<any>} entry
+     * @returns {*}  {boolean}
+     */
+    private isExpired;
+    /**
+     * 创建缓存条目
+     *
+     * @param {T} data
+     * @returns {*}  {CacheEntry<T>}
+     */
+    private createCacheEntry;
+    /**
+     * 加载模型信息，具有缓存和请求去重功能
+     *
+     * @author chitanda
+     * @date 2025-06-20 16:06:05
+     * @param {string} modelKey
+     * @returns {*}  {Promise<ModelMetaDTO>}
+     */
+    loadModel(modelKey: string): Promise<ModelMetaDTO>;
+    /**
+     * 加载多个模型信息
+     *
+     * @author chitanda
+     * @date 2025-06-22 15:06:54
+     * @param {string[]} modelKeys
+     * @returns {*}  {Promise<ModelMetaDTO[]>}
+     */
+    loadModels(modelKeys: string[]): Promise<ModelMetaDTO[]>;
+    /**
+     * 加载指定模型的字段信息
+     *
+     * @author chitanda
+     * @date 2025-06-22 14:06:37
+     * @param {string} modelKey
+     * @param {string} fieldKey
+     * @returns {*}  {(Promise<FieldMetaDTO | undefined>)}
+     */
+    loadField(modelKey: string, fieldKey: string): Promise<FieldMetaDTO | undefined>;
+    /**
+     * 加载指定模型的字段路径信息
+     *
+     * @author chitanda
+     * @date 2025-06-22 14:06:11
+     * @param {string} modelKey
+     * @param {string} fieldKey
+     * @returns {*}  {Promise<string[]>}
+     */
+    loadFieldPaths(modelKey: string, fieldKey: string, fieldCodeChain: IFieldCodeChain): Promise<string[]>;
+    /**
+     * 加载指定模型的枚举列表
+     *
+     * @param {string} modelKey
+     * @param {string} fieldKey
+     * @param {string} [modelCategory=EntityModelCategoryEnum.ENTITY]
+     * @returns {*}  {Promise<IObject[]>}
+     */
+    loadEnumList(modelKey: string, fieldKey: string, modelCategory?: string): Promise<IObject[]>;
+    /**
+     * 加载关联数据查询（QueryRef）
+     *
+     * @param {QueryRefDataRequest} request
+     * @returns {*}  {Promise<ModelPageableRow>}
+     */
+    loadQueryRefData(request: QueryRefDataRequest): Promise<ModelPageableRow>;
+    /**
+     * 获取已缓存的模型
+     * @param modelKey 模型键
+     * @returns ModelMetaDTO | undefined
+     */
+    getCachedModel(modelKey: string): ModelMetaDTO | undefined;
+    /**
+     * 清除指定模型的缓存
+     *
+     * @author chitanda
+     * @date 2025-06-20 16:06:41
+     * @param {string} modelKey
+     */
+    clear(modelKey: string): void;
+    /**
+     * 清除所有模型缓存
+     *
+     * @author chitanda
+     * @date 2025-06-20 16:06:35
+     */
+    clearAll(): void;
+    /**
+     * 获取所有已缓存的模型键
+     *
+     * @author chitanda
+     * @date 2025-06-20 16:06:55
+     * @returns {*}  {string[]}
+     */
+    keys(): string[];
+}
+export declare const modelLoader: ModelLoader;
+export {};

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