docxmlater 10.3.6 → 10.4.0

package/dist/elements/Table.js

@@ -63,6 +63,38 @@ class Table {
         row._setParentTable(this);
         return this;
     }
+    addRowFromArray(cells) {
+        const row = new TableRow_1.TableRow();
+        for (const text of cells) {
+            row.createCell(text || undefined);
+        }
+        this.rows.push(row);
+        row._setParentTable(this);
+        return row;
+    }
+    addSummaryRow(options) {
+        const label = options?.label ?? 'Total';
+        const startRow = options?.startRow ?? 1;
+        const colCount = this.getColumnCount();
+        const defaultCompute = (values) => {
+            const nums = values.map((v) => parseFloat(v)).filter((n) => !isNaN(n));
+            if (nums.length === 0)
+                return '';
+            return String(nums.reduce((a, b) => a + b, 0));
+        };
+        const compute = options?.compute ?? defaultCompute;
+        const cells = [];
+        for (let c = 0; c < colCount; c++) {
+            if (c === 0) {
+                cells.push(label);
+                continue;
+            }
+            const colTexts = this.getColumnTexts(c);
+            const dataValues = colTexts.slice(startRow);
+            cells.push(compute(dataValues, c));
+        }
+        return this.addRowFromArray(cells);
+    }
     createRow(cellCount, formatting) {
         const row = new TableRow_1.TableRow(cellCount, formatting);
         this.rows.push(row);
@@ -112,6 +144,22 @@ class Table {
         const row = this.getRow(rowIndex);
         return row ? row.getCell(columnIndex) : undefined;
     }
+    setCell(rowIndex, colIndex, text) {
+        const cell = this.getCell(rowIndex, colIndex);
+        if (!cell)
+            return this;
+        const paragraphs = cell.getParagraphs();
+        if (paragraphs.length > 0) {
+            paragraphs[0].setText(text);
+            for (let p = paragraphs.length - 1; p >= 1; p--) {
+                cell.removeParagraph(p);
+            }
+        }
+        else {
+            cell.createParagraph(text);
+        }
+        return this;
+    }
     setWidth(twips) {
         const prev = this.formatting.width;
         this.formatting.width = twips;
@@ -240,6 +288,17 @@ class Table {
         }
         return this;
     }
+    setIndentType(type) {
+        const prev = this.formatting.indentType;
+        this.formatting.indentType = type;
+        if (this.trackingContext?.isEnabled() && prev !== type) {
+            this.trackingContext.trackTableChange(this, 'indentType', prev, type);
+        }
+        return this;
+    }
+    getIndentType() {
+        return this.formatting.indentType;
+    }
     setStyle(style) {
         const prev = this.formatting.style;
         this.formatting.style = style;
@@ -570,7 +629,7 @@ class Table {
         if (this.formatting.indent !== undefined) {
             tblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblInd', {
                 'w:w': this.formatting.indent,
-                'w:type': 'dxa',
+                'w:type': this.formatting.indentType || 'dxa',
             }));
         }
         if (this.formatting.borders) {
@@ -660,6 +719,41 @@ class Table {
                 if (prev.style) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblStyle', { 'w:val': prev.style }));
                 }
+                if (prev.position) {
+                    const posAttrs = {};
+                    const pos = prev.position;
+                    if (pos.x !== undefined)
+                        posAttrs['w:tblpX'] = pos.x;
+                    if (pos.y !== undefined)
+                        posAttrs['w:tblpY'] = pos.y;
+                    if (pos.horizontalAnchor)
+                        posAttrs['w:horzAnchor'] = pos.horizontalAnchor;
+                    if (pos.verticalAnchor)
+                        posAttrs['w:vertAnchor'] = pos.verticalAnchor;
+                    if (pos.leftFromText !== undefined)
+                        posAttrs['w:leftFromText'] = pos.leftFromText;
+                    if (pos.rightFromText !== undefined)
+                        posAttrs['w:rightFromText'] = pos.rightFromText;
+                    if (pos.topFromText !== undefined)
+                        posAttrs['w:topFromText'] = pos.topFromText;
+                    if (pos.bottomFromText !== undefined)
+                        posAttrs['w:bottomFromText'] = pos.bottomFromText;
+                    if (Object.keys(posAttrs).length > 0) {
+                        prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblpPr', posAttrs));
+                    }
+                }
+                if (prev.overlap) {
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblOverlap', { 'w:val': prev.overlap }));
+                }
+                if (prev.bidiVisual) {
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('bidiVisual'));
+                }
+                if (prev.tblStyleRowBandSize !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblStyleRowBandSize', { 'w:val': prev.tblStyleRowBandSize }));
+                }
+                if (prev.tblStyleColBandSize !== undefined) {
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblStyleColBandSize', { 'w:val': prev.tblStyleColBandSize }));
+                }
                 if (prev.width !== undefined) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblW', {
                         'w:w': prev.width,
