@nocobase/flow-engine 2.1.0-beta.2 → 2.1.0-beta.20

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.
@@ -119,6 +141,12 @@ const _FlowEngine = class _FlowEngine {
      */
     __publicField(this, "_previousEngine");
     __publicField(this, "_nextEngine");
+    /**
+     * 视图销毁回调。由 useDrawer / useDialog 在创建弹窗视图时注册，
+     * 供外部（如 afterSuccess）通过引擎栈遍历来关闭多层弹窗。
+     * embed 视图（usePage）不注册此回调，因此 destroyView() 会自然跳过。
+     */
+    __publicField(this, "_destroyView");
     __publicField(this, "_resources", /* @__PURE__ */ new Map());
     /**
      * Data change registry used to coordinate "refresh on active" across view-scoped engines.
@@ -258,6 +286,26 @@ const _FlowEngine = class _FlowEngine {
       prev._nextEngine = void 0;
     }
   }
+  /**
+   * 注册视图销毁回调（由 useDrawer / useDialog 调用）。
+   */
+  setDestroyView(fn) {
+    this._destroyView = fn;
+  }
+  /**
+   * 关闭当前引擎关联的弹窗视图。
+   * 路由触发的弹窗会先 navigation.back() 清理 URL，再 destroy() 移除元素；
+   * 非路由弹窗直接 destroy()。
+   * embed 视图不注册回调，调用时返回 false 自动跳过。
+   * @returns 是否成功执行
+   */
+  destroyView() {
+    if (this._destroyView) {
+      this._destroyView();
+      return true;
+    }
+    return false;
+  }
   // （已移除）getModelGlobal/forEachModelGlobal/getAllModelsGlobal：不再维护冗余全局遍历 API
   /**
    * Get the flow engine context object.
@@ -346,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
@@ -358,6 +416,274 @@ const _FlowEngine = class _FlowEngine {
       __privateMethod(this, _FlowEngine_instances, registerModel_fn).call(this, name, modelClass);
     }
   }
+  /**
+   * Register multiple model loader entries.
+   * The `extends` field declares parent class(es) for async subclass discovery via `getSubclassesOfAsync`.
+   * It accepts `string | ModelConstructor | (string | ModelConstructor)[]` and is normalized to `string[]` internally.
+   * @param {FlowModelLoaderInputMap} loaders Model loader input map
+   * @returns {void}
+   * @example
+   * flowEngine.registerModelLoaders({
+   *   DemoModel: {
+   *     extends: 'BaseModel',
+   *     loader: () => import('./models/DemoModel'),
+   *   },
+   * });
+   */
+  registerModelLoaders(loaders) {
+    let changed = false;
+    for (const [name, input] of Object.entries(loaders)) {
+      if (this._modelLoaders.has(name)) {
+        console.warn(`FlowEngine: Model loader with name '${name}' is already registered and will be overwritten.`);
+      }
+      const entry = {
+        loader: input.loader
+      };
+      if (input.extends != null) {
+        const raw = Array.isArray(input.extends) ? input.extends : [input.extends];
+        entry.extends = raw.map((item) => typeof item === "string" ? item : item.name);
+      }
+      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);
@@ -421,6 +747,55 @@ const _FlowEngine = class _FlowEngine {
     }
     return result;
   }
+  /**
+   * Asynchronously get all subclasses of a base class, including those registered via model loaders.
+   * Merges results from already-loaded classes (_modelClasses) and async loader entries with matching `extends` declarations.
+   * Loader-resolved classes are validated with `isInheritedFrom`; mismatches are warned and excluded.
+   * @param {string | ModelConstructor} baseClass Base class name or constructor
+   * @param {(ModelClass: ModelConstructor, className: string) => boolean} [filter] Optional filter function
+   * @returns {Promise<Map<string, ModelConstructor>>} Model classes that are subclasses of the base class
+   */
+  async getSubclassesOfAsync(baseClass, filter) {
+    var _a;
+    const baseClassName = typeof baseClass === "string" ? baseClass : baseClass.name;
+    let parentModelClass;
+    if (typeof baseClass === "string") {
+      if (!this.getModelClass(baseClass)) {
+        await this.ensureModel(baseClass);
+      }
+      parentModelClass = this.getModelClass(baseClass);
+    } else {
+      parentModelClass = baseClass;
+    }
+    if (!parentModelClass) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = this.getSubclassesOf(parentModelClass, filter);
+    const loaderCandidates = [];
+    for (const [name, entry] of this._modelLoaders) {
+      if (result.has(name) || this._modelClasses.has(name)) continue;
+      if ((_a = entry.extends) == null ? void 0 : _a.includes(baseClassName)) {
+        loaderCandidates.push(name);
+      }
+    }
+    if (loaderCandidates.length > 0) {
+      await this.ensureModels(loaderCandidates);
+    }
+    for (const name of loaderCandidates) {
+      const ModelClass = this._modelClasses.get(name);
+      if (!ModelClass) continue;
+      if (!(0, import_utils.isInheritedFrom)(ModelClass, parentModelClass)) {
+        console.warn(
+          `FlowEngine: Model '${name}' declares extends '${baseClassName}' but does not actually inherit from it. Skipping.`
+        );
+        continue;
+      }
+      if (!filter || filter(ModelClass, name)) {
+        result.set(name, ModelClass);
+      }
+    }
+    return result;
+  }
   /**
    * Create and register a model instance.
    * If an instance with the same UID exists, returns the existing instance.
@@ -706,7 +1081,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;
@@ -718,7 +1093,7 @@ const _FlowEngine = class _FlowEngine {
       }
       if (existing) {
         const data = existing.serialize();
-        return this.createModel(data, extra);
+        return this.createModelAsync(data, extra);
       }
     }
     if (parentId && subKey) {
@@ -729,10 +1104,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));
@@ -768,20 +1143,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.
@@ -819,17 +1195,19 @@ 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);
-      await model.save();
+      model = await this.createModelAsync(options, extra);
+      if (!(extra == null ? void 0 : extra.skipSave)) {
+        await model.save();
+      }
     }
     if (model.parent) {
       const subModel = model.parent.findSubModel(model.subKey, (m2) => {
@@ -1070,11 +1448,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 项目配置

package/lib/flowSettings.js

@@ -65,6 +65,7 @@ var import_utils = require("./utils");
 var import_exceptions = require("./utils/exceptions");
 var import_useFlowStep = require("./hooks/useFlowStep");
 var import_views = require("./views");
+var import_lazy_helper = require("./lazy-helper");
 var _forceEnabled, _emitter;
 const Panel = import_antd.Collapse.Panel;
 const _FlowSettings = class _FlowSettings {
@@ -73,10 +74,12 @@ const _FlowSettings = class _FlowSettings {
     __publicField(this, "scopes", {});
     __publicField(this, "antdComponentsLoaded", false);
     __publicField(this, "enabled");
+    __publicField(this, "engine");
     __privateAdd(this, _forceEnabled, false);
     // 强制启用状态，主要用于设计模式下的强制启用
     __publicField(this, "toolbarItems", []);
     __privateAdd(this, _emitter, new import_emitter.Emitter());
+    this.engine = engine;
     this.enabled = false;
     engine.context.defineProperty("flowSettingsEnabled", {
       get: /* @__PURE__ */ __name(() => this.enabled, "get"),
@@ -215,6 +218,29 @@ const _FlowSettings = class _FlowSettings {
       this.components[name] = components[name];
     });
   }
