@nocobase/flow-engine 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/models/CollectionFieldModel.js

@@ -40,11 +40,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 var CollectionFieldModel_exports = {};
 __export(CollectionFieldModel_exports, {
   CollectionFieldModel: () => CollectionFieldModel,
+  FieldDeletePlaceholder: () => FieldDeletePlaceholder,
   FieldPlaceholder: () => FieldPlaceholder
 });
 module.exports = __toCommonJS(CollectionFieldModel_exports);
 var import_antd = require("antd");
 var import_react = __toESM(require("react"));
+var import_react_i18next = require("react-i18next");
+var import_hooks = require("../hooks");
 var import_utils = require("../utils");
 var import_flowModel = require("./flowModel");
 function FieldPlaceholder() {
@@ -62,9 +65,40 @@ function FieldPlaceholder() {
   ));
 }
 __name(FieldPlaceholder, "FieldPlaceholder");
+function FieldDeletePlaceholder() {
+  const { t } = (0, import_react_i18next.useTranslation)();
+  const model = (0, import_hooks.useFlowModel)();
+  const blockModel = model.context.blockModel;
+  const dataSource = blockModel.collection.dataSource;
+  const collection = blockModel.collection;
+  const name = model.fieldPath;
+  const nameValue = (0, import_react.useMemo)(() => {
+    const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
+    const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : "";
+    return `${dataSourcePrefix}${collectionPrefix}${name}`;
+  }, []);
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.Form.Item, null, /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      style: {
+        color: "rgba(0,0,0,0.45)"
+      }
+    },
+    t(`The {{type}} "{{name}}" may have been deleted. Please remove this {{blockType}}.`, {
+      type: t("Field"),
+      name: nameValue,
+      blockType: t("Field")
+    }).replaceAll(">", ">")
+  ));
+}
+__name(FieldDeletePlaceholder, "FieldDeletePlaceholder");
 const defaultWhen = /* @__PURE__ */ __name(() => true, "defaultWhen");
 const _CollectionFieldModel = class _CollectionFieldModel extends import_flowModel.FlowModel {
+  fieldDeleted = false;
   renderHiddenInConfig() {
+    if (this.fieldDeleted) {
+      return /* @__PURE__ */ import_react.default.createElement(FieldDeletePlaceholder, null);
+    }
     return /* @__PURE__ */ import_react.default.createElement(FieldPlaceholder, null);
   }
   get title() {
@@ -86,11 +120,13 @@ const _CollectionFieldModel = class _CollectionFieldModel extends import_flowMod
         return this.fieldPath;
       }, "get")
     });
-    this.context.blockModel.addAppends(this.fieldPath);
-    this.context.blockModel.addAppends(this.associationPathName);
+    if (this.context.blockModel) {
+      this.context.blockModel.addAppends(this.fieldPath);
+      this.context.blockModel.addAppends(this.associationPathName);
+    }
   }
   getFieldSettingsInitParams() {
-    return this.getStepParams("fieldSettings", "init");
+    return this.getStepParams("fieldSettings", "init") || {};
   }
   get fieldPath() {
     return this.getFieldSettingsInitParams().fieldPath;
@@ -107,6 +143,9 @@ const _CollectionFieldModel = class _CollectionFieldModel extends import_flowMod
     }
   }
   static getBindingsByField(ctx, collectionField) {
+    if (!collectionField) {
+      return;
+    }
     const interfaceName = collectionField.interface;
     if (!this.bindings.has(interfaceName)) {
       return [];
@@ -238,5 +277,6 @@ CollectionFieldModel.registerFlow({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CollectionFieldModel,
+  FieldDeletePlaceholder,
   FieldPlaceholder
 });

package/lib/models/flowModel.d.ts

@@ -18,7 +18,7 @@ import { ModelEventRegistry } from '../event-registry/ModelEventRegistry';
 import { GlobalFlowRegistry } from '../flow-registry/GlobalFlowRegistry';
 import { FlowDefinition } from '../FlowDefinition';
 import { FlowSettingsOpenOptions } from '../flowSettings';
-import type { EventDefinition } from '../types';
+import type { EventDefinition, DispatchEventOptions } from '../types';
 import { ForkFlowModel } from './forkFlowModel';
 export declare enum ModelRenderMode {
     ReactElement = "reactElement",
@@ -42,6 +42,7 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     private _options;
     protected _title: string;
     isNew: boolean;
+    skeleton: any;
     /**
      * 所有 fork 实例的引用集合。
      * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
@@ -53,7 +54,7 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
      */
     private forkCache;
     /**
-     * 上一次 applyAutoFlows 的执行参数
+     * 上一次 beforeRender 的执行参数
      */
     private _lastAutoRunParams;
     protected observerDispose: () => void;
@@ -117,7 +118,11 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     setTitle(value: string): void;
     setHidden(value: boolean): void;
     _createSubModels(subModels: Record<string, CreateSubModelOptions | CreateSubModelOptions[]>): void;
-    invalidateAutoFlowCache(deep?: boolean): void;
+    /**
+     * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+     * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+     */
+    invalidateFlowCache(eventName?: string, deep?: boolean): void;
     /**
      * 设置FlowEngine实例
      * @param {FlowEngine} flowEngine FlowEngine实例
@@ -187,45 +192,36 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     private _dispatchEvent;
     private _dispatchEventWithDebounce;
     dispatchEvent(eventName: string, inputArgs?: Record<string, any>, options?: {
-        /**
-         * 是否要开启防抖功能
-         */
-        debounce: boolean;
-    }): Promise<void>;
+        /** 是否要开启防抖功能 */
+        debounce?: boolean;
+    } & DispatchEventOptions): Promise<any[]>;
     /**
-     * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
-     * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+     * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+     * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
      */
-    getAutoFlows(): FlowDefinition[];
+    getEventFlows(eventName: string): FlowDefinition[];
     /**
-     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 重新执行上一次的 beforeRender，保持参数一致
      * 如果之前没有执行过，则直接跳过
      * 使用 lodash debounce 避免频繁调用
      */
     private _rerunLastAutoRun;
     /**
-     * 自动流程执行前钩子。
-     * 子类可覆盖；可抛出 FlowExitException 提前终止。
+     * 通用事件分发钩子：开始
+     * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
      */
