fix: table blockMatch algo

Author: nperez0111

packages/core/src/y/extensions/blockMatchNodes.ts

@@ -8,21 +8,94 @@ import { $prosemirrorDelta } from "@y/prosemirror";
  * `blockContent blockGroup?`) this is its block-content type (paragraph,
  * heading, image, ...).
  */
-const firstChildName = (
+const firstChild = (
   d: schema.Unwrap<typeof $prosemirrorDelta>,
-): string | null => {
+): schema.Unwrap<typeof $prosemirrorDelta> | null => {
   for (const op of (d as any).children) {
     if (delta.$insertOp.check(op)) {
       for (const it of op.insert) {
         if (delta.$deltaAny.check(it)) {
-          return it.name;
+          return it;
         }
       }
     }
   }
   return null;
 };
 
+function getTableDimensions(
+  d: schema.Unwrap<typeof $prosemirrorDelta>,
+): { rows: number; cols: number } | null {
+  if (d.name !== "table") {
+    return null;
+  }
+
+  // Collect all rows with their cells' colspan/rowspan values.
+  const rows: Array<Array<{ colspan: number; rowspan: number }>> = [];
+  for (const op of (d as any).children) {
+    if (delta.$insertOp.check(op)) {
+      for (const tr of op.insert as Array<
+        schema.Unwrap<typeof $prosemirrorDelta>
+      >) {
+        if (tr.name !== "tableRow") {
+          return null;
+        }
+        const cells: Array<{ colspan: number; rowspan: number }> = [];
+        for (const trOp of (tr as any).children) {
+          if (delta.$insertOp.check(trOp)) {
+            for (const td of trOp.insert as Array<
+              schema.Unwrap<typeof $prosemirrorDelta>
+            >) {
+              if (td.name !== "tableCell" && td.name !== "tableHeader") {
+                return null;
+              }
+              cells.push({
+                colspan: Number(td.attrs.colspan) || 1,
+                rowspan: Number(td.attrs.rowspan) || 1,
+              });
+            }
+          }
+        }
+        rows.push(cells);
+      }
+    }
+  }
+
+  if (rows.length === 0) {
+    return null;
+  }
+
+  // Build an occupancy grid to determine the true column count.
+  // Each entry in `grid[r]` tracks which columns are already occupied
+  // (by a cell from a previous row with rowspan > 1).
+  const grid: boolean[][] = [];
+  for (let r = 0; r < rows.length; r++) {
+    if (!grid[r]) {
+      grid[r] = [];
+    }
+    let col = 0;
+    for (const cell of rows[r]) {
+      // Skip columns already occupied by a rowspan from above.
+      while (grid[r][col]) {
+        col++;
+      }
+      // Mark all slots this cell occupies.
+      for (let dr = 0; dr < cell.rowspan; dr++) {
+        if (!grid[r + dr]) {
+          grid[r + dr] = [];
+        }
+        for (let dc = 0; dc < cell.colspan; dc++) {
+          grid[r + dr][col + dc] = true;
+        }
+      }
+      col += cell.colspan;
+    }
+  }
+
+  const numCols = Math.max(...grid.map((row) => row.length));
+  return { rows: rows.length, cols: numCols };
+}
+
 /**
  * BlockNote's node-pairing policy for y-prosemirror's `matchNodes` option
  * (forwarded to `lib0/delta.diff`). This is the schema-specific bit that lives
@@ -48,6 +121,34 @@ const firstChildName = (
 export const blockMatchNodes = (
   a: schema.Unwrap<typeof $prosemirrorDelta>,
   b: schema.Unwrap<typeof $prosemirrorDelta>,
-): boolean =>
-  a.name === b.name &&
-  (a.name !== "blockContainer" || firstChildName(a) === firstChildName(b));
+): boolean => {
+  if (a.name !== b.name) {
+    return false;
+  }
+
+  if (a.name !== "blockContainer") {
+    return true;
+  }
+
+  const childA = firstChild(a);
+  const childB = firstChild(b);
+
+  if (childA?.name !== childB?.name) {
+    return false;
+  }
+
+  if (childA?.name === "table" && childB?.name === "table") {
+    const dimA = getTableDimensions(childA);
+    const dimB = getTableDimensions(childB);
+    if (
+      dimA !== null &&
+      dimB !== null &&
+      dimA.rows !== dimB.rows &&
+      dimA.cols !== dimB.cols
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+};