@harbour-enterprises/superdoc 0.25.0-next.6 → 0.25.0-next.7

package/dist/superdoc.umd.js

@@ -63466,10 +63466,27 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const result = findChildren$5(state2.doc, (node) => node.type.name === "structuredContentBlock");
     return result;
   }
+  function getStructuredContentTablesById(id, state2) {
+    if (!id || !state2) return [];
+    const blocks = getStructuredContentTagsById(id, state2).filter(
+      ({ node }) => node.type.name === "structuredContentBlock"
+    );
+    if (!blocks.length) return [];
+    const { pos: blockPos, node: blockNode } = blocks[0];
+    const tablesInBlock = [];
+    blockNode.descendants((child, relPos) => {
+      if (child.type.name === "table") {
+        const absPos = blockPos + 1 + relPos;
+        tablesInBlock.push({ node: child, pos: absPos });
+      }
+    });
+    return tablesInBlock;
+  }
   const structuredContentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     getStructuredContentBlockTags,
     getStructuredContentInlineTags,
+    getStructuredContentTablesById,
     getStructuredContentTags,
     getStructuredContentTagsById
   }, Symbol.toStringTag, { value: "Module" }));
@@ -63666,6 +63683,36 @@ Please report this to https://github.com/markedjs/marked.`, e) {
             tr.replaceWith(posFrom, posTo, content);
           }
           return true;
+        },
+        /**
+         * Append multiple rows to the end of a table inside a structured content block.
+         * Each inner array represents the cell values for one new row.
+         * @category Command
+         * @param {StructuredContentTableAppendRowsOptions} options - Append configuration
+         * @example
+         * editor.commands.appendRowsToStructuredContentTable({
+         *   id: 'block-123',
+         *   tableIndex: 0,
+         *   rows: [['A', 'B'], ['C', 'D']],
+         *   copyRowStyle: true,
+         * });
+         */
+        appendRowsToStructuredContentTable: ({ id, tableIndex = 0, rows = [], copyRowStyle = false }) => ({ state: state2, commands: commands2, dispatch }) => {
+          const normalized = normalizeRowsInput(rows);
+          if (!normalized.length) return true;
+          const tables = getStructuredContentTablesById(id, state2);
+          if (!tables.length || tableIndex < 0 || tableIndex >= tables.length) return true;
+          const { node: tableNode, pos: tablePos } = tables[tableIndex];
+          if (dispatch) {
+            return commands2.appendRowsWithContent({ tablePos, tableNode, valueRows: normalized, copyRowStyle });
+          }
+          return commands2.appendRowsWithContent({
+            tablePos,
+            tableNode,
+            valueRows: normalized,
+            copyRowStyle,
+            dispatch: false
+          });
         }
       };
     },
@@ -63675,6 +63722,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       };
     }
   });
