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

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

package/es/utils/namespace/namespace.d.ts

@@ -114,3 +114,11 @@ export declare class Namespace {
      */
     cssVarBlockName(name: string): string;
 }
+/**
+ * 获取 bem 操作类
+ *
+ * @export
+ * @param {string} block
+ * @return {*}  {Namespace}
+ */
+export declare function useNamespace(block: string): Namespace;

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}`;
@@ -163,5 +162,8 @@ class Namespace {
     return `--${this.namespace}-${this.block}-${name}`;
   }
 }
+function useNamespace(block) {
+  return new Namespace(block);
+}
 
-export { Namespace };
+export { Namespace, useNamespace };

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

@@ -0,0 +1,2 @@
+export { Modal } from './modal/modal';
+export { OverlayContainer } from './overlay-container/overlay-container';

package/es/utils/openUtil/modal/modal.d.ts

@@ -0,0 +1,61 @@
+import { AsyncSeriesHook } from 'qx-util';
+import { IModal, IModalData } from '../../../interface';
+interface ConstructorOpts {
+    /**
+     * 注入的模态等组件实际的关闭操作，
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 21:03:00
+     */
+    dismiss?: (data: IModalData) => void;
+    /**
+     * 修改属性
+     * @param data
+     * @returns
+     */
+    setOptions?: (data: object) => void;
+}
+export declare class Modal implements IModal {
+    ignoreDismissCheck: boolean;
+    state: {
+        okDisabled?: boolean;
+        cancelDisabled?: boolean;
+    };
+    hooks: {
+        shouldDismiss: AsyncSeriesHook<[], {
+            allowClose?: boolean;
+        }>;
+        beforeDismiss: AsyncSeriesHook<[], IModalData>;
+    };
+    ok?: () => Promise<IModalData | null>;
+    setOptions?: (options: object) => void;
+    constructor(opts: ConstructorOpts);
+    cancel?: (() => Promise<boolean>) | undefined;
+    callback(ok?: () => Promise<IModalData | null>, cancel?: () => Promise<boolean>): void;
+    /**
+     * 外部注入的模态等组件实际的关闭操作
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 21:03:08
+     * @param {IModalData} data
+     */
+    _dismiss: (data: IModalData) => void;
+    /**
+     * 注入模态等组件实际的关闭操作
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 21:03:13
+     * @param {(data: IModalData) => void} dismiss
+     */
+    injectDismiss(dismiss: (data: IModalData) => void): void;
+    dismiss(data?: IModalData): Promise<boolean>;
+    /**
+     * 执行完一次关闭后就会调销毁
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 21:03:22
+     * @protected
+     */
+    protected destroy(): void;
+}
+export {};

package/es/utils/openUtil/modal/modal.mjs

@@ -0,0 +1,80 @@
+import { reactive } from 'vue';
+import { AsyncSeriesHook } from 'qx-util';
+
+class Modal {
+  ignoreDismissCheck = false;
+  state = reactive({
+    okDisabled: false,
+    cancelDisabled: false
+  });
+  hooks = {
+    shouldDismiss: new AsyncSeriesHook(),
+    beforeDismiss: new AsyncSeriesHook()
+  };
+  ok;
+  setOptions;
+  constructor(opts) {
+    if (opts.dismiss) {
+      this._dismiss = opts.dismiss;
+    }
+    if (opts.setOptions) {
+      this.setOptions = opts.setOptions;
+    }
+  }
+  cancel;
+  callback(ok, cancel) {
+    if (ok) {
+      this.ok = ok;
+    }
+    if (cancel) {
+      this.cancel = cancel;
+    }
+  }
+  /**
+   * 外部注入的模态等组件实际的关闭操作
+   *
+   * @author zhanghanrui
+   * @date 2024-03-19 21:03:08
+   * @param {IModalData} data
+   */
+  _dismiss = (data) => {
+    console.warn("外部关闭能力未注册", data);
+  };
+  /**
+   * 注入模态等组件实际的关闭操作
+   *
+   * @author zhanghanrui
+   * @date 2024-03-19 21:03:13
+   * @param {(data: IModalData) => void} dismiss
+   */
+  injectDismiss(dismiss) {
+    this._dismiss = dismiss;
+  }
+  async dismiss(data = { ok: false, data: [] }) {
+    const context = {};
+    if (this.ignoreDismissCheck !== true) {
+      await this.hooks.shouldDismiss.call(context);
+    }
+    if (context.allowClose === false) {
+      console.warn("shouldDismiss结果为false,关闭中断。");
+      return false;
+    }
+    await this.hooks.beforeDismiss.call(data);
+    this._dismiss(data);
+    this.destroy();
+    return true;
+  }
+  /**
+   * 执行完一次关闭后就会调销毁
+   *
+   * @author zhanghanrui
+   * @date 2024-03-19 21:03:22
+   * @protected
+   */
+  destroy() {
+    this.hooks.shouldDismiss.clear();
+    this.hooks.beforeDismiss.clear();
+  }
+}
+
+export { Modal };