@ibiz-template/model-helper 0.7.41-alpha.13 → 0.7.41-alpha.131

package/src/utils/merge-model/merge-treeview.ts

@@ -0,0 +1,197 @@
+/* eslint-disable no-case-declarations */
+import { IDETree, IDETreeNodeRS } from '@ibiz/model-core';
+
+/**
+ * 合并树部件
+ *
+ * @author tony001
+ * @date 2024-09-26 17:09:25
+ * @export
+ * @param {IDETree} dst
+ * @param {IDETree} source
+ */
+export function mergeTreeView(dst: IDETree, source: IDETree): void {
+  if (!dst || !source) return;
+  // 合并树节点
+  if (source.detreeNodes && source.detreeNodes.length > 0) {
+    if (!dst.detreeNodes) {
+      dst.detreeNodes = [];
+    }
+    source.detreeNodes.forEach(sourceNode => {
+      const item = dst.detreeNodes!.find(dstNode => {
+        return dstNode.id === sourceNode.id;
+      });
+      if (!item) {
+        dst.detreeNodes?.push(sourceNode);
+      }
+    });
+  }
+  // 合并树节点关系
+  if (source.detreeNodeRSs && source.detreeNodeRSs.length > 0) {
+    if (!dst.detreeNodeRSs) {
+      dst.detreeNodeRSs = [];
+    }
+    source.detreeNodeRSs.forEach(sourceNodeRs => {
+      // 若配置了用户标记（dynamic_overlay:before|after|replace|delete|start|end:noderesid），则需根据用户标记进行合并，否则原始数据没有则直接附加末尾
+      if (
+        (sourceNodeRs as IModel).userTag &&
+        (sourceNodeRs as IModel).userTag.startsWith('dynamic_overlay') &&
+        (sourceNodeRs as IModel).userTag.split(':').length === 3
+      ) {
+        mergeSubAppTreeNodeResToDst(dst, sourceNodeRs);
+      } else {
+        const itemIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+          return (
+            dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId &&
+            dstNodeRs.childDETreeNodeId === sourceNodeRs.childDETreeNodeId
+          );
+        });
+        // 若存在end标记，则需要添加到第一个end标记节点关系前面，保证end标记节点关系始终添加到最后
+        const endIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+          if (
+            dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+          ) {
+            const tags = (sourceNodeRs as IModel).userTag?.split(':');
+            if (!tags || tags.length !== 3 || tags[1] !== 'end') return false;
+            return true;
+          }
+          return false;
+        });
+        if (itemIndex === -1) {
+          if (endIndex === -1) {
+            dst.detreeNodeRSs?.push(sourceNodeRs);
+          } else {
+            dst.detreeNodeRSs!.splice(endIndex, 0, sourceNodeRs);
+          }
+        }
+      }
+    });
+  }
+}
+
+/**
+ * 合并指定子应用树节点关系到主应用树指定位置
+ * @param dst 原始树
+ * @param sourceNode 子应用树节点关系
+ */
+function mergeSubAppTreeNodeResToDst(
+  dst: IDETree,
+  sourceNodeRs: IDETreeNodeRS,
+): void {
+  // dynamic_overlay:before|after|replace|delete|start|end:nodeid 定义附加位置
+  const [dynamicOverlay, targetPosition, targetTag] = (
+    sourceNodeRs as IModel
+  ).userTag.split(':');
+  if (!dynamicOverlay || !targetPosition || !targetTag) return;
+  switch (targetPosition) {
+    case 'before':
+      // 在目标节点之前,dynamic_overlay:before:childnodeid,这儿最后一节拼接的是子节点标识
+      const beforeIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (beforeIndex !== -1) {
+        dst.detreeNodeRSs!.splice(beforeIndex, 0, sourceNodeRs);
+      }
+      break;
+    case 'after':
+      // 在目标节点之后,格式如：dynamic_overlay:after:childnodeid,最后一节拼接的是子节点标识
+      const afterIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (afterIndex !== -1) {
+        dst.detreeNodeRSs!.splice(afterIndex + 1, 0, sourceNodeRs);
+      }
+      break;
+    case 'replace':
+      // 替换目标节点,格式如：dynamic_overlay:replace:childnodeid,最后一节拼接的是子节点标识
+      const replaceIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (replaceIndex !== -1) {
+        dst.detreeNodeRSs!.splice(replaceIndex, 1, sourceNodeRs);
+      }
+      break;
+    case 'delete':
+      // 删除目标节点,格式如：dynamic_overlay:delete:childnodeid,最后一节拼接的是子节点标识
+      const deleteIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (deleteIndex !== -1) {
+        dst.detreeNodeRSs!.splice(deleteIndex, 1);
+      }
+      break;
+    case 'start':
+      // 在目标节点内部开始，格式如：dynamic_overlay:start:随机字符,最后一节拼接的是随机字符，读的是当前节点关系的父节点标识
+      const startIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId;
+      });
+      if (startIndex !== -1) {
+        dst.detreeNodeRSs!.splice(startIndex, 0, sourceNodeRs);
+      }
+      break;
+    case 'end':
+      // 在目标节点内部结束，格式如：dynamic_overlay:end:随机字符,最后一节拼接的是随机字符，读的是当前节点关系的父节点标识
+      const endIndex = getLastIndex(dst.detreeNodeRSs!, dstNode => {
+        return dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId;
+      });
+      if (endIndex !== -1) {
+        dst.detreeNodeRSs!.splice(endIndex + 1, 0, sourceNodeRs);
+      }
+      break;
+    default:
+      // 未识别位置，若源树不存在该关系，则直接附加到最后
+      const defaultIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+        return (
+          dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId &&
+          dstNodeRs.childDETreeNodeId === sourceNodeRs.childDETreeNodeId
+        );
+      });
+      // 若存在end标记，则需要添加到第一个end标记节点关系前面，保证end标记节点关系始终添加到最后
+      const defaultEndIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+        if (dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId) {
+          const tags = (sourceNodeRs as IModel).userTag?.split(':');
+          if (!tags || tags.length !== 3 || tags[1] !== 'end') return false;
+          return true;
+        }
+        return false;
+      });
+      if (defaultIndex === -1) {
+        if (defaultEndIndex === -1) {
+          dst.detreeNodeRSs?.push(sourceNodeRs);
+        } else {
+          dst.detreeNodeRSs!.splice(defaultEndIndex, 0, sourceNodeRs);
+        }
+      }
+      break;
+  }
+}
+
+/**
+ * 获取指定数组中满足条件的最后一个元素
+ * @param arr 指定数组
+ * @param predicate 过滤条件
+ * @returns 找到则返回指定元素下标，反之返回-1
+ */
+function getLastIndex(
+  arr: IModel[],
+  predicate: (item: IModel) => boolean,
+): number {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+}

