superdoc 1.0.0-beta.10 → 1.0.0-beta.12

package/dist/superdoc.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const superEditor_es = require("./chunks/super-editor.es-Bf7zv4k5.cjs");
-const superdoc = require("./chunks/index-B7kE5mis.cjs");
+const superEditor_es = require("./chunks/super-editor.es-CBMp55sv.cjs");
+const superdoc = require("./chunks/index-ANaY3G41.cjs");
 const blankDocx = require("./chunks/blank-docx-DfW3Eeh2.cjs");
 exports.AnnotatorHelpers = superEditor_es.AnnotatorHelpers;
 exports.Editor = superEditor_es.Editor;

package/dist/superdoc.es.js

@@ -1,5 +1,5 @@
-import { a, E, b, S, d, i, j, n, r, p, q } from "./chunks/super-editor.es-C3Mtq3FL.es.js";
-import { D, H, P, S as S2, m, l } from "./chunks/index-BrS4iO03.es.js";
+import { a, E, b, S, d, i, j, n, r, p, q } from "./chunks/super-editor.es-C-5T9RJI.es.js";
+import { D, H, P, S as S2, m, l } from "./chunks/index-Bs29IidK.es.js";
 import { B } from "./chunks/blank-docx-ABm6XYAA.es.js";
 export {
   a as AnnotatorHelpers,

package/dist/superdoc.umd.js

@@ -35606,7 +35606,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.10") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.12") {
       return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -60094,7 +60094,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const shouldSkipNodeView = (editor) => {
     return isHeadless(editor);
   };
-  const summaryVersion = "1.0.0-beta.10";
+  const summaryVersion = "1.0.0-beta.12";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -60873,7 +60873,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         { default: remarkStringify2 },
         { default: remarkGfm2 }
       ] = await Promise.all([
-        Promise.resolve().then(() => indexCC6Vsniy),
+        Promise.resolve().then(() => indexCha6AFg),
         Promise.resolve().then(() => indexDRCvimau),
         Promise.resolve().then(() => indexC_x_N6Uh),
         Promise.resolve().then(() => indexD_sWOSiG),
@@ -61078,7 +61078,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.10");
+      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.12");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -65179,28 +65179,42 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const indentSource = attrs.indent ?? paragraphProps.indent ?? hydrated?.indent;
     const normalizedIndent = normalizePxIndent(indentSource) ?? normalizeParagraphIndent(indentSource ?? attrs.textIndent);
     const unwrapTabStops = (tabStops) => {
-      if (!Array.isArray(tabStops)) return void 0;
+      if (!Array.isArray(tabStops)) {
+        return void 0;
+      }
       const unwrapped = [];
       for (const entry of tabStops) {
-        if (entry && typeof entry === "object" && "tab" in entry) {
-          const tab = entry.tab;
-          if (tab && typeof tab === "object") {
-            const tabObj = tab;
-            const val = typeof tabObj.tabType === "string" ? tabObj.tabType : typeof tabObj.val === "string" ? tabObj.val : void 0;
-            const pos = pickNumber(tabObj.originalPos ?? tabObj.pos);
-            if (val && pos != null) {
-              const normalized = { val, pos };
-              const leader = tabObj.leader;
-              if (typeof leader === "string") normalized.leader = leader;
-              const originalPos = pickNumber(tabObj.originalPos);
-              if (originalPos != null) normalized.originalPos = originalPos;
-              unwrapped.push(normalized);
-              continue;
-            }
+        if (!entry || typeof entry !== "object") {
+          continue;
+        }
+        if ("tab" in entry) {
+          const entryRecord2 = entry;
+          const tab = entryRecord2.tab;
+          if (!tab || typeof tab !== "object") {
+            continue;
           }
+          const tabObj = tab;
+          const val = typeof tabObj.tabType === "string" ? tabObj.tabType : typeof tabObj.val === "string" ? tabObj.val : void 0;
+          const pos = pickNumber(tabObj.originalPos ?? tabObj.pos);
+          if (!val || pos == null) {
+            continue;
+          }
+          const normalized = { val, pos };
+          const leader = tabObj.leader;
+          if (typeof leader === "string" && leader.length > 0) {
+            normalized.leader = leader;
+          }
+          const originalPos = pickNumber(tabObj.originalPos);
+          if (originalPos != null && Number.isFinite(originalPos)) {
+            normalized.originalPos = originalPos;
+          }
+          unwrapped.push(normalized);
+          continue;
         }
-        if (entry && typeof entry === "object") {
-          unwrapped.push(entry);
+        const entryRecord = entry;
+        const hasValidStructure = ("val" in entryRecord || "tabType" in entryRecord) && ("pos" in entryRecord || "originalPos" in entryRecord);
+        if (hasValidStructure) {
+          unwrapped.push(entryRecord);
         }
       }
       return unwrapped.length > 0 ? unwrapped : void 0;
@@ -73035,7 +73049,7 @@ ${l}
     };
   };
   const renderTableCell = (deps) => {
-    const { doc: doc2, x: x2, y: y2, rowHeight, cellMeasure, cell: cell2, borders, useDefaultBorder, renderLine, context, applySdtDataset } = deps;
+    const { doc: doc2, x: x2, y: y2, rowHeight, cellMeasure, cell: cell2, borders, renderLine, context, applySdtDataset } = deps;
     const cellEl = doc2.createElement("div");
     cellEl.style.position = "absolute";
     cellEl.style.left = `${x2}px`;
@@ -73045,8 +73059,6 @@ ${l}
     cellEl.style.boxSizing = "border-box";
     if (borders) {
       applyCellBorders(cellEl, borders);
-    } else if (useDefaultBorder) {
-      cellEl.style.border = "1px solid rgba(0,0,0,0.6)";
     }
     if (cell2?.attrs?.background) {
       cellEl.style.backgroundColor = cell2.attrs.background;
@@ -73088,25 +73100,55 @@ ${l}
       row: row2,
       totalRows,
       tableBorders,
+      columnWidths,
+      allRowHeights,
       context,
       renderLine,
       applySdtDataset
     } = deps;
-    let x2 = 0;
+    const calculateXPosition = (gridColumnStart) => {
+      let x2 = 0;
+      for (let i2 = 0; i2 < gridColumnStart && i2 < columnWidths.length; i2++) {
+        x2 += columnWidths[i2];
+      }
+      return x2;
+    };
+    const calculateRowspanHeight = (startRowIndex, rowSpan) => {
+      let totalHeight = 0;
+      for (let i2 = 0; i2 < rowSpan && startRowIndex + i2 < allRowHeights.length; i2++) {
+        totalHeight += allRowHeights[startRowIndex + i2];
+      }
+      return totalHeight;
+    };
     for (let cellIndex = 0; cellIndex < rowMeasure.cells.length; cellIndex += 1) {
       const cellMeasure = rowMeasure.cells[cellIndex];
       const cell2 = row2?.cells?.[cellIndex];
-      const hasExplicitBorders = Boolean(cell2?.attrs?.borders);
-      const resolvedBorders = hasExplicitBorders ? cell2?.attrs?.borders : tableBorders ? resolveTableCellBorders(tableBorders, rowIndex, cellIndex, totalRows, rowMeasure.cells.length) : void 0;
+      const x2 = cellMeasure.gridColumnStart != null ? calculateXPosition(cellMeasure.gridColumnStart) : cellIndex === 0 ? 0 : calculateXPosition(cellIndex);
+      const cellBordersAttr = cell2?.attrs?.borders;
+      const hasBordersAttribute = cellBordersAttr !== void 0;
+      const hasExplicitBorders = hasBordersAttribute && cellBordersAttr && (cellBordersAttr.top !== void 0 || cellBordersAttr.right !== void 0 || cellBordersAttr.bottom !== void 0 || cellBordersAttr.left !== void 0);
+      const gridColIndex = cellMeasure.gridColumnStart ?? cellIndex;
+      const totalCols = columnWidths.length;
+      let resolvedBorders;
+      if (hasExplicitBorders) {
+        resolvedBorders = cellBordersAttr;
+      } else if (hasBordersAttribute) {
+        resolvedBorders = void 0;
+      } else if (tableBorders) {
+        resolvedBorders = resolveTableCellBorders(tableBorders, rowIndex, gridColIndex, totalRows, totalCols);
+      } else {
+        resolvedBorders = void 0;
+      }
+      const rowSpan = cellMeasure.rowSpan ?? 1;
+      const cellHeight = rowSpan > 1 ? calculateRowspanHeight(rowIndex, rowSpan) : rowMeasure.height;
       const { cellElement, contentElement } = renderTableCell({
         doc: doc2,
         x: x2,
         y: y2,
-        rowHeight: rowMeasure.height,
+        rowHeight: cellHeight,
         cellMeasure,
         cell: cell2,
         borders: resolvedBorders,
-        useDefaultBorder: !hasExplicitBorders && !tableBorders,
         renderLine,
         context,
         applySdtDataset
@@ -73115,7 +73157,6 @@ ${l}
       if (contentElement) {
         container.appendChild(contentElement);
       }
-      x2 += cellMeasure.width;
     }
   };
   const renderTableFragment = (deps) => {
@@ -73157,6 +73198,45 @@ ${l}
     applySdtDataset(container, block.attrs?.sdt);
     container.classList.add("superdoc-table-fragment");
     if (fragment.metadata?.columnBoundaries) {
+      const columnCount = measure.columnWidths.length;
+      const rowCount = block.rows.length;
+      const boundarySegments = [];
+      for (let i2 = 0; i2 < columnCount; i2++) {
+        boundarySegments.push([]);
+      }
+      let rowY = 0;
+      for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const rowMeasure = measure.rows[rowIndex];
+        if (!rowMeasure) continue;
+        const boundariesInRow = /* @__PURE__ */ new Set();
+        for (const cellMeasure of rowMeasure.cells) {
+          const startCol = cellMeasure.gridColumnStart ?? 0;
+          const colSpan = cellMeasure.colSpan ?? 1;
+          const endCol = startCol + colSpan;
+          if (startCol > 0) {
+            boundariesInRow.add(startCol);
+          }
+          if (endCol < columnCount) {
+            boundariesInRow.add(endCol);
+          }
+        }
+        for (const boundaryCol of boundariesInRow) {
+          const segments = boundarySegments[boundaryCol];
+          const lastSegment = segments[segments.length - 1];
+          if (lastSegment && lastSegment.toRow === rowIndex) {
+            lastSegment.toRow = rowIndex + 1;
+            lastSegment.height += rowMeasure.height;
+          } else {
+            segments.push({
+              fromRow: rowIndex,
+              toRow: rowIndex + 1,
+              y: rowY,
+              height: rowMeasure.height
+            });
+          }
+        }
+        rowY += rowMeasure.height;
+      }
       const metadata = {
         columns: fragment.metadata.columnBoundaries.map((boundary) => ({
           i: boundary.index,
@@ -73164,7 +73244,18 @@ ${l}
           w: boundary.width,
           min: boundary.minWidth,
           r: boundary.resizable ? 1 : 0
-        }))
+        })),
+        // Add segments for each column boundary (segments where resize handle should appear)
+        segments: boundarySegments.map(
+          (segs, colIndex) => segs.map((seg) => ({
+            c: colIndex,
+            // column index
+            y: seg.y,
+            // y position
+            h: seg.height
+            // height of segment
+          }))
+        )
       };
       container.setAttribute("data-table-boundaries", JSON.stringify(metadata));
     }
@@ -73175,6 +73266,7 @@ ${l}
     if (borderCollapse === "separate" && block.attrs?.cellSpacing) {
       container.style.borderSpacing = `${block.attrs.cellSpacing}px`;
     }
+    const allRowHeights = measure.rows.map((r2) => r2.height);
     let y2 = 0;
     for (let r2 = fragment.fromRow; r2 < fragment.toRow; r2 += 1) {
       const rowMeasure = measure.rows[r2];
@@ -73188,6 +73280,8 @@ ${l}
         row: block.rows[r2],
         totalRows: block.rows.length,
         tableBorders,
+        columnWidths: measure.columnWidths,
+        allRowHeights,
         context,
         renderLine,
         applySdtDataset
@@ -75829,21 +75923,9 @@ ${l}
   }
   async function measureTableBlock(block, constraints) {
     const maxWidth = typeof constraints === "number" ? constraints : constraints.maxWidth;
-    const columnCount = Math.max(1, Math.max(...block.rows.map((r2) => r2.cells.length)));
     let columnWidths;
     if (block.columnWidths && block.columnWidths.length > 0) {
       columnWidths = [...block.columnWidths];
-      if (columnWidths.length < columnCount) {
-        const usedWidth = columnWidths.reduce((a2, b2) => a2 + b2, 0);
-        const remainingWidth = Math.max(0, maxWidth - usedWidth);
-        const missingCount = columnCount - columnWidths.length;
-        const defaultWidth = missingCount > 0 ? Math.max(1, Math.floor(remainingWidth / missingCount)) : 0;
-        for (let i2 = columnWidths.length; i2 < columnCount; i2++) {
-          columnWidths.push(defaultWidth);
-        }
-      } else if (columnWidths.length > columnCount) {
-        columnWidths = columnWidths.slice(0, columnCount);
-      }
       const totalWidth2 = columnWidths.reduce((a2, b2) => a2 + b2, 0);
       const hasExplicitWidth = block.attrs?.tableWidth != null;
       if (!hasExplicitWidth && totalWidth2 > maxWidth) {
@@ -75851,22 +75933,56 @@ ${l}
         columnWidths = columnWidths.map((w2) => Math.max(1, Math.floor(w2 * scale)));
       }
     } else {
-      const columnWidth = Math.max(1, Math.floor(maxWidth / columnCount));
-      columnWidths = Array.from({ length: columnCount }, () => columnWidth);
+      const maxCellCount = Math.max(1, Math.max(...block.rows.map((r2) => r2.cells.length)));
+      const columnWidth = Math.max(1, Math.floor(maxWidth / maxCellCount));
+      columnWidths = Array.from({ length: maxCellCount }, () => columnWidth);
     }
+    const gridColumnCount = columnWidths.length;
+    const calculateCellWidth = (startCol, colspan) => {
+      let width = 0;
+      for (let i2 = 0; i2 < colspan && startCol + i2 < columnWidths.length; i2++) {
+        width += columnWidths[startCol + i2];
+      }
+      return Math.max(1, width);
+    };
+    const rowspanTracker = new Array(gridColumnCount).fill(0);
     const rows = [];
-    for (const row2 of block.rows) {
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+      const row2 = block.rows[rowIndex];
       const cellMeasures = [];
-      for (let col = 0; col < columnCount; col++) {
-        const cell2 = row2.cells[col];
-        const cellWidth = columnWidths[col] || columnWidths[0] || Math.floor(maxWidth / columnCount);
-        if (!cell2) {
-          cellMeasures.push({ paragraph: { kind: "paragraph", lines: [], totalHeight: 0 }, width: cellWidth, height: 0 });
-          continue;
+      let gridColIndex = 0;
+      for (const cell2 of row2.cells) {
+        const colspan = cell2.colSpan ?? 1;
+        const rowspan = cell2.rowSpan ?? 1;
+        while (gridColIndex < gridColumnCount && rowspanTracker[gridColIndex] > 0) {
+          rowspanTracker[gridColIndex]--;
+          gridColIndex++;
+        }
+        if (gridColIndex >= gridColumnCount) {
+          break;
+        }
+        const cellWidth = calculateCellWidth(gridColIndex, colspan);
+        if (rowspan > 1) {
+          for (let c2 = 0; c2 < colspan && gridColIndex + c2 < gridColumnCount; c2++) {
+            rowspanTracker[gridColIndex + c2] = rowspan - 1;
+          }
         }
         const paraMeasure = await measureParagraphBlock(cell2.paragraph, cellWidth);
         const height = paraMeasure.totalHeight;
-        cellMeasures.push({ paragraph: paraMeasure, width: cellWidth, height });
+        cellMeasures.push({
+          paragraph: paraMeasure,
+          width: cellWidth,
+          height,
+          gridColumnStart: gridColIndex,
+          colSpan: colspan,
+          rowSpan: rowspan
+        });
+        gridColIndex += colspan;
+      }
+      for (let col = gridColIndex; col < gridColumnCount; col++) {
+        if (rowspanTracker[col] > 0) {
+          rowspanTracker[col]--;
+        }
       }
       const rowHeight = Math.max(0, ...cellMeasures.map((c2) => c2.height));
       rows.push({ cells: cellMeasures, height: rowHeight });
@@ -109057,7 +109173,7 @@ ${style2}
     blobs.forEach((blob, index2) => {
       zip.file(fileNames[index2], blob);
     });
-    const zipBlob = await zip.generateAsync({ type: "blob" });
+    const zipBlob = await zip.generateAsync({ type: "blob", compression: "DEFLATE" });
     return zipBlob;
   }
   var __defProp = Object.defineProperty;
@@ -113886,13 +114002,31 @@ ${style2}
         });
         return boundaries;
       });
-      function getHandleStyle(boundary) {
+      function getBoundarySegments(boundary) {
+        if (boundary.type === "right-edge") {
+          return [{ y: 0, h: null }];
+        }
+        const segmentsData = tableMetadata.value?.segments;
+        if (!segmentsData || !Array.isArray(segmentsData)) {
+          return [{ y: 0, h: null }];
+        }
+        const boundaryColIndex = boundary.index + 1;
+        const colSegments = segmentsData[boundaryColIndex];
+        if (!colSegments || colSegments.length === 0) {
+          return [];
+        }
+        return colSegments.map((seg) => ({
+          y: seg.y,
+          h: seg.h
+        }));
+      }
+      function getSegmentHandleStyle(boundary, segment) {
         return {
           position: "absolute",
           left: `${boundary.x}px`,
-          top: "0",
+          top: segment.y != null ? `${segment.y}px` : "0",
           width: "9px",
-          height: "100%",
+          height: segment.h != null ? `${segment.h}px` : "100%",
           transform: "translateX(-4px)",
           cursor: "col-resize",
           pointerEvents: "auto"
@@ -113947,7 +114081,8 @@ ${style2}
             });
             return;
           }
-          tableMetadata.value = { columns: validatedColumns };
+          const segments = Array.isArray(parsed.segments) ? parsed.segments : void 0;
+          tableMetadata.value = { columns: validatedColumns, segments };
         } catch (error) {
           tableMetadata.value = null;
           emit2("resize-error", {
@@ -114109,7 +114244,7 @@ ${style2}
           updateCellColwidths(tr, tableNode, tablePos, affectedColumns, newWidths);
           dispatch(tr);
           const blockId = props.tableElement?.getAttribute("data-sd-block-id");
-          if (blockId) {
+          if (blockId && blockId.trim()) {
             measureCache.invalidate([blockId]);
           }
           emit2("resize-success", { columnIndex, newWidths });
@@ -114212,18 +114347,24 @@ ${style2}
           onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
           }, ["stop"]))
         }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(resizableBoundaries.value, (boundary, index2) => {
-            return openBlock(), createElementBlock("div", {
-              key: `handle-${boundary.type}-${boundary.index}`,
-              class: normalizeClass(["resize-handle", {
-                "resize-handle--active": dragState.value && dragState.value.boundaryIndex === index2,
-                "resize-handle--edge": boundary.type === "right-edge"
-              }]),
-              "data-boundary-index": index2,
-              "data-boundary-type": boundary.type,
-              style: normalizeStyle(getHandleStyle(boundary)),
-              onMousedown: ($event) => onHandleMouseDown($event, index2)
-            }, null, 46, _hoisted_1$2$1);
+          (openBlock(true), createElementBlock(Fragment, null, renderList(resizableBoundaries.value, (boundary, boundaryIndex) => {
+            return openBlock(), createElementBlock(Fragment, {
+              key: `boundary-${boundaryIndex}`
+            }, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(getBoundarySegments(boundary), (segment, segmentIndex) => {
+                return openBlock(), createElementBlock("div", {
+                  key: `handle-${boundary.type}-${boundary.index}-${segmentIndex}`,
+                  class: normalizeClass(["resize-handle", {
+                    "resize-handle--active": dragState.value && dragState.value.boundaryIndex === boundaryIndex,
+                    "resize-handle--edge": boundary.type === "right-edge"
+                  }]),
+                  "data-boundary-index": boundaryIndex,
+                  "data-boundary-type": boundary.type,
+                  style: normalizeStyle(getSegmentHandleStyle(boundary, segment)),
+                  onMousedown: ($event) => onHandleMouseDown($event, boundaryIndex)
+                }, null, 46, _hoisted_1$2$1);
+              }), 128))
+            ], 64);
           }), 128)),
           dragState.value ? (openBlock(), createElementBlock("div", {
             key: 0,
@@ -114234,7 +114375,7 @@ ${style2}
       };
     }
   };
-  const TableResizeOverlay = /* @__PURE__ */ _export_sfc$1(_sfc_main$2$1, [["__scopeId", "data-v-acc51d8d"]]);
+  const TableResizeOverlay = /* @__PURE__ */ _export_sfc$1(_sfc_main$2$1, [["__scopeId", "data-v-d4258885"]]);
   function adjustPaginationBreaks(editorElem, editor) {
     if (!editorElem.value || !editor?.value?.options?.scale || isHeadless(editor)) return;
     const zoom = editor.value.options.scale;
@@ -131833,7 +131974,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.0.0-beta.10";
+      this.version = "1.0.0-beta.12";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;
@@ -134276,7 +134417,7 @@ ${style2}
       value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
     );
   }
-  const indexCC6Vsniy = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  const indexCha6AFg = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     unified
   }, Symbol.toStringTag, { value: "Module" }));