@nocobase/flow-engine 2.0.22 → 2.1.0-alpha.10

package/lib/components/MobilePopup.js

@@ -41,11 +41,12 @@ __export(MobilePopup_exports, {
 });
 module.exports = __toCommonJS(MobilePopup_exports);
 var import_antd = require("antd");
-var import_antd_mobile = require("antd-mobile");
 var import_react = __toESM(require("react"));
-var import_antd_mobile_icons = require("antd-mobile-icons");
 var import_MobilePopup = require("./MobilePopup.style");
 var import_react_i18next = require("react-i18next");
+var import_lazy_helper = require("../lazy-helper");
+const { Popup } = (0, import_lazy_helper.lazy)(() => import("antd-mobile"), "Popup");
+const { CloseOutline } = (0, import_lazy_helper.lazy)(() => import("antd-mobile-icons"), "CloseOutline");
 const MobilePopup = /* @__PURE__ */ __name((props) => {
   const { title, visible, onClose: closePopup, children, minHeight, className, footer } = props;
   const { t } = (0, import_react_i18next.useTranslation)();
@@ -67,7 +68,7 @@ const MobilePopup = /* @__PURE__ */ __name((props) => {
     };
   }, []);
   return /* @__PURE__ */ import_react.default.createElement(import_antd.ConfigProvider, { theme }, /* @__PURE__ */ import_react.default.createElement(
-    import_antd_mobile.Popup,
+    Popup,
     {
       className: `${componentCls} ${hashId} ${className || ""}`,
       visible,
@@ -81,7 +82,7 @@ const MobilePopup = /* @__PURE__ */ __name((props) => {
       style,
       destroyOnClose: true
     },
-    /* @__PURE__ */ import_react.default.createElement("div", { className: "nb-mobile-action-drawer-header" }, /* @__PURE__ */ import_react.default.createElement("span", { className: "nb-mobile-action-drawer-placeholder" }, /* @__PURE__ */ import_react.default.createElement(import_antd_mobile_icons.CloseOutline, null)), /* @__PURE__ */ import_react.default.createElement("span", null, title), /* @__PURE__ */ import_react.default.createElement(
+    /* @__PURE__ */ import_react.default.createElement("div", { className: "nb-mobile-action-drawer-header" }, /* @__PURE__ */ import_react.default.createElement("span", { className: "nb-mobile-action-drawer-placeholder" }, /* @__PURE__ */ import_react.default.createElement(CloseOutline, null)), /* @__PURE__ */ import_react.default.createElement("span", null, title), /* @__PURE__ */ import_react.default.createElement(
       "span",
       {
         className: "nb-mobile-action-drawer-close-icon",
@@ -90,7 +91,7 @@ const MobilePopup = /* @__PURE__ */ __name((props) => {
         tabIndex: 0,
         "aria-label": t("Close")
       },
-      /* @__PURE__ */ import_react.default.createElement(import_antd_mobile_icons.CloseOutline, null)
+      /* @__PURE__ */ import_react.default.createElement(CloseOutline, null)
     )),
     children,
     footer && /* @__PURE__ */ import_react.default.createElement("div", { className: "nb-mobile-action-drawer-footer" }, footer)

package/lib/components/subModel/AddSubModelButton.js

@@ -430,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,

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/flowEngine.d.ts

@@ -8,7 +8,7 @@ import { FlowResource } from './resources';
 import { Emitter } from './emitter';
 import ModelOperationScheduler from './scheduler/ModelOperationScheduler';
 import type { ScheduleOptions, ScheduledCancel } from './scheduler/ModelOperationScheduler';
-import type { ActionDefinition, ApplyFlowCacheEntry, CreateModelOptions, EventDefinition, FlowModelOptions, IFlowModelRepository, ModelConstructor, PersistOptions, ResourceType } from './types';
+import type { ActionDefinition, ApplyFlowCacheEntry, CreateModelOptions, EnsureBatchResult, EventDefinition, FlowModelLoaderMap, FlowModelOptions, IFlowModelRepository, ModelConstructor, PersistOptions, ResourceType } from './types';
 /**
  * FlowEngine is the core class of the flow engine, responsible for managing flow models, actions, model repository, and more.
  * It provides capabilities for registering, creating, finding, persisting, replacing, and moving models.
@@ -47,6 +47,28 @@ export declare class FlowEngine {
      * @private
      */
     private _modelClasses;
+    /**
+     * Registered model entries.
+     * Key is the model class name, value is the model loader entry.
+     * @private
+     */
+    private _modelLoaders;
+    /**
+     * In-flight model loading promises.
+     * Key is the model class name, value is the loading promise.
+     * @private
+     */
+    private _loadingModelPromises;
+    /**
+     * Whether model-loader preload has completed in this session.
+     * @private
+     */
+    private _modelLoadersPreloaded;
+    /**
+     * In-flight model-loader preload promise.
+     * @private
+     */
+    private _modelLoadersPreloadPromise?;
     /**
      * Created model instances.
      * Key is the model instance UID, value is the model instance object.
@@ -226,6 +248,10 @@ export declare class FlowEngine {
      * Get all registered global events.
      */
     getEvents<TModel extends FlowModel = FlowModel>(): Map<string, EventDefinition<TModel>>;
+    /**
+     * for proxy instance, the #registerModel can't be called.
+     */
+    private _registerModel;
     /**
      * Register multiple model classes.
      * @param {Record<string, ModelConstructor>} models Model class map, key is model name, value is model constructor
@@ -234,6 +260,99 @@ export declare class FlowEngine {
      * flowEngine.registerModels({ UserModel, OrderModel });
      */
     registerModels(models: Record<string, ModelConstructor | typeof FlowModel<any>>): void;
+    /**
+     * Register multiple model loader entries.
+     * @param {FlowModelLoaderMap} loaders Model loader entry map, key is model name, value is the model loader entry
+     * @returns {void}
+     * @example
+     * flowEngine.registerModelLoaders({
+     *   DemoModel: {
+     *     loader: () => import('./models/DemoModel'),
+     *   },
+     * });
+     */
+    registerModelLoaders(loaders: FlowModelLoaderMap): void;
+    /**
+     * Get a registered model class (constructor) asynchronously.
+     * This will first ensure the model loader entry is resolved.
+     * @param {string} name Model class name
+     * @returns {Promise<ModelConstructor | undefined>} Model constructor, or undefined if not found
+     */
+    getModelClassAsync(name: string): Promise<ModelConstructor | undefined>;
+    /**
+     * Get all registered model classes asynchronously.
+     * This will first ensure all registered model loader entries are resolved.
+     * @returns {Promise<Map<string, ModelConstructor>>} Model class map
+     */
+    getModelClassesAsync(): Promise<Map<string, ModelConstructor>>;
+    /**
+     * Create and register a model instance asynchronously.
+     * This will first ensure all string-based model references in the model tree are resolved.
+     * @template T FlowModel subclass type, defaults to FlowModel.
+     * @param {CreateModelOptions} options Model creation options
+     * @returns {Promise<T>} Created model instance
+     */
+    createModelAsync<T extends FlowModel = FlowModel>(options: CreateModelOptions, extra?: {
+        delegateToParent?: boolean;
+        delegate?: FlowContext;
+    }): Promise<T>;
+    /**
+     * Normalize a loader result into a model constructor.
+     * @param {string} name Model class name
+     * @param {FlowModelLoaderResult} loaded Loader result
+     * @returns {ModelConstructor | null} Normalized model constructor
+     * @private
+     */
+    private normalizeModelLoaderResult;
+    /**
+     * Collect string-based model names from a model tree.
+     * @param {unknown} data Model tree data
+     * @param {Set<string>} names Model name set
+     * @private
+     */
+    private collectModelNamesFromTree;
+    /**
+     * Collect additional model names from object-form meta.createModelOptions defaults.
+     * @param {ModelConstructor} modelClass Model class constructor
+     * @param {Set<string>} names Model name set
+     * @private
+     */
+    private collectModelNamesFromMetaDefaults;
+    /**
+     * Ensure a single model class is available.
+     * @param {string} name Model class name
+     * @returns {Promise<ModelConstructor | null>} Model constructor or null when resolution fails
+     * @private
+     */
+    private ensureModel;
+    /**
+     * Ensure multiple model classes are available.
+     * @param {string[]} names Model class names
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     * @private
+     */
+    private ensureModels;
+    /**
+     * Resolve all unresolved string-based model references in a model tree before synchronous creation begins.
+     *
+     * Use this when you already have a model tree object, such as repository-returned data or resolved
+     * `createModelOptions`, and you need to ensure every string `use` in that tree has been loaded and
+     * registered into `_modelClasses` before calling `createModel()`.
+     *
+     * @param {unknown} data Model tree data
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     */
+    resolveModelTree(data: unknown): Promise<EnsureBatchResult>;
+    /**
+     * Preload all currently registered unresolved model loaders.
+     *
+     * This method is intended for flow-settings/discovery style entry points that need registered model
+     * classes to exist before UI is rendered, without requiring callers to know which specific models
+     * will be touched next.
+     *
+     * @returns {Promise<EnsureBatchResult>} Batch ensure result
+     */
+    preloadModelLoaders(): Promise<EnsureBatchResult>;
     registerResources(resources: Record<string, any>): void;
     createResource<T = FlowResource>(resourceType: ResourceType<T>, options?: {
         context?: FlowContext;

package/lib/flowEngine.js

@@ -83,6 +83,28 @@ const _FlowEngine = class _FlowEngine {
      * @private
      */
     __publicField(this, "_modelClasses", import_reactive.observable.shallow(/* @__PURE__ */ new Map()));
+    /**
+     * Registered model entries.
+     * Key is the model class name, value is the model loader entry.
+     * @private
+     */
+    __publicField(this, "_modelLoaders", /* @__PURE__ */ new Map());
+    /**
+     * In-flight model loading promises.
+     * Key is the model class name, value is the loading promise.
+     * @private
+     */
+    __publicField(this, "_loadingModelPromises", /* @__PURE__ */ new Map());
+    /**
+     * Whether model-loader preload has completed in this session.
+     * @private
+     */
+    __publicField(this, "_modelLoadersPreloaded", false);
+    /**
+     * In-flight model-loader preload promise.
+     * @private
+     */
+    __publicField(this, "_modelLoadersPreloadPromise");
     /**
      * Created model instances.
      * Key is the model instance UID, value is the model instance object.
@@ -372,6 +394,16 @@ const _FlowEngine = class _FlowEngine {
   getEvents() {
     return this._eventRegistry.getEvents();
   }
+  /**
+   * for proxy instance, the #registerModel can't be called.
+   */
+  _registerModel(name, modelClass) {
+    if (this._modelClasses.has(name)) {
+      console.warn(`FlowEngine: Model class with name '${name}' is already registered and will be overwritten.`);
+    }
+    Object.defineProperty(modelClass, "name", { value: name });
+    this._modelClasses.set(name, modelClass);
+  }
   /**
    * Register multiple model classes.
    * @param {Record<string, ModelConstructor>} models Model class map, key is model name, value is model constructor
@@ -384,6 +416,264 @@ const _FlowEngine = class _FlowEngine {
       __privateMethod(this, _FlowEngine_instances, registerModel_fn).call(this, name, modelClass);
     }
   }
+  /**
+   * Register multiple model loader entries.
+   * @param {FlowModelLoaderMap} loaders Model loader entry map, key is model name, value is the model loader entry
+   * @returns {void}
+   * @example
+   * flowEngine.registerModelLoaders({
+   *   DemoModel: {
+   *     loader: () => import('./models/DemoModel'),
+   *   },
+   * });
+   */
+  registerModelLoaders(loaders) {
+    let changed = false;
+    for (const [name, entry] of Object.entries(loaders)) {
+      if (this._modelLoaders.has(name)) {
+        console.warn(`FlowEngine: Model loader with name '${name}' is already registered and will be overwritten.`);
+      }
+      this._modelLoaders.set(name, entry);
+      changed = true;
+    }
+    if (changed) {
+      this._modelLoadersPreloaded = false;
+      this._modelLoadersPreloadPromise = void 0;
+    }
+  }
+  /**
+   * Get a registered model class (constructor) asynchronously.
+   * This will first ensure the model loader entry is resolved.
+   * @param {string} name Model class name
+   * @returns {Promise<ModelConstructor | undefined>} Model constructor, or undefined if not found
+   */
+  async getModelClassAsync(name) {
+    await this.ensureModel(name);
+    return this.getModelClass(name);
+  }
+  /**
+   * Get all registered model classes asynchronously.
+   * This will first ensure all registered model loader entries are resolved.
+   * @returns {Promise<Map<string, ModelConstructor>>} Model class map
+   */
+  async getModelClassesAsync() {
+    await this.ensureModels(Array.from(this._modelLoaders.keys()));
+    return this.getModelClasses();
+  }
+  /**
+   * Create and register a model instance asynchronously.
+   * This will first ensure all string-based model references in the model tree are resolved.
+   * @template T FlowModel subclass type, defaults to FlowModel.
+   * @param {CreateModelOptions} options Model creation options
+   * @returns {Promise<T>} Created model instance
+   */
+  async createModelAsync(options, extra) {
+    await this.resolveModelTree(options);
+    return this.createModel(options, extra);
+  }
+  /**
+   * Normalize a loader result into a model constructor.
+   * @param {string} name Model class name
+   * @param {FlowModelLoaderResult} loaded Loader result
+   * @returns {ModelConstructor | null} Normalized model constructor
+   * @private
+   */
+  normalizeModelLoaderResult(name, loaded) {
+    if (typeof loaded === "function") {
+      return loaded;
+    }
+    if (loaded && typeof loaded === "object") {
+      const defaultExport = loaded.default;
+      if (typeof defaultExport === "function") {
+        return defaultExport;
+      }
+      const namedExport = loaded[name];
+      if (typeof namedExport === "function") {
+        return namedExport;
+      }
+    }
+    console.warn(`FlowEngine: model loader for '${name}' did not resolve to a valid model constructor.`);
+    return null;
+  }
+  /**
+   * Collect string-based model names from a model tree.
+   * @param {unknown} data Model tree data
+   * @param {Set<string>} names Model name set
+   * @private
+   */
+  collectModelNamesFromTree(data, names) {
+    if (!data || typeof data !== "object") {
+      return;
+    }
+    if (Array.isArray(data)) {
+      data.forEach((item) => this.collectModelNamesFromTree(item, names));
+      return;
+    }
+    const tree = data;
+    if (typeof tree.use === "string") {
+      names.add(tree.use);
+    }
+    const subModels = tree.subModels;
+    if (!subModels || typeof subModels !== "object") {
+      return;
+    }
+    Object.values(subModels).forEach((value) => {
+      this.collectModelNamesFromTree(value, names);
+    });
+  }
+  /**
+   * Collect additional model names from object-form meta.createModelOptions defaults.
+   * @param {ModelConstructor} modelClass Model class constructor
+   * @param {Set<string>} names Model name set
+   * @private
+   */
+  collectModelNamesFromMetaDefaults(modelClass, names) {
+    var _a;
+    const metaCreate = (_a = modelClass.meta) == null ? void 0 : _a.createModelOptions;
+    if (metaCreate && typeof metaCreate === "object") {
+      this.collectModelNamesFromTree(metaCreate, names);
+    }
+  }
+  /**
+   * Ensure a single model class is available.
+   * @param {string} name Model class name
+   * @returns {Promise<ModelConstructor | null>} Model constructor or null when resolution fails
+   * @private
+   */
+  async ensureModel(name) {
+    const existing = this._modelClasses.get(name);
+    if (existing) {
+      return existing;
+    }
+    const inflight = this._loadingModelPromises.get(name);
+    if (inflight) {
+      return inflight;
+    }
+    const entry = this._modelLoaders.get(name);
+    if (!entry) {
+      console.warn(`FlowEngine: Model entry '${name}' not found. Falling back to ErrorFlowModel when needed.`);
+      return null;
+    }
+    const promise = (async () => {
+      try {
+        const loaded = await entry.loader();
+        const modelClass = this.normalizeModelLoaderResult(name, loaded);
+        if (!modelClass) {
+          return null;
+        }
+        this._registerModel(name, modelClass);
+        return modelClass;
+      } catch (error) {
+        console.warn(`FlowEngine: Failed to load model '${name}'. Falling back to ErrorFlowModel when needed.`, error);
+        return null;
+      } finally {
+        this._loadingModelPromises.delete(name);
+      }
+    })();
+    this._loadingModelPromises.set(name, promise);
+    return promise;
+  }
+  /**
+   * Ensure multiple model classes are available.
+   * @param {string[]} names Model class names
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   * @private
+   */
+  async ensureModels(names) {
+    const requested = Array.from(new Set(names.filter((name) => !!name)));
+    const loaded = [];
+    const failed = [];
+    const results = await Promise.all(
+      requested.map(async (name) => {
+        const modelClass = await this.ensureModel(name);
+        return { name, modelClass };
+      })
+    );
+    results.forEach(({ name, modelClass }) => {
+      if (modelClass) {
+        loaded.push(name);
+      } else {
+        failed.push({ name });
+      }
+    });
+    return { requested, loaded, failed };
+  }
+  /**
+   * Resolve all unresolved string-based model references in a model tree before synchronous creation begins.
+   *
+   * Use this when you already have a model tree object, such as repository-returned data or resolved
+   * `createModelOptions`, and you need to ensure every string `use` in that tree has been loaded and
+   * registered into `_modelClasses` before calling `createModel()`.
+   *
+   * @param {unknown} data Model tree data
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   */
+  async resolveModelTree(data) {
+    const requested = /* @__PURE__ */ new Set();
+    const loaded = /* @__PURE__ */ new Set();
+    const failed = /* @__PURE__ */ new Map();
+    const processed = /* @__PURE__ */ new Set();
+    const pending = /* @__PURE__ */ new Set();
+    this.collectModelNamesFromTree(data, pending);
+    while (pending.size > 0) {
+      const batch = Array.from(pending).filter((name) => !processed.has(name));
+      pending.clear();
+      if (batch.length === 0) {
+        break;
+      }
+      batch.forEach((name) => requested.add(name));
+      const result = await this.ensureModels(batch);
+      result.loaded.forEach((name) => {
+        processed.add(name);
+        loaded.add(name);
+        const modelClass = this.getModelClass(name);
+        if (modelClass) {
+          const discovered = /* @__PURE__ */ new Set();
+          this.collectModelNamesFromMetaDefaults(modelClass, discovered);
+          discovered.forEach((discoveredName) => {
+            if (!processed.has(discoveredName)) {
+              pending.add(discoveredName);
+            }
+          });
+        }
+      });
+      result.failed.forEach((item) => {
+        processed.add(item.name);
+        failed.set(item.name, item);
+      });
+    }
+    return {
+      requested: Array.from(requested),
+      loaded: Array.from(loaded),
+      failed: Array.from(failed.values())
+    };
+  }
+  /**
+   * Preload all currently registered unresolved model loaders.
+   *
+   * This method is intended for flow-settings/discovery style entry points that need registered model
+   * classes to exist before UI is rendered, without requiring callers to know which specific models
+   * will be touched next.
+   *
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   */
+  async preloadModelLoaders() {
+    const unresolved = Array.from(this._modelLoaders.keys()).filter((name) => !this._modelClasses.has(name));
+    if (unresolved.length === 0) {
+      this._modelLoadersPreloaded = true;
+      return { requested: [], loaded: [], failed: [] };
+    }
+    if (this._modelLoadersPreloadPromise) {
+      return this._modelLoadersPreloadPromise;
+    }
+    this._modelLoadersPreloadPromise = (async () => {
+      const result = await this.ensureModels(unresolved);
+      this._modelLoadersPreloaded = result.failed.length === 0;
+      this._modelLoadersPreloadPromise = void 0;
+      return result;
+    })();
+    return this._modelLoadersPreloadPromise;
+  }
   registerResources(resources) {
     for (const [name, resourceClass] of Object.entries(resources)) {
       this._resources.set(name, resourceClass);
@@ -732,7 +1022,7 @@ const _FlowEngine = class _FlowEngine {
    * Hydrate a model into current engine from an already-existing model instance in previous engines.
    * - Avoids repository requests when the model tree is already present in memory.
    */
-  hydrateModelFromPreviousEngines(options, extra) {
+  async hydrateModelFromPreviousEngines(options, extra) {
     var _a;
     const uid = options == null ? void 0 : options.uid;
     const parentId = options == null ? void 0 : options.parentId;
@@ -744,7 +1034,7 @@ const _FlowEngine = class _FlowEngine {
       }
       if (existing) {
         const data = existing.serialize();
-        return this.createModel(data, extra);
+        return this.createModelAsync(data, extra);
       }
     }
     if (parentId && subKey) {
@@ -755,10 +1045,10 @@ const _FlowEngine = class _FlowEngine {
       if (!localParent) {
         const parentData = parentFromPrev.serialize();
         delete parentData.subModels;
-        localParent = this.createModel(parentData, extra);
+        localParent = await this.createModelAsync(parentData, extra);
       }
       const modelData = modelFromPrev.serialize();
-      const localModel = this.createModel(modelData, extra);
+      const localModel = await this.createModelAsync(modelData, extra);
       const mounted = (_a = localParent.subModels) == null ? void 0 : _a[subKey];
       if (Array.isArray(mounted)) {
         const exists = mounted.some((m) => (m == null ? void 0 : m.uid) === (localModel == null ? void 0 : localModel.uid));
@@ -794,20 +1084,21 @@ const _FlowEngine = class _FlowEngine {
       if (model) {
         return model;
       }
-      const hydrated = this.hydrateModelFromPreviousEngines(options);
+      const hydrated = await this.hydrateModelFromPreviousEngines(options);
       if (hydrated) {
         return hydrated;
       }
     }
     const data = await this._modelRepository.findOne(options);
     if (!(data == null ? void 0 : data.uid)) return null;
+    await this.resolveModelTree(data);
     if (refresh) {
       const existing = this.getModel(data.uid);
       if (existing) {
         this.removeModelWithSubModels(existing.uid);
       }
     }
-    return this.createModel(data);
+    return this.createModelAsync(data);
   }
   /**
    * Find a sub-model by parent model ID and subKey.
@@ -845,16 +1136,16 @@ const _FlowEngine = class _FlowEngine {
     if (m) {
       return m;
     }
-    const hydrated = this.hydrateModelFromPreviousEngines(options, extra);
+    const hydrated = await this.hydrateModelFromPreviousEngines(options, extra);
     if (hydrated) {
       return hydrated;
     }
     const data = await this._modelRepository.findOne(options);
     let model = null;
     if (data == null ? void 0 : data.uid) {
-      model = this.createModel(data, extra);
+      model = await this.createModelAsync(data, extra);
     } else {
-      model = this.createModel(options, extra);
+      model = await this.createModelAsync(options, extra);
       if (!(extra == null ? void 0 : extra.skipSave)) {
         await model.save();
       }
@@ -1098,11 +1389,7 @@ _FlowEngine_instances = new WeakSet();
  * @private
  */
 registerModel_fn = /* @__PURE__ */ __name(function(name, modelClass) {
-  if (this._modelClasses.has(name)) {
-    console.warn(`FlowEngine: Model class with name '${name}' is already registered and will be overwritten.`);
-  }
-  Object.defineProperty(modelClass, "name", { value: name });
-  this._modelClasses.set(name, modelClass);
+  return this._registerModel(name, modelClass);
 }, "#registerModel");
 __name(_FlowEngine, "FlowEngine");
 let FlowEngine = _FlowEngine;

package/lib/flowSettings.d.ts

@@ -79,12 +79,19 @@ export interface FlowSettingsOpenOptions {
     /** 配置保存成功后触发的回调 */
     onSaved?: () => void | Promise<void>;
 }
+export type FlowSettingsComponent = React.ComponentType<any>;
+export type FlowSettingsComponentModule = {
+    default?: FlowSettingsComponent;
+} | Record<string, FlowSettingsComponent>;
+export type FlowSettingsComponentLoader = () => Promise<FlowSettingsComponentModule | FlowSettingsComponent>;
+export type FlowSettingsComponentLoaderMap = Record<string, FlowSettingsComponentLoader>;
 export declare class FlowSettings {
     #private;
     components: Record<string, any>;
     scopes: Record<string, any>;
     private antdComponentsLoaded;
     enabled: boolean;
+    private engine;
     toolbarItems: ToolbarItemConfig[];
     constructor(engine: FlowEngine);
     on(event: 'beforeOpen', callback: (...args: any[]) => void): void;
@@ -110,6 +117,7 @@ export declare class FlowSettings {
      * flowSettings.registerComponents({ MyComponent, AnotherComponent });
      */
     registerComponents(components: Record<string, any>): void;
+    registerComponentLoaders(loaders: FlowSettingsComponentLoaderMap): void;
     /**
      * 添加作用域到 FlowSettings 的作用域注册表中。
      * 这些作用域可以在 flow step 的 uiSchema 中使用。
@@ -122,17 +130,17 @@ export declare class FlowSettings {
     /**
      * 启用流程设置组件的显示
      * @example
-     * flowSettings.enable();
+     * await flowSettings.enable();
      */
-    enable(): void;
-    forceEnable(): void;
+    enable(): Promise<void>;
+    forceEnable(): Promise<void>;
     /**
      * 禁用流程设置组件的显示
      * @example
-     * flowSettings.disable();
+     * await flowSettings.disable();
      */
-    disable(): void;
-    forceDisable(): void;
+    disable(): Promise<void>;
+    forceDisable(): Promise<void>;
     /**
      * 添加扩展工具栏项目
      * @param {ToolbarItemConfig} config 项目配置