package/src/utils/model-transformer/model-handler.ts

@@ -0,0 +1,36 @@
+import { IModelHandler } from '../../interface';
+
+/**
+ * @description 模型变换处理器
+ * @export
+ * @abstract
+ * @class ModelHandler
+ * @implements {IModelHandler}
+ */
+export abstract class ModelHandler implements IModelHandler {
+  /**
+   * @description 优先级，默认值为1
+   * @public
+   * @type {number}
+   * @memberof ModelHandler
+   */
+  public priority: number = 1;
+
+  /**
+   * Creates an instance of ModelHandler.
+   * @param {number} [priority=1] 优先级，数值越小越先执行
+   * @memberof ModelHandler
+   */
+  constructor(priority: number = 1) {
+    this.priority = priority;
+  }
+
+  /**
+   * @description 执行器
+   * @abstract
+   * @param {IModel} model
+   * @returns {*}  {IModel}
+   * @memberof ModelHandler
+   */
+  abstract execute(model: IModel): IModel;
+}

package/src/utils/model-transformer/model-register.ts

@@ -0,0 +1,15 @@
+import { ModelHandler } from './model-handler';
+import { ModelTransformer } from './model-transformer';
+
+/**
+ * @description 注册模型处理器
+ * @export
+ * @param {string} pathPattern 路径表达式
+ * @param {ModelHandler} handler 模型处理器
+ */
+export function registerModelHandler(
+  pathPattern: string,
+  handler: ModelHandler,
+): void {
+  ModelTransformer.getInstance().registerHandler(pathPattern, handler);
+}

package/src/utils/model-transformer/model-transformer.ts

