@nocobase/flow-engine 2.1.0-beta.23 → 2.1.0-beta.25

package/lib/components/dnd/gridDragPlanner.js

@@ -44,7 +44,12 @@ __export(gridDragPlanner_exports, {
   MAX_SLOT_THICKNESS: () => MAX_SLOT_THICKNESS,
   MIN_SLOT_THICKNESS: () => MIN_SLOT_THICKNESS,
   buildLayoutSnapshot: () => buildLayoutSnapshot,
+  findModelUidLayoutPosition: () => findModelUidLayoutPosition,
   getSlotKey: () => getSlotKey,
+  isSameGridLayout: () => isSameGridLayout,
+  normalizeGridLayout: () => normalizeGridLayout,
+  projectLayoutToLegacyRows: () => projectLayoutToLegacyRows,
+  replaceUidInGridLayout: () => replaceUidInGridLayout,
   resolveDropIntent: () => resolveDropIntent,
   simulateLayoutForSlot: () => simulateLayoutForSlot
 });
@@ -165,12 +170,46 @@ const createColumnInsertRect = /* @__PURE__ */ __name((itemRect, position) => {
     height: thickness
   });
 }, "createColumnInsertRect");
+const parseLayoutPath = /* @__PURE__ */ __name((value) => {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    const path = parsed.map((entry) => {
+      if (!entry || typeof entry !== "object" || typeof entry.rowId !== "string") {
+        return null;
+      }
+      return {
+        rowId: entry.rowId,
+        ...typeof entry.cellId === "string" ? { cellId: entry.cellId } : {}
+      };
+    }).filter(Boolean);
+    return path.length ? path : void 0;
+  } catch (error) {
+    return void 0;
+  }
+}, "parseLayoutPath");
+const createLegacyCellPath = /* @__PURE__ */ __name((rowId, columnIndex) => [
+  {
+    rowId,
+    cellId: `${rowId}:cell:${columnIndex}`
+  }
+], "createLegacyCellPath");
 const expandColumnRect = /* @__PURE__ */ __name((columnRect) => ({
   top: columnRect.top,
   left: columnRect.left,
   width: columnRect.width,
   height: Math.max(columnRect.height, MIN_SLOT_THICKNESS)
 }), "expandColumnRect");
+const hasDirectNestedRows = /* @__PURE__ */ __name((columnElement) => {
+  return Array.from(columnElement.querySelectorAll("[data-grid-row-id]")).some((rowElement) => {
+    return rowElement.closest("[data-grid-column-row-id][data-grid-column-index]") === columnElement;
+  });
+}, "hasDirectNestedRows");
 const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
   if (!container) {
     return {
@@ -178,13 +217,19 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
       containerRect: { top: 0, left: 0, width: 0, height: 0 }
     };
   }
-  const containerRect = toRect(container.getBoundingClientRect());
+  const scope = container.hasAttribute("data-grid-root") ? container : container.querySelector("[data-grid-root]");
+  const layoutContainer = scope || container;
+  const containerRect = toRect(layoutContainer.getBoundingClientRect());
   const slots = [];
