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

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

package/es/utils/openUtil/overlay-container/overlay-container.d.ts

@@ -0,0 +1,100 @@
+import { IOverlayContainer } from '../../../interface';
+import { QXEvent } from 'qx-util';
+import { App, Component, VNode } from 'vue';
+/**
+ * 全局弹出承载组件
+ *
+ * @author zhanghanrui
+ * @date 2024-03-19 19:03:22
+ * @export
+ * @class OverlayContainer
+ * @implements {IOverlayContainer}
+ * @template O
+ */
+export declare class OverlayContainer<O> implements IOverlayContainer {
+    protected component: unknown;
+    protected render: (...args: any[]) => VNode;
+    protected opts?: O | undefined;
+    protected vm?: App;
+    /**
+     * 具体模态组件对象
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:45
+     * @protected
+     * @type {*}
+     */
+    protected modal: any;
+    /**
+     * 调用dismiss时传的result结果
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:30
+     * @protected
+     * @type {unknown}
+     */
+    protected result?: unknown;
+    /**
+     * 内部事件
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:44
+     * @protected
+     */
+    protected evt: QXEvent<{
+        dismiss: (data?: unknown) => void;
+    }>;
+    /**
+     * init 执行完毕的 Promise，用于确保 present/dismiss 调用时 init 已完成
+     *
+     * @protected
+     * @type {Promise<void>}
+     */
+    protected _initPromise: Promise<void>;
+    /**
+     * 创建全局呈现
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:51
+     * @param {unknown} component
+     * @param {(...args: any[]) => VNode} render
+     * @param {O} [opts]
+     */
+    constructor(component: unknown, render: (...args: any[]) => VNode, opts?: O | undefined);
+    static createVueApp(rootComponent: Component, rootProps?: IData): Promise<App<Element>>;
+    /**
+     * 初始化飘窗
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:00
+     * @protected
+     * @return {*}  {void}
+     */
+    protected init(): Promise<void>;
+    /**
+     * 打开飘窗
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:14
+     * @return {*}  {Promise<void>}
+     */
+    present(): Promise<void>;
+    /**
+     * 手动调用关闭飘窗
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:19
+     * @param {unknown} [data]
+     * @return {*}  {Promise<void>}
+     */
+    dismiss(data?: unknown): Promise<void>;
+    /**
+     * 订阅窗口关闭
+     *
+     * @author zhanghanrui
+     * @date 2024-03-19 19:03:26
+     * @template T
+     * @return {*}  {Promise<T>}
+     */
+    onWillDismiss<T = unknown>(): Promise<T>;
+}