@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/flowEngine.d.ts

@@ -5,6 +5,9 @@ import { FlowSettings } from './flowSettings';
 import { FlowModel } from './models';
 import { ReactView } from './ReactView';
 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';
 /**
  * FlowEngine is the core class of the flow engine, responsible for managing flow models, actions, model repository, and more.
@@ -81,6 +84,24 @@ export declare class FlowEngine {
     private _previousEngine?;
     private _nextEngine?;
     private _resources;
+    /**
+     * Data change registry used to coordinate "refresh on active" across view-scoped engines.
+     *
+     * Keyed by: dataSourceKey -> resourceName -> version.
+     * - mark: increments version
+     * - get: returns current version (default 0)
+     *
+     * NOTE: ViewScopedFlowEngine proxies delegate non-local fields/methods to parents, so this
+     * registry naturally lives on the root engine instance and is shared across the whole view stack.
+     */
+    private _dataSourceDirtyVersions;
+    /**
+     * 引擎事件总线（目前用于模型生命周期等事件）。
+     * ViewScopedFlowEngine 持有自己的实例，实现作用域隔离。
+     */
+    emitter: Emitter;
+    /** 调度器：仅在 View 作用域引擎本地启用；根/Block 作用域默认不持有 */
+    private _modelOperationScheduler?;
     logger: pino.Logger;
     /**
      * Flow settings, including components and form scopes.
@@ -95,13 +116,29 @@ export declare class FlowEngine {
      */
     reactView: ReactView;
     /**
-     * Flow executor that runs flows and auto-flows.
+     * Flow executor that runs event flows.
      */
     executor: FlowExecutor;
     /**
      * Constructor. Initializes React view, registers default model and form scopes.
      */
     constructor();
+    /** 获取/创建当前引擎的调度器（仅在本地作用域） */
+    getScheduler(): ModelOperationScheduler;
+    /** 释放并清理当前引擎本地调度器（若存在） */
+    disposeScheduler(): void;
+    /**
+     * Mark a data source resource as "dirty" (changed).
+     * This is used by data blocks to decide whether to refresh when a view becomes active.
+     */
+    markDataSourceDirty(dataSourceKey: string, resourceName: string): number;
+    /**
+     * Get current dirty version for a data source resource.
+     * Returns 0 when no writes have been recorded.
+     */
+    getDataSourceDirtyVersion(dataSourceKey: string, resourceName: string): number;
+    /** 在目标模型生命周期达成时执行操作（仅在 View 引擎本地存储计划） */
+    scheduleModelOperation(fromModelOrUid: FlowModel | string, toUid: string, fn: (model: FlowModel) => Promise<void> | void, options?: ScheduleOptions): ScheduledCancel;
     /** 上一个引擎（根引擎为 undefined） */
     get previousEngine(): FlowEngine | undefined;
     /** 下一个引擎（若存在） */
@@ -218,6 +255,11 @@ export declare class FlowEngine {
         delegateToParent?: boolean;
         delegate?: FlowContext;
     }): T;
+    /**
+     * 按类上的 resolveUse 链路解析最终用于实例化的模型类。
+     * 允许模型类根据上下文动态指定实际使用的类，支持多级 resolveUse。
+     */
+    private _resolveModelClass;
     /**
      * 尝试应用当前模型可用 flow 的 defaultParams（如果存在）到 model.stepParams。
      * 仅对尚未存在的步骤参数进行填充，不覆盖已有值。
@@ -242,12 +284,33 @@ export declare class FlowEngine {
      * @returns {boolean} Returns true if successfully destroyed, false otherwise (e.g. instance does not exist)
      */
     removeModel(uid: string): boolean;
+    /**
+     * Remove a local model instance and all its sub-models recursively.
+     * @param {string} uid UID of the model instance to destroy
+     * @returns {boolean} Returns true if successfully destroyed, false otherwise
+     */
+    removeModelWithSubModels(uid: string): boolean;
     /**
      * Check if the model repository is set.
      * @returns {boolean} Returns true if set, false otherwise.
      * @private
      */
     private ensureModelRepository;