+  registerComponentLoaders(loaders) {
+    Object.entries(loaders).forEach(([name, loader]) => {
+      if (this.components[name]) {
+        console.warn(`FlowSettings: Component with name '${name}' is already registered and will be overwritten.`);
+      }
+      this.components[name] = (0, import_lazy_helper.lazy)(async () => {
+        const loaded = await loader();
+        if (typeof loaded === "function") {
+          return { default: loaded };
+        }
+        if ((loaded == null ? void 0 : loaded.default) && typeof loaded.default === "function") {
+          return { default: loaded.default };
+        }
+        const namedComponent = loaded == null ? void 0 : loaded[name];
+        if (typeof namedComponent === "function") {
+          return { default: namedComponent };
+        }
+        throw new Error(
+          `FlowSettings: component loader for '${name}' must resolve to a React component or a module exporting it.`
+        );
+      });
+    });
+  }
   /**
    * 添加作用域到 FlowSettings 的作用域注册表中。
    * 这些作用域可以在 flow step 的 uiSchema 中使用。
@@ -234,27 +260,29 @@ const _FlowSettings = class _FlowSettings {
   /**
    * 启用流程设置组件的显示
    * @example
-   * flowSettings.enable();
+   * await flowSettings.enable();
    */
-  enable() {
+  async enable() {
+    await this.engine.preloadModelLoaders();
     this.enabled = true;
   }
-  forceEnable() {
+  async forceEnable() {
+    await this.engine.preloadModelLoaders();
     __privateSet(this, _forceEnabled, true);
     this.enabled = true;
   }
   /**
    * 禁用流程设置组件的显示
    * @example
-   * flowSettings.disable();
+   * await flowSettings.disable();
    */
-  disable() {
+  async disable() {
     if (__privateGet(this, _forceEnabled)) {
       return;
     }
     this.enabled = false;
   }
-  forceDisable() {
+  async forceDisable() {
     __privateSet(this, _forceEnabled, false);
     this.enabled = false;
   }

package/lib/lazy-helper.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+type LazyComponentType<M extends Record<string, any>, K extends keyof M> = {
+    [P in K]: M[P];
+};
+export declare function lazy<M extends Record<'default', any>>(factory: () => Promise<M>): M['default'];
+export declare function lazy<M extends Record<string, any>, K extends keyof M = keyof M>(factory: () => Promise<M>, ...componentNames: K[]): LazyComponentType<M, K>;
+export {};