@nocobase/flow-engine 2.0.0-alpha.2

package/lib/models/flowModel.js

@@ -0,0 +1,1133 @@
+/**
+ * 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_flowEngine = require("../flowEngine");
+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());
+    /**
+     * 上一次 applyAutoFlows 的执行参数
+     */
+    __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) => {
+      return this._dispatchEvent(eventName, inputArgs);
+    }, 100));
+    /**
+     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 如果之前没有执行过，则直接跳过
+     * 使用 lodash debounce 避免频繁调用
+     */
+    __publicField(this, "_rerunLastAutoRun", import_lodash.default.debounce(async () => {
+      if (this._lastAutoRunParams) {
+        try {
+          await this.applyAutoFlows(...this._lastAutoRunParams);
+        } 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.invalidateAutoFlowCache();
+      }
+      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);
+      }
+    });
+  }
+  invalidateAutoFlowCache(deep = false) {
+    if (this.flowEngine) {
+      const cacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey("autoFlow", "all", this.uid);
+      this.flowEngine.applyFlowCache.delete(cacheKey);
+      this.forks.forEach((fork) => {
+        const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${fork["forkId"]}`, "all", this.uid);
+        this.flowEngine.applyFlowCache.delete(forkCacheKey);
+      });
+    }
+    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.invalidateAutoFlowCache(deep);
+          }
+        } else if (subModelValue instanceof _FlowModel) {
+          subModelValue.invalidateAutoFlowCache(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) {
+    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}`
+    );
+    await currentFlowEngine.executor.dispatchEvent(target, eventName, inputArgs);
+  }
+  async dispatchEvent(eventName, inputArgs, options) {
+    if (options == null ? void 0 : options.debounce) {
+      return this._dispatchEventWithDebounce(eventName, inputArgs);
+    }
+    return this._dispatchEvent(eventName, inputArgs);
+  }
+  /**
+   * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
+   * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+   */
+  getAutoFlows() {
+    const allFlows = this.getFlows();
+    const autoFlows = Array.from(allFlows.values()).filter((flow) => {
+      if (flow.on) {
+        return false;
+      }
+      if (flow.manual === true) {
+        return false;
+      }
+      return true;
+    });
+    return autoFlows;
+  }
+  /**
+   * 自动流程执行前钩子。
+   * 子类可覆盖；可抛出 FlowExitException 提前终止。
+   */
+  async onBeforeAutoFlows(inputArgs) {
+  }
+  /**
+   * 自动流程执行后钩子。
+   * 子类可覆盖。
+   */
+  async onAfterAutoFlows(results, inputArgs) {
+  }
+  /**
+   * 自动流程错误钩子。
+   * 子类可覆盖。
+   */
+  async onAutoFlowsError(error, inputArgs) {
+  }
+  useHooksBeforeRender() {
+  }
+  async applyAutoFlows(...args) {
+    var _a, _b;
+    const [inputArgs, useCache = true] = args;
+    const cacheKey = useCache ? import_flowEngine.FlowEngine.generateApplyFlowCacheKey(this["forkId"] ?? "autoFlow", "all", this.uid) : null;
+    if (!import_lodash.default.isEqual(inputArgs, (_a = this._lastAutoRunParams) == null ? void 0 : _a[0]) && cacheKey) {
+      this.flowEngine.applyFlowCache.delete(cacheKey);
+    }
+    this._lastAutoRunParams = args;
+    try {
+      await this.onBeforeAutoFlows(inputArgs);
+    } catch (error) {
+      if (error instanceof import_utils.FlowExitException) {
+        (_b = this.context.logger) == null ? void 0 : _b.debug(`[FlowModel.applyAutoFlows] ${error.message}`);
+        return [];
+      }
+      try {
+        await this.onAutoFlowsError(error, inputArgs);
+      } catch (_2) {
+      }
+      throw error;
+    }
+    let results = [];
+    try {
+      results = await this.flowEngine.executor.runAutoFlows(this, inputArgs, useCache);
+    } catch (error) {
+      try {
+        await this.onAutoFlowsError(error, inputArgs);
+      } catch (_2) {
+      }
+      throw error;
+    }
+    try {
+      await this.onAfterAutoFlows(results, inputArgs);
+    } catch (error) {
+      try {
+        await this.onAutoFlowsError(error, inputArgs);
+      } catch (_2) {
+      }
+      throw error;
+    }
+    return results;
+  }
+  /**
+   * 智能检测是否应该跳过响应式包装
+   * 说明：
+   * - 仅基于标记判断，不会执行 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);
+          }
+          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.applyAutoFlows((_a = this._lastAutoRunParams) == null ? void 0 : _a[0], false);
+  }
+  /**
+   * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+   */
+  getAutoFlowCacheScope() {
+    return "autoFlow";
+  }
+  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);
+  }
+  async applySubModelsAutoFlows(subKey, inputArgs, shared) {
+    await Promise.all(
+      this.mapSubModels(subKey, async (sub) => {
+        await sub.applyAutoFlows(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.invalidateAutoFlowCache(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.invalidateAutoFlowCache(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
+});