@nocobase/flow-engine 2.1.0-alpha.3 → 2.1.0-alpha.30

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

@@ -0,0 +1,315 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useFloatToolbarVisibility_exports = {};
+__export(useFloatToolbarVisibility_exports, {
+  useFloatToolbarVisibility: () => useFloatToolbarVisibility
+});
+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) => {
+  return target instanceof Node && !!(container == null ? void 0 : container.contains(target));
+}, "isNodeWithin");
+const getToolbarModelUidFromTarget = /* @__PURE__ */ __name((target) => {
+  var _a;
+  if (!(target instanceof Element)) {
+    return null;
+  }
+  return ((_a = target.closest(".nb-toolbar-container[data-model-uid]")) == null ? void 0 : _a.getAttribute("data-model-uid")) || null;
+}, "getToolbarModelUidFromTarget");
+const isNodeWithinDescendantFloatToolbar = /* @__PURE__ */ __name((target, container, currentModelUid) => {
+  const targetModelUid = getToolbarModelUidFromTarget(target);
+  if (!container || !targetModelUid || targetModelUid === currentModelUid) {
+    return false;
+  }
+  return Array.from(
+    container.querySelectorAll('[data-has-float-menu="true"][data-float-menu-model-uid]')
+  ).some(
+    (hostElement) => hostElement !== container && hostElement.getAttribute("data-float-menu-model-uid") === targetModelUid
+  );
+}, "isNodeWithinDescendantFloatToolbar");
+const useFloatToolbarVisibility = /* @__PURE__ */ __name(({
+  modelUid,
+  containerRef,
+  toolbarContainerRef,
+  updatePortalRect,
+  schedulePortalRectUpdate
+}) => {
+  const [hideMenu, setHideMenu] = (0, import_react.useState)(false);
+  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 || 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);
+      hideToolbarTimerRef.current = null;
+    }
+    setIsHidePending(false);
+  }, []);
+  const scheduleHideToolbar = (0, import_react.useCallback)(() => {
+    clearHideToolbarTimer();
+    setIsHidePending(true);
+    hideToolbarTimerRef.current = window.setTimeout(() => {
+      hideToolbarTimerRef.current = null;
+      setIsHidePending(false);
+      if (isDraggingToolbarRef.current || isDraggingToolbarItemRef.current || isToolbarPinnedRef.current) {
+        return;
+      }
+      setHostHovered(false);
+      setToolbarHovered(false);
+    }, TOOLBAR_HIDE_DELAY);
+  }, [clearHideToolbarTimer, setHostHovered, setToolbarHovered]);
+  const handleSettingsMenuOpenChange = (0, import_react.useCallback)(
+    (open) => {
+      setToolbarPinned(open);
+    },
+    [setToolbarPinned]
+  );
+  (0, import_react.useEffect)(() => {
+    const hostElement = containerRef.current;
+    if (!hostElement) {
+      return;
+    }
+    const handleChildToolbarActivity = /* @__PURE__ */ __name((event) => {
+      var _a;
+      const customEvent = event;
+      if (!(customEvent.target instanceof HTMLElement) || customEvent.target === hostElement) {
+        return;
+      }
+      const childModelUid = (_a = customEvent.detail) == null ? void 0 : _a.modelUid;
+      if (!childModelUid) {
+        return;
+      }
+      setActiveChildToolbarIds((prevIds) => {
+        var _a2;
+        return ((_a2 = customEvent.detail) == null ? void 0 : _a2.active) ? prevIds.includes(childModelUid) ? prevIds : [...prevIds, childModelUid] : prevIds.filter((id) => id !== childModelUid);
+      });
+    }, "handleChildToolbarActivity");
+    hostElement.addEventListener(CHILD_FLOAT_MENU_ACTIVITY_EVENT, handleChildToolbarActivity);
+    return () => {
+      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) {
+      return;
+    }
+    reportedChildActivityToAncestorsRef.current = isToolbarInteractionActive;
+    hostElement.dispatchEvent(
+      new CustomEvent(CHILD_FLOAT_MENU_ACTIVITY_EVENT, {
+        bubbles: true,
+        detail: { active: isToolbarInteractionActive, modelUid }
+      })
+    );
+  }, [containerRef, isToolbarInteractionActive, modelUid]);
+  (0, import_react.useEffect)(() => {
+    const hostElement = containerRef.current;
+    return () => {
+      if (hostElement && reportedChildActivityToAncestorsRef.current) {
+        hostElement.dispatchEvent(
+          new CustomEvent(CHILD_FLOAT_MENU_ACTIVITY_EVENT, {
+            bubbles: true,
+            detail: { active: false, modelUid }
+          })
+        );
+        reportedChildActivityToAncestorsRef.current = false;
+      }
+      clearHideToolbarTimer();
+    };
+  }, [clearHideToolbarTimer, containerRef, modelUid]);
+  (0, import_react.useEffect)(() => {
+    if (isToolbarPinned) {
+      clearHideToolbarTimer();
+      updatePortalRect();
+    }
+  }, [clearHideToolbarTimer, isToolbarPinned, updatePortalRect]);
+  const handleChildHover = (0, import_react.useCallback)(
+    (e) => {
+      const target = e.target;
+      const childWithMenu = target.closest("[data-has-float-menu]");
+      const isCurrentHostTarget = !childWithMenu || childWithMenu === containerRef.current;
+      if (isCurrentHostTarget) {
+        clearHideToolbarTimer();
+        setHostHovered(true);
+      }
+      setHideMenu(!!childWithMenu && childWithMenu !== containerRef.current);
+    },
+    [clearHideToolbarTimer, containerRef, setHostHovered]
+  );
+  const handleHostMouseEnter = (0, import_react.useCallback)(() => {
+    clearHideToolbarTimer();
+    setHideMenu(false);
+    updatePortalRect();
+    setHostHovered(true);
+  }, [clearHideToolbarTimer, setHostHovered, updatePortalRect]);
+  const handleHostMouseLeave = (0, import_react.useCallback)(
+    (e) => {
+      if (isToolbarPinnedRef.current) {
+        setHostHovered(false);
+        return;
+      }
+      if (isNodeWithin(e.relatedTarget, toolbarContainerRef.current)) {
+        clearHideToolbarTimer();
+        setHostHovered(false);
+        setToolbarHovered(true);
+        return;
+      }
+      if (isNodeWithinDescendantFloatToolbar(e.relatedTarget, containerRef.current, modelUid)) {
+        clearHideToolbarTimer();
+        setHideMenu(false);
+        setHostHovered(true);
+        return;
+      }
+      scheduleHideToolbar();
+    },
+    [
+      clearHideToolbarTimer,
+      containerRef,
+      modelUid,
+      scheduleHideToolbar,
+      setHostHovered,
+      setToolbarHovered,
+      toolbarContainerRef
+    ]
+  );
+  const handleToolbarMouseEnter = (0, import_react.useCallback)(() => {
+    clearHideToolbarTimer();
+    updatePortalRect();
+    setHostHovered(false);
+    setToolbarHovered(true);
+  }, [clearHideToolbarTimer, setHostHovered, setToolbarHovered, updatePortalRect]);
+  const handleToolbarMouseLeave = (0, import_react.useCallback)(
+    (e) => {
+      if (isToolbarPinnedRef.current || isDraggingToolbarItemRef.current) {
+        clearHideToolbarTimer();
+        setToolbarHovered(false);
+        return;
+      }
+      setToolbarHovered(false);
+      if (isNodeWithin(e.relatedTarget, containerRef.current)) {
+        clearHideToolbarTimer();
+        setHostHovered(true);
+        return;
+      }
+      scheduleHideToolbar();
+    },
+    [clearHideToolbarTimer, containerRef, scheduleHideToolbar, setHostHovered, setToolbarHovered]
+  );
+  const handleResizeDragStart = (0, import_react.useCallback)(() => {
+    updatePortalRect();
+    setDraggingToolbar(true);
+    schedulePortalRectUpdate();
+  }, [schedulePortalRectUpdate, setDraggingToolbar, updatePortalRect]);
+  const handleResizeDragEnd = (0, import_react.useCallback)(() => {
+    setDraggingToolbar(false);
+    schedulePortalRectUpdate();
+  }, [schedulePortalRectUpdate, setDraggingToolbar]);
+  return {
+    isToolbarVisible,
+    shouldRenderToolbar,
+    handleSettingsMenuOpenChange,
+    handleChildHover,
+    handleHostMouseEnter,
+    handleHostMouseLeave,
+    handleToolbarMouseEnter,
+    handleToolbarMouseLeave,
+    handleResizeDragStart,
+    handleResizeDragEnd
+  };
+}, "useFloatToolbarVisibility");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFloatToolbarVisibility
+});

