@nocobase/flow-engine 2.0.0-alpha.63 → 2.0.0-alpha.65

package/lib/scheduler/ModelOperationScheduler.js

@@ -125,32 +125,32 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
   bindEngineLifecycle() {
     const emitter = this.engine.emitter;
     if (!emitter || typeof emitter.on !== "function") return;
-    const onCreated = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "created" });
+    const onCreated = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "created" });
     }, "onCreated");
     emitter.on("model:created", onCreated);
     this.unbindHandlers.push(() => emitter.off("model:created", onCreated));
-    const onMounted = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
+    const onMounted = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
     }, "onMounted");
     emitter.on("model:mounted", onMounted);
     this.unbindHandlers.push(() => emitter.off("model:mounted", onMounted));
-    const onGenericBeforeStart = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
+    const onGenericBeforeStart = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
     }, "onGenericBeforeStart");
     emitter.on("model:event:beforeRender:start", onGenericBeforeStart);
     this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:start", onGenericBeforeStart));
-    const onGenericBeforeEnd = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
+    const onGenericBeforeEnd = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
     }, "onGenericBeforeEnd");
     emitter.on("model:event:beforeRender:end", onGenericBeforeEnd);
     this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:end", onGenericBeforeEnd));
-    const onUnmounted = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
+    const onUnmounted = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
     }, "onUnmounted");
     emitter.on("model:unmounted", onUnmounted);
     this.unbindHandlers.push(() => emitter.off("model:unmounted", onUnmounted));