-  const allRowElements = Array.from(container.querySelectorAll("[data-grid-row-id]"));
+  const allRowElements = Array.from(layoutContainer.querySelectorAll("[data-grid-row-id]"));
+  const hasGridRootScope = layoutContainer.hasAttribute("data-grid-root");
   const rowElements = allRowElements.filter((el) => {
     const htmlEl = el;
+    if (hasGridRootScope) {
+      return htmlEl.closest("[data-grid-root]") === layoutContainer;
+    }
     let parent = htmlEl.parentElement;
-    while (parent && parent !== container) {
+    while (parent && parent !== layoutContainer) {
       if (parent.hasAttribute("data-grid-row-id")) {
         return false;
       }
@@ -204,22 +249,39 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
     });
     return { slots, containerRect };
   }
-  rowElements.forEach((rowElement, rowIndex) => {
+  const getRowScopeElement = /* @__PURE__ */ __name((rowElement) => {
+    const parent = rowElement.parentElement;
+    if (!parent || !layoutContainer.contains(parent)) {
+      return layoutContainer;
+    }
+    return parent;
+  }, "getRowScopeElement");
+  const rowElementsByScope = /* @__PURE__ */ new Map();
+  rowElements.forEach((rowElement) => {
+    const rowScopeElement = getRowScopeElement(rowElement);
+    rowElementsByScope.set(rowScopeElement, [...rowElementsByScope.get(rowScopeElement) || [], rowElement]);
+  });
+  rowElements.forEach((rowElement) => {
     const rowId = rowElement.dataset.gridRowId;
     if (!rowId) {
       return;
     }
     const rowRect = toRect(rowElement.getBoundingClientRect());
-    if (rowIndex === 0) {
+    const rowPath = parseLayoutPath(rowElement.dataset.gridPath) || [{ rowId }];
+    const rowScopeElement = getRowScopeElement(rowElement);
+    const rowScopeRect = toRect(rowScopeElement.getBoundingClientRect());
+    const rowElementsInScope = rowElementsByScope.get(rowScopeElement) || [];
+    if (rowElementsInScope[0] === rowElement) {
       slots.push({
         type: "row-gap",
         targetRowId: rowId,
         position: "above",
-        rect: createRowGapRect(rowRect, "above", containerRect)
+        rect: createRowGapRect(rowRect, "above", rowScopeRect),
+        path: rowPath
       });
     }
     const columnElements = Array.from(
-      container.querySelectorAll(`[data-grid-column-row-id="${rowId}"][data-grid-column-index]`)
+      layoutContainer.querySelectorAll(`[data-grid-column-row-id="${rowId}"][data-grid-column-index]`)
     ).filter((el) => {
       return el.closest("[data-grid-row-id]") === rowElement;
     });
@@ -231,19 +293,22 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
     sortedColumns.forEach((columnElement) => {
       const columnIndex = Number(columnElement.dataset.gridColumnIndex || 0);
       const columnRect = toRect(columnElement.getBoundingClientRect());
+      const columnPath = parseLayoutPath(columnElement.dataset.gridPath) || createLegacyCellPath(rowId, columnIndex);
       slots.push({
         type: "column-edge",
         rowId,
         columnIndex,
         direction: "left",
-        rect: createColumnEdgeRect(columnRect, "left")
+        rect: createColumnEdgeRect(columnRect, "left"),
+        path: columnPath
       });
       slots.push({
         type: "column-edge",
         rowId,
         columnIndex,
         direction: "right",
-        rect: createColumnEdgeRect(columnRect, "right")
+        rect: createColumnEdgeRect(columnRect, "right"),
+        path: columnPath
       });
       const itemElements = Array.from(
         columnElement.querySelectorAll(`[data-grid-item-row-id="${rowId}"][data-grid-column-index="${columnIndex}"]`)
@@ -256,11 +321,15 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
         return indexA - indexB;
       });
       if (sortedItems.length === 0) {
+        if (hasDirectNestedRows(columnElement)) {
+          return;
+        }
         slots.push({
           type: "empty-column",
           rowId,
           columnIndex,
-          rect: expandColumnRect(columnRect)
+          rect: expandColumnRect(columnRect),
+          path: columnPath
         });
         return;
       }
@@ -271,17 +340,41 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
         columnIndex,
         insertIndex: 0,
         position: "before",
-        rect: createColumnInsertRect(firstItemRect, "before")
+        rect: createColumnInsertRect(firstItemRect, "before"),
+        path: columnPath
       });
       sortedItems.forEach((itemElement, itemIndex) => {
         const itemRect = toRect(itemElement.getBoundingClientRect());
+        const itemPath = parseLayoutPath(itemElement.dataset.gridPath) || columnPath;
+        const itemUid = itemElement.dataset.gridItemUid || "";
+        slots.push({
+          type: "item-edge",
+          rowId,
+          columnIndex,
+          itemIndex,
+          itemUid,
+          direction: "left",
+          rect: createColumnEdgeRect(itemRect, "left"),
+          path: itemPath
+        });
+        slots.push({
+          type: "item-edge",
+          rowId,
+          columnIndex,
+          itemIndex,
+          itemUid,
+          direction: "right",
+          rect: createColumnEdgeRect(itemRect, "right"),
+          path: itemPath
+        });
         slots.push({
           type: "column",
           rowId,
           columnIndex,
           insertIndex: itemIndex + 1,
           position: "after",
-          rect: createColumnInsertRect(itemRect, "after")
+          rect: createColumnInsertRect(itemRect, "after"),
+          path: itemPath
         });
       });
     });
@@ -289,7 +382,8 @@ const buildLayoutSnapshot = /* @__PURE__ */ __name(({ container }) => {
       type: "row-gap",
       targetRowId: rowId,
       position: "below",
-      rect: createRowGapRect(rowRect, "below", containerRect)
+      rect: createRowGapRect(rowRect, "below", rowScopeRect),
+      path: rowPath
     });
   });
   return {
@@ -309,6 +403,8 @@ const getSlotKey = /* @__PURE__ */ __name((slot) => {
       return `${slot.type}`;
     case "empty-column":
       return `${slot.type}:${slot.rowId}:${slot.columnIndex}`;
+    case "item-edge":
+      return `${slot.type}:${slot.rowId}:${slot.columnIndex}:${slot.itemUid}:${slot.direction}`;
   }
 }, "getSlotKey");
 const isPointInsideRect = /* @__PURE__ */ __name((point, rect) => {
@@ -319,19 +415,38 @@ const distanceToRect = /* @__PURE__ */ __name((point, rect) => {
   const dy = Math.max(rect.top - point.y, 0, point.y - (rect.top + rect.height));
   return Math.sqrt(dx * dx + dy * dy);
 }, "distanceToRect");
+const slotPriority = {
+  "item-edge": 5,
+  "column-edge": 4,
+  column: 3,
+  "row-gap": 2,
+  "empty-column": 1,
+  "empty-row": 0
+};
 const resolveDropIntent = /* @__PURE__ */ __name((point, slots) => {
   if (!slots.length) {
     return null;
   }
-  const insideSlot = slots.find((slot) => isPointInsideRect(point, slot.rect));
-  if (insideSlot) {
-    return insideSlot;
+  let bestInsideSlot = null;
+  let bestInsidePriority = Number.NEGATIVE_INFINITY;
+  slots.forEach((slot) => {
+    if (!isPointInsideRect(point, slot.rect)) {
+      return;
+    }
+    const priority = slotPriority[slot.type];
+    if (priority > bestInsidePriority) {
+      bestInsidePriority = priority;
+      bestInsideSlot = slot;
+    }
+  });
+  if (bestInsideSlot) {
+    return bestInsideSlot;
   }
   let closest = null;
   let minDistance = Number.POSITIVE_INFINITY;
   slots.forEach((slot) => {
     const distance = distanceToRect(point, slot.rect);
-    if (distance < minDistance) {
+    if (distance < minDistance || distance === minDistance && closest && slotPriority[slot.type] > slotPriority[closest.type]) {
       minDistance = distance;
       closest = slot;
     }
@@ -381,7 +496,10 @@ const toIntSizes = /* @__PURE__ */ __name((weights, count) => {
   if (count === 0) {
     return [];
   }
-  const normalizedWeights = weights.map((weight) => Number.isFinite(weight) && weight > 0 ? weight : 1);
+  const normalizedWeights = Array.from({ length: count }, (_2, index) => {
+    const weight = weights[index];
+    return Number.isFinite(weight) && weight > 0 ? weight : 1;
+  });
   const total = normalizedWeights.reduce((sum, weight) => sum + weight, 0) || count;
   const ratios = normalizedWeights.map((weight) => weight / total);
   const raw = ratios.map((ratio) => ratio * DEFAULT_GRID_COLUMNS);
@@ -414,6 +532,234 @@ const toIntSizes = /* @__PURE__ */ __name((weights, count) => {
   }
   return floors;
 }, "toIntSizes");
+const EMPTY_COLUMN_VALUE = "EMPTY_COLUMN";
+const createTopLevelRow = /* @__PURE__ */ __name((itemUid, id) => ({
+  id,
+  cells: [
+    {
+      id: `${id}:cell:0`,
+      items: [itemUid]
+    }
+  ],
+  sizes: [DEFAULT_GRID_COLUMNS]
+}), "createTopLevelRow");
+const convertLegacyRowsToLayout = /* @__PURE__ */ __name((rows = {}, sizes = {}, rowOrder) => {
+  const order = deriveRowOrder(rows, rowOrder);
+  return {
+    version: 2,
+    rows: order.map((rowId) => {
+      const cells = (rows[rowId] || []).map((items, columnIndex) => ({
+        id: `${rowId}:cell:${columnIndex}`,
+        items: [...items]
+      }));
+      return {
+        id: rowId,
+        cells,
+        sizes: toIntSizes(sizes[rowId] || new Array(cells.length).fill(1), cells.length)
+      };
+    }).filter((row) => row.cells.length > 0)
+  };
+}, "convertLegacyRowsToLayout");
+const collectCellItems = /* @__PURE__ */ __name((cell) => {
+  if (Array.isArray(cell.items)) {
+    return cell.items;
+  }
+  return (cell.rows || []).flatMap((row) => row.cells.flatMap((childCell) => collectCellItems(childCell)));
+}, "collectCellItems");
+const projectLayoutToLegacyRows = /* @__PURE__ */ __name((layout) => {
+  const rows = {};
+  const sizes = {};
+  const rowOrder = [];
+  const appendRows = /* @__PURE__ */ __name((sourceRows, prefix = "") => {
+    sourceRows.forEach((row) => {
+      const rowId = prefix ? `${prefix}/${row.id}` : row.id;
+      const cells = row.cells.map((cell) => collectCellItems(cell)).filter((items) => items.length > 0);
+      if (cells.length > 0) {
+        rows[rowId] = cells;
+        sizes[rowId] = toIntSizes(row.sizes || new Array(cells.length).fill(1), cells.length);
+        rowOrder.push(rowId);
+      }
+    });
+  }, "appendRows");
+  appendRows(layout.rows || []);
+  return { rows, sizes, rowOrder, layout };
+}, "projectLayoutToLegacyRows");
+const normalizeGridRows = /* @__PURE__ */ __name((rows, options) => {
+  return (Array.isArray(rows) ? rows : []).map((row, rowIndex) => {
+    const rawCells = Array.isArray(row == null ? void 0 : row.cells) ? row.cells : [];
+    const rawSizes = Array.isArray(row == null ? void 0 : row.sizes) ? row.sizes : [];
+    const cellsWithSizes = rawCells.map((cell, cellIndex) => {
+      const id = typeof (cell == null ? void 0 : cell.id) === "string" && cell.id ? cell.id : `${(row == null ? void 0 : row.id) || `row:${rowIndex}`}:cell:${cellIndex}`;
+      const size = rawSizes[cellIndex];
+      if (Array.isArray(cell == null ? void 0 : cell.rows) && cell.rows.length > 0) {
+        const childRows = normalizeGridRows(cell.rows, options);
+        if (childRows.length > 0) {
+          return { cell: { id, rows: childRows }, size };
+        }
+      }
+      const rawItems = Array.isArray(cell == null ? void 0 : cell.items) ? cell.items : void 0;
+      const items = (rawItems || []).filter((itemUid) => typeof itemUid === "string" && itemUid).filter((itemUid) => !options.validUids || options.validUids.has(itemUid) || itemUid === EMPTY_COLUMN_VALUE).filter((itemUid) => {
+        if (itemUid === EMPTY_COLUMN_VALUE) {
+          return true;
+        }
+        if (options.seenUids.has(itemUid)) {
+          return false;
+        }
+        options.seenUids.add(itemUid);
+        return true;
+      });
+      if (rawItems && (items.length > 0 || rawItems.length === 0)) {
+        return { cell: { id, items }, size };
+      }
+      return null;
+    }).filter(Boolean);
+    const cells = cellsWithSizes.map((entry) => entry.cell);
+    if (cells.length === 0) {
+      return null;
+    }
+    return {
+      id: typeof (row == null ? void 0 : row.id) === "string" && row.id ? row.id : `row:${rowIndex}`,
+      cells,
+      sizes: toIntSizes(
+        cellsWithSizes.map((entry) => entry.size),
+        cells.length
+      )
+    };
+  }).filter(Boolean);
+}, "normalizeGridRows");
+const collapseCell = /* @__PURE__ */ __name((cell) => {
+  var _a;
+  if ((_a = cell.rows) == null ? void 0 : _a.length) {
+    const rows = collapseRows(cell.rows);
+    if (rows.length === 0) {
+      return null;
+    }
+    if (rows.length === 1 && rows[0].cells.length === 1 && rows[0].sizes[0] === DEFAULT_GRID_COLUMNS) {
+      return {
+        id: cell.id,
+        ...import_lodash.default.omit(rows[0].cells[0], ["id"])
+      };
+    }
+    return { id: cell.id, rows };
+  }
+  if (Array.isArray(cell.items)) {
+    return { id: cell.id, items: cell.items.filter(Boolean) };
+  }
+  return null;
+}, "collapseCell");
+const collapseRows = /* @__PURE__ */ __name((rows) => {
+  return rows.map((row) => {
+    const cellsWithSizes = row.cells.map((cell, index) => {
+      var _a;
+      const collapsed = collapseCell(cell);
+      return collapsed ? { cell: collapsed, size: (_a = row.sizes) == null ? void 0 : _a[index] } : null;
+    }).filter(Boolean);
+    const cells = cellsWithSizes.map((entry) => entry.cell);
+    if (cells.length === 0) {
+      return null;
+    }
+    return {
+      id: row.id,
+      cells,
+      sizes: toIntSizes(
+        cellsWithSizes.map((entry) => entry.size),
+        cells.length
+      )
+    };
+  }).filter(Boolean);
+}, "collapseRows");
+const normalizeGridLayout = /* @__PURE__ */ __name(({
+  layout,
+  rows,
+  sizes,
+  rowOrder,
+  itemUids,
+  generateId = import_shared.uid,
+  logger,
+  gridUid
+}) => {
+  var _a;
+  const validUids = itemUids ? new Set(itemUids) : void 0;
+  if (validUids) {
+    validUids.add(EMPTY_COLUMN_VALUE);
+  }
+  try {
+    const source = (layout == null ? void 0 : layout.version) === 2 ? import_lodash.default.cloneDeep(layout) : convertLegacyRowsToLayout(rows || {}, sizes || {}, rowOrder || Object.keys(rows || {}));
+    const seenUids = /* @__PURE__ */ new Set();
+    const next = {
+      version: 2,
+      rows: collapseRows(
+        normalizeGridRows(source.rows || [], {
+          validUids,
+          seenUids
+        })
+      )
+    };
+    if (itemUids == null ? void 0 : itemUids.length) {
+      itemUids.forEach((itemUid) => {
+        if (itemUid === EMPTY_COLUMN_VALUE || seenUids.has(itemUid)) {
+          return;
+        }
+        const rowId = generateId();
+        next.rows.push(createTopLevelRow(itemUid, rowId));
+        seenUids.add(itemUid);
+      });
+    }
+    return next;
+  } catch (error) {
+    (_a = logger == null ? void 0 : logger.warn) == null ? void 0 : _a.call(logger, `[GridModel] Failed to normalize grid layout${gridUid ? ` (${gridUid})` : ""}.`, error);
+    return {
+      version: 2,
+      rows: (itemUids || []).filter((itemUid) => itemUid !== EMPTY_COLUMN_VALUE).map((itemUid) => createTopLevelRow(itemUid, generateId()))
+    };
+  }
+}, "normalizeGridLayout");
+const replaceUidInGridLayout = /* @__PURE__ */ __name((layout, fromUid, toUid) => {
+  const replaceRows = /* @__PURE__ */ __name((rows) => rows.map((row) => ({
+    ...row,
+    cells: row.cells.map((cell) => {
+      if (cell.rows) {
+        return { ...cell, rows: replaceRows(cell.rows) };
+      }
+      return {
+        ...cell,
+        items: (cell.items || []).map((itemUid) => itemUid === fromUid ? toUid : itemUid)
+      };
+    })
+  })), "replaceRows");
+  return { version: 2, rows: replaceRows(import_lodash.default.cloneDeep(layout.rows || [])) };
+}, "replaceUidInGridLayout");
+const findModelUidLayoutPosition = /* @__PURE__ */ __name((layout, uidValue) => {
+  const visitRows = /* @__PURE__ */ __name((rows, parentPath) => {
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+      const row = rows[rowIndex];
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+        const cell = row.cells[cellIndex];
+        const path = [...parentPath, { rowId: row.id, cellId: cell.id }];
+        if (cell.items) {
+          const itemIndex = cell.items.indexOf(uidValue);
+          if (itemIndex !== -1) {
+            return {
+              path,
+              rowIndex,
+              cellIndex,
+              itemIndex,
+              itemUid: uidValue
+            };
+          }
+        }
+        if (cell.rows) {
+          const result = visitRows(cell.rows, path);
+          if (result) {
+            return result;
+          }
+        }
+      }
+    }
+    return null;
+  }, "visitRows");
+  return visitRows(layout.rows || [], []);
+}, "findModelUidLayoutPosition");
 const normalizeRowSizes = /* @__PURE__ */ __name((rowId, layout) => {
   const columns = layout.rows[rowId];
   if (!columns || columns.length === 0) {
@@ -455,12 +801,237 @@ const distributeSizesWithNewColumn = /* @__PURE__ */ __name((sizes, insertIndex,
   weights.splice(insertIndex, 0, reference);
   return toIntSizes(weights, columnCount);
 }, "distributeSizesWithNewColumn");
+const resolveCellPath = /* @__PURE__ */ __name((layout, slot) => {
+  var _a;
+  if ("path" in slot && ((_a = slot.path) == null ? void 0 : _a.length)) {
+    return slot.path;
+  }
+  if ("rowId" in slot && "columnIndex" in slot) {
+    return createLegacyCellPath(slot.rowId, slot.columnIndex);
+  }
+  return void 0;
+}, "resolveCellPath");
+const findRowListByPath = /* @__PURE__ */ __name((layout, path) => {
+  if (!path || path.length <= 1) {
+    return layout.rows;
+  }
+  let rows = layout.rows;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const entry = path[i];
+    const row = rows.find((candidate) => candidate.id === entry.rowId);
+    const cell = row == null ? void 0 : row.cells.find((candidate) => candidate.id === entry.cellId);
+    if (!(cell == null ? void 0 : cell.rows)) {
+      return rows;
+    }
+    rows = cell.rows;
+  }
+  return rows;
+}, "findRowListByPath");
+const findCellByPath = /* @__PURE__ */ __name((layout, path) => {
+  if (!(path == null ? void 0 : path.length)) {
+    return null;
+  }
+  let rows = layout.rows;
+  for (let i = 0; i < path.length; i += 1) {
+    const entry = path[i];
+    const rowIndex = rows.findIndex((candidate) => candidate.id === entry.rowId);
+    const row = rows[rowIndex];
+    if (!row || !entry.cellId) {
+      return null;
+    }
+    const cellIndex = row.cells.findIndex((candidate) => candidate.id === entry.cellId);
+    const cell = row.cells[cellIndex];
+    if (!cell) {
+      return null;
+    }
+    if (i === path.length - 1) {
+      return { rows, row, cell, rowIndex, cellIndex };
+    }
+    rows = cell.rows || [];
+  }
+  return null;
+}, "findCellByPath");
+const removeItemFromGridLayout = /* @__PURE__ */ __name((layout, sourceUid) => {
+  const removeFromRows = /* @__PURE__ */ __name((rows) => rows.map((row) => {
+    const cellsWithSizes = row.cells.map((cell, index) => {
+      var _a, _b;
+      if (cell.rows) {
+        const childRows = removeFromRows(cell.rows);
+        return childRows.length ? { cell: { ...cell, rows: childRows }, size: (_a = row.sizes) == null ? void 0 : _a[index] } : null;
+      }
+      const currentItems = cell.items || [];
+      const hadSourceUid = currentItems.includes(sourceUid);
+      const items = currentItems.filter((itemUid) => itemUid !== sourceUid);
+      if (hadSourceUid && !items.length) {
+        return null;
+      }
+      return { cell: { ...cell, items }, size: (_b = row.sizes) == null ? void 0 : _b[index] };
+    }).filter(Boolean);
+    const cells = cellsWithSizes.map((entry) => entry.cell);
+    return cells.length ? {
+      ...row,
+      cells,
+      sizes: toIntSizes(
+        cellsWithSizes.map((entry) => entry.size),
+        cells.length
+      )
+    } : null;
+  }).filter(Boolean), "removeFromRows");
+  layout.rows = collapseRows(removeFromRows(layout.rows));
+}, "removeItemFromGridLayout");
+const createSingleCellRow = /* @__PURE__ */ __name((itemUid, rowId, cellId) => ({
+  id: rowId,
+  cells: [{ id: cellId, items: [itemUid] }],
+  sizes: [DEFAULT_GRID_COLUMNS]
+}), "createSingleCellRow");
+const getGeneratedId = /* @__PURE__ */ __name((key, options) => {
+  var _a, _b, _c;
+  const existing = (_a = options == null ? void 0 : options.generatedIds) == null ? void 0 : _a.get(key);
+  if (existing) {
+    return existing;
+  }
+  const value = ((_b = options == null ? void 0 : options.generateId) == null ? void 0 : _b.call(options, key)) || (0, import_shared.uid)();
+  (_c = options == null ? void 0 : options.generatedIds) == null ? void 0 : _c.set(key, value);
+  return value;
+}, "getGeneratedId");
+const simulateGridLayoutForSlot = /* @__PURE__ */ __name(({
+  slot,
+  sourceUid,
+  layout,
+  generatedIds,
+  generateId
+}) => {
+  const original = normalizeGridLayout({
+    layout: layout.layout,
+    rows: layout.rows,
+    sizes: layout.sizes,
+    rowOrder: layout.rowOrder
+  });
+  const cloned = import_lodash.default.cloneDeep(original);
+  const slotKey = getSlotKey(slot);
+  const sourcePosition = findModelUidLayoutPosition(cloned, sourceUid);
+  if (slot.type === "item-edge" && slot.itemUid === sourceUid) {
+    return cloned;
+  }
+  const targetPath = resolveCellPath(cloned, slot);
+  const targetItemUid = slot.type === "item-edge" ? slot.itemUid : void 0;
+  removeItemFromGridLayout(cloned, sourceUid);
+  switch (slot.type) {
+    case "column": {
+      const target = findCellByPath(cloned, targetPath);
+      if (!target) {
+        break;
+      }
+      if (target.cell.rows) {
+        target.cell.rows.push(
+          createTopLevelRow(sourceUid, getGeneratedId(`${slotKey}:row`, { generatedIds, generateId }))
+        );
+        break;
+      }
+      target.cell.items ||= [];
+      const insertIndex = Math.max(0, Math.min(slot.insertIndex, target.cell.items.length));
+      target.cell.items.splice(insertIndex, 0, sourceUid);
+      break;
+    }
+    case "empty-column": {
+      const target = findCellByPath(cloned, targetPath);
+      if (target) {
+        delete target.cell.rows;
+        target.cell.items = [sourceUid];
+      }
+      break;
+    }
+    case "column-edge": {
+      const target = findCellByPath(cloned, targetPath);
+      if (!target) {
+        break;
+      }
+      const insertIndex = slot.direction === "left" ? target.cellIndex : target.cellIndex + 1;
+      const cellId = getGeneratedId(`${slotKey}:cell`, { generatedIds, generateId });
+      target.row.cells.splice(insertIndex, 0, { id: cellId, items: [sourceUid] });
+      target.row.sizes = distributeSizesWithNewColumn(target.row.sizes, insertIndex, target.row.cells.length);
+      break;
+    }
+    case "row-gap": {
+      const rows = findRowListByPath(cloned, slot.path);
+      const targetIndex = rows.findIndex((row) => row.id === slot.targetRowId);
+      const insertIndex = targetIndex === -1 ? rows.length : slot.position === "above" ? targetIndex : targetIndex + 1;
+      const rowId = getGeneratedId(`${slotKey}:row`, { generatedIds, generateId });
+      rows.splice(insertIndex, 0, createSingleCellRow(sourceUid, rowId, `${rowId}:cell:0`));
+      break;
+    }
+    case "empty-row": {
+      const rowId = getGeneratedId(`${slotKey}:row`, { generatedIds, generateId });
+      cloned.rows.push(createSingleCellRow(sourceUid, rowId, `${rowId}:cell:0`));
+      break;
+    }
+    case "item-edge": {
+      if (!targetItemUid) {
+        break;
+      }
+      const target = findCellByPath(cloned, targetPath);
+      if (!(target == null ? void 0 : target.cell.items)) {
+        break;
+      }
+      const targetIndex = target.cell.items.indexOf(targetItemUid);
+      if (targetIndex === -1) {
+        break;
+      }
+      const rows = [];
+      target.cell.items.forEach((itemUid, index) => {
+        if (index === targetIndex) {
+          const rowId2 = getGeneratedId(`${slotKey}:target-row`, { generatedIds, generateId });
+          const leftItem = slot.direction === "left" ? sourceUid : itemUid;
+          const rightItem = slot.direction === "left" ? itemUid : sourceUid;
+          rows.push({
+            id: rowId2,
+            cells: [
+              { id: getGeneratedId(`${slotKey}:target-cell:0`, { generatedIds, generateId }), items: [leftItem] },
+              { id: getGeneratedId(`${slotKey}:target-cell:1`, { generatedIds, generateId }), items: [rightItem] }
+            ],
+            sizes: [12, 12]
+          });
+          return;
+        }
+        const rowId = getGeneratedId(`${slotKey}:row:${index}`, { generatedIds, generateId });
+        rows.push(createSingleCellRow(itemUid, rowId, `${rowId}:cell:0`));
+      });
+      delete target.cell.items;
+      target.cell.rows = rows;
+      break;
+    }
+    default:
+      break;
+  }
+  const normalized = normalizeGridLayout({ layout: cloned });
+  if (sourcePosition && isSameGridLayout(normalized, original)) {
+    return original;
+  }
+  return normalized;
+}, "simulateGridLayoutForSlot");
+const isSameGridLayout = /* @__PURE__ */ __name((a, b) => {
+  return JSON.stringify(a) === JSON.stringify(b);
+}, "isSameGridLayout");
 const simulateLayoutForSlot = /* @__PURE__ */ __name(({
   slot,
   sourceUid,
   layout,
-  generateRowId
+  generateRowId,
+  generatedIds,
+  generateId
 }) => {
+  var _a;
+  if (layout.layout || slot.type === "item-edge" || "path" in slot && ((_a = slot.path) == null ? void 0 : _a.length)) {
+    const nextLayout = simulateGridLayoutForSlot({
+      slot,
+      sourceUid,
+      layout,
+      generateRowId,
+      generatedIds,
+      generateId
+    });
+    return projectLayoutToLegacyRows(nextLayout);
+  }
   const cloned = {
     rows: import_lodash.default.cloneDeep(layout.rows),
     sizes: import_lodash.default.cloneDeep(layout.sizes),
@@ -547,7 +1118,12 @@ const simulateLayoutForSlot = /* @__PURE__ */ __name(({
   MAX_SLOT_THICKNESS,
   MIN_SLOT_THICKNESS,
   buildLayoutSnapshot,
+  findModelUidLayoutPosition,
   getSlotKey,
+  isSameGridLayout,
+  normalizeGridLayout,
+  projectLayoutToLegacyRows,
+  replaceUidInGridLayout,
   resolveDropIntent,
   simulateLayoutForSlot
 });