package/lib/components/subModel/AddSubModelButton.js

@@ -376,6 +376,21 @@ const AddSubModelButtonCore = /* @__PURE__ */ __name(function AddSubModelButton(
     }),
     [model, subModelKey, subModelType]
   );
+  import_react.default.useEffect(() => {
+    var _a, _b, _c;
+    const handleSubModelChanged = /* @__PURE__ */ __name(() => {
+      setRefreshTick((x) => x + 1);
+    }, "handleSubModelChanged");
+    (_a = model.emitter) == null ? void 0 : _a.on("onSubModelAdded", handleSubModelChanged);
+    (_b = model.emitter) == null ? void 0 : _b.on("onSubModelRemoved", handleSubModelChanged);
+    (_c = model.emitter) == null ? void 0 : _c.on("onSubModelReplaced", handleSubModelChanged);
+    return () => {
+      var _a2, _b2, _c2;
+      (_a2 = model.emitter) == null ? void 0 : _a2.off("onSubModelAdded", handleSubModelChanged);
+      (_b2 = model.emitter) == null ? void 0 : _b2.off("onSubModelRemoved", handleSubModelChanged);
+      (_c2 = model.emitter) == null ? void 0 : _c2.off("onSubModelReplaced", handleSubModelChanged);
+    };
+  }, [model]);
   const onClick = /* @__PURE__ */ __name(async (info) => {
     const clickedItem = info.originalItem || info;
     const item = clickedItem.originalItem || clickedItem;
@@ -415,7 +430,7 @@ const AddSubModelButtonCore = /* @__PURE__ */ __name(function AddSubModelButton(
     }
     let addedModel;
     try {
-      addedModel = model.flowEngine.createModel({
+      addedModel = await model.flowEngine.createModelAsync({
         ...import_lodash.default.cloneDeep(createOpts),
         parentId: model.uid,
         subKey: subModelKey,
@@ -461,6 +476,17 @@ const AddSubModelButtonCore = /* @__PURE__ */ __name(function AddSubModelButton(
     () => transformItems(finalItems, model, subModelKey, subModelType),
     [finalItems, model, subModelKey, subModelType]
   );
+  (0, import_react.useEffect)(() => {
+    const handleSubModelChange = /* @__PURE__ */ __name(() => {
+      setRefreshTick((x) => x + 1);
+    }, "handleSubModelChange");
+    model.emitter.on("onSubModelAdded", handleSubModelChange);
+    model.emitter.on("onSubModelRemoved", handleSubModelChange);
+    return () => {
+      model.emitter.off("onSubModelAdded", handleSubModelChange);
+      model.emitter.off("onSubModelRemoved", handleSubModelChange);
+    };
+  }, [model]);
   return /* @__PURE__ */ import_react.default.createElement(
     import_LazyDropdown.default,
     {

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/components/subModel/utils.js

@@ -44,7 +44,7 @@ __export(utils_exports, {
   buildWrapperFieldChildren: () => buildWrapperFieldChildren
 });
 module.exports = __toCommonJS(utils_exports);
-var _ = __toESM(require("lodash"));
+var import_lodash = __toESM(require("lodash"));
 var import_utils = require("../../utils");
 async function callHideFunction(hide, ctx) {
   if (typeof hide === "function") {
@@ -107,7 +107,7 @@ function buildSubModelChildren(M, ctx) {
             const extraArg = args && args.length > 0 ? args[args.length - 1] : void 0;
             const defaultOpts = await (0, import_utils.resolveCreateModelOptions)(meta == null ? void 0 : meta.createModelOptions, ctx, extraArg);
             const childOpts = await (0, import_utils.resolveCreateModelOptions)(src, ctx, extraArg);
-            return _.merge({}, _.cloneDeep(defaultOpts), childOpts);
+            return import_lodash.default.merge({}, import_lodash.default.cloneDeep(defaultOpts), childOpts);
           };
         }
         return node;

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[];