@nocobase/flow-engine 2.0.0-alpha.10

package/lib/models/flowModel.js

@@ -0,0 +1,1154 @@
+/**
+ * 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 __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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var flowModel_exports = {};
+__export(flowModel_exports, {
+  ErrorFlowModel: () => ErrorFlowModel,
+  FlowModel: () => FlowModel,
+  ModelRenderMode: () => ModelRenderMode,
+  defineFlow: () => defineFlow
+});
+module.exports = __toCommonJS(flowModel_exports);
+var import_reactive = require("@formily/reactive");
+var import_reactive_react = require("@formily/reactive-react");
+var import_lodash = __toESM(require("lodash"));
+var import_react = __toESM(require("react"));
+var import_secure = require("uid/secure");
+var import_StepRequiredSettingsDialog = require("../components/settings/wrappers/contextual/StepRequiredSettingsDialog");
+var import_StepSettingsDialog = require("../components/settings/wrappers/contextual/StepSettingsDialog");
+var import_emitter = require("../emitter");
+var import_InstanceFlowRegistry = require("../flow-registry/InstanceFlowRegistry");
+var import_flowContext = require("../flowContext");
+var import_utils = require("../utils");
+var import_lib = require("antd/lib");
+var import_ModelActionRegistry = require("../action-registry/ModelActionRegistry");
+var import_utils2 = require("../components/subModel/utils");
+var import_ModelEventRegistry = require("../event-registry/ModelEventRegistry");
+var import_GlobalFlowRegistry = require("../flow-registry/GlobalFlowRegistry");
+var import_forkFlowModel = require("./forkFlowModel");
+var _flowContext;
+const classActionRegistries = /* @__PURE__ */ new WeakMap();
+const classEventRegistries = /* @__PURE__ */ new WeakMap();
+const modelMetas = /* @__PURE__ */ new WeakMap();
+const modelGlobalRegistries = /* @__PURE__ */ new WeakMap();
+var ModelRenderMode = /* @__PURE__ */ ((ModelRenderMode2) => {
+  ModelRenderMode2["ReactElement"] = "reactElement";
+  ModelRenderMode2["RenderFunction"] = "renderFunction";
+  return ModelRenderMode2;
+})(ModelRenderMode || {});
+const _FlowModel = class _FlowModel {
+  constructor(options) {
+    __publicField(this, "uid");
+    __publicField(this, "sortIndex");
+    __publicField(this, "hidden", false);
+    __publicField(this, "props", {});
+    __publicField(this, "stepParams", {});
+    __publicField(this, "flowEngine");
+    __publicField(this, "parent");
+    __publicField(this, "subModels");
+    __publicField(this, "_options");
+    __publicField(this, "_title");
+    __publicField(this, "isNew", false);
+    // 标记是否为新建状态
+    /**
+     * 所有 fork 实例的引用集合。
+     * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
+     */
+    __publicField(this, "forks", /* @__PURE__ */ new Set());
+    __publicField(this, "emitter", new import_emitter.Emitter());
+    /**
+     * 基于 key 的 fork 实例缓存，用于复用 fork 实例
+     */
+    __publicField(this, "forkCache", /* @__PURE__ */ new Map());
+    /**
+     * 上一次 beforeRender 的执行参数
+     */
+    __publicField(this, "_lastAutoRunParams", null);
+    __publicField(this, "observerDispose");
+    __privateAdd(this, _flowContext);
+    /**
+     * 原始 render 方法的引用
+     */
+    __publicField(this, "_originalRender", null);
+    /**
+     * 缓存的响应式包装器组件（每个实例一个）
+     */
+    __publicField(this, "_reactiveWrapperCache");
+    __publicField(this, "flowRegistry");
+    __publicField(this, "_cleanRun");
+    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(
+      async (eventName, inputArgs, options) => {
+        return this._dispatchEvent(eventName, inputArgs, options);
+      },
+      100
+    ));
+    /**
+     * 重新执行上一次的 beforeRender，保持参数一致
+     * 如果之前没有执行过，则直接跳过
+     * 使用 lodash debounce 避免频繁调用
+     */
+    __publicField(this, "_rerunLastAutoRun", import_lodash.default.debounce(async () => {
+      if (this._lastAutoRunParams) {
+        try {
+          const [inputArgs] = this._lastAutoRunParams;
+          await this.dispatchEvent("beforeRender", inputArgs);
+        } catch (error) {
+          console.error("FlowModel._rerunLastAutoRun: Error during rerun:", error);
+        }
+      }
+    }, 100));
+    if (!options.flowEngine) {
+      throw new Error("FlowModel must be initialized with a FlowEngine instance.");
+    }
+    this.flowEngine = options.flowEngine;
+    if (this.flowEngine.getModel(options.uid)) {
+      return this.flowEngine.getModel(options.uid);
+    }
+    if (!options.uid) {
+      options.uid = (0, import_secure.uid)();
+    }
+    this.uid = options.uid;
+    this.props = {
+      ...options.props
+    };
+    this.stepParams = options.stepParams || {};
+    this.subModels = {};
+    this.sortIndex = options.sortIndex || 0;
+    this._options = options;
+    (0, import_reactive.define)(this, {
+      hidden: import_reactive.observable,
+      props: import_reactive.observable,
+      subModels: import_reactive.observable.shallow,
+      stepParams: import_reactive.observable,
+      // setProps: action,
+      setProps: import_reactive.batch,
+      // setStepParams: action,
+      setStepParams: import_reactive.batch
+    });
+    this.flowRegistry = new import_InstanceFlowRegistry.InstanceFlowRegistry(this);
+    this.flowRegistry.addFlows(options.flowRegistry);
+    this.observerDispose = (0, import_reactive.observe)(this.stepParams, (changed) => {
+      if (changed.type === "set" && import_lodash.default.isEqual(changed.value, changed.oldValue)) {
+        return;
+      }
+      if (this.flowEngine) {
+        this.invalidateFlowCache("beforeRender");
+      }
+      this._rerunLastAutoRun();
+      this.forks.forEach((fork) => {
+        fork.rerender();
+      });
+    });
+    try {
+      this.setupReactiveRender();
+    } catch (error) {
+      console.error(`Failed to setup reactive render for ${this.constructor.name}:`, error);
+      if (typeof this.render !== "function") {
+        this.render = () => import_react.default.createElement("div", null, "Render method not available");
+      }
+    }
+    this._cleanRun = !!options["cleanRun"];
+  }
+  /**
+   * 当 flowSettings.enabled 且 model.hidden 为 true 时用于渲染设置态组件（实例方法，子类可覆盖）。
+   * 基类默认仅返回一个透明度降低的占位元素
+   */
+  renderHiddenInConfig() {
+    var _a;
+    return /* @__PURE__ */ import_react.default.createElement("span", { style: { opacity: 0.5 } }, ((_a = this.translate) == null ? void 0 : _a.call(this, "Hidden")) || "Hidden");
+  }
+  /**
+   * 对外暴露的上下文：
+   */
+  get context() {
+    if (!__privateGet(this, _flowContext)) {
+      __privateSet(this, _flowContext, new import_flowContext.FlowModelContext(this));
+    }
+    return __privateGet(this, _flowContext);
+  }
+  on(eventName, listener) {
+    this.emitter.on(eventName, listener);
+  }
+  onInit(options) {
+  }
+  /**
+   * 通过 AddSubModelButton 添加为子模型后调用（子类可覆盖）
+   */
+  async afterAddAsSubModel() {
+  }
+  get async() {
+    return this._options.async || false;
+  }
+  get use() {
+    return this._options.use;
+  }
+  get subKey() {
+    return this._options.subKey;
+  }
+  get subType() {
+    return this._options.subType;
+  }
+  get reactView() {
+    return this.flowEngine.reactView;
+  }
+  get parentId() {
+    return this._options.parentId;
+  }
+  static get meta() {
+    return modelMetas.get(this);
+  }
+  static get globalFlowRegistry() {
+    const Cls = this;
+    let reg = modelGlobalRegistries.get(Cls);
+    if (!reg) {
+      reg = new import_GlobalFlowRegistry.GlobalFlowRegistry(Cls);
+      modelGlobalRegistries.set(Cls, reg);
+    }
+    return reg;
+  }
+  // 获取当前类的动作注册表（含父子链注入），按类缓存
+  static get actionRegistry() {
+    const ModelClass = this;
+    let registry = classActionRegistries.get(ModelClass);
+    if (!registry) {
+      let parentRegistry = null;
+      const ParentClass = Object.getPrototypeOf(ModelClass);
+      if (ParentClass && ParentClass !== Function.prototype && ParentClass !== Object.prototype) {
+        const isSubclassOfFlowModel = ParentClass === _FlowModel || (0, import_utils.isInheritedFrom)(ParentClass, _FlowModel);
+        if (isSubclassOfFlowModel) {
+          parentRegistry = ParentClass.actionRegistry;
+        }
+      }
+      registry = new import_ModelActionRegistry.ModelActionRegistry(ModelClass, parentRegistry);
+      classActionRegistries.set(ModelClass, registry);
+    }
+    return registry;
+  }
+  // 获取当前类的事件注册表（含父子链注入），按类缓存
+  static get eventRegistry() {
+    const ModelClass = this;
+    let registry = classEventRegistries.get(ModelClass);
+    if (!registry) {
+      let parentRegistry = null;
+      const ParentClass = Object.getPrototypeOf(ModelClass);
+      if (ParentClass && ParentClass !== Function.prototype && ParentClass !== Object.prototype) {
+        const isSubclassOfFlowModel = ParentClass === _FlowModel || (0, import_utils.isInheritedFrom)(ParentClass, _FlowModel);
+        if (isSubclassOfFlowModel) {
+          parentRegistry = ParentClass.eventRegistry;
+        }
+      }
+      registry = new import_ModelEventRegistry.ModelEventRegistry(ModelClass, parentRegistry);
+      classEventRegistries.set(ModelClass, registry);
+    }
+    return registry;
+  }
+  /**
+   * 注册仅当前 FlowModel 类及其子类可用的 Action。
+   * 该注册是类级别的，不会影响全局（FlowEngine）的 Action 注册。
+   */
+  static registerAction(definition) {
+    this.actionRegistry.registerAction(definition);
+  }
+  /**
+   * 批量注册仅当前 FlowModel 类及其子类可用的 Actions。
+   */
+  static registerActions(actions) {
+    this.actionRegistry.registerActions(actions);
+  }
+  /**
+   * 注册仅当前 FlowModel 类及其子类可用的 Event。
+   * 该注册是类级别的，不会影响全局（FlowEngine）的 Event 注册。
+   */
+  static registerEvent(definition) {
+    this.eventRegistry.registerEvent(definition);
+  }
+  /**
+   * 批量注册仅当前 FlowModel 类及其子类可用的 Events。
+   */
+  static registerEvents(events) {
+    this.eventRegistry.registerEvents(events);
+  }
+  static buildChildrenFromModels(ctx, Models) {
+    return Models.map((M) => (0, import_utils2.buildSubModelItem)(M, ctx, true));
+  }
+  get title() {
+    var _a;
+    return this.translate(this._title) || this.translate((_a = this.constructor["meta"]) == null ? void 0 : _a.label);
+  }
+  setTitle(value) {
+    this._title = value;
+  }
+  setHidden(value) {
+    this.hidden = !!value;
+  }
+  _createSubModels(subModels) {
+    let mergedSubModels = subModels || {};
+    try {
+      const Cls = this.constructor;
+      const meta = Cls.meta;
+      const metaCreate = meta == null ? void 0 : meta.createModelOptions;
+      if (metaCreate && typeof metaCreate === "object" && metaCreate.subModels) {
+        mergedSubModels = import_lodash.default.merge({}, import_lodash.default.cloneDeep(metaCreate.subModels || {}), import_lodash.default.cloneDeep(subModels || {}));
+      }
+    } catch (e) {
+    }
+    Object.entries(mergedSubModels || {}).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.sort((a, b) => (a.sortIndex || 0) - (b.sortIndex || 0)).forEach((item) => {
+          this.addSubModel(key, item);
+        });
+      } else {
+        this.setSubModel(key, value);
+      }
+    });
+  }
+  /**
+   * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+   * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+   */
+  invalidateFlowCache(eventName, deep = false) {
+    if (this.flowEngine) {
+      const scope = `event:${this.getFlowCacheScope(eventName || "beforeRender")}`;
+      const cache = this.flowEngine.applyFlowCache;
+      if (eventName) {
+        const altScope = scope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+        for (const key of cache.keys()) {
+          const startMatches = key.startsWith(scope) || key.startsWith(altScope);
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          const eventMatches = eventSegments.some((seg) => key.includes(seg));
+          if (startMatches && endMatches && eventMatches) {
+            cache.delete(key);
+          }
+        }
+      } else {
+        const altScope = `${scope}:`.replace(/:/g, "-");
+        const prefixes = [`${scope}:`, altScope];
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        for (const key of cache.keys()) {
+          const startMatches = prefixes.some((p) => key.startsWith(p));
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (startMatches && endMatches) cache.delete(key);
+        }
+      }
+      this.forks.forEach((fork) => {
+        var _a;
+        const forkScope = `event:${((_a = fork.getFlowCacheScope) == null ? void 0 : _a.call(fork, eventName || "beforeRender")) ?? String(fork["forkId"])}`;
+        const altForkScope = forkScope.replace(/:/g, "-");
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        if (eventName) {
+          const eventSegments = [`:${eventName}:`, `-${eventName}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = key.startsWith(forkScope) || key.startsWith(altForkScope);
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            const eventMatches = eventSegments.some((seg) => key.includes(seg));
+            if (startMatches && endMatches && eventMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        } else {
+          const prefixes = [`${forkScope}:`, `${altForkScope}-`];
+          for (const key of this.flowEngine.applyFlowCache.keys()) {
+            const startMatches = prefixes.some((p) => key.startsWith(p));
+            const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+            if (startMatches && endMatches) this.flowEngine.applyFlowCache.delete(key);
+          }
+        }
+      });
+    }
+    if (deep) {
+      const subModelKeys = Object.keys(this.subModels);
+      for (const subModelKey of subModelKeys) {
+        const subModelValue = this.subModels[subModelKey];
+        if (Array.isArray(subModelValue)) {
+          for (const subModel of subModelValue) {
+            subModel.invalidateFlowCache(eventName, deep);
+          }
+        } else if (subModelValue instanceof _FlowModel) {
+          subModelValue.invalidateFlowCache(eventName, deep);
+        }
+      }
+    }
+  }
+  /**
+   * 设置FlowEngine实例
+   * @param {FlowEngine} flowEngine FlowEngine实例
+   */
+  setFlowEngine(flowEngine) {
+  }
+  static define(meta) {
+    modelMetas.set(this, meta);
+  }
+  /**
+   * 注册一个 Flow。
+   * @template TModel 具体的FlowModel子类类型
+   * @param {string | FlowDefinitionOptions<TModel>} keyOrDefinition 流程的 Key 或 FlowDefinitionOptions 对象。
+   *        如果为字符串，则为流程 Key，需要配合 flowDefinition 参数。
+   *        如果为对象，则为包含 key 属性的完整 FlowDefinitionOptions。
+   * @param {FlowDefinitionOptions<TModel>} [flowDefinition] 当第一个参数为流程 Key 时，此参数为流程的定义。
+   * @returns {void}
+   */
+  static registerFlow(keyOrDefinition, flowDefinition) {
+    const Cls = this;
+    if (typeof keyOrDefinition === "string") {
+      Cls.globalFlowRegistry.addFlow(keyOrDefinition, flowDefinition);
+    } else {
+      Cls.globalFlowRegistry.addFlow(keyOrDefinition.key, keyOrDefinition);
+    }
+  }
+  // /**
+  //  * 清空所有注册的流程定义。在测试中用来清理已注册的流，防止对其它测试产生影响。
+  //  */
+  // public static clearFlows(): void {
+  //   modelFlows = new WeakMap<typeof FlowModel, Map<string, FlowDefinition>>();
+  // }
+  /**
+   * 获取已注册的流程定义。
+   * 如果当前类不存在对应的flow，会继续往父类查找。
+   * @param {string} key 流程 Key。
+   * @returns {FlowDefinition | undefined} 流程定义，如果未找到则返回 undefined。
+   */
+  getFlow(key) {
+    if (this.flowRegistry.hasFlow(key)) {
+      return this.flowRegistry.getFlow(key);
+    }
+    const Cls = this.constructor;
+    return Cls.globalFlowRegistry.getFlow(key);
+  }
+  /**
+   * 注册一个实例级别的流程定义。
+   * @template TModel 具体的FlowModel子类类型
+   * @param {string | FlowDefinitionOptions<TModel>} keyOrDefinition 流程的 Key 或 FlowDefinitionOptions 对象。
+   * @param {FlowDefinitionOptions<TModel>} [flowDefinition] 当第一个参数为流程 Key 时，此参数为流程的定义。
+   * @returns {FlowDefinition} 注册的流程定义实例
+   */
+  registerFlow(keyOrDefinition, flowDefinition) {
+    if (typeof keyOrDefinition === "string") {
+      return this.flowRegistry.addFlow(keyOrDefinition, flowDefinition);
+    } else {
+      return this.flowRegistry.addFlow(keyOrDefinition.key, keyOrDefinition);
+    }
+  }
+  /**
+   * 获取当前模型可用的所有 Actions：
+   * - 包含全局（FlowEngine）注册的 Actions；
+   * - 合并类级（FlowModel.registerAction(s)）注册的 Actions，并考虑继承（子类覆盖父类同名 Action）。
+   */
+  getActions() {
+    var _a;
+    const ModelClass = this.constructor;
+    const merged = ModelClass.actionRegistry.getActions();
+    const actions = /* @__PURE__ */ new Map();
+    const globalActions = (_a = this.flowEngine) == null ? void 0 : _a.getActions();
+    if (globalActions) for (const [k, v] of globalActions) actions.set(k, v);
+    for (const [k, v] of merged) actions.set(k, v);
+    return actions;
+  }
+  /**
+   * 获取当前模型可用的所有 Events：
+   * - 包含全局（FlowEngine）注册的 Events；
+   * - 合并类级（FlowModel.registerEvent(s)）注册的 Events，并考虑继承（子类覆盖父类同名 Event）。
+   */
+  getEvents() {
+    var _a;
+    const ModelClass = this.constructor;
+    const merged = ModelClass.eventRegistry.getEvents();
+    const events = /* @__PURE__ */ new Map();
+    const globalEvents = (_a = this.flowEngine) == null ? void 0 : _a.getEvents();
+    if (globalEvents) for (const [k, v] of globalEvents) events.set(k, v);
+    for (const [k, v] of merged) events.set(k, v);
+    return events;
+  }
+  /**
+   * 获取指定名称的 Event（优先返回类级注册的，未找到则回退到全局）。
+   */
+  getEvent(name) {
+    var _a;
+    const ModelClass = this.constructor;
+    const own = ModelClass.eventRegistry.getEvent(name);
+    if (own) return own;
+    return (_a = this.flowEngine) == null ? void 0 : _a.getEvent(name);
+  }
+  /**
+   * 获取指定名称的 Action（优先返回类级注册的，未找到则回退到全局）。
+   */
+  getAction(name) {
+    var _a;
+    const ModelClass = this.constructor;
+    const own = ModelClass.actionRegistry.getAction(name);
+    if (own) return own;
+    return (_a = this.flowEngine) == null ? void 0 : _a.getAction(name);
+  }
+  getFlows() {
+    const instanceFlows = this.flowRegistry.getFlows();
+    const staticFlows = this.constructor.globalFlowRegistry.getFlows();
+    const instanceKeys = new Set(instanceFlows.keys());
+    const staticEntries = Array.from(staticFlows.entries()).filter(([key]) => !instanceKeys.has(key));
+    const instanceEntries = Array.from(instanceFlows.entries());
+    const allEntries = [...staticEntries, ...instanceEntries];
+    allEntries.sort(([, a], [, b]) => {
+      const sa = a.sort ?? 0;
+      const sb = b.sort ?? 0;
+      if (sa !== sb) return sa - sb;
+      return 0;
+    });
+    return new Map(allEntries);
+  }
+  setProps(props, value) {
+    if (typeof props === "string") {
+      this.props[props] = value;
+    } else {
+      this.props = { ...this.props, ...props };
+    }
+  }
+  getProps() {
+    return this.props;
+  }
+  setStepParams(flowKeyOrAllParams, stepKeyOrStepsParams, params) {
+    if (typeof flowKeyOrAllParams === "string") {
+      const flowKey = flowKeyOrAllParams;
+      if (typeof stepKeyOrStepsParams === "string" && params !== void 0) {
+        if (!this.stepParams[flowKey]) {
+          this.stepParams[flowKey] = {};
+        }
+        this.stepParams[flowKey][stepKeyOrStepsParams] = {
+          ...this.stepParams[flowKey][stepKeyOrStepsParams],
+          ...params
+        };
+      } else if (typeof stepKeyOrStepsParams === "object" && stepKeyOrStepsParams !== null) {
+        this.stepParams[flowKey] = { ...this.stepParams[flowKey] || {}, ...stepKeyOrStepsParams };
+      }
+    } else if (typeof flowKeyOrAllParams === "object" && flowKeyOrAllParams !== null) {
+      for (const fk in flowKeyOrAllParams) {
+        if (Object.prototype.hasOwnProperty.call(flowKeyOrAllParams, fk)) {
+          this.stepParams[fk] = { ...this.stepParams[fk] || {}, ...flowKeyOrAllParams[fk] };
+        }
+      }
+    }
+  }
+  getStepParams(flowKey, stepKey) {
+    var _a;
+    if (flowKey && stepKey) {
+      return (_a = this.stepParams[flowKey]) == null ? void 0 : _a[stepKey];
+    }
+    if (flowKey) {
+      return this.stepParams[flowKey];
+    }
+    return this.stepParams;
+  }
+  async applyFlow(flowKey, inputArgs, runId) {
+    const currentFlowEngine = this.flowEngine;
+    if (!currentFlowEngine) {
+      console.warn("FlowEngine not available on this model for applyFlow. Check and model.flowEngine setup.");
+      return Promise.reject(new Error("FlowEngine not available for applyFlow. Please set flowEngine on the model."));
+    }
+    const isFork = this.isFork === true;
+    const target = this;
+    console.log(
+      `[FlowModel] applyFlow: uid=${this.uid}, flowKey=${flowKey}, isFork=${isFork}, cleanRun=${this.cleanRun}, targetIsFork=${(target == null ? void 0 : target.isFork) === true}`
+    );
+    return currentFlowEngine.executor.runFlow(target, flowKey, inputArgs, runId);
+  }
+  async _dispatchEvent(eventName, inputArgs, options) {
+    const currentFlowEngine = this.flowEngine;
+    if (!currentFlowEngine) {
+      console.warn("FlowEngine not available on this model for dispatchEvent. Please set flowEngine on the model.");
+      return;
+    }
+    const isFork = this.isFork === true;
+    const target = this;
+    console.log(
+      `[FlowModel] dispatchEvent: uid=${this.uid}, event=${eventName}, isFork=${isFork}, cleanRun=${this.cleanRun}, targetIsFork=${(target == null ? void 0 : target.isFork) === true}`
+    );
+    return await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs, options);
+  }
+  async dispatchEvent(eventName, inputArgs, options) {
+    const isBeforeRender = eventName === "beforeRender";
+    const defaults = isBeforeRender ? { sequential: true, useCache: true } : {};
+    const execOptions = {
+      sequential: (options == null ? void 0 : options.sequential) ?? defaults.sequential,
+      useCache: (options == null ? void 0 : options.useCache) ?? defaults.useCache
+    };
+    if (isBeforeRender) {
+      this._lastAutoRunParams = [inputArgs, execOptions.useCache];
+    }
+    if (options == null ? void 0 : options.debounce) {
+      return this._dispatchEventWithDebounce(eventName, inputArgs, execOptions);
+    }
+    return this._dispatchEvent(eventName, inputArgs, execOptions);
+  }
+  /**
+   * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+   * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
+   */
+  getEventFlows(eventName) {
+    const allFlows = this.getFlows();
+    const beforeRender = eventName === "beforeRender";
+    const isMatch = /* @__PURE__ */ __name((flow) => {
+      var _a;
+      if (beforeRender) {
+        if (flow.manual === true) return false;
+        if (!flow.on) return true;
+        return typeof flow.on === "string" ? flow.on === "beforeRender" : ((_a = flow.on) == null ? void 0 : _a.eventName) === "beforeRender";
+      }
+      const on = flow.on;
+      if (!on) return false;
+      return typeof on === "string" ? on === eventName : (on == null ? void 0 : on.eventName) === eventName;
+    }, "isMatch");
+    return Array.from(allFlows.values()).filter(isMatch);
+  }
+  /**
+   * 通用事件分发钩子：开始
+   * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
+   */
+  async onDispatchEventStart(eventName, options, inputArgs) {
+  }
+  /**
+   * 通用事件分发钩子：结束
+   * 子类可覆盖。
+   */
+  async onDispatchEventEnd(eventName, options, inputArgs, results) {
+  }
+  /**
+   * 通用事件分发钩子：错误
+   * 子类可覆盖。
+   */
+  async onDispatchEventError(eventName, options, inputArgs, error) {
+  }
+  useHooksBeforeRender() {
+  }
+  /**
+   * 智能检测是否应该跳过响应式包装
+   * 说明：
+   * - 仅基于标记判断，不会执行 render，避免出现“预调用 render”带来的副作用和双调用问题。
+   * - 当子类需要返回函数（如表格列的单元格渲染器），应在子类上设置静态属性 `renderReturnsFunction = true`。
+   */
+  shouldSkipReactiveWrapping() {
+    if (this.render.__isReactiveWrapped) {
+      return true;
+    }
+    const Cls = this.constructor;
+    if (Cls.renderMode === "renderFunction" /* RenderFunction */) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 设置 render 方法的响应式包装
+   * @private
+   */
+  setupReactiveRender() {
+    if (typeof this.render !== "function") {
+      return;
+    }
+    try {
+      const originalRender = this.render;
+      this._originalRender = originalRender;
+      if (typeof originalRender !== "function") {
+        console.error(`FlowModel ${this.constructor.name}: original render method is not a function`, originalRender);
+        return;
+      }
+      if (this.shouldSkipReactiveWrapping()) {
+        const wrappedNonReactive = /* @__PURE__ */ __name(function() {
+          var _a, _b, _c;
+          const isConfigMode = !!((_b = (_a = this == null ? void 0 : this.flowEngine) == null ? void 0 : _a.flowSettings) == null ? void 0 : _b.enabled);
+          if (this.hidden) {
+            if (!isConfigMode) return null;
+            const rendered = (_c = this.renderHiddenInConfig) == null ? void 0 : _c.call(this);
+            const Cls = this.constructor;
+            const returnsFunction = Cls.renderMode === "renderFunction" /* RenderFunction */;
+            return returnsFunction ? typeof rendered === "function" ? rendered : () => rendered : rendered;
+          }
+          return originalRender.call(this);
+        }, "wrappedNonReactive");
+        wrappedNonReactive.__originalRender = originalRender;
+        this.render = wrappedNonReactive;
+        return;
+      }
+      const createReactiveWrapper = /* @__PURE__ */ __name((modelInstance) => {
+        const ReactiveWrapper = (0, import_reactive_react.observer)(() => {
+          var _a, _b, _c;
+          const renderTarget = modelInstance;
+          if (renderTarget !== modelInstance && (renderTarget == null ? void 0 : renderTarget.localProps) !== void 0) {
+            renderTarget.localProps;
+            modelInstance.props;
+          } else {
+            modelInstance.props;
+          }
+          import_react.default.useEffect(() => {
+            if (typeof renderTarget.onMount === "function") {
+              renderTarget.onMount();
+            }
+            return () => {
+              if (typeof renderTarget.onUnmount === "function") {
+                renderTarget.onUnmount();
+              }
+            };
+          }, [renderTarget]);
+          const isConfigMode = !!((_b = (_a = modelInstance == null ? void 0 : modelInstance.flowEngine) == null ? void 0 : _a.flowSettings) == null ? void 0 : _b.enabled);
+          if (modelInstance.hidden) {
+            if (!isConfigMode) {
+              return null;
+            }
+            return (_c = modelInstance.renderHiddenInConfig) == null ? void 0 : _c.call(modelInstance);
+          }
+          modelInstance.stepParams;
+          return originalRender.call(renderTarget);
+        });
+        ReactiveWrapper.displayName = `ReactiveWrapper(${modelInstance.constructor.name})`;
+        return ReactiveWrapper;
+      }, "createReactiveWrapper");
+      const wrappedRender = /* @__PURE__ */ __name(function() {
+        if (!this._reactiveWrapperCache) {
+          this._reactiveWrapperCache = createReactiveWrapper(this);
+        }
+        return import_react.default.createElement(this._reactiveWrapperCache);
+      }, "wrappedRender");
+      wrappedRender.__isReactiveWrapped = true;
+      wrappedRender.__originalRender = originalRender;
+      this.render = wrappedRender;
+    } catch (error) {
+      console.error(`FlowModel ${this.constructor.name}: Error during render method wrapping:`, error);
+    }
+  }
+  get cleanRun() {
+    return true;
+  }
+  setCleanRun(value) {
+    const prev = this._cleanRun;
+    this._cleanRun = !!value;
+  }
+  /**
+   * 组件挂载时的生命周期钩子
+   * 子类可以重写此方法来添加挂载时的逻辑
+   * @protected
+   */
+  // eslint-disable-next-line no-empty
+  onMount() {
+  }
+  /**
+   * 组件卸载时的生命周期钩子
+   * 子类可以重写此方法来添加卸载时的逻辑
+   * @protected
+   */
+  onUnmount() {
+  }
+  /**
+   * 有权限时的渲染逻辑。
+   * 这是一个抽象方法，所有子类都必须实现，用于返回自己的正常 UI。
+   *
+   * @returns {React.ReactNode} 有权限时的渲染结果
+   */
+  render() {
+    return /* @__PURE__ */ import_react.default.createElement("div", { ...this.props });
+  }
+  async rerender() {
+    var _a;
+    await this.dispatchEvent("beforeRender", (_a = this._lastAutoRunParams) == null ? void 0 : _a[0], { useCache: false });
+  }
+  /**
+   * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
+   */
+  getFlowCacheScope(eventName) {
+    return String(eventName);
+  }
+  setParent(parent) {
+    const isValidParent = parent && (parent.constructor === _FlowModel || (0, import_utils.isInheritedFrom)(parent.constructor, _FlowModel));
+    if (!isValidParent) {
+      throw new Error("Parent must be an instance of FlowModel.");
+    }
+    this.parent = parent;
+    this._options.parentId = parent.uid;
+    if (this._options.delegateToParent !== false) {
+      this.context.addDelegate(this.parent.context);
+    }
+  }
+  removeParentDelegate() {
+    if (!this.parent) {
+      return;
+    }
+    this.context.removeDelegate(this.parent.context);
+  }
+  addSubModel(subKey, options) {
+    var _a;
+    const actualParent = this["master"] || this;
+    let model;
+    if (options instanceof _FlowModel) {
+      const hasParent = !!options.parent;
+      const parentUid = (_a = options.parent) == null ? void 0 : _a.uid;
+      if (hasParent && parentUid && parentUid !== actualParent.uid) {
+        throw new Error("Sub model already has a parent.");
+      }
+      model = options;
+    } else {
+      model = actualParent.flowEngine.createModel({
+        ...options,
+        parentId: actualParent.uid,
+        subKey,
+        subType: "array"
+      });
+    }
+    model.setParent(actualParent);
+    const subModels = actualParent.subModels;
+    if (!Array.isArray(subModels[subKey])) {
+      subModels[subKey] = import_reactive.observable.shallow([]);
+    }
+    const maxSortIndex = Math.max(...subModels[subKey].map((item) => item.sortIndex || 0), 0);
+    model.sortIndex = maxSortIndex + 1;
+    subModels[subKey].push(model);
+    actualParent.emitter.emit("onSubModelAdded", model);
+    return model;
+  }
+  setSubModel(subKey, options) {
+    var _a;
+    const actualParent = this["master"] || this;
+    let model;
+    if (options instanceof _FlowModel) {
+      const hasParent = !!options.parent;
+      const parentUid = (_a = options.parent) == null ? void 0 : _a.uid;
+      if (hasParent && parentUid && parentUid !== actualParent.uid) {
+        throw new Error("Sub model already has a parent.");
+      }
+      model = options;
+    } else {
+      model = actualParent.flowEngine.createModel({
+        ...options,
+        parentId: actualParent.uid,
+        subKey,
+        subType: "object"
+      });
+    }
+    model.setParent(actualParent);
+    actualParent.subModels[subKey] = model;
+    actualParent.emitter.emit("onSubModelAdded", model);
+    return model;
+  }
+  filterSubModels(subKey, callback) {
+    const model = this.subModels[subKey];
+    if (!model) {
+      return [];
+    }
+    const results = [];
+    import_lodash.default.castArray(model).sort((a, b) => (a.sortIndex || 0) - (b.sortIndex || 0)).forEach((item, index) => {
+      const result = callback(item, index);
+      if (result) {
+        results.push(item);
+      }
+    });
+    return results;
+  }
+  mapSubModels(subKey, callback) {
+    const model = this.subModels[subKey];
+    if (!model) {
+      return [];
+    }
+    const results = [];
+    import_lodash.default.castArray(model).sort((a, b) => (a.sortIndex || 0) - (b.sortIndex || 0)).forEach((item, index) => {
+      const result = callback(item, index);
+      results.push(result);
+    });
+    return results;
+  }
+  hasSubModel(subKey) {
+    const subModel = this.subModels[subKey];
+    if (!subModel) {
+      return false;
+    }
+    return import_lodash.default.castArray(subModel).length > 0;
+  }
+  findSubModel(subKey, callback) {
+    const model = this.subModels[subKey];
+    if (!model) {
+      return null;
+    }
+    return import_lodash.default.castArray(model).find((item) => {
+      return callback(item);
+    }) || null;
+  }
+  createRootModel(options) {
+    return this.flowEngine.createModel(options);
+  }
+  /**
+   * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+   */
+  async applySubModelsBeforeRenderFlows(subKey, inputArgs, shared) {
+    await Promise.all(
+      this.mapSubModels(subKey, async (sub) => {
+        await sub.dispatchEvent("beforeRender", inputArgs);
+      })
+    );
+  }
+  /**
+   * 创建一个 fork 实例，实现"一份数据（master）多视图（fork）"的能力。
+   * @param {IModelComponentProps} [localProps={}] fork 专属的局部 props，优先级高于 master.props
+   * @param {string} [key] 可选的 key，用于复用 fork 实例。如果提供了 key，会尝试复用已存在的 fork
+   * @returns {ForkFlowModel<this>} 创建的 fork 实例
+   */
+  createFork(localProps, key, options) {
+    if (key) {
+      const cachedFork = this.forkCache.get(key);
+      if (cachedFork && !cachedFork.disposed) {
+        cachedFork.setProps(localProps || {});
+        return cachedFork;
+      }
+    }
+    const forkId = this.forks.size;
+    const fork = new import_forkFlowModel.ForkFlowModel(this, localProps, forkId);
+    if ((options == null ? void 0 : options.register) !== false) {
+      this.forks.add(fork);
+    }
+    if (key && (options == null ? void 0 : options.register) !== false) {
+      this.forkCache.set(key, fork);
+    }
+    return fork;
+  }
+  clearForks() {
+    var _a;
+    console.log(`FlowModel ${this.uid} clearing all forks.`);
+    if ((_a = this.forks) == null ? void 0 : _a.size) {
+      this.forks.forEach((fork) => fork.dispose());
+      this.forks.clear();
+    }
+    this.forkCache.clear();
+  }
+  getFork(key) {
+    return this.forkCache.get(key);
+  }
+  /**
+   * 移动当前模型到目标模型的位置
+   * @param {FlowModel} targetModel 目标模型
+   * @param {PersistOptions} [options] 可选的持久化选项
+   * @returns {boolean} 是否成功移动
+   */
+  moveTo(targetModel, options) {
+    if (!this.flowEngine) {
+      throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
+    }
+    return this.flowEngine.moveModel(this.uid, targetModel.uid, options);
+  }
+  remove() {
+    if (!this.flowEngine) {
+      throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
+    }
+    this.observerDispose();
+    this.invalidateFlowCache("beforeRender", true);
+    return this.flowEngine.removeModel(this.uid);
+  }
+  async save() {
+    if (!this.flowEngine) {
+      throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
+    }
+    return this.flowEngine.saveModel(this);
+  }
+  async saveStepParams() {
+    return this.flowEngine.saveModel(this, { onlyStepParams: true });
+  }
+  async destroy() {
+    if (!this.flowEngine) {
+      throw new Error("FlowEngine is not set on this model. Please set flowEngine before deleting.");
+    }
+    this.observerDispose();
+    this.invalidateFlowCache("beforeRender", true);
+    return this.flowEngine.destroyModel(this.uid);
+  }
+  /**
+   * @deprecated
+   * 打开步骤设置对话框
+   * 用于配置流程中特定步骤的参数和设置
+   * @param {string} flowKey 流程的唯一标识符
+   * @param {string} stepKey 步骤的唯一标识符
+   * @returns {void}
+   */
+  openStepSettingsDialog(flowKey, stepKey) {
+    var _a;
+    const flow = this.getFlow(flowKey);
+    const step = (_a = flow == null ? void 0 : flow.steps) == null ? void 0 : _a[stepKey];
+    if (!flow || !step) {
+      console.error(`Flow ${flowKey} or step ${stepKey} not found`);
+      return;
+    }
+    const ctx = new import_flowContext.FlowRuntimeContext(this, flowKey, "settings");
+    (0, import_utils.setupRuntimeContextSteps)(ctx, flow.steps, this, flowKey);
+    ctx.defineProperty("currentStep", { value: step });
+    return (0, import_StepSettingsDialog.openStepSettingsDialog)({
+      model: this,
+      flowKey,
+      stepKey,
+      ctx
+    });
+  }
+  /**
+   * 配置必填步骤参数
+   * 用于在一个分步表单中配置所有需要参数的步骤
+   * @param {number | string} [dialogWidth=800] 对话框宽度，默认为800
+   * @param {string} [dialogTitle='步骤参数配置'] 对话框标题，默认为'步骤参数配置'
+   * @returns {Promise<any>} 返回表单提交的值
+   */
+  async configureRequiredSteps(dialogWidth, dialogTitle) {
+    return (0, import_StepRequiredSettingsDialog.openRequiredParamsStepFormDialog)({
+      model: this,
+      dialogWidth,
+      dialogTitle
+    });
+  }
+  /**
+   * @deprecated
+   * @param dialogWidth
+   * @param dialogTitle
+   * @returns
+   */
+  async openPresetStepSettingsDialog(dialogWidth, dialogTitle) {
+    return this.configureRequiredSteps(dialogWidth, dialogTitle);
+  }
+  async openFlowStepSettingsDialog(options) {
+  }
+  get translate() {
+    return this.flowEngine.translate.bind(this.flowEngine);
+  }
+  // TODO: 不完整，需要考虑 sub-model 的情况
+  serialize() {
+    const data = {
+      uid: this.uid,
+      ...import_lodash.default.omit(this._options, ["flowEngine"]),
+      stepParams: this.stepParams,
+      sortIndex: this.sortIndex
+    };
+    const subModels = this.subModels;
+    for (const subModelKey in subModels) {
+      data.subModels = data.subModels || {};
+      if (Array.isArray(subModels[subModelKey])) {
+        data.subModels[subModelKey] = subModels[subModelKey].map((model, index) => ({
+          ...model.serialize(),
+          sortIndex: index
+        }));
+      } else if (subModels[subModelKey] instanceof _FlowModel) {
+        data.subModels[subModelKey] = subModels[subModelKey].serialize();
+      }
+    }
+    for (const [key, flow] of this.flowRegistry.getFlows()) {
+      data["flowRegistry"] = data["flowRegistry"] || {};
+      data["flowRegistry"][key] = flow.toData();
+    }
+    return data;
+  }
+  /**
+   * Opens the flow settings dialog for this flow model.
+   * @param options - Configuration options for opening flow settings, excluding the model property
+   * @returns A promise that resolves when the flow settings dialog is opened
+   */
+  async openFlowSettings(options) {
+    return this.flowEngine.flowSettings.open({
+      model: this,
+      ...options
+    });
+  }
+  // =============================
+  // Dynamic flows (disabled)
+  // The following APIs are kept as comments to preserve context
+  // =============================
+  /*
+    async openDynamicFlowsEditor(
+      options?: Omit<FlowSettingsOpenOptions, 'model' | 'flowKey' | 'flowKeys' | 'stepKey' | 'preset'>,
+    ) {
+      return this.flowEngine.flowSettings.openDynamicFlowsEditor({
+        model: this,
+        ...options,
+      });
+    }
+  
+    #dynamicFlows: FlowDefinition[] = [];
+  
+    async loadDynamicFlows(): Promise<FlowDefinition[]> {
+      return JSON.parse(localStorage.getItem('DYNAMIC_FLOWS') || '[]');
+    }
+  
+    async saveDynamicFlows(): Promise<void> {
+      localStorage.setItem('DYNAMIC_FLOWS', JSON.stringify(this.#dynamicFlows));
+    }
+  
+    setDynamicFlows(flows: FlowDefinition[]): void {
+      this.#dynamicFlows = flows;
+      flows.forEach((flow) => {
+        // @ts-ignore
+        this.constructor.registerFlow(flow);
+      });
+    }
+  
+    getDynamicFlows(): FlowDefinitionOptions[] {
+      return this.#dynamicFlows;
+    }
+    */
+};
+_flowContext = new WeakMap();
+__name(_FlowModel, "FlowModel");
+/**
+ * 声明渲染模式：
+ * - 'renderElement': render 返回 React 节点，框架会用 observer 包装以获得响应式；
+ * - 'renderFunction': render 返回渲染函数（例如表格单元格渲染器），不做包装也不预调用；
+ */
+__publicField(_FlowModel, "renderMode", "reactElement" /* ReactElement */);
+let FlowModel = _FlowModel;
+const _ErrorFlowModel = class _ErrorFlowModel extends FlowModel {
+  errorMessage;
+  setErrorMessage(msg) {
+    this.errorMessage = msg;
+  }
+  render() {
+    return /* @__PURE__ */ import_react.default.createElement(import_lib.Typography.Text, { type: "danger" }, this.errorMessage);
+  }
+};
+__name(_ErrorFlowModel, "ErrorFlowModel");
+let ErrorFlowModel = _ErrorFlowModel;
+function defineFlow(definition) {
+  return definition;
+}
+__name(defineFlow, "defineFlow");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorFlowModel,
+  FlowModel,
+  ModelRenderMode,
+  defineFlow
+});