@@ -0,0 +1,147 @@
+import AntPathMatcher from '@maxbilbow/ant-path-matcher';
+import { ModelHandler } from './model-handler';
+
+/**
+ * @description 模型变换器
+ * @author tony001
+ * @date 2026-08-13 09:08:03
+ * @export
+ * @class ModelTransformer
+ */
+export class ModelTransformer {
+  /**
+   * @description 单例变量声明
+   * @private
+   * @static
+   * @type {ModelTransformer}
+   * @memberof ModelTransformer
+   */
+  private static modelTransformer: ModelTransformer;
+
+  /**
+   * @description 获取 ModelTransformer 单例对象
+   * @static
+   * @returns {*}  {ModelTransformer}
+   * @memberof ModelTransformer
+   */
+  public static getInstance(): ModelTransformer {
+    if (!this.modelTransformer) {
+      this.modelTransformer = new ModelTransformer();
+    }
+    return this.modelTransformer;
+  }
+
+  /**
+   * @description 模型处理器Map
+   * @private
+   * @type {Map<string, ModelHandler[]>}
+   * @memberof ModelTransformer
+   */
+  private handlerMap: Map<string, ModelHandler[]> = new Map();
+
+  /**
+   * @description 路径匹配器（支持通配符路径匹配）
+   * @private
+   * @type {ReturnType<typeof AntPathMatcher>}
+   * @memberof ModelTransformer
+   */
+  private pathMatcher = AntPathMatcher();
+
+  /**
+   * @description 注册模型处理器
+   * @param {string} pathPattern 路径表达式（奇数位路径段支持通配符）
+   * @param {IModelHandler} handler 执行器
+   * @memberof ModelTransformer
+   */
+  public registerHandler(pathPattern: string, handler: ModelHandler): void {
+    if (!this.validatePattern(pathPattern)) {
+      return;
+    }
+    const handlers = this.handlerMap.get(pathPattern);
+    if (handlers) {
+      handlers.push(handler);
+    } else {
+      this.handlerMap.set(pathPattern, [handler]);
+    }
+  }
+
+  /**
+   * @description 校验模型路径，从0开始数，偶数位路径段（如PSSYSAPPS、PSAPPDATAENTITIES等类型段）不允许使用通配符，奇数位路径段可使用
+   * @private
+   * @param {string} pathPattern 路径表达式
+   * @returns {*}  {boolean}
+   * @memberof ModelTransformer
+   */
+  private validatePattern(pathPattern: string): boolean {
+    const segments = pathPattern.split('/');
+    const isValid = segments.every((segment: string, index: number) => {
+      // 偶数位不允许出现通配符，奇数位有无通配符均可
+      return index % 2 === 1 || !/[*?]/.test(segment);
+    });
+    if (!isValid) {
+      ibiz.log.error(
+        ibiz.i18n.t('modelHelper.utils.invalidPathPattern', {
+          pathPattern,
+        }),
+      );
+    }
+    return isValid;
+  }
+
+  /**
+   * @description 变换模型
+   * @param {string} dynaModelFilePath 模型路径
+   * @param {IModel} model 原始模型
+   * @returns {*}  {IModel}
+   * @memberof ModelTransformer
+   */
+  public transform(dynaModelFilePath: string, model: IModel): IModel {
+    ibiz.log.debug(
+      ibiz.i18n.t('modelHelper.utils.tryGetModel', {
+        dynaModelFilePath,
+      }),
+    );
+    // 收集所有匹配当前路径的处理器（支持通配符路径）
+    const matchedHandlers: ModelHandler[] = [];
+    this.handlerMap.forEach((handlers: ModelHandler[], pattern: string) => {
+      if (this.pathMatcher.match(pattern, dynaModelFilePath)) {
+        matchedHandlers.push(...handlers);
+      }
+    });
+    if (matchedHandlers.length === 0) {
+      return model;
+    }
+    // 按照优先级升序排序，优先级高的后执行
+    const sortedHandlers = [...matchedHandlers].sort(
+      (a: ModelHandler, b: ModelHandler) => a.priority - b.priority,
+    );
+    // 模型处理
+    let result = model;
+    for (const handler of sortedHandlers) {
+      try {
+        const next = handler.execute(result);
+        if (next) {
+          result = next;
+        } else {
+          ibiz.log.error(
+            ibiz.i18n.t('modelHelper.utils.transformNoModelData', {
+              dynaModelFilePath,
+            }),
+          );
+          // 未返回模型数据时返回传入的原始模型，防止界面异常
+          return model;
+        }
+      } catch (error) {
+        ibiz.log.error(
+          ibiz.i18n.t('modelHelper.utils.transformException', {
+            dynaModelFilePath,
+          }),
+          error,
+        );
+        // 执行异常时返回传入的原始模型，防止界面异常
+        return model;
+      }
+    }
+    return result;
+  }
+}

package/src/utils/plural/plural.ts

@@ -0,0 +1,30 @@
+import pluralize from 'pluralize';
+
+// 补充特殊转换规则
+pluralize.addPluralRule(/(matr|vert|ind)ix|ex$/, '$1ices');
+
+/**
+ * 英文转复数写法
+ *
+ * @author chitanda
+ * @date 2022-08-25 18:08:41
+ * @export
+ * @param {string} key
+ * @return {*}  {string}
+ */
+export function plural(key: string): string {
+  return pluralize(key);
+}
+
+/**
+ * 英文转复数写法并转全小写
+ *
+ * @author chitanda
+ * @date 2022-08-25 18:08:23
+ * @export
+ * @param {string} key
+ * @return {*}  {string}
+ */
+export function pluralLower(key: string): string {
+  return plural(key).toLowerCase();
+}