+    /**
+     * Try to locate a model instance in previous engines (view stack) by uid.
+     * This is mainly used by view-scoped engines to reuse already-loaded model trees
+     * (e.g. models created from local JSON) without hitting the repository.
+     */
+    private findModelInPreviousEngines;
+    /**
+     * Try to locate a sub-model in previous engines (view stack) by (parentId, subKey).
+     */
+    private findSubModelInPreviousEngines;
+    /**
+     * 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.
+     */
+    private hydrateModelFromPreviousEngines;
     /**
      * Load a model instance (prefers local, falls back to repository).
      * @template T FlowModel subclass type, defaults to FlowModel.
@@ -304,6 +367,13 @@ export declare class FlowEngine {
      * @returns {Promise<boolean>} Whether destroyed successfully
      */
     destroyModel(uid: string): Promise<boolean>;
+    /**
+     * Duplicate a model tree via repository API.
+     * Returns the duplicated model JSON (root with subModels) or null if not available.
+     * @param {string} uid UID of the model to duplicate
+     * @returns {Promise<any | null>} Duplicated model JSON or null
+     */
+    duplicateModel(uid: string): Promise<Record<string, any>>;
     /**
      * Replace a model instance with a new instance of a class.
      * @template T New model type

package/lib/flowEngine.js

@@ -59,6 +59,8 @@ var import_flowSettings = require("./flowSettings");
 var import_models = require("./models");
 var import_ReactView = require("./ReactView");
 var import_resources = require("./resources");
+var import_emitter = require("./emitter");
+var import_ModelOperationScheduler = __toESM(require("./scheduler/ModelOperationScheduler"));
 var import_utils = require("./utils");
 var _FlowEngine_instances, registerModel_fn;
 const _FlowEngine = class _FlowEngine {
@@ -118,6 +120,24 @@ const _FlowEngine = class _FlowEngine {
     __publicField(this, "_previousEngine");
     __publicField(this, "_nextEngine");
     __publicField(this, "_resources", /* @__PURE__ */ new Map());
+    /**
+     * Data change registry used to coordinate "refresh on active" across view-scoped engines.
+     *
+     * Keyed by: dataSourceKey -> resourceName -> version.
+     * - mark: increments version
+     * - get: returns current version (default 0)
+     *
+     * NOTE: ViewScopedFlowEngine proxies delegate non-local fields/methods to parents, so this
+     * registry naturally lives on the root engine instance and is shared across the whole view stack.
+     */
+    __publicField(this, "_dataSourceDirtyVersions", /* @__PURE__ */ new Map());
+    /**
+     * 引擎事件总线（目前用于模型生命周期等事件）。
+     * ViewScopedFlowEngine 持有自己的实例，实现作用域隔离。
+     */
+    __publicField(this, "emitter", new import_emitter.Emitter());
+    /** 调度器：仅在 View 作用域引擎本地启用；根/Block 作用域默认不持有 */
+    __publicField(this, "_modelOperationScheduler");
     __publicField(this, "logger");
     /**
      * Flow settings, including components and form scopes.
@@ -132,7 +152,7 @@ const _FlowEngine = class _FlowEngine {
      */
     __publicField(this, "reactView");
     /**
-     * Flow executor that runs flows and auto-flows.
+     * Flow executor that runs event flows.
      */
     __publicField(this, "executor");
     this.reactView = new import_ReactView.ReactView(this);
@@ -161,6 +181,54 @@ const _FlowEngine = class _FlowEngine {
     });
     this.executor = new import_FlowExecutor.FlowExecutor(this);
   }
