@nocobase/flow-engine 2.1.0-alpha.40 → 2.1.0-alpha.46

package/lib/FlowContextProvider.d.ts

@@ -8,7 +8,7 @@
  */
 import React from 'react';
 import { FlowContext, FlowEngineContext } from './flowContext';
-import { FlowView } from './views/FlowView';
+import { FlowView, FlowViewer } from './views/FlowView';
 export declare const FlowReactContext: React.Context<FlowContext>;
 export declare const FlowViewContext: React.Context<FlowContext>;
 export declare function FlowContextProvider(props: {
@@ -22,3 +22,7 @@ export declare const FlowViewContextProvider: React.MemoExoticComponent<(props:
 export declare function useFlowContext<T = FlowEngineContext>(): T;
 export declare function useFlowViewContext<T = FlowEngineContext>(): T;
 export declare function useFlowView(): FlowView;
+/**
+ * Access the `FlowViewer` that opens new drawers / modals / pages (`viewer.drawer({...})`, `viewer.modal({...})`, etc.). This is the counterpart to `useFlowView()`: `useFlowView()` returns the *current* mounted view (use it to close yourself, render Header/Footer slots, etc.), while `useFlowViewer()` returns the surface that lets you open a *new* view from inside any flow-context subtree.
+ */
+export declare function useFlowViewer(): FlowViewer;

package/lib/FlowContextProvider.js

@@ -43,7 +43,8 @@ __export(FlowContextProvider_exports, {
   FlowViewContextProvider: () => FlowViewContextProvider,
   useFlowContext: () => useFlowContext,
   useFlowView: () => useFlowView,
-  useFlowViewContext: () => useFlowViewContext
+  useFlowViewContext: () => useFlowViewContext,
+  useFlowViewer: () => useFlowViewer
 });
 module.exports = __toCommonJS(FlowContextProvider_exports);
 var import_react = __toESM(require("react"));
@@ -70,6 +71,11 @@ function useFlowView() {
   return ctx.view;
 }
 __name(useFlowView, "useFlowView");
+function useFlowViewer() {
+  const ctx = useFlowContext();
+  return ctx.viewer;
+}
+__name(useFlowViewer, "useFlowViewer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FlowContextProvider,
@@ -78,5 +84,6 @@ __name(useFlowView, "useFlowView");
   FlowViewContextProvider,
   useFlowContext,
   useFlowView,
-  useFlowViewContext
+  useFlowViewContext,
+  useFlowViewer
 });

package/lib/components/settings/wrappers/contextual/DefaultSettingsIcon.js

@@ -183,6 +183,13 @@ const getToolbarPopupContainer = /* @__PURE__ */ __name((triggerNode) => {
   }
   return triggerNode.closest(TOOLBAR_ICONS_SELECTOR) || triggerNode.closest(TOOLBAR_CONTAINER_SELECTOR);
 }, "getToolbarPopupContainer");
+const removeExtraMenuItemClickHandlers = /* @__PURE__ */ __name((item) => {
+  const { onClick: _onClick, children, ...rest } = item;
+  return {
+    ...rest,
+    children: (children == null ? void 0 : children.length) ? children.map(removeExtraMenuItemClickHandlers) : void 0
+  };
+}, "removeExtraMenuItemClickHandlers");
 const DefaultSettingsIcon = /* @__PURE__ */ __name(({
   model,
   showDeleteButton = true,
@@ -200,8 +207,17 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
   const [visible, setVisible] = (0, import_react.useState)(false);
   const [refreshTick, setRefreshTick] = (0, import_react.useState)(0);
   const [extraMenuItems, setExtraMenuItems] = (0, import_react.useState)([]);
+  const [extraMenuItemsLoaded, setExtraMenuItemsLoaded] = (0, import_react.useState)(false);
   const [configurableFlowsAndSteps, setConfigurableFlowsAndSteps] = (0, import_react.useState)([]);
   const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const commonExtras = (0, import_react.useMemo)(
+    () => extraMenuItems.filter((it) => it.group === "common-actions").sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0)),
+    [extraMenuItems]
+  );
+  const hasCommonActions = showCopyUidButton || showDeleteButton || commonExtras.length > 0;
+  const shouldDeferConfigLoading = flattenSubMenus && menuLevels > 1 && hasCommonActions;
+  const shouldWaitForCommonActionProbe = flattenSubMenus && menuLevels > 1 && !showCopyUidButton && !showDeleteButton && !extraMenuItemsLoaded;
+  const canRenderIcon = hasCommonActions || !isLoading && configurableFlowsAndSteps.length > 0;
   const closeDropdown = (0, import_react.useCallback)(() => {
     setVisible(false);
     onDropdownVisibleChange == null ? void 0 : onDropdownVisibleChange(false);
@@ -233,24 +249,28 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
     let mounted = true;
     const loadExtras = /* @__PURE__ */ __name(async () => {
       var _a;
-      const allExtras = [];
-      const modelsToProcess = [];
-      walkSubModels(model, { maxDepth: menuLevels, arrayLimit: 50, mode: "stack" }, (targetModel, { modelKey }) => {
-        modelsToProcess.push({ model: targetModel, modelKey });
-      });
-      for (const { model: targetModel, modelKey } of modelsToProcess) {
-        const Cls = targetModel.constructor;
-        const extras = await ((_a = Cls.getExtraMenuItems) == null ? void 0 : _a.call(Cls, targetModel, t));
-        if (extras == null ? void 0 : extras.length) {
-          allExtras.push(
-            ...extras.map((item) => ({
-              ...item,
-              key: modelKey ? `${modelKey}:${item.key}` : item.key
-            }))
-          );
+      setExtraMenuItemsLoaded(false);
+      try {
+        const allExtras = [];
+        const modelsToProcess = [];
+        walkSubModels(model, { maxDepth: menuLevels, arrayLimit: 50, mode: "stack" }, (targetModel, { modelKey }) => {
+          modelsToProcess.push({ model: targetModel, modelKey });
+        });
+        for (const { model: targetModel, modelKey } of modelsToProcess) {
+          const Cls = targetModel.constructor;
+          const extras = await ((_a = Cls.getExtraMenuItems) == null ? void 0 : _a.call(Cls, targetModel, t));
+          if (extras == null ? void 0 : extras.length) {
+            allExtras.push(
+              ...extras.map((item) => ({
+                ...item,
+                key: modelKey ? `${modelKey}:${item.key}` : item.key
+              }))
+            );
+          }
+        }
+        if (!mounted) {
+          return;
         }
-      }
-      if (mounted) {
         const seen = /* @__PURE__ */ new Set();
         const dedupedExtras = allExtras.filter((item) => {
           if (seen.has(`${item.key}`)) {
@@ -260,15 +280,22 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
           return true;
         });
         setExtraMenuItems(dedupedExtras);
+      } catch (error) {
+        console.error("Failed to load extra menu items:", error);
+        if (mounted) {
+          setExtraMenuItems([]);
+        }
+      } finally {
+        if (mounted) {
+          setExtraMenuItemsLoaded(true);
+        }
       }
     }, "loadExtras");
-    if (visible) {
-      loadExtras();
-    }
+    loadExtras();
     return () => {
       mounted = false;
     };
-  }, [model, menuLevels, t, refreshTick, visible]);
+  }, [model, menuLevels, t, refreshTick]);
   const copyUidToClipboard = (0, import_react.useCallback)(
     async (uid) => {
       var _a;
@@ -513,7 +540,7 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
         return [];
       }
     },
-    []
+    [t]
   );
   const getConfigurableFlowsAndSteps = (0, import_react.useCallback)(async () => {
     const result = [];
@@ -551,20 +578,47 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
     };
   }, [model, menuLevels, refreshTick]);
   (0, import_react.useEffect)(() => {
+    let mounted = true;
     const loadConfigurableFlowsAndSteps = /* @__PURE__ */ __name(async () => {
       setIsLoading(true);
+      if (shouldDeferConfigLoading) {
+        setConfigurableFlowsAndSteps([]);
+      }
       try {
         const flows = await getConfigurableFlowsAndSteps();
-        setConfigurableFlowsAndSteps(flows);
+        if (mounted) {
+          setConfigurableFlowsAndSteps(flows);
+        }
       } catch (error) {
         console.error("Failed to load configurable flows and steps:", error);
-        setConfigurableFlowsAndSteps([]);
+        if (mounted) {
+          setConfigurableFlowsAndSteps([]);
+        }
       } finally {
-        setIsLoading(false);
+        if (mounted) {
+          setIsLoading(false);
+        }
       }
     }, "loadConfigurableFlowsAndSteps");
+    if (shouldWaitForCommonActionProbe) {
+      setConfigurableFlowsAndSteps([]);
+      setIsLoading(false);
+      return () => {
+        mounted = false;
+      };
+    }
+    if (!visible && shouldDeferConfigLoading) {
+      setConfigurableFlowsAndSteps([]);
+      setIsLoading(false);
+      return () => {
+        mounted = false;
+      };
+    }
     loadConfigurableFlowsAndSteps();
-  }, [getConfigurableFlowsAndSteps, refreshTick]);
+    return () => {
+      mounted = false;
+    };
+  }, [getConfigurableFlowsAndSteps, refreshTick, shouldDeferConfigLoading, shouldWaitForCommonActionProbe, visible]);
   const menuItems = (0, import_react.useMemo)(() => {
     const items = [];
     const keyCounter = /* @__PURE__ */ new Map();
@@ -689,16 +743,15 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
       }
     }
     return items;
