@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/components/settings/wrappers/embedded/FlowsSettingsContent.js

@@ -13,6 +13,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -39,50 +40,69 @@ __export(FlowsSettingsContent_exports, {
   default: () => FlowsSettingsContent_default
 });
 module.exports = __toCommonJS(FlowsSettingsContent_exports);
-var import_react = require("@formily/react");
 var import_antd = require("antd");
-var import_react2 = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_utils = require("../../../../utils");
 var import_FlowSettings = require("./FlowSettings");
+var import_reactive = require("../../../../reactive");
 const { Panel } = import_antd.Collapse;
-const FlowsSettingsContent = (0, import_react.observer)(({ model, expandAll = false }) => {
+const FlowsSettingsContent = (0, import_reactive.observer)(({ model, expandAll = false }) => {
   const flows = model.getFlows();
-  const filterFlows = Array.from(flows.values()).filter((flow) => {
-    const configurableSteps = Object.entries(flow.steps).map(([stepKey, actionStep]) => {
-      var _a, _b;
-      if (actionStep.hideInSettings) {
-        return null;
-      }
-      const stepUiSchema = actionStep.uiSchema || {};
-      let actionUiSchema = {};
-      if (actionStep.use) {
-        const action = (_b = (_a = model.flowEngine) == null ? void 0 : _a.getAction) == null ? void 0 : _b.call(_a, actionStep.use);
-        if (action && action.uiSchema) {
-          actionUiSchema = action.uiSchema;
+  const [filterFlows, setFilterFlows] = (0, import_react.useState)([]);
+  (0, import_react.useEffect)(() => {
+    let mounted = true;
+    const buildFilterFlows = /* @__PURE__ */ __name(async () => {
+      const result = [];
+      for (const flow of Array.from(flows.values())) {
+        const configurableSteps = await Promise.all(
+          Object.entries(flow.steps).map(async ([stepKey, actionStep]) => {
+            var _a, _b;
+            if (await (0, import_utils.shouldHideStepInSettings)(model, flow, actionStep)) {
+              return null;
+            }
+            const stepUiSchema = actionStep.uiSchema || {};
+            let actionUiSchema = {};
+            if (actionStep.use) {
+              const action = (_b = (_a = model.flowEngine) == null ? void 0 : _a.getAction) == null ? void 0 : _b.call(_a, actionStep.use);
+              if (action && action.uiSchema) {
+                actionUiSchema = action.uiSchema;
+              }
+            }
+            const mergedUiSchema = { ...actionUiSchema };
+            Object.entries(stepUiSchema).forEach(([fieldKey, schema]) => {
+              if (mergedUiSchema[fieldKey]) {
+                mergedUiSchema[fieldKey] = { ...mergedUiSchema[fieldKey], ...schema };
+              } else {
+                mergedUiSchema[fieldKey] = schema;
+              }
+            });
+            if (Object.keys(mergedUiSchema).length === 0) {
+              return null;
+            }
+            return { stepKey, step: actionStep, uiSchema: mergedUiSchema };
+          })
+        ).then((steps) => steps.filter(Boolean));
+        if (configurableSteps.length > 0) {
+          result.push(flow);
         }
       }
-      const mergedUiSchema = { ...actionUiSchema };
-      Object.entries(stepUiSchema).forEach(([fieldKey, schema]) => {
-        if (mergedUiSchema[fieldKey]) {
-          mergedUiSchema[fieldKey] = { ...mergedUiSchema[fieldKey], ...schema };
-        } else {
-          mergedUiSchema[fieldKey] = schema;
-        }
-      });
-      if (Object.keys(mergedUiSchema).length === 0) {
-        return null;
+      if (mounted) {
+        setFilterFlows(result);
       }
-      return { stepKey, step: actionStep, uiSchema: mergedUiSchema };
-    }).filter(Boolean);
-    return configurableSteps.length > 0;
-  });
+    }, "buildFilterFlows");
+    buildFilterFlows();
+    return () => {
+      mounted = false;
+    };
+  }, [model, flows]);
   const flowKeys = filterFlows.map((flow) => flow.key);
   if (flowKeys.length === 0) {
-    return /* @__PURE__ */ import_react2.default.createElement(import_antd.Empty, { description: "\u6CA1\u6709\u53EF\u7528\u7684\u6D41\u7A0B" });
+    return /* @__PURE__ */ import_react.default.createElement(import_antd.Empty, { description: "\u6CA1\u6709\u53EF\u7528\u7684\u6D41\u7A0B" });
   }
   const defaultActiveKey = expandAll ? flowKeys : void 0;
-  return /* @__PURE__ */ import_react2.default.createElement(import_antd.Card, { title: "Flows\u8BBE\u7F6E" }, /* @__PURE__ */ import_react2.default.createElement(import_antd.Collapse, { defaultActiveKey }, flowKeys.map((flowKey) => {
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Card, { title: "Flows\u8BBE\u7F6E" }, /* @__PURE__ */ import_react.default.createElement(import_antd.Collapse, { defaultActiveKey }, flowKeys.map((flowKey) => {
     var _a;
-    return /* @__PURE__ */ import_react2.default.createElement(Panel, { header: ((_a = flows.get(flowKey)) == null ? void 0 : _a.title) || flowKey, key: flowKey }, /* @__PURE__ */ import_react2.default.createElement(import_FlowSettings.FlowSettings, { model, flowKey }));
+    return /* @__PURE__ */ import_react.default.createElement(Panel, { header: ((_a = flows.get(flowKey)) == null ? void 0 : _a.title) || flowKey, key: flowKey }, /* @__PURE__ */ import_react.default.createElement(import_FlowSettings.FlowSettings, { model, flowKey }));
   })));
 });
 var FlowsSettingsContent_default = FlowsSettingsContent;

package/lib/components/subModel/AddSubModelButton.d.ts

@@ -15,11 +15,18 @@ type CreateModelOptionsStringUse = Omit<CreateModelOptions, 'use'> & {
     use?: string;
 };
 type CreateModelOptionsFn = (ctx: FlowModelContext, extra?: any) => CreateModelOptionsStringUse | Promise<CreateModelOptionsStringUse>;
+type HideOrFactory = boolean | ((ctx: FlowModelContext) => boolean | Promise<boolean>);
 export interface SubModelItem {
     key?: string;
     label?: string | React.ReactNode;
     type?: 'group' | 'divider';
     disabled?: boolean;
+    /**
+     * 动态隐藏菜单项（支持异步）。与模型 meta.hide 语义一致。
+     * - `true` 表示隐藏
+     * - function(ctx) 返回 true 表示隐藏
+     */
+    hide?: HideOrFactory;
     icon?: React.ReactNode;
     children?: false | SubModelItemsType;
     createModelOptions?: CreateModelOptionsStringUse | CreateModelOptionsFn;

package/lib/components/subModel/AddSubModelButton.js

@@ -114,6 +114,7 @@ const hasToggleItems = /* @__PURE__ */ __name((items) => {
   const walk = /* @__PURE__ */ __name((nodes) => {
     for (const node of nodes) {
       if (!node) continue;
+      if (typeof node.hide === "function") return true;
       if (!node.children && (node.toggleDetector || node.toggleable)) return true;
       if (Array.isArray(node.children)) {
         if (walk(node.children)) return true;
@@ -125,14 +126,70 @@ const hasToggleItems = /* @__PURE__ */ __name((items) => {
   }, "walk");
   return walk(items);
 }, "hasToggleItems");
+const isHidden = /* @__PURE__ */ __name(async (item, ctx) => {
+  const hide = item.hide;
+  if (!hide) return false;
+  if (typeof hide === "function") {
+    return !!await hide(ctx);
+  }
+  return !!hide;
+}, "isHidden");
+const hasVisibleSubModelItems = /* @__PURE__ */ __name(async (items, ctx) => {
+  for (const item of items) {
+    if (!item) continue;
+    try {
+      if (await isHidden(item, ctx)) continue;
+    } catch (e) {
+      console.error("[NocoBase]: Failed to resolve item.hide:", e);
+    }
+    if (Array.isArray(item.children)) {
+      const hasVisibleChildren = await hasVisibleSubModelItems(item.children, ctx);
+      if (hasVisibleChildren) return true;
+      if (item.type === "group" || !item.createModelOptions) {
+        continue;
+      }
+      return true;
+    }
+    if (typeof item.children === "function") {
+      return true;
+    }
+    return true;
+  }
+  return false;
+}, "hasVisibleSubModelItems");
 const transformSubModelItems = /* @__PURE__ */ __name(async (items, model, subModelKey, subModelType) => {
   if (items.length === 0) return [];
+  const hidden = await Promise.all(
+    items.map(async (item) => {
+      if (!item) return true;
+      try {
+        return await isHidden(item, model.context);
+      } catch (e) {
+        console.error("[NocoBase]: Failed to resolve item.hide:", e);
+        return false;
+      }
+    })
+  );
+  const visibleItems = items.filter((item, idx) => !!item && !hidden[idx]);
+  if (visibleItems.length === 0) return [];
   const toggleItems = [];
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    if (item.toggleable && item.useModel) {
+  for (let i = 0; i < visibleItems.length; i++) {
+    const item = visibleItems[i];
+    let resolvedUseModel = item.useModel;
+    if (!resolvedUseModel && item.toggleable) {
+      try {
+        const createOpts = await getCreateModelOptions(item, model.context);
+        resolvedUseModel = createOpts == null ? void 0 : createOpts.use;
+        if (resolvedUseModel) {
+          item.useModel = resolvedUseModel;
+        }
+      } catch (error) {
+        console.error("[NocoBase]: Failed to resolve useModel for toggleable item:", error);
+      }
+    }
+    if (item.toggleable && resolvedUseModel) {
       item.toggleDetector = (ctx) => {
-        const C = ctx.engine.getModelClass(item.useModel);
+        const C = ctx.engine.getModelClass(resolvedUseModel);
         const r = ctx.model.findSubModel(subModelKey, (m) => {
           if (item.toggleable === true) {
             return m.constructor === C;
@@ -143,7 +200,7 @@ const transformSubModelItems = /* @__PURE__ */ __name(async (items, model, subMo
         return !!r;
       };
       item.customRemove = async (ctx, item2) => {
-        const C = ctx.engine.getModelClass(item2.useModel);
+        const C = ctx.engine.getModelClass(resolvedUseModel);
         const r = ctx.model.findSubModel(subModelKey, (m) => {
           if (item2.toggleable === true) {
             return m.constructor === C;
@@ -168,7 +225,7 @@ const transformSubModelItems = /* @__PURE__ */ __name(async (items, model, subMo
     const result = toggleResults[i];
     toggleMap.set(index, result.status === "fulfilled" ? result.value : false);
   });
-  const transformPromises = items.map(async (item, index) => {
+  const transformPromises = visibleItems.map(async (item, index) => {
     const transformedItem = {
       key: item.key,
       label: item.label,
@@ -191,12 +248,24 @@ const transformSubModelItems = /* @__PURE__ */ __name(async (items, model, subMo
         const staticChildren = item.children;
         const childHasToggle = hasToggleItems(staticChildren);
         if (childHasToggle) {
-          transformedItem.children = async () => transformSubModelItems(staticChildren, model, subModelKey, subModelType);
+          const hasVisibleChildren = await hasVisibleSubModelItems(staticChildren, model.context);
+          if (!hasVisibleChildren) {
+            if (item.type === "group" || !item.createModelOptions) {
+              return null;
+            }
+          } else {
+            transformedItem.children = async () => transformSubModelItems(staticChildren, model, subModelKey, subModelType);
+          }
         } else {
           transformedItem.children = await transformSubModelItems(staticChildren, model, subModelKey, subModelType);
         }
       }
     }
+    if (Array.isArray(transformedItem.children) && transformedItem.children.length === 0) {
+      if (item.type === "group" || !item.createModelOptions) {
+        return null;
+      }
+    }
     if (item.toggleDetector && !item.children) {
       const isToggled = toggleMap.get(index) || false;
       const originalLabel = model.translate(item.label) || "";
@@ -206,7 +275,8 @@ const transformSubModelItems = /* @__PURE__ */ __name(async (items, model, subMo
     }
     return transformedItem;
   });
-  return Promise.all(transformPromises);
+  const transformed = await Promise.all(transformPromises);
+  return transformed.filter((item) => !!item);
 }, "transformSubModelItems");
 const transformItems = /* @__PURE__ */ __name((items, model, subModelKey, subModelType) => {
   if (typeof items === "function") {

package/lib/components/subModel/LazyDropdown.js

@@ -342,20 +342,18 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
       }
       setRootItems(resolvedItems);
     }, "loadRootItems");
-    if (menuVisible) {
-      loadRootItems();
-    }
-  }, [menuVisible, stateVersion, menuItems]);
+    loadRootItems();
+  }, [stateVersion, menuItems]);
   function buildSearchChildren(children, item, keyPath, path, menuVisible2, resolve) {
     const searchKey = keyPath;
     const currentSearchValue = searchValues[searchKey] || "";
-    const filteredChildren = currentSearchValue ? (/* @__PURE__ */ __name(function deepFilter(items) {
+    const filteredChildren = currentSearchValue ? (/* @__PURE__ */ __name(function deepFilter(items2) {
       const searchText = currentSearchValue.toLowerCase();
       const tryString = /* @__PURE__ */ __name((v) => {
         if (!v) return "";
         return typeof v === "string" ? v : String(v);
       }, "tryString");
-      return items.map((child) => {
+      return items2.map((child) => {
         const labelStr = tryString(child.label).toLowerCase();
         const selfMatch = labelStr.includes(searchText) || child.key && String(child.key).toLowerCase().includes(searchText);
         if (child.type === "group" && Array.isArray(child.children)) {
@@ -377,8 +375,8 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
     return [searchItem, dividerItem, ...resolvedFiltered];
   }
   __name(buildSearchChildren, "buildSearchChildren");
-  const resolveItems = /* @__PURE__ */ __name((items, path = []) => {
-    return items.map((item) => {
+  const resolveItems = /* @__PURE__ */ __name((items2, path = []) => {
+    return items2.map((item) => {
       const keyPath = getKeyPath(path, item.key);
       const isGroup = item.type === "group";
       const hasAsyncChildren = typeof item.children === "function";
@@ -483,6 +481,13 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
       }
     `;
   }, [dropdownMaxHeight]);
+  const items = rootLoading && rootItems.length === 0 ? [
+    {
+      key: "root-loading",
+      label: /* @__PURE__ */ import_react.default.createElement(import_antd.Spin, { size: "small" }),
+      disabled: true
+    }
+  ] : resolveItems(rootItems);
   return /* @__PURE__ */ import_react.default.createElement(
     import_antd.Dropdown,
     {
@@ -493,13 +498,7 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
       placement: "bottomLeft",
       menu: {
         ...dropdownMenuProps,
-        items: rootLoading && rootItems.length === 0 ? [
-          {
-            key: "root-loading",
-            label: /* @__PURE__ */ import_react.default.createElement(import_antd.Spin, { size: "small" }),
-            disabled: true
-          }
-        ] : resolveItems(rootItems),
+        items,
         onClick: /* @__PURE__ */ __name(() => {
         }, "onClick"),
         style: {

package/lib/components/subModel/utils.d.ts

@@ -10,7 +10,7 @@ import type { Collection } from '../../data-source';
 import { FlowModelContext } from '../../flowContext';
 import { ModelConstructor } from '../../types';
 import { SubModelItem } from './AddSubModelButton';
-export declare function buildSubModelItem(M: ModelConstructor, ctx: FlowModelContext, skipHide?: boolean): SubModelItem;
+export declare function buildSubModelItem(M: ModelConstructor, ctx: FlowModelContext, skipHide?: boolean): Promise<SubModelItem | undefined>;
 export declare function buildItems(subModelBaseClass: string | ModelConstructor): (ctx: FlowModelContext) => Promise<any>;
 export declare function buildSubModelItems(subModelBaseClass: string | ModelConstructor, exclude?: any[]): (ctx: FlowModelContext) => Promise<SubModelItem[]>;
 export declare function buildSubModelGroups(subModelBaseClasses?: (string | ModelConstructor)[]): (ctx: FlowModelContext) => Promise<SubModelItem[]>;

package/lib/components/subModel/utils.js

@@ -46,9 +46,16 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var _ = __toESM(require("lodash"));
 var import_utils = require("../../utils");
-function buildSubModelItem(M, ctx, skipHide = false) {
+async function callHideFunction(hide, ctx) {
+  if (typeof hide === "function") {
+    return await hide(ctx);
+  }
+  return hide;
+}
+__name(callHideFunction, "callHideFunction");
+async function buildSubModelItem(M, ctx, skipHide = false) {
   const meta = M.meta ?? {};
-  if (meta.hide && !skipHide) {
+  if (await callHideFunction(meta.hide, ctx) && !skipHide) {
     return;
   }
   const item = {
@@ -127,12 +134,15 @@ function buildItems(subModelBaseClass) {
 __name(buildItems, "buildItems");
 function buildSubModelItems(subModelBaseClass, exclude = []) {
   return async (ctx) => {
-    var _a;
+    var _a, _b;
     const SubModelClasses = ctx.engine.getSubclassesOf(subModelBaseClass);
-    let candidates = Array.from(SubModelClasses.values()).filter((C) => {
-      var _a2;
-      return !((_a2 = C.meta) == null ? void 0 : _a2.hide);
-    }).filter((C) => {
+    let candidates = [];
+    for (const C of Array.from(SubModelClasses.values())) {
+      if (!await callHideFunction((_a = C.meta) == null ? void 0 : _a.hide, ctx)) {
+        candidates.push(C);
+      }
+    }
+    candidates = candidates.filter((C) => {
       for (const P of exclude) {
         if (typeof P === "string") {
           if (C.name === P) return false;
@@ -142,18 +152,18 @@ function buildSubModelItems(subModelBaseClass, exclude = []) {
       }
       return true;
     }).sort((A, B) => {
-      var _a2, _b;
-      return (((_a2 = A.meta) == null ? void 0 : _a2.sort) ?? 1e3) - (((_b = B.meta) == null ? void 0 : _b.sort) ?? 1e3);
+      var _a2, _b2;
+      return (((_a2 = A.meta) == null ? void 0 : _a2.sort) ?? 1e3) - (((_b2 = B.meta) == null ? void 0 : _b2.sort) ?? 1e3);
     });
     if (candidates.length === 0) {
       const BaseClass = typeof subModelBaseClass === "string" ? ctx.engine.getModelClass(subModelBaseClass) : subModelBaseClass;
-      if (BaseClass && !((_a = BaseClass.meta) == null ? void 0 : _a.hide)) {
+      if (BaseClass && !await callHideFunction((_b = BaseClass.meta) == null ? void 0 : _b.hide, ctx)) {
         candidates = [BaseClass];
       }
     }
     const items = [];
     for (const M of candidates) {
-      const item = buildSubModelItem(M, ctx);
+      const item = await buildSubModelItem(M, ctx);
       if (item) items.push(item);
     }
     return items;

package/lib/components/variables/VariableInput.js

@@ -94,6 +94,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   showValueComponent = true,
   onlyLeafSelectable = false,
   clearValue,
+  ignoreFieldNames,
   ...restProps
 }) => {
   const [currentMetaTreeNode, setCurrentMetaTreeNode] = (0, import_react.useState)(null);
@@ -143,7 +144,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   }, [currentMetaTreeNode, innerValue, resolvedMetaTree, resolvePathFromValue]);
   (0, import_react.useEffect)(() => {
     const restoreFromValue = /* @__PURE__ */ __name(async () => {
-      if (!Array.isArray(resolvedMetaTree) || !value) return;
+      if (!Array.isArray(resolvedMetaTree) || value == null) return;
       if (currentMetaTreeNode) {
         return;
       }
@@ -196,7 +197,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   }, [renderInputComponent, resolvedMetaTreeNode, innerValue]);
   (0, import_react.useEffect)(() => {
     if (!resolvedMetaTreeNode) return;
-    if (!Array.isArray(resolvedMetaTree) || !innerValue) return;
+    if (!Array.isArray(resolvedMetaTree) || innerValue == null) return;
     const finalValue = (resolveValueFromPath == null ? void 0 : resolveValueFromPath(resolvedMetaTreeNode)) || innerValue;
     emitChange(finalValue, resolvedMetaTreeNode);
     setCurrentMetaTreeNode(resolvedMetaTreeNode);
@@ -229,30 +230,48 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
   );
   const handleVariableSelect = (0, import_react.useCallback)(
     (variableValue, metaTreeNode) => {
+      if (!metaTreeNode && variableValue === "") {
+        const cleared = clearValue !== void 0 ? clearValue : null;
+        setInnerValue(cleared);
+        emitChange(cleared);
+        return;
+      }
       setCurrentMetaTreeNode(metaTreeNode);
       const finalValue = (resolveValueFromPath == null ? void 0 : resolveValueFromPath(metaTreeNode)) || variableValue;
       setInnerValue(finalValue);
       emitChange(finalValue, metaTreeNode);
     },
-    [emitChange, resolveValueFromPath]
+    [emitChange, resolveValueFromPath, clearValue]
   );
   const { disabled } = restProps;
   const handleClear = (0, import_react.useCallback)(() => {
     if (disabled) {
       return;
     }
-    setCurrentMetaTreeNode(null);
     const cleared = clearValue !== void 0 ? clearValue : null;
     setInnerValue(cleared);
+    try {
+      const path = resolvePathFromValue == null ? void 0 : resolvePathFromValue(cleared);
+      if (Array.isArray(resolvedMetaTree) && path && path.length > 0) {
+        const node = findMetaTreeNodeByPath(resolvedMetaTree, path);
+        if (node) {
+          setCurrentMetaTreeNode(node);
+          emitChange(cleared, node);
+          return;
+        }
+      }
+    } catch (_) {
+    }
+    setCurrentMetaTreeNode(null);
     emitChange(cleared);
-  }, [emitChange, disabled, clearValue]);
+  }, [emitChange, disabled, clearValue, resolvedMetaTree, resolvePathFromValue]);
   const stableProps = (0, import_react.useMemo)(() => {
     const { style, onFocus, onBlur, disabled: disabled2, ...otherProps } = restProps;
     return { style, onFocus, onBlur, otherProps };
   }, [restProps]);
   const inputProps = (0, import_react.useMemo)(() => {
     const baseProps = {
-      value: innerValue || "",
+      value: ValueComponent === import_antd.Input ? innerValue ?? "" : innerValue,
       onChange: handleInputChange,
       disabled
     };
@@ -311,6 +330,7 @@ const VariableInputComponent = /* @__PURE__ */ __name(({
       parseValueToPath: resolvePathFromValue,
       formatPathToValue: resolveValueFromPath,
       onlyLeafSelectable,
+      ignoreFieldNames,
       ...!showValueComponent && { children: null, placeholder: restProps == null ? void 0 : restProps.placeholder }
     }
   ));

package/lib/components/variables/VariableTag.js

@@ -63,8 +63,49 @@ const VariableTagComponent = /* @__PURE__ */ __name(({
         return metaTreeNode.parentTitles ? [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join("/") : ctx.t(metaTreeNode.title) || "";
       }
       if (!value) return String(value);
-      const path = (0, import_utils.parseValueToPath)(value);
-      return path ? path.join("/") : String(value);
+      const rawPath = (0, import_utils.parseValueToPath)(value);
+      if (!rawPath || !Array.isArray(resolvedMetaTree)) {
+        return Array.isArray(rawPath) ? rawPath.join("/") : String(value);
+      }
+      const topNames = new Set((resolvedMetaTree || []).map((n) => String(n == null ? void 0 : n.name)));
+      const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
+      if (!path.length) return "";
+      let nodes = resolvedMetaTree;
+      let deepest = null;
+      let matchedCount = 0;
+      for (let i = 0; i < path.length; i++) {
+        if (!nodes) break;
+        const seg = String(path[i]);
+        const node = nodes.find((n) => String(n == null ? void 0 : n.name) === seg);
+        if (!node) break;
+        deepest = node;
+        matchedCount = i + 1;
+        if (i < path.length - 1) {
+          if (Array.isArray(node.children)) {
+            nodes = node.children;
+          } else if (typeof node.children === "function") {
+            try {
+              const childNodes = await node.children();
+              node.children = childNodes;
+              nodes = childNodes;
+            } catch {
+              nodes = void 0;
+            }
+          } else {
+            nodes = void 0;
+          }
+        }
+      }
+      if (deepest) {
+        const titles = deepest.parentTitles ? [...deepest.parentTitles, deepest.title] : [deepest.title];
+        let label = titles.map(ctx.t).join("/");
+        if (matchedCount < path.length) {
+          const tail = path.slice(matchedCount).join("/");
+          label = tail ? `${label}/${tail}` : label;
+        }
+        return label;
+      }
+      return path.join("/");
     },
     { refreshDeps: [resolvedMetaTree, value, metaTreeNode] }
   );

package/lib/components/variables/types.d.ts

@@ -18,6 +18,7 @@ export interface FlowContextSelectorProps extends Omit<CascaderProps<ContextSele
     formatPathToValue?: (item: MetaTreeNode) => string;
     open?: boolean;
     onlyLeafSelectable?: boolean;
+    ignoreFieldNames?: string[];
 }
 export interface ContextSelectorItem {
     label: React.ReactNode;
@@ -62,6 +63,7 @@ export interface VariableInputProps {
      * 默认行为为 null；可设置为 '' 等，以便清空后默认切换为“常量-空字符串”。
      */
     clearValue?: any;
+    ignoreFieldNames?: string[];
     [key: string]: any;
 }
 export interface VariableTagProps {

package/lib/components/variables/utils.js

@@ -92,6 +92,8 @@ const buildContextSelectorItems = /* @__PURE__ */ __name((metaTree) => {
     return [];
   }
   const convertNode = /* @__PURE__ */ __name((node) => {
+    const hidden = !!(typeof node.hidden === "function" ? node.hidden() : node.hidden);
+    if (hidden) return null;
     const hasChildren = !!(node.children && (typeof node.children === "function" || Array.isArray(node.children) && node.children.length > 0));
     const disabled = !!(typeof node.disabled === "function" ? node.disabled() : node.disabled);
     const option = {
@@ -103,11 +105,11 @@ const buildContextSelectorItems = /* @__PURE__ */ __name((metaTree) => {
       disabled
     };
     if (Array.isArray(node.children) && node.children.length > 0) {
-      option.children = node.children.map((child) => convertNode(child));
+      option.children = node.children.map((child) => convertNode(child)).filter((item) => item !== null);
     }
     return option;
   }, "convertNode");
-  return metaTree.map((node) => convertNode(node));
+  return metaTree.map((node) => convertNode(node)).filter((item) => item !== null);
 }, "buildContextSelectorItems");
 const preloadContextSelectorPath = /* @__PURE__ */ __name(async (options, pathSegments, triggerUpdate) => {
   if (!options || !Array.isArray(options) || !pathSegments || pathSegments.length === 0) return;

package/lib/data-source/index.d.ts

@@ -49,7 +49,9 @@ export declare class DataSource {
     addCollection(collection: Collection | CollectionOptions): void;
     updateCollection(newOptions: CollectionOptions): void;
     upsertCollection(options: CollectionOptions): Collection;
-    upsertCollections(collections: CollectionOptions[]): void;
+    upsertCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     removeCollection(name: string): void;
     clearCollections(): void;
     setOptions(newOptions?: any): void;
@@ -64,18 +66,30 @@ export interface CollectionOptions {
 export declare class CollectionManager {
     dataSource: DataSource;
     collections: Map<string, Collection>;
+    allCollectionsInheritChain: string[];
+    protected childrenCollectionsName: {
+        supportView?: string[];
+        notSupportView?: string[];
+    };
     constructor(dataSource: DataSource);
     get flowEngine(): FlowEngine;
     addCollection(collection: Collection | CollectionOptions): void;
     removeCollection(name: string): void;
-    updateCollection(newOptions: CollectionOptions): void;
+    updateCollection(newOptions: CollectionOptions, options?: {
+        clearFields?: boolean;
+    }): void;
     upsertCollection(options: CollectionOptions): Collection;
-    upsertCollections(collections: CollectionOptions[]): void;
+    upsertCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];
     getCollection(name: string): Collection | undefined;
     getCollections(): Collection[];
     clearCollections(): void;
     getAssociation(associationName: string): CollectionField | undefined;
+    getChildrenCollections(name: any): any[];
+    getChildrenCollectionsName(name: any, isSupportView?: boolean): string[];
+    getAllCollectionsInheritChain(name: any): string[];
 }
 export declare class Collection {
     fields: Map<string, CollectionField>;
@@ -83,7 +97,9 @@ export declare class Collection {
     inherits: Map<string, Collection>;
     dataSource: DataSource;
     constructor(options?: Record<string, any>);
+    clone(): Collection;
     getFilterByTK(record: any): any;
+    get titleableFields(): CollectionField[];
     get hidden(): any;
     get flowEngine(): FlowEngine;
     get collectionManager(): CollectionManager;
@@ -97,7 +113,9 @@ export declare class Collection {
     get titleCollectionField(): CollectionField;
     initInherits(): void;
     setDataSource(dataSource: DataSource): void;
-    setOptions(newOptions?: any): void;
+    setOptions(newOptions?: any, options?: {
+        clearFields?: boolean;
+    }): void;
     getFields(): CollectionField[];
     getToOneAssociationFields(): CollectionField[];
     getAssociationFields(types?: any[]): CollectionField[];
@@ -140,6 +158,7 @@ export declare class CollectionField {
     get resourceName(): string;
     get collectionName(): any;
     get readonly(): any;
+    get titleable(): boolean;
     get fullpath(): string;
     get name(): any;
     get type(): any;