-    const onDestroyed = /* @__PURE__ */ __name((e) => {
+    const onDestroyed = /* @__PURE__ */ __name(async (e) => {
       const targetBucket = this.itemsByTargetUid.get(e.uid);
       const event = { ...e, type: "destroyed" };
       if (targetBucket && targetBucket.size) {
@@ -159,7 +159,7 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
           const it = this.itemsById.get(id);
           if (!it) continue;
           if (this.shouldTrigger(it.options.when, event)) {
-            void this.tryExecuteOnce(id, event);
+            await this.tryExecuteOnce(id, event);
           } else {
             this.internalCancel(id);
           }
@@ -177,14 +177,14 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
     if (this.subscribedEventNames.has(name)) return;
     this.subscribedEventNames.add(name);
     const emitter = this.engine.emitter;
-    const onStart = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
+    const onStart = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
     }, "onStart");
-    const onEnd = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
+    const onEnd = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
     }, "onEnd");
-    const onError = /* @__PURE__ */ __name((e) => {
-      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
+    const onError = /* @__PURE__ */ __name(async (e) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
     }, "onError");
     emitter.on(`model:event:${name}:start`, onStart);
     emitter.on(`model:event:${name}:end`, onEnd);
@@ -195,11 +195,11 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
   }
   parseEventWhen(when) {
     if (!when || typeof when !== "string") return null;
-    const m = /^event:([^:]+):(start|end|error)$/.exec(when);
+    const m = /^event:(.+):(start|end|error)$/.exec(when);
     if (!m) return null;
     return { name: m[1], phase: m[2] };
   }
-  processLifecycleEvent(targetUid, event) {
+  async processLifecycleEvent(targetUid, event) {
     const targetBucket = this.itemsByTargetUid.get(targetUid);
     if (!targetBucket || targetBucket.size === 0) return;
     const ids = Array.from(targetBucket.keys());
@@ -208,7 +208,7 @@ const _ModelOperationScheduler = class _ModelOperationScheduler {
       if (!item) continue;
       const should = this.shouldTrigger(item.options.when, event);
       if (!should) continue;
-      void this.tryExecuteOnce(id, event);
+      await this.tryExecuteOnce(id, event);
     }
   }
   shouldTrigger(when, event) {

package/lib/types.d.ts

@@ -166,12 +166,27 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
  * - 允许扩展字符串以保持向后兼容。
  */
 export type FlowEventName = 'click' | 'submit' | 'reset' | 'remove' | 'openView' | 'dropdownOpen' | 'popupScroll' | 'search' | 'customRequest' | 'collapseToggle' | (string & {});
+/**
+ * 事件流的执行时机（phase）。
+ *
+ * 说明：
+ * - 缺省（phase 未配置）表示保持现有行为；
+ * - 当配置了 phase 时，运行时会将其映射为 `scheduleModelOperation` 的 `when` 锚点；
+ * - phase 同时适用于动态事件流（实例级）与静态流（内置）。
+ */
+export type FlowEventPhase = 'beforeAllFlows' | 'afterAllFlows' | 'beforeFlow' | 'afterFlow' | 'beforeStep' | 'afterStep';
 /**
  * Flow 事件类型（供 FlowDefinitionOptions.on 使用）。
  */
 export type FlowEvent<TModel extends FlowModel = FlowModel> = FlowEventName | {
     eventName: FlowEventName;
     defaultParams?: Record<string, any>;
+    /** 动态事件流的执行时机（默认 beforeAllFlows） */
+    phase?: FlowEventPhase;
+    /** phase 为 beforeFlow/afterFlow/beforeStep/afterStep 时使用 */
+    flowKey?: string;
+    /** phase 为 beforeStep/afterStep 时使用 */
+    stepKey?: string;
 };
 /**
  * 事件分发选项。

package/lib/views/useDialog.js

@@ -170,9 +170,9 @@ function useDialog() {
             className: "nb-dialog-overflow-hidden",
             ref: dialogRef,
             hidden: (_d = (_c2 = config.inputArgs) == null ? void 0 : _c2.hidden) == null ? void 0 : _d.value,
-            ...config,
             footer: currentFooter,
             header: currentHeader,
+            ...config,
             onCancel: () => {
               currentDialog.close(config.result);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.0-alpha.63",
+  "version": "2.0.0-alpha.65",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.0.0-alpha.63",
-    "@nocobase/shared": "2.0.0-alpha.63",
+    "@nocobase/sdk": "2.0.0-alpha.65",
+    "@nocobase/shared": "2.0.0-alpha.65",
     "ahooks": "^3.7.2",
     "dayjs": "^1.11.9",
     "dompurify": "^3.0.2",
@@ -36,5 +36,5 @@
   ],
   "author": "NocoBase Team",
   "license": "AGPL-3.0",
-  "gitHead": "0d5e9eb45e4d0f3ba70d7561a0d296d12a4d8bf8"
+  "gitHead": "790dd7ba2bb5b1dc905163f11c7b492a5b862365"
 }

package/src/__tests__/provider.test.tsx

@@ -14,11 +14,6 @@ import { FlowEngine } from '../flowEngine';
 import { FlowEngineProvider, useFlowEngine } from '../provider';
 
 describe('FlowEngineProvider/useFlowEngine', () => {
-  it('throws without provider', () => {
-    const run = () => renderHook(() => useFlowEngine());
-    expect(run).toThrow(/FlowEngineProvider/);
-  });
-
   it('returns engine within provider', () => {
     const engine = new FlowEngine();
     const wrapper = ({ children }: any) => <FlowEngineProvider engine={engine}>{children}</FlowEngineProvider>;

package/src/acl/Acl.tsx

@@ -6,7 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { omit } from 'lodash';
+import _, { omit } from 'lodash';
 import { FlowEngine } from '../flowEngine';
 import { FlowModel } from '../models/flowModel';
 
@@ -31,11 +31,11 @@ export class ACL {
   constructor(private flowEngine: FlowEngine) {}
 
   setData(data: Record<string, any>) {
-    this.data = data;
+    this.data = _.cloneDeep(data);
   }
 
   setMeta(data: Record<string, any>) {
-    this.meta = data;
+    this.meta = _.cloneDeep(data);
   }
 
   async load() {

package/src/components/__tests__/gridDragPlanner.test.ts

@@ -19,9 +19,14 @@ import {
 
 const rect = { top: 0, left: 0, width: 100, height: 100 };
 
-const createLayout = (rows: Record<string, string[][]>, sizes: Record<string, number[]>): GridLayoutData => ({
+const createLayout = (
+  rows: Record<string, string[][]>,
+  sizes: Record<string, number[]>,
+  rowOrder?: string[],
+): GridLayoutData => ({
   rows,
   sizes,
+  rowOrder,
 });
 
 describe('getSlotKey', () => {
@@ -275,6 +280,7 @@ describe('simulateLayoutForSlot', () => {
         rowA: [24],
         rowB: [24],
       },
+      ['rowA', 'rowB'],
     );
 
     const slot: LayoutSlot = {
@@ -315,6 +321,33 @@ describe('simulateLayoutForSlot', () => {
     expect(result.sizes['row-new']).toEqual([24]);
   });
 
+  it('removes empty source row when moving item into empty container slot', () => {
+    const layout = createLayout(
+      {
+        rowA: [['block-x']],
+      },
+      {
+        rowA: [24],
+      },
+    );
+
+    const slot: LayoutSlot = {
+      type: 'empty-row',
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({
+      slot,
+      sourceUid: 'block-x',
+      layout,
+      generateRowId: () => 'row-new',
+    });
+
+    expect(result.rows['row-new']).toEqual([['block-x']]);
+    expect(result.rows.rowA).toBeUndefined();
+    expect(result.sizes.rowA).toBeUndefined();
+  });
+
   it('handles column slot with after position', () => {
     const layout = createLayout(
       {
@@ -373,6 +406,7 @@ describe('simulateLayoutForSlot', () => {
         rowA: [24],
         rowB: [24],
       },
+      ['rowA', 'rowB'],
     );
 
     const slot: LayoutSlot = {
@@ -392,6 +426,112 @@ describe('simulateLayoutForSlot', () => {
     expect(Object.keys(result.rows)).toEqual(['rowA', 'row-inserted', 'rowB']);
   });
 
+  it('inserts row into rowOrder when dropping below target row', () => {
+    const layout = createLayout(
+      {
+        rowA: [['a']],
+        rowB: [['b']],
+      },
+      {
+        rowA: [24],
+        rowB: [24],
+      },
+      ['rowA', 'rowB'],
+    );
+
+    const slot: LayoutSlot = {
+      type: 'row-gap',
+      targetRowId: 'rowA',
+      position: 'below',
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({
+      slot,
+      sourceUid: 'c',
+      layout,
+      generateRowId: () => 'row-new',
+    });
+
+    expect(result.rowOrder).toEqual(['rowA', 'row-new', 'rowB']);
+  });
+
+  it('maintains rowOrder and inserts new row before target when provided', () => {
+    const layout = createLayout(
+      {
+        rowA: [['a']],
+        rowB: [['b']],
+      },
+      {
+        rowA: [24],
+        rowB: [24],
+      },
+      ['rowA', 'rowB'],
+    );
+
+    const slot: LayoutSlot = {
+      type: 'row-gap',
+      targetRowId: 'rowB',
+      position: 'above',
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({
+      slot,
+      sourceUid: 'c',
+      layout,
+      generateRowId: () => 'row-new',
+    });
+
+    expect(result.rowOrder).toEqual(['rowA', 'row-new', 'rowB']);
+    expect(result.rows).toEqual({
+      rowA: [['a']],
+      'row-new': [['c']],
+      rowB: [['b']],
+    });
+    expect(result.sizes).toEqual({
+      rowA: [24],
+      'row-new': [24],
+      rowB: [24],
+    });
+  });
+
+  it('derives rowOrder from rows when missing and removes empty rows from order', () => {
+    const layout = createLayout(
+      {
+        row1: [['a']],
+        row2: [['b']],
+        row3: [['c']],
+      },
+      {
+        row1: [24],
+        row2: [24],
+        row3: [24],
+      },
+    );
+
+    const slot: LayoutSlot = {
+      type: 'column',
+      rowId: 'row1',
+      columnIndex: 0,
+      insertIndex: 0,
+      position: 'before',
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({ slot, sourceUid: 'b', layout });
+
+    expect(result.rowOrder).toEqual(['row1', 'row3']);
+    expect(result.rows).toEqual({
+      row1: [['b', 'a']],
+      row3: [['c']],
+    });
+    expect(result.sizes).toEqual({
+      row1: [24],
+      row3: [24],
+    });
+  });
+
   it('handles empty-column slot by replacing empty column', () => {
     const layout = createLayout(
       {

package/src/components/dnd/gridDragPlanner.ts

@@ -46,6 +46,7 @@ export interface Point {
 export interface GridLayoutData {
   rows: Record<string, string[][]>;
   sizes: Record<string, number[]>;
+  rowOrder?: string[];
 }
 
 export interface ColumnSlot {
@@ -142,6 +143,49 @@ export interface LayoutSnapshot {
   containerRect: Rect;
 }
 
+const deriveRowOrder = (rows: Record<string, string[][]>, provided?: string[]) => {
+  const order: string[] = [];
+  const used = new Set<string>();
+
+  (provided || Object.keys(rows)).forEach((rowId) => {
+    if (rows[rowId] && !used.has(rowId)) {
+      order.push(rowId);
+      used.add(rowId);
+    }
+  });
+
+  Object.keys(rows).forEach((rowId) => {
+    if (!used.has(rowId)) {
+      order.push(rowId);
+      used.add(rowId);
+    }
+  });
+
+  return order;
+};
+
+const normalizeRowsWithOrder = (rows: Record<string, string[][]>, order: string[]) => {
+  const next: Record<string, string[][]> = {};
+  order.forEach((rowId) => {
+    if (rows[rowId]) {
+      next[rowId] = rows[rowId];
+    }
+  });
+  Object.keys(rows).forEach((rowId) => {
+    if (!next[rowId]) {
+      next[rowId] = rows[rowId];
+    }
+  });
+  return next;
+};
+
+const ensureRowOrder = (layout: GridLayoutData) => {
+  const order = deriveRowOrder(layout.rows, layout.rowOrder);
+  layout.rowOrder = order;
+  layout.rows = normalizeRowsWithOrder(layout.rows, order);
+  return order;
+};
+
 export interface BuildLayoutSnapshotOptions {
   container: HTMLElement | null;
 }
@@ -465,10 +509,12 @@ const removeItemFromLayout = (layout: GridLayoutData, uidValue: string) => {
   if (columns.length === 0) {
     delete layout.rows[rowId];
     delete layout.sizes[rowId];
+    ensureRowOrder(layout);
     return;
   }
 
   normalizeRowSizes(rowId, layout);
+  ensureRowOrder(layout);
 };
 
 const toIntSizes = (weights: number[], count: number): number[] => {
@@ -592,8 +638,10 @@ export const simulateLayoutForSlot = ({
   const cloned: GridLayoutData = {
     rows: _.cloneDeep(layout.rows),
     sizes: _.cloneDeep(layout.sizes),
+    rowOrder: layout.rowOrder ? [...layout.rowOrder] : undefined,
   };
 
+  ensureRowOrder(cloned);
   removeItemFromLayout(cloned, sourceUid);
 
   const createRowId = generateRowId ?? uid;
@@ -638,8 +686,16 @@ export const simulateLayoutForSlot = ({
     case 'row-gap': {
       const newRowId = createRowId();
       const rowPosition: 'before' | 'after' = slot.position === 'above' ? 'before' : 'after';
+      const currentOrder = deriveRowOrder(cloned.rows, cloned.rowOrder);
       cloned.rows = insertRow(cloned.rows, slot.targetRowId, newRowId, rowPosition, [[sourceUid]]);
       cloned.sizes[newRowId] = [DEFAULT_GRID_COLUMNS];
+      const targetIndex = currentOrder.indexOf(slot.targetRowId);
+      const insertIndex =
+        targetIndex === -1 ? currentOrder.length : rowPosition === 'before' ? targetIndex : targetIndex + 1;
+      const nextOrder = [...currentOrder];
+      nextOrder.splice(insertIndex, 0, newRowId);
+      cloned.rowOrder = nextOrder;
+      cloned.rows = normalizeRowsWithOrder(cloned.rows, nextOrder);
       break;
     }
     case 'empty-row': {
@@ -649,11 +705,15 @@ export const simulateLayoutForSlot = ({
         [newRowId]: [[sourceUid]],
       };
       cloned.sizes[newRowId] = [DEFAULT_GRID_COLUMNS];
+      const currentOrder = deriveRowOrder(cloned.rows, cloned.rowOrder);
+      cloned.rowOrder = [...currentOrder.filter((id) => id !== newRowId), newRowId];
+      cloned.rows = normalizeRowsWithOrder(cloned.rows, cloned.rowOrder);
       break;
     }
     default:
       break;
   }
 
+  ensureRowOrder(cloned);
   return cloned;
 };

package/src/data-source/index.ts

@@ -815,6 +815,9 @@ export class CollectionField {
         if (typeof v !== 'object') {
           return v;
         }
+        if (v.value === null || v.value === undefined) {
+          return v;
+        }
         return {
           ...v,
           value: Number(v.value),