-  }, [configurableFlowsAndSteps, disabledIconColor, flattenSubMenus, t]);
+  }, [configurableFlowsAndSteps, disabledIconColor, flattenSubMenus, message, model, t]);
   const finalMenuItems = (0, import_react.useMemo)(() => {
     const items = [...menuItems];
-    const commonExtras = extraMenuItems.filter((it) => it.group === "common-actions").sort((a, b) => (a.sort ?? 0) - (b.sort ?? 0));
     if (showCopyUidButton || showDeleteButton || commonExtras.length > 0) {
       items.push({
         type: "divider"
       });
       if (commonExtras.length > 0) {
-        items.push(...commonExtras);
+        items.push(...commonExtras.map(removeExtraMenuItemClickHandlers));
       }
       if (showCopyUidButton && model.uid) {
         items.push({
@@ -714,9 +767,8 @@ const DefaultSettingsIcon = /* @__PURE__ */ __name(({
       }
     }
     return items;
-  }, [menuItems, showCopyUidButton, showDeleteButton, model.uid, model.destroy, t, extraMenuItems]);
-  const hasExtras = extraMenuItems.some((it) => it.group === "common-actions");
-  if (isLoading || configurableFlowsAndSteps.length === 0 && !showDeleteButton && !showCopyUidButton && !hasExtras) {
+  }, [menuItems, showCopyUidButton, showDeleteButton, commonExtras, model.uid, model.destroy, t]);
+  if (!canRenderIcon) {
     return null;
   }
   if (!model || !model.uid) {

package/lib/components/subModel/LazyDropdown.js

@@ -169,16 +169,66 @@ const useKeepDropdownOpen = /* @__PURE__ */ __name(() => {
 }, "useKeepDropdownOpen");
 const useMenuSearch = /* @__PURE__ */ __name(() => {
   const [searchValues, setSearchValues] = (0, import_react.useState)({});
+  const [inputValues, setInputValues] = (0, import_react.useState)({});
   const [isSearching, setIsSearching] = (0, import_react.useState)(false);
+  const [composingCount, setComposingCount] = (0, import_react.useState)(0);
+  const composingKeysRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
   const searchTimeoutRef = (0, import_react.useRef)(null);
-  const updateSearchValue = /* @__PURE__ */ __name((key, value) => {
+  const updateSearchValue = (0, import_react.useCallback)((key, value) => {
     setIsSearching(true);
+    setInputValues((prev) => ({ ...prev, [key]: value }));
     setSearchValues((prev) => ({ ...prev, [key]: value }));
     if (searchTimeoutRef.current) {
       clearTimeout(searchTimeoutRef.current);
     }
     searchTimeoutRef.current = setTimeout(() => setIsSearching(false), 300);
-  }, "updateSearchValue");
+  }, []);
+  const startComposition = (0, import_react.useCallback)((key) => {
+    composingKeysRef.current.add(key);
+    setIsSearching(true);
+    setComposingCount(composingKeysRef.current.size);
+    if (searchTimeoutRef.current) {
+      clearTimeout(searchTimeoutRef.current);
+      searchTimeoutRef.current = null;
+    }
+  }, []);
+  const endComposition = (0, import_react.useCallback)(
+    (key, value) => {
+      composingKeysRef.current.delete(key);
+      setComposingCount(composingKeysRef.current.size);
+      updateSearchValue(key, value);
+    },
+    [updateSearchValue]
+  );
+  const updateInputValue = (0, import_react.useCallback)((key, value) => {
+    setInputValues((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const clearSearchValue = (0, import_react.useCallback)((key) => {
+    composingKeysRef.current.delete(key);
+    setComposingCount(composingKeysRef.current.size);
+    setInputValues((prev) => {
+      if (!(key in prev)) return prev;
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+    setSearchValues((prev) => {
+      if (!(key in prev)) return prev;
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  }, []);
+  const clearAllSearchValues = (0, import_react.useCallback)(() => {
+    composingKeysRef.current.clear();
+    setComposingCount(0);
+    setInputValues({});
+    setSearchValues({});
+    setIsSearching(false);
+  }, []);
+  const isComposing = (0, import_react.useCallback)((key) => {
+    return key ? composingKeysRef.current.has(key) : composingKeysRef.current.size > 0;
+  }, []);
   (0, import_react.useEffect)(() => {
     return () => {
       if (searchTimeoutRef.current) {
@@ -188,8 +238,15 @@ const useMenuSearch = /* @__PURE__ */ __name(() => {
   }, []);
   return {
     searchValues,
-    isSearching,
-    updateSearchValue
+    inputValues,
+    isSearching: isSearching || composingCount > 0,
+    updateSearchValue,
+    updateInputValue,
+    startComposition,
+    endComposition,
+    clearSearchValue,
+    clearAllSearchValues,
+    isComposing
   };
 }, "useMenuSearch");
 const useSubmenuStyles = /* @__PURE__ */ __name((menuVisible, dropdownMaxHeight) => {
@@ -275,10 +332,10 @@ const getLabelSearchText = /* @__PURE__ */ __name((label) => {
   }
   return "";
 }, "getLabelSearchText");
-const createSearchItem = /* @__PURE__ */ __name((item, searchKey, currentSearchValue, menuVisible, t, updateSearchValue) => ({
+const createSearchItem = /* @__PURE__ */ __name((item, searchKey, currentSearchValue, menuVisible, t, searchHandlers, activateSearchSubmenu, deactivateSearchSubmenu, shouldActivateSearchSubmenu) => ({
   key: `${searchKey}-search`,
   type: "group",
-  label: /* @__PURE__ */ import_react.default.createElement("div", null, /* @__PURE__ */ import_react.default.createElement(
+  label: /* @__PURE__ */ import_react.default.createElement("div", { onMouseDown: (e) => e.stopPropagation(), onClick: (e) => e.stopPropagation() }, /* @__PURE__ */ import_react.default.createElement(
     SearchInputWithAutoFocus,
     {
       visible: menuVisible,
@@ -286,11 +343,50 @@ const createSearchItem = /* @__PURE__ */ __name((item, searchKey, currentSearchV
       allowClear: true,
       placeholder: t(item.searchPlaceholder || "Search"),
       value: currentSearchValue,
+      onFocus: (e) => {
+        e.stopPropagation();
+      },
       onChange: (e) => {
+        var _a;
+        e.stopPropagation();
+        const value = e.target.value;
+        if (shouldActivateSearchSubmenu) {
+          activateSearchSubmenu(searchKey);
+        }
+        if (((_a = e.nativeEvent) == null ? void 0 : _a.isComposing) || searchHandlers.isComposing(searchKey)) {
+          searchHandlers.updateInputValue(searchKey, value);
+          return;
+        }
+        if (!value && shouldActivateSearchSubmenu) {
+          deactivateSearchSubmenu(searchKey);
+        }
+        searchHandlers.updateSearchValue(searchKey, value);
+      },
+      onCompositionStart: (e) => {
+        e.stopPropagation();
+        if (shouldActivateSearchSubmenu) {
+          activateSearchSubmenu(searchKey);
+        }
+        searchHandlers.startComposition(searchKey);
+      },
+      onCompositionEnd: (e) => {
+        e.stopPropagation();
+        const value = e.currentTarget.value;
+        if (shouldActivateSearchSubmenu) {
+          if (value) {
+            activateSearchSubmenu(searchKey);
+          } else {
+            deactivateSearchSubmenu(searchKey);
+          }
+        }
+        searchHandlers.endComposition(searchKey, value);
+      },
+      onClick: (e) => {
+        e.stopPropagation();
+      },
+      onKeyDown: (e) => {
         e.stopPropagation();
-        updateSearchValue(searchKey, e.target.value);
       },
-      onClick: (e) => e.stopPropagation(),
       onMouseDown: (e) => {
         e.stopPropagation();
       },
@@ -313,13 +409,21 @@ const KEEP_OPEN_LABEL_STYLE = {
   width: "100%"
 };
 const DROPDOWN_PERSIST_TTL_MS = 350;
+const SUBMENU_CLOSE_DELAY = 0.05;
+const SUBMENU_MOTION_DISABLED = {
+  motionEnter: false,
+  motionLeave: false
+};
 const dropdownPersistRegistry = /* @__PURE__ */ new Map();
 const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
   const engine = (0, import_provider.useFlowEngine)();
   const [menuVisible, setMenuVisible] = (0, import_react.useState)(false);
   const [openKeys, setOpenKeys] = (0, import_react.useState)(/* @__PURE__ */ new Set());
+  const [activeSearchKey, setActiveSearchKey] = (0, import_react.useState)(null);
   const [rootItems, setRootItems] = (0, import_react.useState)([]);
   const [rootLoading, setRootLoading] = (0, import_react.useState)(false);
+  const closeByOutsideClickRef = (0, import_react.useRef)(false);
+  const skipPreserveActiveSearchRef = (0, import_react.useRef)(false);
   const dropdownMaxHeight = useNiceDropdownMaxHeight();
   const t = engine.translate.bind(engine);
   const { items: menuItems, keepDropdownOpen, persistKey, stateVersion, refreshKeys, ...dropdownMenuProps } = menu;
@@ -330,22 +434,89 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
     openKeys,
     refreshKeys
   );
-  const { searchValues, isSearching, updateSearchValue } = useMenuSearch();
+  const searchHandlers = useMenuSearch();
+  const { searchValues, inputValues, clearSearchValue, clearAllSearchValues } = searchHandlers;
   const { requestKeepOpen, shouldPreventClose } = useKeepDropdownOpen();
   useSubmenuStyles(menuVisible, dropdownMaxHeight);
+  const closeMenu = (0, import_react.useCallback)(() => {
+    setMenuVisible(false);
+    setActiveSearchKey(null);
+    setOpenKeys(/* @__PURE__ */ new Set());
+    clearAllSearchValues();
+  }, [clearAllSearchValues]);
+  const activateSearchSubmenu = (0, import_react.useCallback)((key) => {
+    setActiveSearchKey(key);
+    setOpenKeys((prev) => {
+      if (prev.has(key)) return prev;
+      const next = new Set(prev);
+      next.add(key);
+      return next;
+    });
+  }, []);
+  const deactivateSearchSubmenu = (0, import_react.useCallback)((key) => {
+    setActiveSearchKey((prev) => prev === key ? null : prev);
+  }, []);
+  const closeActiveSearchForPath = (0, import_react.useCallback)(
+    (keyPath) => {
+      if (!activeSearchKey || keyPath === activeSearchKey || keyPath.startsWith(`${activeSearchKey}/`) || activeSearchKey.startsWith(`${keyPath}/`)) {
+        return;
+      }
+      skipPreserveActiveSearchRef.current = true;
+      clearSearchValue(activeSearchKey);
+      setActiveSearchKey(null);
+      setOpenKeys((prev) => {
+        const next = new Set(prev);
+        next.delete(activeSearchKey);
+        return next;
+      });
+    },
+    [activeSearchKey, clearSearchValue]
+  );
   const handleMenuOpenChange = (0, import_react.useCallback)(
     (nextOpenKeys) => {
       var _a, _b;
-      if (!nextOpenKeys.length && shouldPreventClose()) {
+      let normalized = normalizeOpenKeys(nextOpenKeys);
+      if (activeSearchKey && openKeys.has(activeSearchKey) && !normalized.includes(activeSearchKey)) {
+        if (normalized.length || skipPreserveActiveSearchRef.current) {
+          clearSearchValue(activeSearchKey);
+          setActiveSearchKey(null);
+        } else {
+          normalized = [activeSearchKey];
+        }
+      }
+      if (!normalized.length && shouldPreventClose()) {
         (_a = dropdownMenuProps.onOpenChange) == null ? void 0 : _a.call(dropdownMenuProps, Array.from(openKeys));
+        skipPreserveActiveSearchRef.current = false;
         return;
       }
-      const normalized = normalizeOpenKeys(nextOpenKeys);
+      Array.from(openKeys).forEach((key) => {
+        if (!normalized.includes(key)) {
+          clearSearchValue(key);
+        }
+      });
       setOpenKeys(new Set(normalized));
       (_b = dropdownMenuProps.onOpenChange) == null ? void 0 : _b.call(dropdownMenuProps, normalized);
+      skipPreserveActiveSearchRef.current = false;
     },
-    [dropdownMenuProps, openKeys, shouldPreventClose]
+    [activeSearchKey, clearSearchValue, dropdownMenuProps, openKeys, shouldPreventClose]
   );
+  (0, import_react.useEffect)(() => {
+    if (!menuVisible) return;
+    const markOutsideClick = /* @__PURE__ */ __name((event) => {
+      const target = event.target;
+      const isOutside = !(target == null ? void 0 : target.closest(".ant-dropdown, .ant-dropdown-menu, .ant-dropdown-menu-submenu-popup"));
+      closeByOutsideClickRef.current = isOutside;
+      if (isOutside) {
+        closeMenu();
+      }
+    }, "markOutsideClick");
+    document.addEventListener("pointerdown", markOutsideClick, true);
+    document.addEventListener("mousedown", markOutsideClick, true);
+    return () => {
+      document.removeEventListener("pointerdown", markOutsideClick, true);
+      document.removeEventListener("mousedown", markOutsideClick, true);
+    };
+  }, [closeMenu, menuVisible]);
   (0, import_react.useEffect)(() => {
     if (!persistKey) return;
     const until = dropdownPersistRegistry.get(persistKey) || 0;
@@ -391,6 +562,8 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
   function buildSearchChildren(children, item, keyPath, path, menuVisible2, resolve) {
     const searchKey = keyPath;
     const currentSearchValue = searchValues[searchKey] || "";
+    const currentInputValue = inputValues[searchKey] ?? currentSearchValue;
+    const shouldActivateSearchSubmenu = !(item.type === "group" && path.length === 0);
     const filteredChildren = currentSearchValue ? (/* @__PURE__ */ __name(function deepFilter(items2) {
       const searchText = currentSearchValue.toLowerCase();
       return items2.map((child) => {
@@ -407,7 +580,17 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
       }).filter(Boolean);
     }, "deepFilter"))(children) : children;
     const resolvedFiltered = resolve(filteredChildren, [...path, item.key]);
-    const searchItem = createSearchItem(item, searchKey, currentSearchValue, menuVisible2, t, updateSearchValue);
+    const searchItem = createSearchItem(
+      item,
+      searchKey,
+      currentInputValue,
+      menuVisible2,
+      t,
+      searchHandlers,
+      activateSearchSubmenu,
+      deactivateSearchSubmenu,
+      shouldActivateSearchSubmenu
+    );
     const dividerItem = { key: `${keyPath}-search-divider`, type: "divider" };
     if (currentSearchValue && resolvedFiltered.length === 0) {
       return [searchItem, dividerItem, createEmptyItem(keyPath, t)];
@@ -466,6 +649,7 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
           label,
           onClick: /* @__PURE__ */ __name((info) => {
           }, "onClick"),
+          onMouseEnter: /* @__PURE__ */ __name(() => closeActiveSearchForPath(keyPath), "onMouseEnter"),
           children: buildSearchChildren(children, item, keyPath, path, menuVisible, resolveItems)
         };
       }
@@ -513,6 +697,7 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
         onClick: /* @__PURE__ */ __name((info) => {
           if (!itemShouldKeepOpen) handleLeafClick(info);
         }, "onClick"),
+        onMouseEnter: /* @__PURE__ */ __name(() => closeActiveSearchForPath(keyPath), "onMouseEnter"),
         onMouseDown: /* @__PURE__ */ __name(() => {
           if (!itemShouldKeepOpen) {
             return;
@@ -555,6 +740,8 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
         ...dropdownMenuProps,
         openKeys: Array.from(openKeys),
         items,
+        subMenuCloseDelay: dropdownMenuProps.subMenuCloseDelay ?? SUBMENU_CLOSE_DELAY,
+        motion: dropdownMenuProps.motion ?? SUBMENU_MOTION_DISABLED,
         onClick: /* @__PURE__ */ __name(() => {
         }, "onClick"),
         onOpenChange: handleMenuOpenChange,
@@ -564,14 +751,19 @@ const LazyDropdown = /* @__PURE__ */ __name(({ menu, ...props }) => {
           ...dropdownMenuProps == null ? void 0 : dropdownMenuProps.style
         }
       },
-      onOpenChange: (visible) => {
-        if (!visible && isSearching) {
+      onOpenChange: (visible, info) => {
+        if (!visible && activeSearchKey && (info == null ? void 0 : info.source) === "trigger" && !closeByOutsideClickRef.current) {
           return;
         }
         if (!visible && shouldPreventClose()) {
           return;
         }
-        setMenuVisible(visible);
+        if (!visible) {
+          closeMenu();
+        } else {
+          setMenuVisible(visible);
+        }
+        closeByOutsideClickRef.current = false;
       }
     },
     props.children

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

@@ -19,6 +19,7 @@ export interface BuildFieldChildrenOptions {
     fieldUseModel?: string | ((field: any) => string);
     collection?: Collection;
     associationPathName?: string;
+    maxAssociationFieldDepth?: number;
     /**
      * 点击这些子项后，除自身路径外，还需要联动刷新的其他菜单路径前缀
      */

package/lib/components/subModel/utils.js

@@ -231,14 +231,18 @@ function buildSubModelGroups(subModelBaseClasses = []) {
 }
 __name(buildSubModelGroups, "buildSubModelGroups");
 function buildWrapperFieldChildren(ctx, options) {
-  var _a;
-  const { useModel, fieldUseModel, associationPathName, refreshTargets } = options;
+  var _a, _b;
+  const { useModel, fieldUseModel, associationPathName, refreshTargets, maxAssociationFieldDepth = 2 } = options;
   const collection = options.collection || ctx.model["collection"] || ctx.collection;
   const fields = collection.getFields();
   const defaultItemKeys = ["fieldSettings", "init"];
   const children = [];
+  const associationDepth = associationPathName ? associationPathName.split(".").filter(Boolean).length : 0;
   for (const f of fields) {
     if (!((_a = f == null ? void 0 : f.options) == null ? void 0 : _a.interface)) continue;
+    if (associationDepth >= maxAssociationFieldDepth && (((_b = f.isAssociationField) == null ? void 0 : _b.call(f)) || f.target || f.targetCollection)) {
+      continue;
+    }
     const fieldPath = associationPathName ? `${associationPathName}.${f.name}` : f.name;
     const childUse = typeof fieldUseModel === "function" ? fieldUseModel(f) : fieldUseModel ?? "FieldModel";
     if (childUse) {

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

@@ -38,7 +38,13 @@ export declare class DataSourceManager {
         }>) => void;
         addFieldInterfaceComponentOption?: (name: string, option: any) => void;
         addFieldInterfaceOperator?: (name: string, operator: any) => void;
+        registerFieldFilterOperator?: (operator: any) => void;
+        registerFieldFilterOperatorGroup?: (name: string, operators?: any[]) => void;
+        addFieldFilterOperatorsToGroup?: (name: string, operators?: any[]) => void;
         getFieldInterface?: (name: string) => any;
+        registerFieldInterfaceConfigure?: (options: unknown) => void;
+        getFieldInterfaceConfigure?: (name: string, collectionInfo?: unknown) => unknown;
+        getFieldInterfaceConfigureProperties?: (name: string, collectionInfo?: any) => Record<string, any>;
     };
     loaders: Map<string, DataSourceLoader>;
     loadedKeys: Set<string>;
@@ -56,6 +62,9 @@ export declare class DataSourceManager {
     }>): void;
     addFieldInterfaceComponentOption(name: string, option: any): void;
     addFieldInterfaceOperator(name: string, operator: any): void;
+    registerFieldFilterOperator(operator: any): void;
+    registerFieldFilterOperatorGroup(name: string, operators?: any[]): void;
+    addFieldFilterOperatorsToGroup(name: string, operators?: any[]): void;
     registerLoader(key: string, loader: DataSourceLoader): void;
     removeLoader(key: string): void;
     addDataSource(ds: DataSource | DataSourceOptions): void;

package/lib/data-source/index.js

@@ -89,6 +89,18 @@ const _DataSourceManager = class _DataSourceManager {
     var _a, _b;
     (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldInterfaceOperator) == null ? void 0 : _b.call(_a, name, operator);
   }
+  registerFieldFilterOperator(operator) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.registerFieldFilterOperator) == null ? void 0 : _b.call(_a, operator);
+  }
+  registerFieldFilterOperatorGroup(name, operators = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.registerFieldFilterOperatorGroup) == null ? void 0 : _b.call(_a, name, operators);
+  }
+  addFieldFilterOperatorsToGroup(name, operators = []) {
+    var _a, _b;
+    (_b = (_a = this.collectionFieldInterfaceManager) == null ? void 0 : _a.addFieldFilterOperatorsToGroup) == null ? void 0 : _b.call(_a, name, operators);
+  }
   registerLoader(key, loader) {
     this.loaders.set(key, loader);
   }

package/lib/executor/FlowExecutor.js

@@ -153,9 +153,6 @@ const _FlowExecutor = class _FlowExecutor {
         const stepDefaultParams = await (0, import_utils.resolveDefaultParams)(step.defaultParams, runtimeCtx);
         combinedParams = { ...stepDefaultParams };
       } else {
-        flowContext.logger.warn(
-          `BaseModel.applyFlow: Step '${stepKey}' in flow '${flowKey}' has neither 'use' nor 'handler'. Skipping.`
-        );
         continue;
       }
       const modelStepParams = model.getStepParams(flowKey, stepKey);