+  const normalizeRowsInput = (rowsOrValues) => {
+    if (!Array.isArray(rowsOrValues) || !rowsOrValues.length) {
+      return [];
+    }
+    if (Array.isArray(rowsOrValues[0])) {
+      return rowsOrValues;
+    }
+    return [rowsOrValues];
+  };
   class DocumentSectionView {
     constructor(node, getPos, decorations, editor) {
       __privateAdd$1(this, _DocumentSectionView_instances);
@@ -69427,6 +69483,107 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     return null;
   }
+  function resolveTable(tr, tablePos, tableNode) {
+    if (tableNode && tableNode.type && tableNode.type.name === "table") {
+      return tableNode;
+    }
+    if (typeof tablePos === "number") {
+      const current = tr.doc.nodeAt(tablePos);
+      if (current && current.type.name === "table") {
+        return current;
+      }
+    }
+    return null;
+  }
+  function pickTemplateRowForAppend(tableNode, schema) {
+    const RowType = schema.nodes.tableRow;
+    const rows = [];
+    tableNode.descendants((child) => {
+      if (child.type === RowType) rows.push(child);
+    });
+    if (!rows.length) return null;
+    for (let i2 = rows.length - 1; i2 >= 0; i2--) {
+      const r2 = rows[i2];
+      const hasBodyCell = r2.content?.content?.some((c2) => c2.type.name === "tableCell");
+      if (hasBodyCell) return r2;
+    }
+    return rows[rows.length - 1];
+  }
+  function extractRowTemplateFormatting(cellNode, schema) {
+    const ParagraphType = schema.nodes.paragraph;
+    let blockType = ParagraphType;
+    let blockAttrs = null;
+    let textMarks = [];
+    const blocks = cellNode?.content?.content || [];
+    for (const block of blocks) {
+      const isParagraphish = block.type === ParagraphType || block.type.name === "heading";
+      if (isParagraphish) {
+        blockType = block.type || ParagraphType;
+        blockAttrs = block.attrs || null;
+      }
+      let foundText = null;
+      block.descendants?.((n) => {
+        if (!foundText && n.isText) foundText = n;
+      });
+      if (foundText) {
+        textMarks = foundText.marks ? Array.from(foundText.marks) : [];
+        break;
+      }
+    }
+    if (!blockType || !blockType.validContent) blockType = ParagraphType;
+    return { blockType, blockAttrs, textMarks };
+  }
+  function buildFormattedCellBlock(schema, value, { blockType, blockAttrs, textMarks }, copyRowStyle = false) {
+    const text = typeof value === "string" ? value : value == null ? "" : String(value);
+    const marks = copyRowStyle ? textMarks || [] : [];
+    const textNode = schema.text(text, marks);
+    const type2 = blockType || schema.nodes.paragraph;
+    return type2.createAndFill(blockAttrs || null, textNode);
+  }
+  function buildRowFromTemplateRow({ schema, tableNode, templateRow, values, copyRowStyle = false }) {
+    const RowType = schema.nodes.tableRow;
+    const CellType = schema.nodes.tableCell;
+    const HeaderType = schema.nodes.tableHeader;
+    const map2 = TableMap.get(tableNode);
+    const totalColumns = map2.width;
+    const byColumns = Array.isArray(values) && values.length === totalColumns;
+    const newCells = [];
+    let columnCursor = 0;
+    templateRow.content.content.forEach((cellNode, cellIndex) => {
+      const isHeaderCell = cellNode.type === HeaderType;
+      const targetCellType = isHeaderCell ? CellType : cellNode.type;
+      const attrs = { ...cellNode.attrs };
+      const formatting = extractRowTemplateFormatting(cellNode, schema);
+      let cellValue = "";
+      if (byColumns) {
+        const span = Math.max(1, attrs.colspan || 1);
+        cellValue = values[columnCursor] ?? "";
+        columnCursor += span;
+      } else {
+        cellValue = Array.isArray(values) ? values[cellIndex] ?? "" : "";
+      }
+      const content = buildFormattedCellBlock(schema, cellValue, formatting, copyRowStyle);
+      const newCell = targetCellType.createAndFill(attrs, content);
+      if (newCell) newCells.push(newCell);
+    });
+    return RowType.createAndFill(null, newCells);
+  }
+  function insertRowsAtTableEnd({ tr, tablePos, tableNode, rows }) {
+    if (!rows || !rows.length) return;
+    const RowTypeName = "tableRow";
+    let lastRowRelPos = 0;
+    let lastRowNode = null;
+    tableNode.descendants((child, relPos) => {
+      if (child.type.name === RowTypeName) {
+        lastRowRelPos = relPos;
+        lastRowNode = child;
+      }
+    });
+    if (!lastRowNode) return;
+    const lastRowAbsEnd = tablePos + 1 + lastRowRelPos + lastRowNode.nodeSize;
+    const frag = Fragment.fromArray(rows);
+    tr.insert(lastRowAbsEnd, frag);
+  }
   const Table = Node$1.create({
     name: "table",
     content: "tableRow+",
@@ -69586,6 +69743,47 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     },
     addCommands() {
       return {
+        /**
+         * Append multiple rows to the end of a table in a single transaction.
+         * @category Command
+         * @param {appendRowsWithContentOptions} options - Append configuration
+         * @example
+         * editor.commands.appendRowsWithContent({ tablePos, valueRows: [['A','B'], ['C','D']], copyRowStyle: true })
+         */
+        appendRowsWithContent: ({ tablePos, tableNode, valueRows = [], copyRowStyle = false }) => ({ editor, chain }) => {
+          if (typeof tablePos !== "number" && !tableNode || !Array.isArray(valueRows) || !valueRows.length) {
+            return false;
+          }
+          return chain().command(({ tr, dispatch }) => {
+            const workingTable = resolveTable(tr, tablePos, tableNode);
+            if (!workingTable) return false;
+            const templateRow = pickTemplateRowForAppend(workingTable, editor.schema);
+            if (!templateRow) return false;
+            const newRows = valueRows.map(
+              (vals) => buildRowFromTemplateRow({
+                schema: editor.schema,
+                tableNode: workingTable,
+                templateRow,
+                values: vals,
+                copyRowStyle
+              })
+            ).filter(Boolean);
+            if (!newRows.length) return false;
+            let resolvedTablePos = tablePos;
+            if (typeof resolvedTablePos !== "number" && workingTable) {
+              const tables = editor.getNodesOfType("table");
+              const match = workingTable ? tables.find((t) => t.node.eq(workingTable)) : tables[0];
+              resolvedTablePos = match?.pos ?? null;
+            }
+            if (typeof resolvedTablePos !== "number") {
+              return false;
+            }
+            if (dispatch) {
+              insertRowsAtTableEnd({ tr, tablePos, tableNode: workingTable, rows: newRows });
+            }
+            return true;
+          }).run();
+        },
         /**
          * Insert a new table into the document
          * @category Command