+  /** 获取/创建当前引擎的调度器（仅在本地作用域） */
+  getScheduler() {
+    if (!this._modelOperationScheduler) {
+      this._modelOperationScheduler = new import_ModelOperationScheduler.default(this);
+    }
+    return this._modelOperationScheduler;
+  }
+  /** 释放并清理当前引擎本地调度器（若存在） */
+  disposeScheduler() {
+    if (this._modelOperationScheduler) {
+      try {
+        this._modelOperationScheduler.dispose();
+      } finally {
+        this._modelOperationScheduler = void 0;
+      }
+    }
+  }
+  /**
+   * Mark a data source resource as "dirty" (changed).
+   * This is used by data blocks to decide whether to refresh when a view becomes active.
+   */
+  markDataSourceDirty(dataSourceKey, resourceName) {
+    const dsKey = String(dataSourceKey || "main");
+    const resName = String(resourceName || "");
+    if (!resName) return this.getDataSourceDirtyVersion(dsKey, resName);
+    const ds = this._dataSourceDirtyVersions.get(dsKey) || /* @__PURE__ */ new Map();
+    if (!this._dataSourceDirtyVersions.has(dsKey)) {
+      this._dataSourceDirtyVersions.set(dsKey, ds);
+    }
+    const next = (ds.get(resName) || 0) + 1;
+    ds.set(resName, next);
+    return next;
+  }
+  /**
+   * Get current dirty version for a data source resource.
+   * Returns 0 when no writes have been recorded.
+   */
+  getDataSourceDirtyVersion(dataSourceKey, resourceName) {
+    var _a;
+    const dsKey = String(dataSourceKey || "main");
+    const resName = String(resourceName || "");
+    if (!resName) return 0;
+    return ((_a = this._dataSourceDirtyVersions.get(dsKey)) == null ? void 0 : _a.get(resName)) || 0;
+  }
+  /** 在目标模型生命周期达成时执行操作（仅在 View 引擎本地存储计划） */
+  scheduleModelOperation(fromModelOrUid, toUid, fn, options) {
+    return this.getScheduler().schedule(fromModelOrUid, toUid, fn, options);
+  }
   /** 上一个引擎（根引擎为 undefined） */
   get previousEngine() {
     return this._previousEngine;
@@ -361,8 +429,14 @@ const _FlowEngine = class _FlowEngine {
    * @returns {T} Created model instance
    */
   createModel(options, extra) {
+    var _a;
     const { parentId, uid, use: modelClassName, subModels } = options;
-    const ModelClass = typeof modelClassName === "string" ? this.getModelClass(modelClassName) : modelClassName;
+    const parentModel = parentId ? this.getModel(parentId) || ((_a = this.previousEngine) == null ? void 0 : _a.getModel(parentId)) : void 0;
+    const ModelClass = this._resolveModelClass(
+      typeof modelClassName === "string" ? this.getModelClass(modelClassName) : modelClassName,
+      options,
+      parentModel
+    );
     if (uid && this._modelInstances.has(uid)) {
       return this._modelInstances.get(uid);
     }
@@ -376,20 +450,69 @@ const _FlowEngine = class _FlowEngine {
     if (extra == null ? void 0 : extra.delegate) {
       modelInstance.context.addDelegate(extra.delegate);
     }
-    if (parentId && this._modelInstances.has(parentId)) {
-      modelInstance.setParent(this._modelInstances.get(parentId));
+    if (parentModel) {
+      modelInstance.setParent(parentModel);
       if ((extra == null ? void 0 : extra.delegateToParent) === false) {
         modelInstance.removeParentDelegate();
       }
     }
     this._modelInstances.set(modelInstance.uid, modelInstance);
     modelInstance.onInit(options);
+    void this.emitter.emitAsync("model:created", {
+      uid: modelInstance.uid,
+      model: modelInstance
+    });
     this._applyFlowDefinitionDefaultParams(modelInstance).catch((err) => {
       console.warn("FlowEngine: apply flow defaultParams failed:", err);
     });
     modelInstance._createSubModels(options.subModels);
     return modelInstance;
   }
+  /**
+   * 按类上的 resolveUse 链路解析最终用于实例化的模型类。
+   * 允许模型类根据上下文动态指定实际使用的类，支持多级 resolveUse。
+   */
+  _resolveModelClass(initial, options, parent) {
+    const normalize = /* @__PURE__ */ __name((resolved) => {
+      if (!resolved) return {};
+      if (typeof resolved === "object" && "use" in resolved) {
+        return { target: resolved.use, stop: !!resolved.stop };
+      }
+      return { target: resolved, stop: false };
+    }, "normalize");
+    let current = initial;
+    const visited = /* @__PURE__ */ new Set();
+    while (current) {
+      if (visited.has(current)) {
+        console.warn(`FlowEngine: resolveUse circular reference detected on '${current.name}'.`);
+        break;
+      }
+      visited.add(current);
+      const resolver = current == null ? void 0 : current.resolveUse;
+      if (typeof resolver !== "function") {
+        break;
+      }
+      const { target, stop } = normalize(resolver(options, this, parent));
+      if (!target || target === current) {
+        break;
+      }
+      let next;
+      if (typeof target === "string") {
+        next = this.getModelClass(target);
+        if (!next) {
+          console.warn(`FlowEngine: resolveUse returned '${target}' but no model is registered under that name.`);
+          return void 0;
+        }
+      } else {
+        next = target;
+      }
+      current = next;
+      if (stop) {
+        break;
+      }
+    }
+    return current;
+  }
   /**
    * 尝试应用当前模型可用 flow 的 defaultParams（如果存在）到 model.stepParams。
    * 仅对尚未存在的步骤参数进行填充，不覆盖已有值。
@@ -460,12 +583,13 @@ const _FlowEngine = class _FlowEngine {
    * @returns {boolean} Returns true if successfully destroyed, false otherwise (e.g. instance does not exist)
    */
   removeModel(uid) {
-    var _a;
+    var _a, _b, _c;
     if (!this._modelInstances.has(uid)) {
       console.warn(`FlowEngine: Model with UID '${uid}' does not exist.`);
       return false;
     }
     const modelInstance = this._modelInstances.get(uid);
+    modelInstance.invalidateFlowCache(void 0, true);
     modelInstance.clearForks();
     if ((_a = modelInstance.parent) == null ? void 0 : _a.subModels) {
       for (const subKey in modelInstance.parent.subModels) {
@@ -475,18 +599,65 @@ const _FlowEngine = class _FlowEngine {
           if (index !== -1) {
             subModelValue.splice(index, 1);
             modelInstance.parent.emitter.emit("onSubModelRemoved", modelInstance);
+            (_b = this.emitter) == null ? void 0 : _b.emit("model:subModel:removed", {
+              parentUid: modelInstance.parent.uid,
+              parent: modelInstance.parent,
+              model: modelInstance
+            });
             break;
           }
         } else if (subModelValue && subModelValue === modelInstance) {
           delete modelInstance.parent.subModels[subKey];
           modelInstance.parent.emitter.emit("onSubModelRemoved", modelInstance);
+          (_c = this.emitter) == null ? void 0 : _c.emit("model:subModel:removed", {
+            parentUid: modelInstance.parent.uid,
+            parent: modelInstance.parent,
+            model: modelInstance
+          });
           break;
         }
       }
     }
     this._modelInstances.delete(uid);
+    void this.emitter.emitAsync("model:destroyed", {
+      uid,
+      model: modelInstance
+    });
     return true;
   }
+  /**
+   * Remove a local model instance and all its sub-models recursively.
+   * @param {string} uid UID of the model instance to destroy
+   * @returns {boolean} Returns true if successfully destroyed, false otherwise
+   */
+  removeModelWithSubModels(uid) {
+    const model = this.getModel(uid);
+    if (!model) {
+      return false;
+    }
+    const collectDescendants = /* @__PURE__ */ __name((m, acc) => {
+      if (m.subModels) {
+        for (const key in m.subModels) {
+          const sub = m.subModels[key];
+          if (Array.isArray(sub)) {
+            [...sub].forEach((s) => collectDescendants(s, acc));
+          } else if (sub) {
+            collectDescendants(sub, acc);
+          }
+        }
+      }
+      acc.push(m);
+    }, "collectDescendants");
+    const allModels = [];
+    collectDescendants(model, allModels);
+    let success = true;
+    for (const m of allModels) {
+      if (!this.removeModel(m.uid)) {
+        success = false;
+      }
+    }
+    return success;
+  }
   /**
    * Check if the model repository is set.
    * @returns {boolean} Returns true if set, false otherwise.
@@ -498,6 +669,91 @@ const _FlowEngine = class _FlowEngine {
     }
     return true;
   }
+  /**
+   * Try to locate a model instance in previous engines (view stack) by uid.
+   * This is mainly used by view-scoped engines to reuse already-loaded model trees
+   * (e.g. models created from local JSON) without hitting the repository.
+   */
+  findModelInPreviousEngines(uid) {
+    let eng = this.previousEngine;
+    while (eng) {
+      const found = eng.getModel(uid);
+      if (found) return found;
+      eng = eng.previousEngine;
+    }
+    return void 0;
+  }
+  /**
+   * Try to locate a sub-model in previous engines (view stack) by (parentId, subKey).
+   */
+  findSubModelInPreviousEngines(parentId, subKey) {
+    var _a;
+    let eng = this.previousEngine;
+    while (eng) {
+      const parent = eng.getModel(parentId);
+      if (parent) {
+        const sub = (_a = parent.subModels) == null ? void 0 : _a[subKey];
+        if (sub) {
+          const model = Array.isArray(sub) ? sub[0] : sub;
+          if (model) return { parent, model };
+        }
+      }
+      eng = eng.previousEngine;
+    }
+    return void 0;
+  }
+  /**
+   * 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) {
+    var _a;
+    const uid = options == null ? void 0 : options.uid;
+    const parentId = options == null ? void 0 : options.parentId;
+    const subKey = options == null ? void 0 : options.subKey;
+    if (uid && !this._modelInstances.has(uid)) {
+      const existing = this.findModelInPreviousEngines(uid);
+      if (existing == null ? void 0 : existing.context.flowSettingsEnabled) {
+        return null;
+      }
+      if (existing) {
+        const data = existing.serialize();
+        return this.createModel(data, extra);
+      }
+    }
+    if (parentId && subKey) {
+      const found = this.findSubModelInPreviousEngines(parentId, subKey);
+      if (!found || found.parent.context.flowSettingsEnabled) return null;
+      const { parent: parentFromPrev, model: modelFromPrev } = found;
+      let localParent = this.getModel(parentId);
+      if (!localParent) {
+        const parentData = parentFromPrev.serialize();
+        delete parentData.subModels;
+        localParent = this.createModel(parentData, extra);
+      }
+      const modelData = modelFromPrev.serialize();
+      const localModel = this.createModel(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));
+        if (!exists) {
+          localParent.addSubModel(subKey, localModel);
+        }
+      } else if (mounted instanceof import_models.FlowModel) {
+        if (mounted.uid !== (localModel == null ? void 0 : localModel.uid)) {
+          localParent.setSubModel(subKey, localModel);
+        }
+      } else {
+        if ((localModel == null ? void 0 : localModel.subType) === "array") {
+          localParent.addSubModel(subKey, localModel);
+        } else {
+          localParent.setSubModel(subKey, localModel);
+        }
+      }
+      return localModel;
+    }
+    return null;
+  }
   /**
    * Load a model instance (prefers local, falls back to repository).
    * @template T FlowModel subclass type, defaults to FlowModel.
@@ -506,12 +762,26 @@ const _FlowEngine = class _FlowEngine {
    */
   async loadModel(options) {
     if (!this.ensureModelRepository()) return;
-    const model = this.findModelByParentId(options.parentId, options.subKey);
-    if (model) {
-      return model;
+    const refresh = !!(options == null ? void 0 : options.refresh);
+    if (!refresh) {
+      const model = this.findModelByParentId(options.parentId, options.subKey);
+      if (model) {
+        return model;
+      }
+      const hydrated = this.hydrateModelFromPreviousEngines(options);
+      if (hydrated) {
+        return hydrated;
+      }
     }
     const data = await this._modelRepository.findOne(options);
-    return (data == null ? void 0 : data.uid) ? this.createModel(data) : null;
+    if (!(data == null ? void 0 : data.uid)) return null;
+    if (refresh) {
+      const existing = this.getModel(data.uid);
+      if (existing) {
+        this.removeModelWithSubModels(existing.uid);
+      }
+    }
+    return this.createModel(data);
   }
   /**
    * Find a sub-model by parent model ID and subKey.
@@ -549,6 +819,10 @@ const _FlowEngine = class _FlowEngine {
     if (m) {
       return m;
     }
+    const hydrated = 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) {
@@ -627,7 +901,21 @@ const _FlowEngine = class _FlowEngine {
     if (this.ensureModelRepository()) {
       await this._modelRepository.destroy(uid);
     }
-    return this.removeModel(uid);
+    const modelInstance = this._modelInstances.get(uid);
+    const parent = modelInstance == null ? void 0 : modelInstance.parent;
+    const result = this.removeModel(uid);
+    parent && parent.emitter.emit("onSubModelDestroyed", modelInstance);
+    return result;
+  }
+  /**
+   * Duplicate a model tree via repository API.
+   * Returns the duplicated model JSON (root with subModels) or null if not available.
+   * @param {string} uid UID of the model to duplicate
+   * @returns {Promise<any | null>} Duplicated model JSON or null
+   */
+  async duplicateModel(uid) {
+    if (!this.ensureModelRepository()) return null;
+    return this._modelRepository.duplicate(uid);
   }
   /**
    * Replace a model instance with a new instance of a class.
@@ -640,7 +928,7 @@ const _FlowEngine = class _FlowEngine {
    * @returns {Promise<T | null>} Newly created model instance
    */
   async replaceModel(uid, optionsOrFn) {
-    var _a;
+    var _a, _b;
     const oldModel = this.getModel(uid);
     if (!oldModel) {
       console.warn(`FlowEngine: Cannot replace model. Model with UID '${uid}' not found.`);
@@ -674,9 +962,15 @@ const _FlowEngine = class _FlowEngine {
     }
     if (currentParent) {
       currentParent.emitter.setPaused(false);
-      currentParent.parent.invalidateAutoFlowCache(true);
+      currentParent.parent.invalidateFlowCache("beforeRender", true);
       (_a = currentParent.parent) == null ? void 0 : _a.rerender();
       currentParent.emitter.emit("onSubModelReplaced", { oldModel, newModel });
+      (_b = this.emitter) == null ? void 0 : _b.emit("model:subModel:replaced", {
+        parentUid: currentParent.uid,
+        parent: currentParent,
+        oldModel,
+        newModel
+      });
     }
     await newModel.save();
     return newModel;
@@ -688,6 +982,7 @@ const _FlowEngine = class _FlowEngine {
    * @returns {Promise<void>} No return value
    */
   async moveModel(sourceId, targetId, options) {
+    var _a, _b;
     const sourceModel = this.getModel(sourceId);
     const targetModel = this.getModel(targetId);
     if (!sourceModel || !targetModel) {
@@ -704,7 +999,8 @@ const _FlowEngine = class _FlowEngine {
         console.error("FlowModel.moveTo: Parent subModels must be an array to perform move operation.");
         return false;
       }
-      const findIndex = /* @__PURE__ */ __name((model) => subModels.findIndex((item) => item.uid === model.uid), "findIndex");
+      const subModelsCopy = [...subModels];
+      const findIndex = /* @__PURE__ */ __name((model) => subModelsCopy.findIndex((item) => item.uid === model.uid), "findIndex");
       const currentIndex = findIndex(sourceModel2);
       const targetIndex = findIndex(targetModel2);
       if (currentIndex === -1 || targetIndex === -1) {
@@ -715,11 +1011,12 @@ const _FlowEngine = class _FlowEngine {
         console.warn("FlowModel.moveTo: Current model is already at the target position. No action taken.");
         return false;
       }
-      const [movedModel] = subModels.splice(currentIndex, 1);
-      subModels.splice(targetIndex, 0, movedModel);
-      subModels.forEach((model, index) => {
+      const [movedModel] = subModelsCopy.splice(currentIndex, 1);
+      subModelsCopy.splice(targetIndex, 0, movedModel);
+      subModelsCopy.forEach((model, index) => {
         model.sortIndex = index;
       });
+      subModels.splice(0, subModels.length, ...subModelsCopy);
       return true;
     }, "move");
     move(sourceModel, targetModel);
@@ -728,6 +1025,12 @@ const _FlowEngine = class _FlowEngine {
       await this._modelRepository.move(sourceId, targetId, position);
     }
     sourceModel.parent.emitter.emit("onSubModelMoved", { source: sourceModel, target: targetModel });
+    (_b = this.emitter) == null ? void 0 : _b.emit("model:subModel:moved", {
+      parentUid: (_a = sourceModel.parent) == null ? void 0 : _a.uid,
+      parent: sourceModel.parent,
+      source: sourceModel,
+      target: targetModel
+    });
   }
   /**
    * Filter model classes by parent class (supports multi-level inheritance).

package/lib/flowSettings.d.ts

@@ -25,8 +25,8 @@ export interface FlowSettingsOpenOptions {
     /** 指定打开的步骤 key（配合 flowKey 使用） */
     stepKey?: string;
     /** 弹窗展现形式（drawer 或 dialog） */
-    uiMode?: 'dialog' | 'drawer' | 'embed' | {
-        type?: 'dialog' | 'drawer' | 'embed';
+    uiMode?: 'select' | 'switch' | 'dialog' | 'drawer' | 'embed' | {
+        type?: 'dialog' | 'drawer' | 'embed' | 'select' | 'switch';
         props?: {
             title?: string;
             width?: number;
@@ -227,12 +227,13 @@ export declare class FlowSettings {
      * @param {any} form 表单实例（从外部传入以便统一管理）
      * @returns {React.ReactElement} 渲染的表单元素
      */
-    renderStepForm({ uiSchema, initialValues, flowEngine, form, onFormValuesChange, }: {
+    renderStepForm({ uiSchema, initialValues, flowEngine, form, onFormValuesChange, key, }: {
         uiSchema: any;
         initialValues: any;
         flowEngine: any;
         form?: any;
         onFormValuesChange?: (form: any) => void;
+        key?: string;
     }): React.ReactElement;
     /**
      * 打开流程设置入口（聚合渲染多个 flow 的可配置步骤）