@@ -669,8 +763,15 @@ class Table {
                 if (prev.alignment) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('jc', { 'w:val': prev.alignment }));
                 }
+                if (prev.cellSpacing !== undefined) {
+                    const csAttrs = {
+                        'w:w': prev.cellSpacing,
+                        'w:type': prev.cellSpacingType || 'dxa',
+                    };
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblCellSpacing', csAttrs));
+                }
                 if (prev.indent !== undefined) {
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblInd', { 'w:w': prev.indent, 'w:type': 'dxa' }));
+                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblInd', { 'w:w': prev.indent, 'w:type': prev.indentType || 'dxa' }));
                 }
                 if (prev.borders) {
                     const borderChildren = [];
@@ -701,23 +802,19 @@ class Table {
                 if (prev.layout) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblLayout', { 'w:type': prev.layout }));
                 }
-                if (prev.cellSpacing !== undefined) {
-                    const csAttrs = {
-                        'w:w': prev.cellSpacing,
-                        'w:type': prev.cellSpacingType || 'dxa',
-                    };
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblCellSpacing', csAttrs));
-                }
-                if (prev.bidiVisual) {
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('bidiVisual'));
-                }
                 if (prev.cellMargins) {
                     const cmChildren = [];
-                    for (const side of ['top', 'start', 'bottom', 'end']) {
-                        const val = prev.cellMargins[side];
-                        if (val !== undefined) {
-                            cmChildren.push(XMLBuilder_1.XMLBuilder.wSelf(side, { 'w:w': val, 'w:type': 'dxa' }));
-                        }
+                    if (prev.cellMargins.top !== undefined) {
+                        cmChildren.push(XMLBuilder_1.XMLBuilder.wSelf('top', { 'w:w': prev.cellMargins.top, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.left !== undefined) {
+                        cmChildren.push(XMLBuilder_1.XMLBuilder.wSelf('left', { 'w:w': prev.cellMargins.left, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.bottom !== undefined) {
+                        cmChildren.push(XMLBuilder_1.XMLBuilder.wSelf('bottom', { 'w:w': prev.cellMargins.bottom, 'w:type': 'dxa' }));
+                    }
+                    if (prev.cellMargins.right !== undefined) {
+                        cmChildren.push(XMLBuilder_1.XMLBuilder.wSelf('right', { 'w:w': prev.cellMargins.right, 'w:type': 'dxa' }));
                     }
                     if (cmChildren.length > 0) {
                         prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.w('tblCellMar', undefined, cmChildren));
@@ -726,15 +823,6 @@ class Table {
                 if (prev.tblLook) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblLook', buildTblLookAttributes(prev.tblLook)));
                 }
-                if (prev.tblStyleRowBandSize !== undefined) {
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblStyleRowBandSize', { 'w:val': prev.tblStyleRowBandSize }));
-                }
-                if (prev.tblStyleColBandSize !== undefined) {
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblStyleColBandSize', { 'w:val': prev.tblStyleColBandSize }));
-                }
-                if (prev.overlap) {
-                    prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblOverlap', { 'w:val': prev.overlap }));
-                }
                 if (prev.caption) {
                     prevTblPrChildren.push(XMLBuilder_1.XMLBuilder.wSelf('tblCaption', { 'w:val': prev.caption }));
                 }
@@ -772,6 +860,9 @@ class Table {
     }
     removeRow(index) {
         if (index >= 0 && index < this.rows.length) {
+            if (this.rows.length <= 1 && !this.trackingContext?.isEnabled()) {
+                return false;
+            }
             if (this.trackingContext?.isEnabled()) {
                 const author = this.trackingContext.getAuthor();
                 const row = this.rows[index];
@@ -799,8 +890,10 @@ class Table {
         if (index > this.rows.length)
             index = this.rows.length;
         if (!row) {
-            const columnCount = this.getColumnCount();
-            row = new TableRow_1.TableRow(columnCount);
+            const gridColumns = this.formatting.tableGrid
+                ? this.formatting.tableGrid.length
+                : Math.max(...this.rows.map((r) => r.getTotalGridSpan()), 1);
+            row = new TableRow_1.TableRow(gridColumns);
         }
         this.rows.splice(index, 0, row);
         if (this.trackingContext?.isEnabled()) {
@@ -865,6 +958,94 @@ class Table {
         }
         return Math.max(...this.rows.map((row) => row.getCellCount()));
     }
+    getColumnCells(colIndex) {
+        const cells = [];
+        for (const row of this.rows) {
+            const cell = row.getCell(colIndex);
+            if (cell)
+                cells.push(cell);
+        }
+        return cells;
+    }
+    getColumnTexts(colIndex) {
+        return this.getColumnCells(colIndex).map((cell) => cell.getText());
+    }
+    mapColumn(colIndex, transform) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cell = this.rows[r].getCell(colIndex);
+            if (!cell)
+                continue;
+            const currentText = cell.getText();
+            const newText = transform(currentText, r);
+            if (newText !== currentText) {
+                const paragraphs = cell.getParagraphs();
+                if (paragraphs.length > 0) {
+                    const firstPara = paragraphs[0];
+                    firstPara.setText(newText);
+                    for (let p = paragraphs.length - 1; p >= 1; p--) {
+                        cell.removeParagraph(p);
+                    }
+                }
+                else {
+                    cell.createParagraph(newText);
+                }
+            }
+        }
+        return this;
+    }
+    forEachCell(callback) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cells = this.rows[r].getCells();
+            for (let c = 0; c < cells.length; c++) {
+                const result = callback(r, c, cells[c]);
+                if (result === false)
+                    return;
+            }
+        }
+    }
+    findCell(predicate) {
+        for (let r = 0; r < this.rows.length; r++) {
+            const cells = this.rows[r].getCells();
+            for (let c = 0; c < cells.length; c++) {
+                if (predicate(cells[c], r, c)) {
+                    return { row: r, col: c, cell: cells[c] };
+                }
+            }
+        }
+        return undefined;
+    }
+    filterRows(predicate) {
+        const indices = [];
+        for (let r = 0; r < this.rows.length; r++) {
+            if (predicate(this.rows[r].getCells(), r)) {
+                indices.push(r);
+            }
+        }
+        return indices;
+    }
+    removeEmptyRows() {
+        const emptyIndices = this.filterRows((cells) => cells.every((c) => c.getText().trim() === ''));
+        const toRemove = emptyIndices.length === this.rows.length
+            ? emptyIndices.slice(1)
+            : emptyIndices;
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            this.removeRow(toRemove[i]);
+        }
+        return toRemove.length;
+    }
+    removeEmptyColumns() {
+        const colCount = this.getColumnCount();
+        let removed = 0;
+        for (let c = colCount - 1; c >= 0; c--) {
+            const columnCells = this.getColumnCells(c);
+            const isEmpty = columnCells.every((cell) => cell.getText().trim() === '');
+            if (isEmpty) {
+                this.removeColumn(c);
+                removed++;
+            }
+        }
+        return removed;
+    }
     setColumnWidths(widths) {
         this.formatting.tableGrid = widths.map((w) => (w === null ? undefined : w));
         return this;
@@ -872,6 +1053,21 @@ class Table {
     static create(rows, columns, formatting) {
         return new Table(rows, columns, formatting);
     }
+    static fromArray(data, formatting) {
+        if (data.length === 0)
+            return new Table(0, 0, formatting);
+        const maxCols = Math.max(...data.map((row) => row.length));
+        const table = new Table(0, 0, formatting);
+        for (const rowData of data) {
+            const row = new TableRow_1.TableRow();
+            for (let c = 0; c < maxCols; c++) {
+                const text = c < rowData.length ? rowData[c] : undefined;
+                row.createCell(text || undefined);
+            }
+            table.addRow(row);
+        }
+        return table;
+    }
     mergeCells(startRow, startCol, endRow, endCol) {
         if (startRow < 0 || endRow >= this.rows.length || startCol < 0 || endCol < 0) {
             return this;
@@ -1029,7 +1225,9 @@ class Table {
     }
     insertRows(startIndex, count) {
         const insertedRows = [];
-        const columnCount = this.getColumnCount();
+        const columnCount = this.formatting.tableGrid
+            ? this.formatting.tableGrid.length
+            : Math.max(...this.rows.map((r) => r.getTotalGridSpan()), 1);
         for (let i = 0; i < count; i++) {
             const row = new TableRow_1.TableRow(columnCount);
             this.insertRow(startIndex + i, row);
@@ -1091,24 +1289,143 @@ class Table {
         this.rows = headerRow ? [headerRow, ...rowsToSort] : rowsToSort;
         return this;
     }
+    toArray() {
+        return this.rows.map((row) => row.getCells().map((cell) => cell.getText()));
+    }
+    toPlainText(columnSeparator = '\t', rowSeparator = '\n') {
+        return this.rows
+            .map((row) => row
+            .getCells()
+            .map((cell) => cell.getText())
+            .join(columnSeparator))
+            .join(rowSeparator);
+    }
+    toCSV(delimiter = ',') {
+        return this.rows
+            .map((row) => row
+            .getCells()
+            .map((cell) => {
+            const text = cell.getText();
+            if (text.includes(delimiter) || text.includes('"') || text.includes('\n')) {
+                return '"' + text.replace(/"/g, '""') + '"';
+            }
+            return text;
+        })
+            .join(delimiter))
+            .join('\n');
+    }
+    static fromCSV(csv, delimiter = ',', formatting) {
+        const rows = [];
+        let currentRow = [];
+        let currentField = '';
+        let inQuotes = false;
+        let i = 0;
+        while (i < csv.length) {
+            const ch = csv[i];
+            if (inQuotes) {
+                if (ch === '"') {
+                    if (i + 1 < csv.length && csv[i + 1] === '"') {
+                        currentField += '"';
+                        i += 2;
+                    }
+                    else {
+                        inQuotes = false;
+                        i++;
+                    }
+                }
+                else {
+                    currentField += ch;
+                    i++;
+                }
+            }
+            else {
+                if (ch === '"') {
+                    inQuotes = true;
+                    i++;
+                }
+                else if (ch === delimiter) {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    i++;
+                }
+                else if (ch === '\n') {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i++;
+                }
+                else if (ch === '\r') {
+                    if (i + 1 < csv.length && csv[i + 1] === '\n') {
+                        i++;
+                    }
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i++;
+                }
+                else {
+                    currentField += ch;
+                    i++;
+                }
+            }
+        }
+        if (currentField || currentRow.length > 0) {
+            currentRow.push(currentField);
+            rows.push(currentRow);
+        }
+        if (rows.length === 0)
+            return new Table(0, 0, formatting);
+        return Table.fromArray(rows, formatting);
+    }
+    transpose() {
+        const srcRows = this.rows.length;
+        if (srcRows === 0)
+            return new Table(0, 0);
+        const srcCols = this.getColumnCount();
+        if (srcCols === 0)
+            return new Table(0, 0);
+        const transposed = new Table(0, 0);
+        for (let c = 0; c < srcCols; c++) {
+            const newRow = new TableRow_1.TableRow();
+            for (let r = 0; r < srcRows; r++) {
+                const srcCell = this.getCell(r, c);
+                if (srcCell) {
+                    newRow.addCell(srcCell.clone());
+                }
+                else {
+                    newRow.createCell();
+                }
+            }
+            transposed.addRow(newRow);
+        }
+        return transposed;
+    }
     clone() {
         const clonedFormatting = (0, deepClone_1.deepClone)(this.formatting);
         const clonedTable = new Table(0, 0, clonedFormatting);
         for (const row of this.rows) {
-            const cells = row.getCells();
-            const clonedRow = new TableRow_1.TableRow(0);
-            for (const cell of cells) {
-                const cellFormatting = cell.getFormatting();
-                const clonedCell = new TableCell_1.TableCell((0, deepClone_1.deepClone)(cellFormatting));
-                for (const para of cell.getParagraphs()) {
-                    clonedCell.addParagraph(para.clone());
-                }
-                clonedRow.addCell(clonedCell);
-            }
-            clonedTable.addRow(clonedRow);
+            clonedTable.addRow(row.clone());
         }
         return clonedTable;
     }
+    duplicateRow(rowIndex, count = 1) {
+        if (rowIndex < 0 || rowIndex >= this.rows.length) {
+            throw new RangeError(`Row index ${rowIndex} is out of bounds (0-${this.rows.length - 1})`);
+        }
+        if (count < 1)
+            return [];
+        const sourceRow = this.rows[rowIndex];
+        const inserted = [];
+        for (let i = 0; i < count; i++) {
+            const clonedRow = sourceRow.clone();
+            this.rows.splice(rowIndex + 1 + i, 0, clonedRow);
+            clonedRow._setParentTable(this);
+            inserted.push(clonedRow);
+        }
+        return inserted;
+    }
 }
 exports.Table = Table;
 //# sourceMappingURL=Table.js.map