-    onBeforeAutoFlows(inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventStart(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>): Promise<void>;
     /**
-     * 自动流程执行后钩子。
+     * 通用事件分发钩子：结束
      * 子类可覆盖。
      */
-    onAfterAutoFlows(results: any[], inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventEnd(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>, results?: any[]): Promise<void>;
     /**
-     * 自动流程错误钩子。
+     * 通用事件分发钩子：错误
      * 子类可覆盖。
      */
-    onAutoFlowsError(error: Error, inputArgs?: Record<string, any>): Promise<void>;
+    onDispatchEventError(eventName: string, options?: DispatchEventOptions, inputArgs?: Record<string, any>, error?: Error): Promise<void>;
     useHooksBeforeRender(): void;
-    /**
-     * 执行所有自动应用流程
-     * @param {Record<string, any>} [inputArgs] 可选的运行时参数
-     * @param {boolean} [useCache=true] 是否使用缓存机制，默认为 true
-     * @returns {Promise<any[]>} 所有自动应用流程的执行结果数组
-     */
-    applyAutoFlows(inputArgs?: Record<string, any>, useCache?: boolean): Promise<any[]>;
     /**
      * 智能检测是否应该跳过响应式包装
      * 说明：
@@ -261,9 +257,9 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     render(): any;
     rerender(): Promise<void>;
     /**
-     * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+     * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     setParent(parent: FlowModel): void;
     removeParentDelegate(): void;
     addSubModel<T extends FlowModel>(subKey: string, options: CreateModelOptions | T): T;
@@ -273,7 +269,10 @@ export declare class FlowModel<Structure extends DefaultStructure = DefaultStruc
     hasSubModel<K extends keyof Structure['subModels']>(subKey: K): boolean;
     findSubModel<K extends keyof Structure['subModels'], R>(subKey: K, callback: (model: ArrayElementType<Structure['subModels'][K]>) => R): ArrayElementType<Structure['subModels'][K]> | null;
     createRootModel(options: any): FlowModel<DefaultStructure>;
-    applySubModelsAutoFlows<K extends keyof Structure['subModels']>(subKey: K, inputArgs?: Record<string, any>, shared?: Record<string, any>): Promise<void>;
+    /**
+     * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+     */
+    applySubModelsBeforeRenderFlows<K extends keyof Structure['subModels']>(subKey: K, inputArgs?: Record<string, any>, shared?: Record<string, any>): Promise<void>;
     /**
      * 创建一个 fork 实例，实现"一份数据（master）多视图（fork）"的能力。
      * @param {IModelComponentProps} [localProps={}] fork 专属的局部 props，优先级高于 master.props

package/lib/models/flowModel.js

@@ -62,7 +62,6 @@ var import_StepSettingsDialog = require("../components/settings/wrappers/context
 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");
@@ -94,6 +93,7 @@ const _FlowModel = class _FlowModel {
     __publicField(this, "_title");
     __publicField(this, "isNew", false);
     // 标记是否为新建状态
+    __publicField(this, "skeleton", null);
     /**
      * 所有 fork 实例的引用集合。
      * 使用 Set 便于在销毁时主动遍历并调用 dispose，避免悬挂引用。
@@ -105,7 +105,7 @@ const _FlowModel = class _FlowModel {
      */
     __publicField(this, "forkCache", /* @__PURE__ */ new Map());
     /**
-     * 上一次 applyAutoFlows 的执行参数
+     * 上一次 beforeRender 的执行参数
      */
     __publicField(this, "_lastAutoRunParams", null);
     __publicField(this, "observerDispose");
@@ -120,18 +120,22 @@ const _FlowModel = class _FlowModel {
     __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));
+    __publicField(this, "_dispatchEventWithDebounce", import_lodash.default.debounce(
+      async (eventName, inputArgs, options) => {
+        return this._dispatchEvent(eventName, inputArgs, options);
+      },
+      100
+    ));
     /**
-     * 重新执行上一次的 applyAutoFlows，保持参数一致
+     * 重新执行上一次的 beforeRender，保持参数一致
      * 如果之前没有执行过，则直接跳过
      * 使用 lodash debounce 避免频繁调用
      */
     __publicField(this, "_rerunLastAutoRun", import_lodash.default.debounce(async () => {
       if (this._lastAutoRunParams) {
         try {
-          await this.applyAutoFlows(...this._lastAutoRunParams);
+          const [inputArgs] = this._lastAutoRunParams;
+          await this.dispatchEvent("beforeRender", inputArgs);
         } catch (error) {
           console.error("FlowModel._rerunLastAutoRun: Error during rerun:", error);
         }
@@ -172,7 +176,7 @@ const _FlowModel = class _FlowModel {
         return;
       }
       if (this.flowEngine) {
-        this.invalidateAutoFlowCache();
+        this.invalidateFlowCache("beforeRender");
       }
       this._rerunLastAutoRun();
       this.forks.forEach((fork) => {
@@ -342,13 +346,57 @@ const _FlowModel = class _FlowModel {
       }
     });
   }
-  invalidateAutoFlowCache(deep = false) {
+  /**
+   * 失效指定事件的流程缓存；未指定 eventName 时，失效当前模型全部事件缓存。
+   * - 默认 beforeRender 与其它事件共享同一缓存体系：prefix=`event:${scope}`，flowKey=`eventName`，uid=`model.uid`
+   */
+  invalidateFlowCache(eventName, deep = false) {
     if (this.flowEngine) {
-      const cacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey("autoFlow", "all", this.uid);
-      this.flowEngine.applyFlowCache.delete(cacheKey);
+      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) => {
-        const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${fork["forkId"]}`, "all", this.uid);
-        this.flowEngine.applyFlowCache.delete(forkCacheKey);
+        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) {
@@ -357,10 +405,10 @@ const _FlowModel = class _FlowModel {
         const subModelValue = this.subModels[subModelKey];
         if (Array.isArray(subModelValue)) {
           for (const subModel of subModelValue) {
-            subModel.invalidateAutoFlowCache(deep);
+            subModel.invalidateFlowCache(eventName, deep);
           }
         } else if (subModelValue instanceof _FlowModel) {
-          subModelValue.invalidateAutoFlowCache(deep);
+          subModelValue.invalidateFlowCache(eventName, deep);
         }
       }
     }
@@ -544,7 +592,7 @@ const _FlowModel = class _FlowModel {
     );
     return currentFlowEngine.executor.runFlow(target, flowKey, inputArgs, runId);
   }
-  async _dispatchEvent(eventName, inputArgs) {
+  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.");
@@ -555,93 +603,63 @@ const _FlowModel = class _FlowModel {
     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);
+    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);
+      return this._dispatchEventWithDebounce(eventName, inputArgs, execOptions);
     }
-    return this._dispatchEvent(eventName, inputArgs);
+    return this._dispatchEvent(eventName, inputArgs, execOptions);
   }
   /**
-   * 获取所有自动应用流程定义（保持 getFlows 的顺序，即按 sort 排序）
-   * @returns {FlowDefinition[]} 自动应用流程定义数组（已按 sort 排序）
+   * 按事件名获取对应的流程集合（保持 getFlows 的顺序，即按 sort 排序）。
+   * - beforeRender 兼容：除显式 on: 'beforeRender' 外，包含未声明 on 且 manual !== true 的流程。
    */
-  getAutoFlows() {
+  getEventFlows(eventName) {
     const allFlows = this.getFlows();
-    const autoFlows = Array.from(allFlows.values()).filter((flow) => {
-      if (flow.on) {
-        return false;
+    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";
       }
-      if (flow.manual === true) {
-        return false;
-      }
-      return true;
-    });
-    return autoFlows;
+      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);
   }
   /**
-   * 自动流程执行前钩子。
-   * 子类可覆盖；可抛出 FlowExitException 提前终止。
+   * 通用事件分发钩子：开始
+   * 子类可覆盖；beforeRender 事件可通过抛出 FlowExitException 提前终止。
    */
-  async onBeforeAutoFlows(inputArgs) {
+  async onDispatchEventStart(eventName, options, inputArgs) {
   }
   /**
-   * 自动流程执行后钩子。
+   * 通用事件分发钩子：结束
    * 子类可覆盖。
    */
-  async onAfterAutoFlows(results, inputArgs) {
+  async onDispatchEventEnd(eventName, options, inputArgs, results) {
   }
   /**
-   * 自动流程错误钩子。
+   * 通用事件分发钩子：错误
    * 子类可覆盖。
    */
-  async onAutoFlowsError(error, inputArgs) {
+  async onDispatchEventError(eventName, options, inputArgs, error) {
   }
   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;
-  }
   /**
    * 智能检测是否应该跳过响应式包装
    * 说明：
@@ -717,6 +735,7 @@ const _FlowModel = class _FlowModel {
             }
             return (_c = modelInstance.renderHiddenInConfig) == null ? void 0 : _c.call(modelInstance);
           }
+          modelInstance.stepParams;
           return originalRender.call(renderTarget);
         });
         ReactiveWrapper.displayName = `ReactiveWrapper(${modelInstance.constructor.name})`;
@@ -768,13 +787,13 @@ const _FlowModel = class _FlowModel {
   }
   async rerender() {
     var _a;
-    await this.applyAutoFlows((_a = this._lastAutoRunParams) == null ? void 0 : _a[0], false);
+    await this.dispatchEvent("beforeRender", (_a = this._lastAutoRunParams) == null ? void 0 : _a[0], { useCache: false });
   }
   /**
-   * 自动流程缓存的作用域标识；fork 实例可覆盖以区分缓存。
+   * 事件缓存的作用域标识；可按事件区分（默认与事件无关的 scope 返回 'default'）。
    */
-  getAutoFlowCacheScope() {
-    return "autoFlow";
+  getFlowCacheScope(eventName) {
+    return String(eventName);
   }
   setParent(parent) {
     const isValidParent = parent && (parent.constructor === _FlowModel || (0, import_utils.isInheritedFrom)(parent.constructor, _FlowModel));
@@ -892,10 +911,13 @@ const _FlowModel = class _FlowModel {
   createRootModel(options) {
     return this.flowEngine.createModel(options);
   }
-  async applySubModelsAutoFlows(subKey, inputArgs, shared) {
+  /**
+   * 对指定子模型派发 beforeRender 事件（顺序执行并使用缓存）。
+   */
+  async applySubModelsBeforeRenderFlows(subKey, inputArgs, shared) {
     await Promise.all(
       this.mapSubModels(subKey, async (sub) => {
-        await sub.applyAutoFlows(inputArgs);
+        await sub.dispatchEvent("beforeRender", inputArgs);
       })
     );
   }
@@ -952,7 +974,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before saving.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.removeModel(this.uid);
   }
   async save() {
@@ -969,7 +991,7 @@ const _FlowModel = class _FlowModel {
       throw new Error("FlowEngine is not set on this model. Please set flowEngine before deleting.");
     }
     this.observerDispose();
-    this.invalidateAutoFlowCache(true);
+    this.invalidateFlowCache("beforeRender", true);
     return this.flowEngine.destroyModel(this.uid);
   }
   /**

package/lib/models/forkFlowModel.d.ts

@@ -63,9 +63,9 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      */
     render(): any;
     /**
-     * 自动流程缓存的作用域标识（fork 专用）。
+     * 事件缓存的作用域标识（fork 专用）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     /**
      * 释放 fork：从 master.forks 中移除自身并断开引用
      */

package/lib/models/forkFlowModel.js

@@ -38,7 +38,6 @@ __export(forkFlowModel_exports, {
 module.exports = __toCommonJS(forkFlowModel_exports);
 var import_reactive = require("@formily/reactive");
 var import_flowContext = require("../flowContext");
-var import_flowEngine = require("../flowEngine");
 var _flowContext;
 const _ForkFlowModel = class _ForkFlowModel {
   constructor(master, initialProps = {}, forkId = 0) {
@@ -194,10 +193,10 @@ const _ForkFlowModel = class _ForkFlowModel {
     }
   }
   /**
-   * 自动流程缓存的作用域标识（fork 专用）。
+   * 事件缓存的作用域标识（fork 专用）。
    */
-  getAutoFlowCacheScope() {
-    return String(this.forkId);
+  getFlowCacheScope(eventName) {
+    return `${String(eventName)}:${String(this.forkId)}`;
   }
   // onUnmount() {
   //   // 不在此处自动 dispose（避免破坏外部 fork 管理），但应透传到 master 的 onUnmount 钩子，
@@ -216,11 +215,35 @@ const _ForkFlowModel = class _ForkFlowModel {
    * 释放 fork：从 master.forks 中移除自身并断开引用
    */
   dispose() {
+    var _a;
     if (this.disposed) return;
     this.disposed = true;
+    try {
+      const cache = (_a = this.flowEngine) == null ? void 0 : _a.applyFlowCache;
+      if (cache && cache.size > 0) {
+        const uidSuffixes = [`:${this.uid}`, `-${this.uid}`];
+        const forkIdColon = `:${this.forkId}:`;
+        const forkIdHyphen = `-${this.forkId}-`;
+        for (const key of cache.keys()) {
+          const isEventCache = key.startsWith("event:") || key.startsWith("event-");
+          if (!isEventCache) continue;
+          const endMatches = uidSuffixes.some((s) => key.endsWith(s));
+          if (!endMatches) continue;
+          let trimmed = key;
+          for (const suf of uidSuffixes) {
+            if (trimmed.endsWith(suf)) {
+              trimmed = trimmed.slice(0, -suf.length);
+              break;
+            }
+          }
+          if (trimmed.includes(forkIdColon) || trimmed.includes(forkIdHyphen)) {
+            cache.delete(key);
+          }
+        }
+      }
+    } catch {
+    }
     if (this.master && this.master.forks) {
-      const forkCacheKey = import_flowEngine.FlowEngine.generateApplyFlowCacheKey(`${this.forkId}`, "all", this.uid);
-      this.flowEngine.applyFlowCache.delete(forkCacheKey);
       this.master.forks.delete(this);
     }
     if (this.master && this.master.forkCache) {

package/lib/provider.d.ts

@@ -17,6 +17,8 @@ export declare const FlowEngineProvider: React.FC<FlowEngineProviderProps>;
 export declare const FlowEngineGlobalsContextProvider: React.FC<{
     children: React.ReactNode;
 }>;
-export declare const useFlowEngine: () => FlowEngine;
+export declare const useFlowEngine: ({ throwError }?: {
+    throwError?: boolean;
+}) => FlowEngine;
 export declare const useFlowEngineContext: () => FlowEngineContext;
 export {};

package/lib/provider.js

@@ -49,14 +49,16 @@ var import_FlowContextProvider = require("./FlowContextProvider");
 var import_views = require("./views");
 var import_FlowView = require("./views/FlowView");
 const FlowEngineReactContext = (0, import_react.createContext)(null);
-const FlowEngineProvider = /* @__PURE__ */ __name((props) => {
+const FlowEngineProvider = import_react.default.memo((props) => {
   const { engine, children } = props;
   if (!engine) {
     throw new Error("FlowEngineProvider must be supplied with an engine.");
   }
   return /* @__PURE__ */ import_react.default.createElement(FlowEngineReactContext.Provider, { value: engine }, /* @__PURE__ */ import_react.default.createElement(import_FlowContextProvider.FlowContextProvider, { context: engine.context }, children));
-}, "FlowEngineProvider");
+});
+FlowEngineProvider.displayName = "FlowEngineProvider";
 const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) => {
+  var _a;
   const { modal, message, notification } = import_antd.App.useApp();
   const [drawer, contextHolder] = (0, import_views.useDrawer)();
   const [embed, pageContextHolder] = (0, import_views.usePage)();
@@ -90,11 +92,11 @@ const FlowEngineGlobalsContextProvider = /* @__PURE__ */ __name(({ children }) =
     }
     engine.reactView.refresh();
   }, [engine, drawer, modal, message, notification, config, popover, token, dialog, embed]);
-  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
+  return /* @__PURE__ */ import_react.default.createElement(import_antd.ConfigProvider, { ...config, locale: (_a = engine.context.locales) == null ? void 0 : _a.antd, popupMatchSelectWidth: false }, children, contextHolder, popoverContextHolder, pageContextHolder, dialogContextHolder);
 }, "FlowEngineGlobalsContextProvider");
-const useFlowEngine = /* @__PURE__ */ __name(() => {
+const useFlowEngine = /* @__PURE__ */ __name(({ throwError = true } = {}) => {
   const context = (0, import_react.useContext)(FlowEngineReactContext);
-  if (!context) {
+  if (!context && throwError) {
     throw new Error(
       "useFlowEngine must be used within a FlowEngineProvider, and FlowEngineProvider must be supplied with an engine."
     );