@nocobase/flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.11

package/src/components/variables/utils.ts

@@ -13,6 +13,18 @@ import type { MetaTreeNode } from '../../flowContext';
 import type { ContextSelectorItem, Converters } from './types';
 import { isVariableExpression } from '../../utils';
 
+const getContextSelectorLabelText = (node: ContextSelectorItem) => {
+  if (typeof node.label === 'string') {
+    return node.label;
+  }
+
+  if (typeof node.meta?.title === 'string') {
+    return node.meta.title;
+  }
+
+  return node.value;
+};
+
 export const parseValueToPath = (value: string): string[] | undefined => {
   if (typeof value !== 'string') return undefined;
 
@@ -66,12 +78,7 @@ export const searchInLoadedNodes = (
       const nodePath = [...currentPath, node.value];
 
       // 计算可搜索的纯文本标签
-      const labelText =
-        typeof node.label === 'string'
-          ? node.label
-          : typeof node.meta?.title === 'string'
-            ? node.meta!.title
-            : String(node.value);
+      const labelText = getContextSelectorLabelText(node);
 
       // 检查节点标签是否匹配搜索文本
       if (labelText.toLowerCase().includes(lowerSearchText)) {
@@ -89,6 +96,60 @@ export const searchInLoadedNodes = (
   return results;
 };
 
+/**
+ * 仅在“已加载节点”范围内按关键字过滤 options（保留树结构）。
+ * - 匹配父节点：保留原节点引用（含原 children），避免不必要的实体重建。
+ * - 匹配子节点：返回裁剪后的父节点副本，children 仅包含命中分支。
+ * - 未加载 children（即 children 不为数组）不会递归搜索。
+ */
+export const filterLoadedContextSelectorItems = (
+  options: ContextSelectorItem[] | undefined,
+  keyword: string,
+): ContextSelectorItem[] => {
+  if (!Array.isArray(options) || options.length === 0) return [];
+
+  const normalizedKeyword = keyword.trim().toLowerCase();
+  if (!normalizedKeyword) {
+    return options;
+  }
+
+  const filterNode = (node: ContextSelectorItem): ContextSelectorItem | null => {
+    const labelText = getContextSelectorLabelText(node).toLowerCase();
+    const selfMatched = labelText.includes(normalizedKeyword);
+
+    if (selfMatched) {
+      return node;
+    }
+
+    if (!Array.isArray(node.children) || node.children.length === 0) {
+      return null;
+    }
+
+    const filteredChildren = node.children
+      .map((child) => filterNode(child))
+      .filter((item): item is ContextSelectorItem => item !== null);
+
+    if (filteredChildren.length === 0) {
+      return null;
+    }
+
+    // 所有子节点都保留原引用时，直接复用父节点对象。
+    if (
+      filteredChildren.length === node.children.length &&
+      filteredChildren.every((child, idx) => child === node.children![idx])
+    ) {
+      return node;
+    }
+
+    return {
+      ...node,
+      children: filteredChildren,
+    };
+  };
+
+  return options.map((node) => filterNode(node)).filter((item): item is ContextSelectorItem => item !== null);
+};
+
 export const buildContextSelectorItems = (metaTree: MetaTreeNode[]): ContextSelectorItem[] => {
   if (!metaTree || !Array.isArray(metaTree)) {
     console.warn('buildContextSelectorItems received invalid metaTree:', metaTree);

package/src/data-source/index.ts

@@ -99,7 +99,7 @@ export class DataSource {
   }
 
   get displayName() {
-    return this.options.displayName ? this.flowEngine.translate(this.options.displayName) : this.key;
+    return this.flowEngine.translate(this.options.displayName, { ns: 'lm-collections' }) || this.key;
   }
 
   get key() {
@@ -187,6 +187,9 @@ export interface CollectionOptions {
 export class CollectionManager {
   collections: Map<string, Collection>;
 
+  allCollectionsInheritChain: string[];
+  protected childrenCollectionsName: { supportView?: string[]; notSupportView?: string[] } = {};
+
   constructor(public dataSource: DataSource) {
     this.collections = observable.shallow<Map<string, Collection>>(new Map());
   }
@@ -339,117 +342,80 @@ export class CollectionManager {
     };
     return getChildrens(name);
   }
-
-  getCollectionFieldsOptions(
-    collectionName: string,
-    type?: string | string[],
-    interfaces?: string | string[],
-    opts?: {
-      dataSource?: string;
-      cached?: Record<string, any>;
-      collectionNames?: string[];
-      /**
-       * 为 true 时允许查询所有关联字段
-       * 为 Array<string> 时仅允许查询指定的关联字段
-       */
-      association?: boolean | string[];
-      /**
-       * Max depth of recursion
-       */
-      maxDepth?: number;
-      allowAllTypes?: boolean;
-      /**
-       * 排除这些接口的字段
-       */
-      exceptInterfaces?: string[];
-      /**
-       * field value 的前缀，用 . 连接，比如 a.b.c
-       */
-      prefixFieldValue?: string;
-      /**
-       * 是否使用 prefixFieldValue 作为 field value
-       */
-      usePrefix?: boolean;
-    },
-  ) {
-    const {
-      association = false,
-      cached = {},
-      collectionNames = [collectionName],
-      maxDepth = 1,
-      allowAllTypes = false,
-      exceptInterfaces = [],
-      prefixFieldValue = '',
-      usePrefix = false,
-      dataSource: customDataSourceNameValue,
-    } = opts || {};
-
-    if (collectionNames.length - 1 > maxDepth) {
-      return;
+  getChildrenCollectionsName(name, isSupportView = false) {
+    const cacheKey = isSupportView ? 'supportView' : 'notSupportView';
+    if (this.childrenCollectionsName[cacheKey]) {
+      return this.childrenCollectionsName[cacheKey].slice();
     }
 
-    if (cached[collectionName]) {
-      // avoid infinite recursion
-      return _.cloneDeep(cached[collectionName]);
-    }
-
-    // Fetch the collection
-    const collection = this.getCollection(collectionName);
-    if (!collection) {
-      throw new Error(`Collection ${collectionName} not found`);
-    }
-
-    // Get the fields of the collection
-    const fields = collection.getFields(); // Assuming `getFields` returns an array of fields for the collection.
-
-    const options = fields
-      ?.filter(
-        (field) =>
-          field.interface &&
-          !exceptInterfaces.includes(field.interface) &&
-          (allowAllTypes ||
-            (type && type.includes(field.type)) ||
-            (interfaces && interfaces.includes(field.interface)) ||
-            (association && field.target && field.target !== collectionName && Array.isArray(association)
-              ? association.includes(field.interface)
-              : false)),
-      )
-      ?.map((field) => {
-        const result: CascaderProps<any>['options'][0] = {
-          value: usePrefix && prefixFieldValue ? `${prefixFieldValue}.${field.name}` : field.name,
-          label: field?.uiSchema?.title || field.name,
-          ...field,
-        };
+    const children: string[] = [];
+    const collections = [...this.getCollections()];
+    const getChildrenCollectionsInner = (collectionName: string) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return [...v.inherits]?.includes(collectionName);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        children.push(collectionKey);
+        return getChildrenCollectionsInner(collectionKey);
+      });
+      if (isSupportView) {
+        const sourceCollections = collections.filter((v: any) => {
+          return [...v.sources]?.length === 1 && v?.sources[0] === collectionName;
+        });
+        sourceCollections.forEach((v) => {
+          const collectionKey = v.name;
+          children.push(v.name);
+          return getChildrenCollectionsInner(collectionKey);
+        });
+      }
+      return _.uniq(children);
+    };
 
-        if (association && field.target) {
-          result.children = collectionNames.includes(field.target)
-            ? []
-            : this.getCollectionFieldsOptions(field.target, type, interfaces, {
-                ...opts,
-                cached,
-                dataSource: customDataSourceNameValue,
-                collectionNames: [...collectionNames, field.target],
-                prefixFieldValue: usePrefix
-                  ? prefixFieldValue
-                    ? `${prefixFieldValue}.${field.name}`
-                    : field.name
-                  : '',
-                usePrefix,
-              });
-
-          // If no children are found, don't return the field
-          if (!result.children?.length) {
-            return null;
+    this.childrenCollectionsName[cacheKey] = getChildrenCollectionsInner(name);
+    return this.childrenCollectionsName[cacheKey];
+  }
+
+  getAllCollectionsInheritChain(name) {
+    if (this.allCollectionsInheritChain) {
+      return this.allCollectionsInheritChain.slice();
+    }
+
+    const collectionsInheritChain = [name];
+    const getInheritChain = (name: string) => {
+      const collection = this.getCollection(name);
+      if (collection) {
+        const { inherits } = collection as any;
+        const children = this.getChildrenCollectionsName(name);
+        // 搜寻祖先表
+        if (inherits) {
+          for (let index = 0; index < inherits.length; index++) {
+            const collectionKey = inherits[index];
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
           }
         }
-        return result;
-      })
-      // Filter out null values (i.e., fields with no valid options)
-      .filter(Boolean);
+        // 搜寻后代表
+        if (children) {
+          for (let index = 0; index < children.length; index++) {
+            const collection = this.getCollection(children[index]);
+            const collectionKey = collection.name;
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
+        }
+      }
+      return collectionsInheritChain;
+    };
 
-    // Cache the result to avoid infinite recursion
-    cached[collectionName] = options;
-    return options;
+    this.allCollectionsInheritChain = getInheritChain(name);
+    return this.allCollectionsInheritChain || [];
   }
 }
 
@@ -486,6 +452,9 @@ export class Collection {
     if (typeof this.filterTargetKey === 'string') {
       return record[this.filterTargetKey];
     }
+    if (Array.isArray(this.filterTargetKey) && this.filterTargetKey.length === 1) {
+      return record[this.filterTargetKey[0]];
+    }
     return _.pick(record, this.filterTargetKey);
   }
 
@@ -527,7 +496,7 @@ export class Collection {
     return this.options.storage || 'local';
   }
   get title() {
-    return this.options.title ? this.flowEngine.translate(this.options.title) : this.name;
+    return this.flowEngine.translate(this.options.title, { ns: 'lm-collections' }) || this.name;
   }
 
   get titleCollectionField() {
@@ -800,8 +769,8 @@ export class CollectionField {
   }
 
   get title() {
-    const titleValue = this.options?.uiSchema?.title || this.options?.title || this.options.name;
-    return this.flowEngine.translate(titleValue);
+    const titleValue = this.options?.uiSchema?.title || this.options?.title;
+    return this.flowEngine.translate(titleValue, { ns: 'lm-collections' }) || this.options.name;
   }
 
   set title(value: string) {
@@ -815,13 +784,22 @@ export class CollectionField {
         if (typeof v !== 'object') {
           return v;
         }
+        if (v.value === null || v.value === undefined) {
+          return v;
+        }
         return {
           ...v,
+          label: v.label ? this.flowEngine.translate(v.label, { ns: 'lm-collections' }) : v.label,
           value: Number(v.value),
         };
       });
     }
-    return options;
+    return options.map((v) => {
+      return {
+        ...v,
+        label: this.flowEngine.translate(v.label, { ns: 'lm-collections' }),
+      };
+    });
   }
 
   get defaultValue() {