@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.40

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) => {
@@ -234,6 +238,10 @@ const _FlowModel = class _FlowModel {
   get parentId() {
     return this._options.parentId;
   }
+  scheduleModelOperation(toUid, fn, options) {
+    var _a;
+    return (_a = this.flowEngine) == null ? void 0 : _a.scheduleModelOperation(this, toUid, fn, options);
+  }
   static get meta() {
     return modelMetas.get(this);
   }
@@ -342,13 +350,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 +409,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);
         }
       }
     }
@@ -480,14 +532,15 @@ const _FlowModel = class _FlowModel {
     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;
+    const instanceEntriesWithIndex = instanceEntries.map((e, i) => ({ e, i }));
+    instanceEntriesWithIndex.sort((a, b) => {
+      const sa = a.e[1].sort ?? 0;
+      const sb = b.e[1].sort ?? 0;
       if (sa !== sb) return sa - sb;
-      return 0;
+      return a.i - b.i;
     });
-    return new Map(allEntries);
+    const merged = [...instanceEntriesWithIndex.map(({ e }) => e), ...staticEntries];
+    return new Map(merged);
   }
   setProps(props, value) {
     if (typeof props === "string") {
@@ -544,7 +597,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 +608,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 } : { sequential: 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;
-      }
-      if (flow.manual === true) {
-        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";
       }
-      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;
-  }
   /**
    * 智能检测是否应该跳过响应式包装
    * 说明：
@@ -701,13 +724,23 @@ const _FlowModel = class _FlowModel {
             modelInstance.props;
           }
           import_react.default.useEffect(() => {
+            var _a2, _b2;
             if (typeof renderTarget.onMount === "function") {
               renderTarget.onMount();
             }
+            void ((_b2 = (_a2 = renderTarget.flowEngine) == null ? void 0 : _a2.emitter) == null ? void 0 : _b2.emitAsync("model:mounted", {
+              uid: renderTarget.uid,
+              model: renderTarget
+            }));
             return () => {
+              var _a3, _b3;
               if (typeof renderTarget.onUnmount === "function") {
                 renderTarget.onUnmount();
               }
+              void ((_b3 = (_a3 = renderTarget.flowEngine) == null ? void 0 : _a3.emitter) == null ? void 0 : _b3.emitAsync("model:unmounted", {
+                uid: renderTarget.uid,
+                model: renderTarget
+              }));
             };
           }, [renderTarget]);
           const isConfigMode = !!((_b = (_a = modelInstance == null ? void 0 : modelInstance.flowEngine) == null ? void 0 : _a.flowSettings) == null ? void 0 : _b.enabled);
@@ -717,6 +750,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 +802,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 +926,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);
       })
     );
   }
@@ -913,7 +950,7 @@ const _FlowModel = class _FlowModel {
         return cachedFork;
       }
     }
-    const forkId = this.forks.size;
+    const forkId = (0, import_secure.uid)();
     const fork = new import_forkFlowModel.ForkFlowModel(this, localProps, forkId);
     if ((options == null ? void 0 : options.register) !== false) {
       this.forks.add(fork);
@@ -952,7 +989,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 +1006,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);
   }
   /**
@@ -1032,7 +1069,8 @@ const _FlowModel = class _FlowModel {
       uid: this.uid,
       ...import_lodash.default.omit(this._options, ["flowEngine"]),
       stepParams: this.stepParams,
-      sortIndex: this.sortIndex
+      sortIndex: this.sortIndex,
+      flowRegistry: {}
     };
     const subModels = this.subModels;
     for (const subModelKey in subModels) {
@@ -1047,8 +1085,7 @@ const _FlowModel = class _FlowModel {
       }
     }
     for (const [key, flow] of this.flowRegistry.getFlows()) {
-      data["flowRegistry"] = data["flowRegistry"] || {};
-      data["flowRegistry"][key] = flow.toData();
+      data.flowRegistry[key] = flow.toData();
     }
     return data;
   }

package/lib/models/forkFlowModel.d.ts

@@ -31,7 +31,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
     /** 是否已被释放 */
     private disposed;
     /** fork 在 master.forks 中的索引 */
-    readonly forkId: number;
+    readonly forkId: string;
     /** 需要与 master 共享的属性列表 */
     private static readonly SHARED_PROPERTIES;
     /**
@@ -48,7 +48,7 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      * 注意：此属性通过 Proxy 在 get/set 陷阱中被动态访问，IDE 可能无法检测到使用, 切勿删除！
      */
     private localProperties;
