@nocobase/flow-engine 2.1.0-beta.21 → 2.1.0-beta.23

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

@@ -31,6 +31,7 @@ __export(useFloatToolbarVisibility_exports, {
 });
 module.exports = __toCommonJS(useFloatToolbarVisibility_exports);
 var import_react = require("react");
+var import_dnd = require("../../../dnd");
 const TOOLBAR_HIDE_DELAY = 180;
 const CHILD_FLOAT_MENU_ACTIVITY_EVENT = "nb-float-menu-child-activity";
 const isNodeWithin = /* @__PURE__ */ __name((target, container) => {
@@ -65,15 +66,41 @@ const useFloatToolbarVisibility = /* @__PURE__ */ __name(({
   const [isHostHovered, setIsHostHovered] = (0, import_react.useState)(false);
   const [isToolbarHovered, setIsToolbarHovered] = (0, import_react.useState)(false);
   const [isDraggingToolbar, setIsDraggingToolbar] = (0, import_react.useState)(false);
+  const [isDraggingToolbarItem, setIsDraggingToolbarItem] = (0, import_react.useState)(false);
   const [isToolbarPinned, setIsToolbarPinned] = (0, import_react.useState)(false);
   const [isHidePending, setIsHidePending] = (0, import_react.useState)(false);
   const [activeChildToolbarIds, setActiveChildToolbarIds] = (0, import_react.useState)([]);
   const hideToolbarTimerRef = (0, import_react.useRef)(null);
   const reportedChildActivityToAncestorsRef = (0, import_react.useRef)(false);
+  const isHostHoveredRef = (0, import_react.useRef)(false);
+  const isToolbarHoveredRef = (0, import_react.useRef)(false);
+  const isDraggingToolbarRef = (0, import_react.useRef)(false);
+  const isDraggingToolbarItemRef = (0, import_react.useRef)(false);
+  const isToolbarPinnedRef = (0, import_react.useRef)(false);
+  const setHostHovered = (0, import_react.useCallback)((value) => {
+    isHostHoveredRef.current = value;
+    setIsHostHovered(value);
+  }, []);
+  const setToolbarHovered = (0, import_react.useCallback)((value) => {
+    isToolbarHoveredRef.current = value;
+    setIsToolbarHovered(value);
+  }, []);
+  const setDraggingToolbar = (0, import_react.useCallback)((value) => {
+    isDraggingToolbarRef.current = value;
+    setIsDraggingToolbar(value);
+  }, []);
+  const setDraggingToolbarItem = (0, import_react.useCallback)((value) => {
+    isDraggingToolbarItemRef.current = value;
+    setIsDraggingToolbarItem(value);
+  }, []);
+  const setToolbarPinned = (0, import_react.useCallback)((value) => {
+    isToolbarPinnedRef.current = value;
+    setIsToolbarPinned(value);
+  }, []);
   const hasActiveChildToolbar = activeChildToolbarIds.length > 0;
-  const isToolbarVisible = !hideMenu && !hasActiveChildToolbar && (isHostHovered || isToolbarHovered || isDraggingToolbar || isToolbarPinned);
-  const shouldRenderToolbar = isToolbarVisible || isToolbarPinned || isDraggingToolbar;
-  const isToolbarInteractionActive = isHostHovered || isToolbarHovered || isDraggingToolbar || isToolbarPinned || isHidePending;
+  const isToolbarVisible = !hideMenu && !hasActiveChildToolbar && (isHostHovered || isToolbarHovered || isDraggingToolbar || isDraggingToolbarItem || isToolbarPinned);
+  const shouldRenderToolbar = isToolbarVisible || isToolbarPinned || isDraggingToolbar || isDraggingToolbarItem;
+  const isToolbarInteractionActive = isHostHovered || isToolbarHovered || isDraggingToolbar || isDraggingToolbarItem || isToolbarPinned || isHidePending;
   const clearHideToolbarTimer = (0, import_react.useCallback)(() => {
     if (hideToolbarTimerRef.current !== null) {
       window.clearTimeout(hideToolbarTimerRef.current);
@@ -87,16 +114,19 @@ const useFloatToolbarVisibility = /* @__PURE__ */ __name(({
     hideToolbarTimerRef.current = window.setTimeout(() => {
       hideToolbarTimerRef.current = null;
       setIsHidePending(false);
-      if (isDraggingToolbar || isToolbarPinned) {
+      if (isDraggingToolbarRef.current || isDraggingToolbarItemRef.current || isToolbarPinnedRef.current) {
         return;
       }
-      setIsHostHovered(false);
-      setIsToolbarHovered(false);
+      setHostHovered(false);
+      setToolbarHovered(false);
     }, TOOLBAR_HIDE_DELAY);
-  }, [clearHideToolbarTimer, isDraggingToolbar, isToolbarPinned]);
-  const handleSettingsMenuOpenChange = (0, import_react.useCallback)((open) => {
-    setIsToolbarPinned(open);
-  }, []);
+  }, [clearHideToolbarTimer, setHostHovered, setToolbarHovered]);
+  const handleSettingsMenuOpenChange = (0, import_react.useCallback)(
+    (open) => {
+      setToolbarPinned(open);
+    },
+    [setToolbarPinned]
+  );
   (0, import_react.useEffect)(() => {
     const hostElement = containerRef.current;
     if (!hostElement) {
@@ -122,6 +152,35 @@ const useFloatToolbarVisibility = /* @__PURE__ */ __name(({
       hostElement.removeEventListener(CHILD_FLOAT_MENU_ACTIVITY_EVENT, handleChildToolbarActivity);
     };
   }, [containerRef]);
+  (0, import_react.useEffect)(() => {
+    const hostElement = containerRef.current;
+    const ownerDocument = hostElement == null ? void 0 : hostElement.ownerDocument;
+    if (!ownerDocument) {
+      return;
+    }
+    const handleToolbarDragActivity = /* @__PURE__ */ __name((event) => {
+      var _a, _b;
+      const customEvent = event;
+      if (((_a = customEvent.detail) == null ? void 0 : _a.modelUid) !== modelUid) {
+        return;
+      }
+      if ((_b = customEvent.detail) == null ? void 0 : _b.active) {
+        clearHideToolbarTimer();
+        setDraggingToolbarItem(true);
+        return;
+      }
+      setDraggingToolbarItem(false);
+      if (isHostHoveredRef.current || isToolbarHoveredRef.current || isToolbarPinnedRef.current) {
+        clearHideToolbarTimer();
+        return;
+      }
+      scheduleHideToolbar();
+    }, "handleToolbarDragActivity");
+    ownerDocument.addEventListener(import_dnd.TOOLBAR_DRAG_ACTIVITY_EVENT, handleToolbarDragActivity);
+    return () => {
+      ownerDocument.removeEventListener(import_dnd.TOOLBAR_DRAG_ACTIVITY_EVENT, handleToolbarDragActivity);
+    };
+  }, [clearHideToolbarTimer, containerRef, modelUid, scheduleHideToolbar, setDraggingToolbarItem]);
   (0, import_react.useEffect)(() => {
     const hostElement = containerRef.current;
     if (!hostElement || reportedChildActivityToAncestorsRef.current === isToolbarInteractionActive) {
@@ -163,71 +222,80 @@ const useFloatToolbarVisibility = /* @__PURE__ */ __name(({
       const isCurrentHostTarget = !childWithMenu || childWithMenu === containerRef.current;
       if (isCurrentHostTarget) {
         clearHideToolbarTimer();
-        setIsHostHovered(true);
+        setHostHovered(true);
       }
       setHideMenu(!!childWithMenu && childWithMenu !== containerRef.current);
     },
-    [clearHideToolbarTimer, containerRef]
+    [clearHideToolbarTimer, containerRef, setHostHovered]
   );
   const handleHostMouseEnter = (0, import_react.useCallback)(() => {
     clearHideToolbarTimer();
     setHideMenu(false);
     updatePortalRect();
-    setIsHostHovered(true);
-  }, [clearHideToolbarTimer, updatePortalRect]);
+    setHostHovered(true);
+  }, [clearHideToolbarTimer, setHostHovered, updatePortalRect]);
   const handleHostMouseLeave = (0, import_react.useCallback)(
     (e) => {
-      if (isToolbarPinned) {
-        setIsHostHovered(false);
+      if (isToolbarPinnedRef.current) {
+        setHostHovered(false);
         return;
       }
       if (isNodeWithin(e.relatedTarget, toolbarContainerRef.current)) {
         clearHideToolbarTimer();
-        setIsHostHovered(false);
-        setIsToolbarHovered(true);
+        setHostHovered(false);
+        setToolbarHovered(true);
         return;
       }
       if (isNodeWithinDescendantFloatToolbar(e.relatedTarget, containerRef.current, modelUid)) {
         clearHideToolbarTimer();
         setHideMenu(false);
-        setIsHostHovered(true);
+        setHostHovered(true);
         return;
       }
       scheduleHideToolbar();
     },
-    [clearHideToolbarTimer, containerRef, isToolbarPinned, modelUid, scheduleHideToolbar, toolbarContainerRef]
+    [
+      clearHideToolbarTimer,
+      containerRef,
+      modelUid,
+      scheduleHideToolbar,
+      setHostHovered,
+      setToolbarHovered,
+      toolbarContainerRef
+    ]
   );
   const handleToolbarMouseEnter = (0, import_react.useCallback)(() => {
     clearHideToolbarTimer();
     updatePortalRect();
-    setIsHostHovered(false);
-    setIsToolbarHovered(true);
-  }, [clearHideToolbarTimer, updatePortalRect]);
+    setHostHovered(false);
+    setToolbarHovered(true);
+  }, [clearHideToolbarTimer, setHostHovered, setToolbarHovered, updatePortalRect]);
   const handleToolbarMouseLeave = (0, import_react.useCallback)(
     (e) => {
-      if (isToolbarPinned) {
-        setIsToolbarHovered(false);
+      if (isToolbarPinnedRef.current || isDraggingToolbarItemRef.current) {
+        clearHideToolbarTimer();
+        setToolbarHovered(false);
         return;
       }
-      setIsToolbarHovered(false);
+      setToolbarHovered(false);
       if (isNodeWithin(e.relatedTarget, containerRef.current)) {
         clearHideToolbarTimer();
-        setIsHostHovered(true);
+        setHostHovered(true);
         return;
       }
       scheduleHideToolbar();
     },
-    [clearHideToolbarTimer, containerRef, isToolbarPinned, scheduleHideToolbar]
+    [clearHideToolbarTimer, containerRef, scheduleHideToolbar, setHostHovered, setToolbarHovered]
   );
   const handleResizeDragStart = (0, import_react.useCallback)(() => {
     updatePortalRect();
-    setIsDraggingToolbar(true);
+    setDraggingToolbar(true);
     schedulePortalRectUpdate();
-  }, [schedulePortalRectUpdate, updatePortalRect]);
+  }, [schedulePortalRectUpdate, setDraggingToolbar, updatePortalRect]);
   const handleResizeDragEnd = (0, import_react.useCallback)(() => {
-    setIsDraggingToolbar(false);
+    setDraggingToolbar(false);
     schedulePortalRectUpdate();
-  }, [schedulePortalRectUpdate]);
+  }, [schedulePortalRectUpdate, setDraggingToolbar]);
   return {
     isToolbarVisible,
     shouldRenderToolbar,

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

@@ -7,4 +7,5 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export * from './AddSubModelButton';
+export { default as LazyDropdown } from './LazyDropdown';
 export * from './utils';

package/lib/components/subModel/index.js

@@ -7,10 +7,16 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -20,13 +26,26 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var subModel_exports = {};
+__export(subModel_exports, {
+  LazyDropdown: () => import_LazyDropdown.default
+});
 module.exports = __toCommonJS(subModel_exports);
 __reExport(subModel_exports, require("./AddSubModelButton"), module.exports);
+var import_LazyDropdown = __toESM(require("./LazyDropdown"));
 __reExport(subModel_exports, require("./utils"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LazyDropdown,
   ...require("./AddSubModelButton"),
   ...require("./utils")
 });

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

@@ -29,6 +29,6 @@ export declare function buildWrapperFieldChildren(ctx: FlowModelContext, options
     label: string;
     type: "group";
     searchable: boolean;
-    searchPlaceholder: any;
+    searchPlaceholder: string;
     children: SubModelItem[];
 }[];

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

@@ -15,11 +15,49 @@ export interface DataSourceOptions extends Record<string, any> {
     description?: string;
     [key: string]: any;
 }
+export type DataSourceRequester = (options: Record<string, any>) => Promise<any>;
+export interface DataSourceLoadResult {
+    collections?: CollectionOptions[];
+    dataSources?: Array<DataSourceOptions & {
+        collections?: CollectionOptions[];
+    }>;
+}
+export type DataSourceLoader = (context: {
+    key: string;
+    manager: DataSourceManager;
+}) => Promise<DataSourceLoadResult>;
 export declare class DataSourceManager {
     dataSources: Map<string, DataSource>;
     flowEngine: FlowEngine;
+    requester?: DataSourceRequester;
+    collectionFieldInterfaceManager?: {
+        addFieldInterfaces?: (fieldInterfaceClasses?: any[]) => void;
+        addFieldInterfaceGroups?: (groups: Record<string, {
+            label: string;
+            order?: number;
+        }>) => void;
+        addFieldInterfaceComponentOption?: (name: string, option: any) => void;
+        addFieldInterfaceOperator?: (name: string, operator: any) => void;
+        getFieldInterface?: (name: string) => any;
+    };
+    loaders: Map<string, DataSourceLoader>;
+    loadedKeys: Set<string>;
+    loadingKeys: Set<string>;
+    loadErrors: Map<string, Error>;
+    loadingPromise: Promise<void> | null;
     constructor();
     setFlowEngine(flowEngine: FlowEngine): void;
+    setRequester(requester?: DataSourceRequester): void;
+    setCollectionFieldInterfaceManager(manager: DataSourceManager['collectionFieldInterfaceManager']): void;
+    addFieldInterfaces(fieldInterfaceClasses?: any[]): void;
+    addFieldInterfaceGroups(groups: Record<string, {
+        label: string;
+        order?: number;
+    }>): void;
+    addFieldInterfaceComponentOption(name: string, option: any): void;
+    addFieldInterfaceOperator(name: string, operator: any): void;
+    registerLoader(key: string, loader: DataSourceLoader): void;
+    removeLoader(key: string): void;
     addDataSource(ds: DataSource | DataSourceOptions): void;
     upsertDataSource(ds: DataSource | DataSourceOptions): void;
     removeDataSource(key: string): void;
@@ -28,6 +66,29 @@ export declare class DataSourceManager {
     getDataSource(key: string): DataSource | undefined;
     getCollection(dataSourceKey: string, collectionName: string): Collection | undefined;
     getCollectionField(fieldPathWithDataSource: string): CollectionField;
+    ensureLoaded(options?: {
+        force?: boolean;
+        keys?: string[];
+    }): Promise<void>;
+    reload(options?: {
+        keys?: string[];
+    }): Promise<void>;
+    reloadDataSource(key: string): Promise<void>;
+    protected resolveLoadKeys(requestedKeys?: string[]): string[];
+    protected getApp(): {
+        eventBus?: EventTarget;
+    };
+    protected dispatchDataSourceEvent(type: 'dataSource:loaded' | 'dataSource:loadFailed', detail: {
+        dataSourceKey: string;
+        initial: boolean;
+        error?: Error;
+    }): void;
+    protected setDataSourceState(key: string, options: Partial<Pick<DataSourceOptions, 'status' | 'errorMessage'>> & Record<string, any>): void;
+    protected applyDataSourceLoadResult(key: string, result: DataSourceLoadResult): void;
+    protected loadKey(key: string, options: {
+        initial: boolean;
+        force: boolean;
+    }): Promise<void>;
 }
 export declare class DataSource {
     dataSourceManager: DataSourceManager;
@@ -38,6 +99,8 @@ export declare class DataSource {
     get displayName(): any;
     get key(): any;
     get name(): any;
+    get status(): any;
+    get errorMessage(): any;
     setDataSourceManager(dataSourceManager: DataSourceManager): void;
     getCollections(): Collection[];
     getCollection(name: string): Collection | undefined;
@@ -52,9 +115,14 @@ export declare class DataSource {
     upsertCollections(collections: CollectionOptions[], options?: {
         clearFields?: boolean;
     }): void;
+    setCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     removeCollection(name: string): void;
     clearCollections(): void;
     setOptions(newOptions?: any): void;
+    patchOptions(newOptions?: any): void;
+    reload(): Promise<void>;
     getCollectionField(fieldPath: string): CollectionField;
 }
 export interface CollectionOptions {
@@ -72,6 +140,7 @@ export declare class CollectionManager {
         notSupportView?: string[];
     };
     constructor(dataSource: DataSource);
+    protected resetCaches(): void;
     get flowEngine(): FlowEngine;
     addCollection(collection: Collection | CollectionOptions): void;
     removeCollection(name: string): void;
@@ -82,6 +151,9 @@ export declare class CollectionManager {
     upsertCollections(collections: CollectionOptions[], options?: {
         clearFields?: boolean;
     }): void;
+    setCollections(collections: CollectionOptions[], options?: {
+        clearFields?: boolean;
+    }): void;
     sortCollectionsByInherits(collections: CollectionOptions[]): CollectionOptions[];
     getCollection(name: string): Collection | undefined;
     getCollections(): Collection[];
@@ -116,6 +188,7 @@ export declare class Collection {
     setOptions(newOptions?: any, options?: {
         clearFields?: boolean;
     }): void;
+    setOption(key: string, value: any): void;
     getFields(): CollectionField[];
     getToOneAssociationFields(): CollectionField[];
     getAssociationFields(types?: any[]): CollectionField[];