@nocobase/flow-engine 2.0.45 → 2.0.47

package/lib/components/dnd/index.js

@@ -104,7 +104,9 @@ const Droppable = /* @__PURE__ */ __name(({ model, children }) => {
 const DndProvider = /* @__PURE__ */ __name(({
   persist = true,
   children,
+  onDragStart,
   onDragEnd,
+  onDragCancel,
   ...restProps
 }) => {
   const [activeId, setActiveId] = (0, import_react.useState)(null);
@@ -112,10 +114,10 @@ const DndProvider = /* @__PURE__ */ __name(({
   return /* @__PURE__ */ import_react.default.createElement(
     import_core.DndContext,
     {
+      ...restProps,
       onDragStart: (event) => {
-        var _a;
         setActiveId(event.active.id);
-        (_a = restProps.onDragStart) == null ? void 0 : _a.call(restProps, event);
+        onDragStart == null ? void 0 : onDragStart(event);
       },
       onDragEnd: (event) => {
         setActiveId(null);
@@ -127,13 +129,17 @@ const DndProvider = /* @__PURE__ */ __name(({
           onDragEnd(event);
         }
       },
-      ...restProps
+      onDragCancel: (event) => {
+        setActiveId(null);
+        onDragCancel == null ? void 0 : onDragCancel(event);
+      }
     },
     children,
     (0, import_react_dom.createPortal)(
       /* @__PURE__ */ import_react.default.createElement(import_core.DragOverlay, { dropAnimation: null, zIndex: 2e3 }, activeId && /* @__PURE__ */ import_react.default.createElement(
         "span",
         {
+          "data-testid": "flow-drag-preview",
           style: {
             display: "inline-flex",
             alignItems: "center",
@@ -143,7 +149,6 @@ const DndProvider = /* @__PURE__ */ __name(({
             borderRadius: 4,
             padding: "4px 12px",
             color: "#1890ff",
-            // fontSize: 18,
             boxShadow: "0 2px 8px rgba(0,0,0,0.15)"
           }
         },

package/lib/utils/createCollectionContextMeta.js

@@ -32,6 +32,10 @@ __export(createCollectionContextMeta_exports, {
 module.exports = __toCommonJS(createCollectionContextMeta_exports);
 const RELATION_FIELD_TYPES = ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"];
 const NUMERIC_FIELD_TYPES = ["integer", "float", "double", "decimal"];
+function shouldShowFieldInMeta(field, includeNonFilterable) {
+  return Boolean(field.interface && (includeNonFilterable || field.filterable));
+}
+__name(shouldShowFieldInMeta, "shouldShowFieldInMeta");
 function createFieldMetadata(field, includeNonFilterable) {
   const baseProperties = createMetaBaseProperties(field);
   if (field.isAssociationField()) {
@@ -49,7 +53,7 @@ function createFieldMetadata(field, includeNonFilterable) {
       properties: /* @__PURE__ */ __name(async () => {
         const subProperties = {};
         targetCollection.fields.forEach((subField) => {
-          if (includeNonFilterable || subField.filterable) {
+          if (shouldShowFieldInMeta(subField, includeNonFilterable)) {
             subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
           }
         });
@@ -104,7 +108,7 @@ function createCollectionContextMeta(collectionOrFactory, title, includeNonFilte
       properties: /* @__PURE__ */ __name(async () => {
         const properties = {};
         collection.fields.forEach((field) => {
-          if (includeNonFilterable || field.filterable) {
+          if (shouldShowFieldInMeta(field, includeNonFilterable)) {
             properties[field.name] = createFieldMetadata(field, includeNonFilterable);
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.0.45",
+  "version": "2.0.47",
   "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.45",
-    "@nocobase/shared": "2.0.45",
+    "@nocobase/sdk": "2.0.47",
+    "@nocobase/shared": "2.0.47",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "9b720e650924098938f8c3c50978273748082cb7"
+  "gitHead": "c2ac5cf739e1160ca5af4ad933498b70e771abd3"
 }

package/src/__tests__/objectVariable.test.ts

@@ -26,6 +26,7 @@ function setupEngineWithCollections() {
     fields: [
       { name: 'id', type: 'integer', interface: 'number' },
       { name: 'name', type: 'string', interface: 'text' },
+      { name: 'rawUserPayload', type: 'json', filterable: true },
     ],
   });
   ds.addCollection({
@@ -41,6 +42,8 @@ function setupEngineWithCollections() {
     filterTargetKey: 'id',
     fields: [
       { name: 'title', type: 'string', interface: 'text' },
+      { name: 'internalName', type: 'string', interface: 'text' },
+      { name: 'rawPostPayload', type: 'json', filterable: true },
       { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o' },
       { name: 'tags', type: 'belongsToMany', target: 'tags', interface: 'm2m' },
     ],
@@ -91,6 +94,27 @@ describe('objectVariable utilities', () => {
     });
   });
 
+  it('createAssociationAwareObjectMetaFactory should hide fields without interface from object variable meta', async () => {
+    const { collection } = setupEngineWithCollections();
+    const obj = { title: 'hello', internalName: 'internal', rawPostPayload: { secret: true }, author: 1 };
+    const metaFactory = createAssociationAwareObjectMetaFactory(
+      () => collection,
+      'Current object',
+      () => obj,
+    );
+
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorFields = await props?.author?.properties?.();
+
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('internalName');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
+    expect(authorFields).toHaveProperty('name');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
+  });
+
   it('integrates with FlowContext.resolveJsonTemplate to call variables:resolve with flattened contextParams', async () => {
     const { engine, collection } = setupEngineWithCollections();
     const obj = { author: 1 };

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

@@ -16,6 +16,9 @@ import {
   resolveDropIntent,
   Point,
   buildLayoutSnapshot,
+  normalizeGridLayout,
+  projectLayoutToLegacyRows,
+  replaceUidInGridLayout,
 } from '../dnd/gridDragPlanner';
 
 const rect = { top: 0, left: 0, width: 100, height: 100 };
@@ -106,15 +109,105 @@ describe('buildLayoutSnapshot', () => {
     const snapshot = buildLayoutSnapshot({ container });
     const columnEdgeSlots = snapshot.slots.filter((slot) => slot.type === 'column-edge');
     const columnSlots = snapshot.slots.filter((slot) => slot.type === 'column');
+    const itemEdgeSlots = snapshot.slots.filter((slot) => slot.type === 'item-edge');
 
-    // 外层单行单列单项应只有 6 个 slot：上/下 row-gap + 左/右 column-edge + before/after column
-    expect(snapshot.slots).toHaveLength(6);
+    // 外层单行单列单项应只有 8 个 slot：上/下 row-gap + 左/右 column-edge + before/after column + 左/右 item-edge
+    expect(snapshot.slots).toHaveLength(8);
     expect(columnEdgeSlots).toHaveLength(2);
     expect(columnSlots).toHaveLength(2);
+    expect(itemEdgeSlots).toHaveLength(2);
 
     // 不应混入嵌套 grid（其 top >= 360）
     expect(snapshot.slots.every((slot) => slot.rect.top < 300)).toBe(true);
   });
+
+  it('does not create an empty-column slot for a cell that contains nested rows', () => {
+    const container = document.createElement('div');
+    container.setAttribute('data-grid-root', '');
+    const row = document.createElement('div');
+    row.setAttribute('data-grid-row-id', 'outer');
+    row.setAttribute('data-grid-path', JSON.stringify([{ rowId: 'outer' }]));
+    container.appendChild(row);
+
+    const leftColumn = document.createElement('div');
+    leftColumn.setAttribute('data-grid-column-row-id', 'outer');
+    leftColumn.setAttribute('data-grid-column-index', '0');
+    leftColumn.setAttribute('data-grid-path', JSON.stringify([{ rowId: 'outer', cellId: 'outer-left' }]));
+    row.appendChild(leftColumn);
+
+    const leftItem = document.createElement('div');
+    leftItem.setAttribute('data-grid-item-row-id', 'outer');
+    leftItem.setAttribute('data-grid-column-index', '0');
+    leftItem.setAttribute('data-grid-item-index', '0');
+    leftItem.setAttribute('data-grid-item-uid', 'left');
+    leftColumn.appendChild(leftItem);
+
+    const rightColumn = document.createElement('div');
+    rightColumn.setAttribute('data-grid-column-row-id', 'outer');
+    rightColumn.setAttribute('data-grid-column-index', '1');
+    rightColumn.setAttribute('data-grid-path', JSON.stringify([{ rowId: 'outer', cellId: 'outer-right' }]));
+    row.appendChild(rightColumn);
+
+    const nestedRow = document.createElement('div');
+    nestedRow.setAttribute('data-grid-row-id', 'nested');
+    nestedRow.setAttribute(
+      'data-grid-path',
+      JSON.stringify([{ rowId: 'outer', cellId: 'outer-right' }, { rowId: 'nested' }]),
+    );
+    rightColumn.appendChild(nestedRow);
+
+    const nestedColumn = document.createElement('div');
+    nestedColumn.setAttribute('data-grid-column-row-id', 'nested');
+    nestedColumn.setAttribute('data-grid-column-index', '0');
+    nestedColumn.setAttribute(
+      'data-grid-path',
+      JSON.stringify([
+        { rowId: 'outer', cellId: 'outer-right' },
+        { rowId: 'nested', cellId: 'nested-cell' },
+      ]),
+    );
+    nestedRow.appendChild(nestedColumn);
+
+    const nestedItem = document.createElement('div');
+    nestedItem.setAttribute('data-grid-item-row-id', 'nested');
+    nestedItem.setAttribute('data-grid-column-index', '0');
+    nestedItem.setAttribute('data-grid-item-index', '0');
+    nestedItem.setAttribute('data-grid-item-uid', 'nested-item');
+    nestedColumn.appendChild(nestedItem);
+
+    mockRect(container, { top: 0, left: 0, width: 1200, height: 500 });
+    mockRect(row, { top: 10, left: 10, width: 1180, height: 420 });
+    mockRect(leftColumn, { top: 10, left: 10, width: 480, height: 420 });
+    mockRect(leftItem, { top: 20, left: 20, width: 460, height: 380 });
+    mockRect(rightColumn, { top: 10, left: 500, width: 690, height: 420 });
+    mockRect(nestedRow, { top: 20, left: 510, width: 670, height: 120 });
+    mockRect(nestedColumn, { top: 20, left: 510, width: 670, height: 120 });
+    mockRect(nestedItem, { top: 30, left: 520, width: 650, height: 90 });
+
+    const snapshot = buildLayoutSnapshot({ container });
+
+    expect(
+      snapshot.slots.some(
+        (slot) =>
+          slot.type === 'empty-column' &&
+          slot.rowId === 'outer' &&
+          slot.columnIndex === 1 &&
+          slot.rect.left === 500 &&
+          slot.rect.width === 690,
+      ),
+    ).toBe(false);
+    expect(snapshot.slots.some((slot) => slot.type === 'column' && slot.rowId === 'nested')).toBe(true);
+
+    const nestedBelowGap = snapshot.slots.find(
+      (slot) => slot.type === 'row-gap' && slot.targetRowId === 'nested' && slot.position === 'below',
+    );
+    expect(nestedBelowGap?.rect).toEqual({
+      top: 140,
+      left: 500,
+      width: 690,
+      height: 48,
+    });
+  });
 });
 
 describe('getSlotKey', () => {
@@ -178,6 +271,184 @@ describe('getSlotKey', () => {
     const key = getSlotKey(slot);
     expect(key).toBe('empty-column:row1:0');
   });
+
+  it('should generate unique key for item-edge slot', () => {
+    const slot: LayoutSlot = {
+      type: 'item-edge',
+      rowId: 'row1',
+      columnIndex: 0,
+      itemIndex: 1,
+      itemUid: 'block-2',
+      direction: 'right',
+      rect,
+    };
+
+    const key = getSlotKey(slot);
+    expect(key).toBe('item-edge:row1:0:block-2:right');
+  });
+});
+
+describe('GridLayoutV2 helpers', () => {
+  it('converts legacy rows to stable v2 layout and legacy projection', () => {
+    const layout = normalizeGridLayout({
+      rows: {
+        rowA: [['a'], ['b', 'c']],
+      },
+      sizes: {
+        rowA: [8, 16],
+      },
+      rowOrder: ['rowA'],
+      itemUids: ['a', 'b', 'c'],
+    });
+
+    expect(layout).toMatchObject({
+      version: 2,
+      rows: [
+        {
+          id: 'rowA',
+          cells: [
+            { id: 'rowA:cell:0', items: ['a'] },
+            { id: 'rowA:cell:1', items: ['b', 'c'] },
+          ],
+          sizes: [8, 16],
+        },
+      ],
+    });
+
+    const projected = projectLayoutToLegacyRows(layout);
+    expect(projected.rows.rowA).toEqual([['a'], ['b', 'c']]);
+    expect(projected.sizes.rowA).toEqual([8, 16]);
+  });
+
+  it('deduplicates items, removes invalid uids, appends missing items, and fixes sizes', () => {
+    const layout = normalizeGridLayout({
+      layout: {
+        version: 2,
+        rows: [
+          {
+            id: 'rowA',
+            cells: [
+              { id: 'cellA', items: ['a', 'b', 'a', 'ghost'] },
+              { id: 'cellB', items: ['c'] },
+            ],
+            sizes: [5],
+          },
+        ],
+      },
+      itemUids: ['a', 'b', 'c', 'd'],
+      generateId: () => 'row-missing',
+    });
+
+    expect(layout.rows[0].cells[0]).toMatchObject({ id: 'cellA', items: ['a', 'b'] });
+    expect(layout.rows[0].cells[1]).toMatchObject({ id: 'cellB', items: ['c'] });
+    expect(layout.rows[0].sizes).toHaveLength(2);
+    expect(layout.rows[0].sizes.reduce((sum, value) => sum + value, 0)).toBe(24);
+    expect(layout.rows[1]).toMatchObject({
+      id: 'row-missing',
+      cells: [{ id: 'row-missing:cell:0', items: ['d'] }],
+      sizes: [24],
+    });
+  });
+
+  it('preserves explicit empty v2 cells while removing invalid-only cells', () => {
+    const layout = normalizeGridLayout({
+      layout: {
+        version: 2,
+        rows: [
+          {
+            id: 'rowA',
+            cells: [
+              { id: 'empty-cell', items: [] },
+              { id: 'invalid-cell', items: ['ghost'] },
+              { id: 'valid-cell', items: ['a'] },
+            ],
+            sizes: [8, 8, 8],
+          },
+        ],
+      },
+      itemUids: ['a'],
+    });
+
+    expect(layout.rows[0].cells).toEqual([
+      { id: 'empty-cell', items: [] },
+      { id: 'valid-cell', items: ['a'] },
+    ]);
+    expect(layout.rows[0].sizes).toEqual([12, 12]);
+  });
+
+  it('replaces uid in nested layout', () => {
+    const layout = normalizeGridLayout({
+      layout: {
+        version: 2,
+        rows: [
+          {
+            id: 'rowA',
+            cells: [
+              {
+                id: 'cellA',
+                rows: [
+                  {
+                    id: 'nested',
+                    cells: [{ id: 'nested-cell', items: ['old'] }],
+                    sizes: [24],
+                  },
+                ],
+              },
+            ],
+            sizes: [24],
+          },
+        ],
+      },
+      itemUids: ['old'],
+    });
+
+    const replaced = replaceUidInGridLayout(layout, 'old', 'new');
+    expect(projectLayoutToLegacyRows(replaced).rows.rowA).toEqual([['new']]);
+  });
+
+  it('projects nested layout without duplicating nested items', () => {
+    const layout = normalizeGridLayout({
+      layout: {
+        version: 2,
+        rows: [
+          {
+            id: 'rowA',
+            cells: [
+              {
+                id: 'cellA',
+                rows: [
+                  {
+                    id: 'nestedA',
+                    cells: [{ id: 'nestedA:cell:0', items: ['a'] }],
+                    sizes: [24],
+                  },
+                  {
+                    id: 'nestedB',
+                    cells: [
+                      { id: 'nestedB:cell:0', items: ['two'] },
+                      { id: 'nestedB:cell:1', items: ['four'] },
+                    ],
+                    sizes: [12, 12],
+                  },
+                  {
+                    id: 'nestedC',
+                    cells: [{ id: 'nestedC:cell:0', items: ['three'] }],
+                    sizes: [24],
+                  },
+                ],
+              },
+            ],
+            sizes: [24],
+          },
+        ],
+      },
+      itemUids: ['a', 'two', 'four', 'three'],
+    });
+
+    const projected = projectLayoutToLegacyRows(layout);
+    expect(Object.keys(projected.rows)).toEqual(['rowA']);
+    expect(projected.rows.rowA).toEqual([['a', 'two', 'four', 'three']]);
+  });
 });
 
 describe('resolveDropIntent', () => {
@@ -231,7 +502,7 @@ describe('resolveDropIntent', () => {
     expect(result).toEqual(targetSlot);
   });
 
-  it('should return first matching slot when multiple slots contain the point', () => {
+  it('should return highest-priority matching slot when multiple slots contain the point', () => {
     const firstSlot: LayoutSlot = {
       type: 'empty-row',
       rect: { top: 0, left: 0, width: 500, height: 500 },
@@ -250,8 +521,7 @@ describe('resolveDropIntent', () => {
 
     const point: Point = { x: 125, y: 110 };
     const result = resolveDropIntent(point, slots);
-    // Returns first slot that contains the point
-    expect(result).toEqual(firstSlot);
+    expect(result).toEqual(secondSlot);
   });
 
   it('should handle empty-column slot correctly', () => {
@@ -484,6 +754,112 @@ describe('simulateLayoutForSlot', () => {
     expect(result.rows.rowA[2]).toEqual(['c']);
   });
 
+  it('preserves remaining cell size ratios after removing a non-last source cell in v2 layout', () => {
+    const layout = createLayout(
+      {
+        rowA: [['a'], ['b'], ['c']],
+      },
+      {
+        rowA: [4, 8, 12],
+      },
+    );
+    layout.layout = normalizeGridLayout({
+      rows: layout.rows,
+      sizes: layout.sizes,
+      rowOrder: ['rowA'],
+      itemUids: ['a', 'b', 'c'],
+    });
+
+    const slot: LayoutSlot = {
+      type: 'column',
+      rowId: 'rowA',
+      columnIndex: 2,
+      insertIndex: 1,
+      position: 'after',
+      path: [{ rowId: 'rowA', cellId: 'rowA:cell:2' }],
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({ slot, sourceUid: 'a', layout });
+
+    expect(result.layout!.rows[0].cells.map((cell) => cell.items)).toEqual([['b'], ['c', 'a']]);
+    expect(result.layout!.rows[0].sizes).toEqual([10, 14]);
+  });
+
+  it('splits a stacked cell around item-edge right with stable generated ids', () => {
+    const layout = createLayout(
+      {
+        rowA: [['a', 'two', 'three', 'd']],
+      },
+      {
+        rowA: [24],
+      },
+    );
+    layout.layout = normalizeGridLayout({
+      rows: layout.rows,
+      sizes: layout.sizes,
+      rowOrder: ['rowA'],
+      itemUids: ['a', 'two', 'three', 'd', 'four'],
+    });
+
+    const slot: LayoutSlot = {
+      type: 'item-edge',
+      rowId: 'rowA',
+      columnIndex: 0,
+      itemIndex: 1,
+      itemUid: 'two',
+      direction: 'right',
+      path: [{ rowId: 'rowA', cellId: 'rowA:cell:0' }],
+      rect,
+    };
+
+    const generatedIds = new Map<string, string>();
+    const generateId = (key: string) => `id:${key}`;
+    const first = simulateLayoutForSlot({ slot, sourceUid: 'four', layout, generatedIds, generateId });
+    const second = simulateLayoutForSlot({ slot, sourceUid: 'four', layout, generatedIds, generateId });
+
+    expect(first.layout).toEqual(second.layout);
+    const nestedRows = first.layout!.rows[0].cells[0].rows!;
+    expect(nestedRows.map((row) => row.cells.map((cell) => cell.items))).toEqual([
+      [['a']],
+      [['two'], ['four']],
+      [['three']],
+      [['d']],
+    ]);
+    expect(nestedRows[1].sizes).toEqual([12, 12]);
+  });
+
+  it('treats dragging an item to its own item-edge as no-op', () => {
+    const layout = createLayout(
+      {
+        rowA: [['two']],
+      },
+      {
+        rowA: [24],
+      },
+    );
+    layout.layout = normalizeGridLayout({
+      rows: layout.rows,
+      sizes: layout.sizes,
+      rowOrder: ['rowA'],
+      itemUids: ['two'],
+    });
+
+    const slot: LayoutSlot = {
+      type: 'item-edge',
+      rowId: 'rowA',
+      columnIndex: 0,
+      itemIndex: 0,
+      itemUid: 'two',
+      direction: 'right',
+      path: [{ rowId: 'rowA', cellId: 'rowA:cell:0' }],
+      rect,
+    };
+
+    const result = simulateLayoutForSlot({ slot, sourceUid: 'two', layout });
+    expect(result.layout).toEqual(layout.layout);
+  });
+
   it('handles row-gap slot below position', () => {
     const layout = createLayout(
       {
@@ -719,4 +1095,49 @@ describe('simulateLayoutForSlot', () => {
     const total = result.sizes.rowA.reduce((sum, size) => sum + size, 0);
     expect(total).toBe(24);
   });
+
+  it('preserves explicit empty v2 cells when moving another item', () => {
+    const layout: GridLayoutData = {
+      rows: {},
+      sizes: {},
+      layout: {
+        version: 2,
+        rows: [
+          {
+            id: 'rowA',
+            cells: [
+              { id: 'empty-cell', items: [] },
+              { id: 'source-cell', items: ['source'] },
+              { id: 'target-cell', items: ['target'] },
+            ],
+            sizes: [8, 8, 8],
+          },
+        ],
+      },
+    };
+
+    const slot: LayoutSlot = {
+      type: 'column-edge',
+      rowId: 'rowA',
+      columnIndex: 2,
+      direction: 'right',
+      rect,
+      path: [{ rowId: 'rowA', cellId: 'target-cell' }],
+    };
+
+    const result = simulateLayoutForSlot({
+      slot,
+      sourceUid: 'source',
+      layout,
+      generateId: (key) => key,
+    });
+
+    expect(result.layout?.rows[0].cells).toEqual([
+      { id: 'empty-cell', items: [] },
+      { id: 'target-cell', items: ['target'] },
+      { id: 'column-edge:rowA:2:right:cell', items: ['source'] },
+    ]);
+    expect(result.layout?.rows[0].sizes).toHaveLength(3);
+    expect(result.layout?.rows[0].sizes.reduce((sum, size) => sum + size, 0)).toBe(24);
+  });
 });