docxmlater 10.4.0 → 11.0.4

package/dist/esm/elements/TableRow.js

@@ -0,0 +1,555 @@
+import { deepClone } from '../utils/deepClone.js';
+import { TableCell } from './TableCell.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+import { buildShadingAttributes, } from './CommonTypes.js';
+import { defaultLogger } from '../utils/logger.js';
+export class TableRow {
+    cells = [];
+    formatting;
+    _parentTable;
+    trackingContext;
+    trPrChange;
+    constructor(cellCount, formatting = {}) {
+        this.formatting = formatting;
+        if (cellCount !== undefined && cellCount > 0) {
+            for (let i = 0; i < cellCount; i++) {
+                const cell = new TableCell();
+                cell._setParentRow(this);
+                this.cells.push(cell);
+            }
+        }
+    }
+    _setTrackingContext(context) {
+        this.trackingContext = context;
+    }
+    getTrPrChange() {
+        return this.trPrChange;
+    }
+    setTrPrChange(change) {
+        this.trPrChange = change;
+    }
+    clearTrPrChange() {
+        this.trPrChange = undefined;
+    }
+    getRowInsertion() {
+        return this.formatting.rowInsertion;
+    }
+    setRowInsertion(change) {
+        this.formatting.rowInsertion = change;
+        return this;
+    }
+    getRowDeletion() {
+        return this.formatting.rowDeletion;
+    }
+    setRowDeletion(change) {
+        this.formatting.rowDeletion = change;
+        return this;
+    }
+    addCell(cell) {
+        this.cells.push(cell);
+        cell._setParentRow(this);
+        return this;
+    }
+    createCell(text) {
+        const cell = new TableCell();
+        if (text) {
+            cell.createParagraph(text);
+        }
+        this.cells.push(cell);
+        cell._setParentRow(this);
+        return cell;
+    }
+    getCell(index) {
+        return this.cells[index];
+    }
+    insertCellAt(index, cell) {
+        this.cells.splice(index, 0, cell);
+        cell._setParentRow(this);
+    }
+    removeCellAt(index) {
+        if (index < 0 || index >= this.cells.length)
+            return undefined;
+        const removed = this.cells.splice(index, 1);
+        const cell = removed[0];
+        if (cell)
+            cell._setParentRow(undefined);
+        return cell;
+    }
+    getCells() {
+        return [...this.cells];
+    }
+    getCellCount() {
+        return this.cells.length;
+    }
+    getTotalGridSpan() {
+        let totalSpan = 0;
+        for (const cell of this.cells) {
+            const formatting = cell.getFormatting();
+            totalSpan += formatting.columnSpan || 1;
+        }
+        return totalSpan;
+    }
+    validateGridAlignment(expectedColumns) {
+        const actualSpan = this.getTotalGridSpan();
+        if (actualSpan === expectedColumns) {
+            return { isValid: true, actualSpan };
+        }
+        const message = `Row grid alignment mismatch: has ${actualSpan} grid columns but expected ${expectedColumns}. ` +
+            `Cell count: ${this.cells.length}. ` +
+            (actualSpan < expectedColumns
+                ? 'Missing cells or incorrect columnSpan values.'
+                : 'Extra cells or excessive columnSpan values.');
+        defaultLogger.warn(`[TableRow] ${message}`);
+        return {
+            isValid: false,
+            actualSpan,
+            message,
+        };
+    }
+    setHeight(twips, rule = 'atLeast') {
+        const prevHeight = this.formatting.height;
+        const prevRule = this.formatting.heightRule;
+        this.formatting.height = twips;
+        this.formatting.heightRule = rule;
+        if (this.trackingContext?.isEnabled()) {
+            if (prevHeight !== twips) {
+                this.trackingContext.trackTableChange(this, 'height', prevHeight, twips);
+            }
+            if (prevRule !== rule) {
+                this.trackingContext.trackTableChange(this, 'heightRule', prevRule, rule);
+            }
+        }
+        return this;
+    }
+    setHeightRule(rule) {
+        const prevRule = this.formatting.heightRule;
+        this.formatting.heightRule = rule;
+        if (this.trackingContext?.isEnabled() && prevRule !== rule) {
+            this.trackingContext.trackTableChange(this, 'heightRule', prevRule, rule);
+        }
+        return this;
+    }
+    clearHeight() {
+        delete this.formatting.height;
+        delete this.formatting.heightRule;
+        return this;
+    }
+    setHeader(isHeader = true) {
+        const prev = this.formatting.isHeader;
+        this.formatting.isHeader = isHeader;
+        if (this.trackingContext?.isEnabled() && prev !== isHeader) {
+            this.trackingContext.trackTableChange(this, 'isHeader', prev, isHeader);
+        }
+        return this;
+    }
+    setCantSplit(cantSplit = true) {
+        const prev = this.formatting.cantSplit;
+        this.formatting.cantSplit = cantSplit;
+        if (this.trackingContext?.isEnabled() && prev !== cantSplit) {
+            this.trackingContext.trackTableChange(this, 'cantSplit', prev, cantSplit);
+        }
+        return this;
+    }
+    setJustification(alignment) {
+        const prev = this.formatting.justification;
+        this.formatting.justification = alignment;
+        if (this.trackingContext?.isEnabled() && prev !== alignment) {
+            this.trackingContext.trackTableChange(this, 'justification', prev, alignment);
+        }
+        return this;
+    }
+    setHidden(hidden = true) {
+        const prev = this.formatting.hidden;
+        this.formatting.hidden = hidden;
+        if (this.trackingContext?.isEnabled() && prev !== hidden) {
+            this.trackingContext.trackTableChange(this, 'hidden', prev, hidden);
+        }
+        return this;
+    }
+    setGridBefore(columns) {
+        const prev = this.formatting.gridBefore;
+        this.formatting.gridBefore = columns;
+        if (this.trackingContext?.isEnabled() && prev !== columns) {
+            this.trackingContext.trackTableChange(this, 'gridBefore', prev, columns);
+        }
+        return this;
+    }
+    setGridAfter(columns) {
+        const prev = this.formatting.gridAfter;
+        this.formatting.gridAfter = columns;
+        if (this.trackingContext?.isEnabled() && prev !== columns) {
+            this.trackingContext.trackTableChange(this, 'gridAfter', prev, columns);
+        }
+        return this;
+    }
+    setTablePropertyExceptions(exceptions) {
+        const prev = this.formatting.tablePropertyExceptions;
+        this.formatting.tablePropertyExceptions = exceptions;
+        if (this.trackingContext?.isEnabled() && prev !== exceptions) {
+            this.trackingContext.trackTableChange(this, 'tablePropertyExceptions', prev, exceptions);
+        }
+        return this;
+    }
+    setWBefore(width, type = 'dxa') {
+        const prevWidth = this.formatting.wBefore;
+        const prevType = this.formatting.wBeforeType;
+        this.formatting.wBefore = width;
+        this.formatting.wBeforeType = type;
+        if (this.trackingContext?.isEnabled()) {
+            if (prevWidth !== width) {
+                this.trackingContext.trackTableChange(this, 'wBefore', prevWidth, width);
+            }
+            if (prevType !== type) {
+                this.trackingContext.trackTableChange(this, 'wBeforeType', prevType, type);
+            }
+        }
+        return this;
+    }
+    setWAfter(width, type = 'dxa') {
+        const prevWidth = this.formatting.wAfter;
+        const prevType = this.formatting.wAfterType;
+        this.formatting.wAfter = width;
+        this.formatting.wAfterType = type;
+        if (this.trackingContext?.isEnabled()) {
+            if (prevWidth !== width) {
+                this.trackingContext.trackTableChange(this, 'wAfter', prevWidth, width);
+            }
+            if (prevType !== type) {
+                this.trackingContext.trackTableChange(this, 'wAfterType', prevType, type);
+            }
+        }
+        return this;
+    }
+    setRowCellSpacing(spacing, type = 'dxa') {
+        const prevSpacing = this.formatting.cellSpacing;
+        const prevType = this.formatting.cellSpacingType;
+        this.formatting.cellSpacing = spacing;
+        this.formatting.cellSpacingType = type;
+        if (this.trackingContext?.isEnabled()) {
+            if (prevSpacing !== spacing) {
+                this.trackingContext.trackTableChange(this, 'cellSpacing', prevSpacing, spacing);
+            }
+            if (prevType !== type) {
+                this.trackingContext.trackTableChange(this, 'cellSpacingType', prevType, type);
+            }
+        }
+        return this;
+    }
+    setCnfStyle(cnfStyle) {
+        const prev = this.formatting.cnfStyle;
+        this.formatting.cnfStyle = cnfStyle;
+        if (this.trackingContext?.isEnabled() && prev !== cnfStyle) {
+            this.trackingContext.trackTableChange(this, 'cnfStyle', prev, cnfStyle);
+        }
+        return this;
+    }
+    setDivId(id) {
+        this.formatting.divId = id;
+        return this;
+    }
+    getDivId() {
+        return this.formatting.divId;
+    }
+    getTablePropertyExceptions() {
+        return this.formatting.tablePropertyExceptions;
+    }
+    getFormatting() {
+        return { ...this.formatting };
+    }
+    getHeight() {
+        return this.formatting.height;
+    }
+    getHeightRule() {
+        return this.formatting.heightRule;
+    }
+    getIsHeader() {
+        return this.formatting.isHeader ?? false;
+    }
+    getCantSplit() {
+        return this.formatting.cantSplit ?? false;
+    }
+    getJustification() {
+        return this.formatting.justification;
+    }
+    isHidden() {
+        return this.formatting.hidden ?? false;
+    }
+    _setParentTable(table) {
+        this._parentTable = table;
+    }
+    _getParentTable() {
+        return this._parentTable;
+    }
+    buildTablePropertyExceptionsXML(exceptions) {
+        const children = [];
+        if (exceptions.width !== undefined) {
+            children.push(XMLBuilder.wSelf('tblW', {
+                'w:w': exceptions.width,
+                'w:type': 'dxa',
+            }));
+        }
+        if (exceptions.justification) {
+            const jcMap = { start: 'left', end: 'right' };
+            const jcVal = jcMap[exceptions.justification] || exceptions.justification;
+            children.push(XMLBuilder.wSelf('jc', { 'w:val': jcVal }));
+        }
+        if (exceptions.cellSpacing !== undefined) {
+            children.push(XMLBuilder.wSelf('tblCellSpacing', {
+                'w:w': exceptions.cellSpacing,
+                'w:type': 'dxa',
+            }));
+        }
+        if (exceptions.indentation !== undefined) {
+            children.push(XMLBuilder.wSelf('tblInd', {
+                'w:w': exceptions.indentation,
+                'w:type': 'dxa',
+            }));
+        }
+        if (exceptions.borders) {
+            const borderChildren = this.buildBordersXML(exceptions.borders);
+            if (borderChildren.length > 0) {
+                children.push(XMLBuilder.w('tblBorders', undefined, borderChildren));
+            }
+        }
+        if (exceptions.shading) {
+            const shdAttrs = buildShadingAttributes(exceptions.shading);
+            children.push(XMLBuilder.wSelf('shd', shdAttrs));
+        }
+        return children;
+    }
+    buildBordersXML(borders) {
+        const children = [];
+        const borderNames = [
+            'top',
+            'left',
+            'bottom',
+            'right',
+            'insideH',
+            'insideV',
+        ];
+        for (const name of borderNames) {
+            const border = borders[name];
+            if (border) {
+                const attrs = {};
+                attrs['w:val'] = border.style ?? 'nil';
+                if (border.size !== undefined)
+                    attrs['w:sz'] = border.size;
+                if (border.space !== undefined)
+                    attrs['w:space'] = border.space;
+                if (border.color)
+                    attrs['w:color'] = border.color;
+                const b = border;
+                if (b.themeColor)
+                    attrs['w:themeColor'] = b.themeColor;
+                if (b.themeTint)
+                    attrs['w:themeTint'] = b.themeTint;
+                if (b.themeShade)
+                    attrs['w:themeShade'] = b.themeShade;
+                if (b.shadow !== undefined)
+                    attrs['w:shadow'] = b.shadow ? '1' : '0';
+                if (b.frame !== undefined)
+                    attrs['w:frame'] = b.frame ? '1' : '0';
+                children.push(XMLBuilder.wSelf(name, attrs));
+            }
+        }
+        return children;
+    }
+    toXML() {
+        const trPrChildren = [];
+        if (this.formatting.cnfStyle) {
+            trPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': this.formatting.cnfStyle }));
+        }
+        if (this.formatting.divId !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': this.formatting.divId }));
+        }
+        if (this.formatting.gridBefore !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('gridBefore', { 'w:val': this.formatting.gridBefore }));
+        }
+        if (this.formatting.gridAfter !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('gridAfter', { 'w:val': this.formatting.gridAfter }));
+        }
+        if (this.formatting.wBefore !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('wBefore', {
+                'w:w': this.formatting.wBefore,
+                'w:type': this.formatting.wBeforeType || 'dxa',
+            }));
+        }
+        if (this.formatting.wAfter !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('wAfter', {
+                'w:w': this.formatting.wAfter,
+                'w:type': this.formatting.wAfterType || 'dxa',
+            }));
+        }
+        if (this.formatting.cantSplit !== undefined) {
+            if (this.formatting.cantSplit) {
+                trPrChildren.push(XMLBuilder.wSelf('cantSplit'));
+            }
+            else {
+                trPrChildren.push(XMLBuilder.wSelf('cantSplit', { 'w:val': 'off' }));
+            }
+        }
+        if (this.formatting.height !== undefined) {
+            const attrs = {
+                'w:val': this.formatting.height,
+            };
+            if (this.formatting.heightRule) {
+                attrs['w:hRule'] = this.formatting.heightRule;
+            }
+            trPrChildren.push(XMLBuilder.wSelf('trHeight', attrs));
+        }
+        if (this.formatting.isHeader !== undefined) {
+            if (this.formatting.isHeader) {
+                trPrChildren.push(XMLBuilder.wSelf('tblHeader'));
+            }
+            else {
+                trPrChildren.push(XMLBuilder.wSelf('tblHeader', { 'w:val': 'off' }));
+            }
+        }
+        if (this.formatting.cellSpacing !== undefined) {
+            trPrChildren.push(XMLBuilder.wSelf('tblCellSpacing', {
+                'w:w': this.formatting.cellSpacing,
+                'w:type': this.formatting.cellSpacingType || 'dxa',
+            }));
+        }
+        if (this.formatting.justification) {
+            const jcMap = { start: 'left', end: 'right' };
+            const jcVal = jcMap[this.formatting.justification] || this.formatting.justification;
+            trPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': jcVal }));
+        }
+        if (this.formatting.hidden !== undefined) {
+            if (this.formatting.hidden) {
+                trPrChildren.push(XMLBuilder.wSelf('hidden'));
+            }
+            else {
+                trPrChildren.push(XMLBuilder.wSelf('hidden', { 'w:val': 'false' }));
+            }
+        }
+        if (this.formatting.rowInsertion) {
+            const ins = this.formatting.rowInsertion;
+            trPrChildren.push(XMLBuilder.wSelf('ins', {
+                'w:id': ins.id,
+                'w:author': ins.author,
+                'w:date': ins.date,
+            }));
+        }
+        if (this.formatting.rowDeletion) {
+            const del = this.formatting.rowDeletion;
+            trPrChildren.push(XMLBuilder.wSelf('del', {
+                'w:id': del.id,
+                'w:author': del.author,
+                'w:date': del.date,
+            }));
+        }
+        if (this.trPrChange) {
+            const changeAttrs = {
+                'w:id': this.trPrChange.id,
+                'w:author': this.trPrChange.author,
+                'w:date': this.trPrChange.date,
+            };
+            const prevTrPrChildren = [];
+            const prev = this.trPrChange.previousProperties;
+            if (prev) {
+                if (prev.cnfStyle) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('cnfStyle', { 'w:val': prev.cnfStyle }));
+                }
+                if (prev.divId !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('divId', { 'w:val': prev.divId }));
+                }
+                if (prev.gridBefore !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('gridBefore', { 'w:val': prev.gridBefore }));
+                }
+                if (prev.gridAfter !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('gridAfter', { 'w:val': prev.gridAfter }));
+                }
+                if (prev.wBefore !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('wBefore', {
+                        'w:w': prev.wBefore,
+                        'w:type': prev.wBeforeType || 'dxa',
+                    }));
+                }
+                if (prev.wAfter !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('wAfter', {
+                        'w:w': prev.wAfter,
+                        'w:type': prev.wAfterType || 'dxa',
+                    }));
+                }
+                if (prev.cantSplit !== undefined) {
+                    if (prev.cantSplit) {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('cantSplit'));
+                    }
+                    else {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('cantSplit', { 'w:val': 'off' }));
+                    }
+                }
+                if (prev.height !== undefined) {
+                    const heightAttrs = { 'w:val': prev.height };
+                    if (prev.heightRule)
+                        heightAttrs['w:hRule'] = prev.heightRule;
+                    prevTrPrChildren.push(XMLBuilder.wSelf('trHeight', heightAttrs));
+                }
+                if (prev.isHeader !== undefined) {
+                    if (prev.isHeader) {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('tblHeader'));
+                    }
+                    else {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('tblHeader', { 'w:val': 'off' }));
+                    }
+                }
+                if (prev.cellSpacing !== undefined) {
+                    prevTrPrChildren.push(XMLBuilder.wSelf('tblCellSpacing', {
+                        'w:w': prev.cellSpacing,
+                        'w:type': prev.cellSpacingType || 'dxa',
+                    }));
+                }
+                if (prev.justification) {
+                    const jcPrevMap = { start: 'left', end: 'right' };
+                    prevTrPrChildren.push(XMLBuilder.wSelf('jc', { 'w:val': jcPrevMap[prev.justification] || prev.justification }));
+                }
+                if (prev.hidden !== undefined) {
+                    if (prev.hidden) {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('hidden'));
+                    }
+                    else {
+                        prevTrPrChildren.push(XMLBuilder.wSelf('hidden', { 'w:val': 'false' }));
+                    }
+                }
+            }
+            const prevTrPr = XMLBuilder.w('trPr', undefined, prevTrPrChildren);
+            trPrChildren.push(XMLBuilder.w('trPrChange', changeAttrs, [prevTrPr]));
+        }
+        const rowChildren = [];
+        if (this.formatting.tablePropertyExceptions) {
+            const tblPrExChildren = this.buildTablePropertyExceptionsXML(this.formatting.tablePropertyExceptions);
+            if (tblPrExChildren.length > 0) {
+                rowChildren.push(XMLBuilder.w('tblPrEx', undefined, tblPrExChildren));
+            }
+        }
+        if (trPrChildren.length > 0) {
+            rowChildren.push(XMLBuilder.w('trPr', undefined, trPrChildren));
+        }
+        for (const cell of this.cells) {
+            rowChildren.push(cell.toXML());
+        }
+        return XMLBuilder.w('tr', undefined, rowChildren);
+    }
+    toArray() {
+        return this.cells.map((cell) => cell.getText());
+    }
+    getText(separator = '\t') {
+        return this.cells.map((cell) => cell.getText()).join(separator);
+    }
+    clone() {
+        const clonedRow = new TableRow(0, deepClone(this.formatting));
+        for (const cell of this.cells) {
+            clonedRow.addCell(cell.clone());
+        }
+        if (this.trPrChange) {
+            clonedRow.setTrPrChange(deepClone(this.trPrChange));
+        }
+        return clonedRow;
+    }
+    static create(cellCount, formatting) {
+        return new TableRow(cellCount, formatting);
+    }
+}
+//# sourceMappingURL=TableRow.js.map