-    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: number);
+    constructor(master: TMaster, initialProps?: IModelComponentProps, forkId?: string);
     get context(): FlowModelContext;
     /**
      * 获取对象及其原型链上的属性描述符
@@ -58,14 +58,18 @@ export declare class ForkFlowModel<TMaster extends FlowModel = FlowModel> {
      * 修改局部 props，仅影响当前 fork
      */
     setProps(key: string | IModelComponentProps, value?: any): void;
+    /**
+     * 清理局部 props，仅影响当前 fork
+     */
+    clearProps(): {};
     /**
      * render 依旧使用 master 的方法，但合并后的 props 需要透传
      */
     render(): any;
     /**
-     * 自动流程缓存的作用域标识（fork 专用）。
+     * 事件缓存的作用域标识（fork 专用）。
      */
-    getAutoFlowCacheScope(): string;
+    getFlowCacheScope(eventName: string): string;
     /**
      * 释放 fork：从 master.forks 中移除自身并断开引用
      */

package/lib/models/forkFlowModel.js

@@ -38,10 +38,10 @@ __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 import_secure = require("uid/secure");
 var _flowContext;
 const _ForkFlowModel = class _ForkFlowModel {
-  constructor(master, initialProps = {}, forkId = 0) {
+  constructor(master, initialProps = {}, forkId) {
     /** 与 master 相同的 UID，用于日志调试 */
     __publicField(this, "uid");
     /** 调试标识，便于在日志或断言中快速识别 */
@@ -65,7 +65,7 @@ const _ForkFlowModel = class _ForkFlowModel {
     this.master = master;
     this.uid = master.uid;
     this.localProps = { ...initialProps };
-    this.forkId = forkId;
+    this.forkId = forkId || (0, import_secure.uid)();
     this.hidden = this.master.hidden;
     (0, import_reactive.define)(this, {
       localProps: import_reactive.observable,
@@ -179,6 +179,12 @@ const _ForkFlowModel = class _ForkFlowModel {
       this.localProps = { ...this.localProps, ...key };
     }
   }
+  /**
+   * 清理局部 props，仅影响当前 fork
+   */
+  clearProps() {
+    return this.localProps = {};
+  }
   /**
    * render 依旧使用 master 的方法，但合并后的 props 需要透传
    */
@@ -194,10 +200,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 +222,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."
     );

package/lib/resources/multiRecordResource.js

@@ -130,6 +130,7 @@ const _MultiRecordResource = class _MultiRecordResource extends import_baseRecor
   async create(data, options) {
     const config = this.mergeRequestConfig({ data }, this.createActionOptions, options);
     await this.runAction("create", config);
+    this.emit("saved", data);
     await this.refresh();
   }
   async get(filterByTk) {
@@ -144,17 +145,35 @@ const _MultiRecordResource = class _MultiRecordResource extends import_baseRecor
     return data;
   }
   async update(filterByTk, data, options) {
+    const collection = this.context.collection;
+    const filterTargetKey = collection == null ? void 0 : collection.filterTargetKey;
+    const tkData = collection == null ? void 0 : collection.getFilterByTK(this.context.record);
+    let result = data;
+    if (collection && filterTargetKey) {
+      if (Array.isArray(filterTargetKey)) {
+        result = {
+          ...data,
+          ...tkData || {}
+        };
+      } else {
+        result = {
+          ...data,
+          [filterTargetKey]: tkData
+        };
+      }
+    }
     const config = this.mergeRequestConfig(
       {
         params: {
           filterByTk
         },
-        data
+        data: result
       },
       this.updateActionOptions,
       options
     );
     await this.runAction("update", config);
+    this.emit("saved", data);
     await this.refresh();
   }
   async destroySelectedRows() {
@@ -176,6 +195,11 @@ const _MultiRecordResource = class _MultiRecordResource extends import_baseRecor
       options
     );
     await this.runAction("destroy", config);
+    const currentPage = this.getPage();
+    const lastPage = Math.ceil((this.getCount() - import_lodash.default.castArray(filterByTk).length) / this.getPageSize());
+    if (currentPage > lastPage) {
+      this.setPage(lastPage);
+    }
     await this.refresh();
   }
   setItem(index, newDataItem) {