packages/docs/src/view/text-editor.ts (1)

2607-2625: Consolidate with cloneTableCells to avoid divergent deep-clone logic.

This block duplicates most of cloneTableCells's cell-clone body (style/spans/per-block regenerate-id + shallow inline/style copy). Calling the helper here keeps the deep-clone contract in one place and automatically benefits from any nested-tableData recursion added to it (see the cloneTableCells comment).

♻️ Suggested refactor

       if (block.tableData) {
         cloned.tableData = {
           columnWidths: [...block.tableData.columnWidths],
           ...(block.tableData.rowHeights ? { rowHeights: [...block.tableData.rowHeights] } : {}),
-          rows: block.tableData.rows.map(row => ({
-            cells: row.cells.map(cell => ({
-              style: { ...cell.style },
-              ...(cell.colSpan != null ? { colSpan: cell.colSpan } : {}),
-              ...(cell.rowSpan != null ? { rowSpan: cell.rowSpan } : {}),
-              blocks: cell.blocks.map(b => ({
-                ...b,
-                id: generateBlockId(),
-                inlines: b.inlines.map(il => ({ text: il.text, style: { ...il.style } })),
-                style: { ...b.style },
-              })),
-            })),
-          })),
+          rows: block.tableData.rows.map(row => ({
+            cells: cloneTableCells([row.cells])[0],
+          })),
         };
       }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/text-editor.ts` around lines 2607 - 2625, The table
deep-clone code duplicates the cell-cloning logic; replace the duplicated
mapping in the if (block.tableData) branch by calling the existing
cloneTableCells helper so cloning logic is centralized. Specifically, set
cloned.tableData.columnWidths and optional rowHeights as before, but use
cloneTableCells(block.tableData.rows) (or the helper's expected input) to
produce rows/cells instead of reimplementing cells/blocks/inline copying and
generateBlockId usage; ensure compatibility with generateBlockId and the
helper's contract so nested tableData recursion and id regeneration remain
handled in one place.

packages/docs/src/view/clipboard.ts (1)

51-65: cloneTableCells does not deep-clone nested table tableData.

When a cell's blocks contains a block with type: 'table', the { ...b, id, inlines, style } spread keeps the original tableData (rows/cells/columnWidths/rowHeights) by reference. In the current PR flow, clipboard contents always pass through JSON.stringify → JSON.parse, so this works end-to-end; but the helper is a public export and pasteTableCells calls it per destination cell on already-deserialized data. A later refactor that uses cloneTableCells on live in-memory cells — or any code that mutates a cloned cell's nested table — would silently mutate the source.

Either deep-clone tableData inside the block mapper, or document that cloneTableCells is shallow w.r.t. nested tables and only safe after a JSON round-trip.

♻️ Suggested fix

 export function cloneTableCells(cells: TableCell[][]): TableCell[][] {
-  return cells.map(row =>
-    row.map(cell => ({
-      style: { ...cell.style },
-      ...(cell.colSpan != null ? { colSpan: cell.colSpan } : {}),
-      ...(cell.rowSpan != null ? { rowSpan: cell.rowSpan } : {}),
-      blocks: cell.blocks.map(b => ({
-        ...b,
-        id: generateBlockId(),
-        inlines: b.inlines.map(il => ({ text: il.text, style: { ...il.style } })),
-        style: { ...b.style },
-      })),
-    }))
-  );
+  const cloneBlock = (b: Block): Block => ({
+    ...b,
+    id: generateBlockId(),
+    inlines: b.inlines.map(il => ({ text: il.text, style: { ...il.style } })),
+    style: { ...b.style },
+    ...(b.tableData ? {
+      tableData: {
+        columnWidths: [...b.tableData.columnWidths],
+        ...(b.tableData.rowHeights ? { rowHeights: [...b.tableData.rowHeights] } : {}),
+        rows: b.tableData.rows.map(row => ({
+          cells: row.cells.map(cell => ({
+            style: { ...cell.style },
+            ...(cell.colSpan != null ? { colSpan: cell.colSpan } : {}),
+            ...(cell.rowSpan != null ? { rowSpan: cell.rowSpan } : {}),
+            blocks: cell.blocks.map(cloneBlock),
+          })),
+        })),
+      },
+    } : {}),
+  });
+  return cells.map(row =>
+    row.map(cell => ({
+      style: { ...cell.style },
+      ...(cell.colSpan != null ? { colSpan: cell.colSpan } : {}),
+      ...(cell.rowSpan != null ? { rowSpan: cell.rowSpan } : {}),
+      blocks: cell.blocks.map(cloneBlock),
+    }))
+  );
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/src/view/clipboard.ts` around lines 51 - 65, cloneTableCells
currently shallow-copies block objects so nested table blocks retain their
original tableData by reference; update the block mapper inside cloneTableCells
to deep-clone b.tableData when b.type === 'table' (e.g. use a safe deep-clone
like structuredClone or a JSON round-trip) so returned cells have independent
rows/cells/columnWidths/rowHeights, and keep existing id/inlines/style behavior;
ensure this change is applied in the blocks: cell.blocks.map(...) path and
verify pasteTableCells uses the updated clone behavior.

packages/docs/test/view/clipboard.test.ts (1)

254-297: Optional: extend cloneTableCells tests to cover nested tables and merge spans.

Current tests verify top-level deep-clone independence and ID regeneration, but not two behaviors worth pinning down:

1. A cell whose blocks contains a nested type: 'table' block — today the implementation uses { ...b, id: …, inlines: …, style: … }, which keeps the nested tableData reference shared with the original. A test asserting that mutating cells[0][0].blocks[0].tableData.rows[...] does not affect the clone would either confirm intent or catch a regression.
2. colSpan / rowSpan preservation on the clone (the implementation conditionally copies them).

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/docs/test/view/clipboard.test.ts` around lines 254 - 297, Add tests
to cloneTableCells that assert nested table blocks are deep-copied (i.e., when a
block with type: 'table' contains tableData.rows, mutating the original's
tableData.rows does not change the cloned block's tableData) and that
colSpan/rowSpan values on TableCell objects are preserved on the clone; target
the cloneTableCells test suite, create a cell whose blocks[0] has type: 'table'
with nested tableData and a cell having colSpan/rowSpan, call
cloneTableCells(cells), then mutate the original nested tableData.rows and
change original colSpan/rowSpan and assert the cloned nested tableData and
cloned colSpan/rowSpan remain unchanged.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes