docxmlater 1.3.0 → 1.3.2

package/dist/core/Document.js

@@ -46,6 +46,7 @@ const HeaderFooterManager_1 = require("../elements/HeaderFooterManager");
 const TableOfContents_1 = require("../elements/TableOfContents");
 const TableOfContentsElement_1 = require("../elements/TableOfContentsElement");
 const Bookmark_1 = require("../elements/Bookmark");
+const StructuredDocumentTag_1 = require("../elements/StructuredDocumentTag");
 const BookmarkManager_1 = require("../elements/BookmarkManager");
 const Revision_1 = require("../elements/Revision");
 const RevisionManager_1 = require("../elements/RevisionManager");
@@ -221,6 +222,52 @@ class Document {
     getTables() {
         return this.bodyElements.filter((el) => el instanceof Table_1.Table);
     }
+    getAllParagraphs() {
+        const result = [];
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                result.push(element);
+            }
+            else if (element instanceof Table_1.Table) {
+                for (const row of element.getRows()) {
+                    for (const cell of row.getCells()) {
+                        result.push(...cell.getParagraphs());
+                    }
+                }
+            }
+            else if (element instanceof StructuredDocumentTag_1.StructuredDocumentTag) {
+                for (const content of element.getContent()) {
+                    if (content instanceof Paragraph_1.Paragraph) {
+                        result.push(content);
+                    }
+                    else if (content instanceof Table_1.Table) {
+                        for (const row of content.getRows()) {
+                            for (const cell of row.getCells()) {
+                                result.push(...cell.getParagraphs());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    getAllTables() {
+        const result = [];
+        for (const element of this.bodyElements) {
+            if (element instanceof Table_1.Table) {
+                result.push(element);
+            }
+            else if (element instanceof StructuredDocumentTag_1.StructuredDocumentTag) {
+                for (const content of element.getContent()) {
+                    if (content instanceof Table_1.Table) {
+                        result.push(content);
+                    }
+                }
+            }
+        }
+        return result;
+    }
     getTableOfContentsElements() {
         return this.bodyElements.filter((el) => el instanceof TableOfContentsElement_1.TableOfContentsElement);
     }
@@ -598,6 +645,13 @@ class Document {
         }
         return tables.length;
     }
+    applyBordersToAllTables(border) {
+        const tables = this.getAllTables();
+        for (const table of tables) {
+            table.setAllBorders(border);
+        }
+        return tables.length;
+    }
     applyTableFormattingBySize(singleCellShading, multiCellFirstRowShading) {
         const tables = this.getTables();
         let singleCellCount = 0;
@@ -872,6 +926,341 @@ class Document {
     normalizeAllListIndentation() {
         return this.numberingManager.normalizeAllListIndentation();
     }
+    applyStandardListFormatting() {
+        const instances = this.numberingManager.getAllInstances();
+        let count = 0;
+        for (const instance of instances) {
+            const abstractNumId = instance.getAbstractNumId();
+            const abstractNum = this.numberingManager.getAbstractNumbering(abstractNumId);
+            if (!abstractNum)
+                continue;
+            const level0 = abstractNum.getLevel(0);
+            if (!level0 || level0.getFormat() !== 'bullet')
+                continue;
+            for (let levelIndex = 0; levelIndex < 9; levelIndex++) {
+                const numLevel = abstractNum.getLevel(levelIndex);
+                if (!numLevel)
+                    continue;
+                const bullet = levelIndex % 2 === 0 ? '•' : '○';
+                numLevel.setText(bullet);
+                numLevel.setFont('Arial');
+                numLevel.setFontSize(24);
+                numLevel.setLeftIndent(720 * (levelIndex + 1));
+                numLevel.setHangingIndent(360);
+            }
+            this.applyFormattingToListParagraphs(instance.getNumId());
+            count++;
+        }
+        return count;
+    }
+    applyFormattingToListParagraphs(numId) {
+        const paragraphs = this.getAllParagraphs();
+        for (const para of paragraphs) {
+            const numbering = para.getNumbering();
+            if (numbering?.numId === numId) {
+                const runs = para.getRuns();
+                for (const run of runs) {
+                    run.setFont('Verdana', 12);
+                }
+                para.setSpaceBefore(0);
+                para.setSpaceAfter(60);
+                para.setContextualSpacing(true);
+                para.formatting.indentation = undefined;
+            }
+        }
+    }
+    isParagraphInTable(para) {
+        const allTables = this.getAllTables();
+        for (const table of allTables) {
+            for (const row of table.getRows()) {
+                for (const cell of row.getCells()) {
+                    const cellParas = cell.getParagraphs();
+                    for (const cellPara of cellParas) {
+                        if (cellPara === para) {
+                            return { inTable: true, cell };
+                        }
+                    }
+                }
+            }
+        }
+        return { inTable: false };
+    }
+    wrapParagraphInTable(para, options) {
+        const paraIndex = this.bodyElements.indexOf(para);
+        if (paraIndex === -1) {
+            throw new Error('Paragraph not found in document body elements');
+        }
+        const table = new Table_1.Table(1, 1);
+        const cell = table.getCell(0, 0);
+        if (!cell) {
+            throw new Error('Failed to get cell from newly created table');
+        }
+        this.bodyElements.splice(paraIndex, 1);
+        cell.addParagraph(para);
+        if (options.shading) {
+            cell.setShading({ fill: options.shading });
+        }
+        if (options.marginTop !== undefined || options.marginBottom !== undefined ||
+            options.marginLeft !== undefined || options.marginRight !== undefined) {
+            cell.setMargins({
+                top: options.marginTop ?? 100,
+                bottom: options.marginBottom ?? 100,
+                left: options.marginLeft ?? 100,
+                right: options.marginRight ?? 100
+            });
+        }
+        if (options.tableWidthPercent !== undefined) {
+            table.setWidth(options.tableWidthPercent);
+            table.setWidthType('pct');
+        }
+        this.bodyElements.splice(paraIndex, 0, table);
+        return table;
+    }
+    applyCustomStylesToDocument() {
+        const counts = { heading1: 0, heading2: 0, normal: 0 };
+        const header1Style = Style_1.Style.create({
+            styleId: 'CustomHeader1',
+            name: 'Custom Header 1',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            runFormatting: {
+                font: 'Verdana',
+                size: 18,
+                bold: true,
+                color: '000000'
+            },
+            paragraphFormatting: {
+                alignment: 'left',
+                spacing: {
+                    before: 0,
+                    after: 240
+                }
+            }
+        });
+        const header2Style = Style_1.Style.create({
+            styleId: 'CustomHeader2',
+            name: 'Custom Header 2',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            runFormatting: {
+                font: 'Verdana',
+                size: 14,
+                bold: true,
+                color: '000000'
+            },
+            paragraphFormatting: {
+                alignment: 'left',
+                spacing: {
+                    before: 120,
+                    after: 120
+                }
+            }
+        });
+        const normalStyle = Style_1.Style.create({
+            styleId: 'CustomNormal',
+            name: 'Custom Normal',
+            type: 'paragraph',
+            basedOn: 'Normal',
+            runFormatting: {
+                font: 'Verdana',
+                size: 12,
+                color: '000000'
+            },
+            paragraphFormatting: {
+                alignment: 'left',
+                spacing: {
+                    before: 60,
+                    after: 60
+                }
+            }
+        });
+        this.addStyle(header1Style);
+        this.addStyle(header2Style);
+        this.addStyle(normalStyle);
+        const allParagraphs = this.getAllParagraphs();
+        for (const para of allParagraphs) {
+            const currentStyle = para.getStyle();
+            if (currentStyle === 'Heading1' || currentStyle === 'Heading 1') {
+                para.setStyle('CustomHeader1');
+                counts.heading1++;
+            }
+            else if (currentStyle === 'Heading2' || currentStyle === 'Heading 2') {
+                para.setStyle('CustomHeader2');
+                const { inTable, cell } = this.isParagraphInTable(para);
+                if (inTable && cell) {
+                    cell.setShading({ fill: 'BFBFBF' });
+                    cell.setMargins({ top: 0, bottom: 0, left: 101, right: 101 });
+                    const table = this.getAllTables().find(t => {
+                        for (const row of t.getRows()) {
+                            for (const c of row.getCells()) {
+                                if (c === cell)
+                                    return true;
+                            }
+                        }
+                        return false;
+                    });
+                    if (table) {
+                        table.setWidth(5000);
+                        table.setWidthType('pct');
+                    }
+                }
+                else {
+                    this.wrapParagraphInTable(para, {
+                        shading: 'BFBFBF',
+                        marginTop: 0,
+                        marginBottom: 0,
+                        marginLeft: 101,
+                        marginRight: 101,
+                        tableWidthPercent: 5000
+                    });
+                }
+                counts.heading2++;
+            }
+            else if (currentStyle === 'Normal' || currentStyle === undefined) {
+                para.setStyle('CustomNormal');
+                counts.normal++;
+            }
+        }
+        return counts;
+    }
+    applyCustomFormattingToExistingStyles() {
+        const results = { heading1: false, heading2: false, normal: false };
+        const heading1 = this.stylesManager.getStyle('Heading1');
+        const heading2 = this.stylesManager.getStyle('Heading2');
+        const normal = this.stylesManager.getStyle('Normal');
+        if (heading1) {
+            heading1.setRunFormatting({
+                font: 'Verdana',
+                size: 18,
+                bold: true,
+                color: '000000'
+            });
+            heading1.setParagraphFormatting({
+                alignment: 'left',
+                spacing: { before: 0, after: 240, line: 240, lineRule: 'auto' }
+            });
+            results.heading1 = true;
+        }
+        if (heading2) {
+            heading2.setRunFormatting({
+                font: 'Verdana',
+                size: 14,
+                bold: true,
+                color: '000000'
+            });
+            heading2.setParagraphFormatting({
+                alignment: 'left',
+                spacing: { before: 120, after: 120, line: 240, lineRule: 'auto' }
+            });
+            results.heading2 = true;
+        }
+        if (normal) {
+            normal.setRunFormatting({
+                font: 'Verdana',
+                size: 12,
+                color: '000000'
+            });
+            normal.setParagraphFormatting({
+                alignment: 'left',
+                spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' }
+            });
+            results.normal = true;
+        }
+        const processedParagraphs = new Set();
+        const allParas = this.getAllParagraphs();
+        for (const para of allParas) {
+            if (processedParagraphs.has(para)) {
+                continue;
+            }
+            const styleId = para.getStyle();
+            if (styleId === 'Heading1' && heading1) {
+                para.clearDirectFormattingConflicts(heading1);
+                for (const run of para.getRuns()) {
+                    run.setItalic(false);
+                    run.setUnderline(false);
+                }
+                if (para.formatting.paragraphMarkRunProperties) {
+                    delete para.formatting.paragraphMarkRunProperties.italic;
+                    delete para.formatting.paragraphMarkRunProperties.underline;
+                }
+                processedParagraphs.add(para);
+            }
+            else if (styleId === 'Heading2' && heading2) {
+                const hasContent = para.getRuns().some(run => run.getText().trim().length > 0);
+                if (!hasContent) {
+                    processedParagraphs.add(para);
+                    continue;
+                }
+                para.clearDirectFormattingConflicts(heading2);
+                for (const run of para.getRuns()) {
+                    run.setItalic(false);
+                    run.setUnderline(false);
+                }
+                if (para.formatting.paragraphMarkRunProperties) {
+                    delete para.formatting.paragraphMarkRunProperties.italic;
+                    delete para.formatting.paragraphMarkRunProperties.underline;
+                }
+                const { inTable, cell } = this.isParagraphInTable(para);
+                if (inTable && cell) {
+                    cell.setShading({ fill: 'BFBFBF' });
+                    cell.setMargins({ top: 0, bottom: 0, left: 101, right: 101 });
+                    const table = this.getAllTables().find(t => {
+                        for (const row of t.getRows()) {
+                            for (const c of row.getCells()) {
+                                if (c === cell)
+                                    return true;
+                            }
+                        }
+                        return false;
+                    });
+                    if (table) {
+                        table.setWidth(5000);
+                        table.setWidthType('pct');
+                    }
+                }
+                else {
+                    this.wrapParagraphInTable(para, {
+                        shading: 'BFBFBF',
+                        marginTop: 0,
+                        marginBottom: 0,
+                        marginLeft: 101,
+                        marginRight: 101,
+                        tableWidthPercent: 5000
+                    });
+                }
+                processedParagraphs.add(para);
+            }
+            else if ((styleId === 'Normal' || styleId === undefined) && normal) {
+                para.clearDirectFormattingConflicts(normal);
+                for (const run of para.getRuns()) {
+                    run.setItalic(false);
+                    run.setUnderline(false);
+                }
+                if (para.formatting.paragraphMarkRunProperties) {
+                    delete para.formatting.paragraphMarkRunProperties.italic;
+                    delete para.formatting.paragraphMarkRunProperties.underline;
+                }
+                processedParagraphs.add(para);
+            }
+        }
+        const hyperlinks = this.getHyperlinks();
+        for (const { hyperlink, paragraph } of hyperlinks) {
+            const text = hyperlink.getText().trim();
+            if (text === 'Top of the Document' || text === 'Top of Document') {
+                paragraph.setAlignment('right');
+                paragraph.setSpaceBefore(0);
+                paragraph.setSpaceAfter(0);
+            }
+        }
+        this.updateAllHyperlinkColors('0000FF');
+        const tocElements = this.getTableOfContentsElements();
+        for (const tocElement of tocElements) {
+            const toc = tocElement.getTableOfContents();
+            toc.setShowPageNumbers(false);
+            toc.setHideInWebLayout(true);
+        }
+        return results;
+    }
     getSection() {
         return this.section;
     }
@@ -1676,33 +2065,80 @@ class Document {
         }
         return false;
     }
-    insertParagraphAt(index, paragraph) {
+    validateParagraph(paragraph) {
+        if (!(paragraph instanceof Paragraph_1.Paragraph)) {
+            throw new Error('insertParagraphAt: parameter must be a Paragraph instance');
+        }
+        const paraId = paragraph.getFormatting().paraId;
+        if (paraId) {
+            const existingIds = this.bodyElements
+                .filter((el) => el instanceof Paragraph_1.Paragraph)
+                .map(p => p.getFormatting().paraId)
+                .filter(id => id === paraId);
+            if (existingIds.length > 0) {
+                throw new Error(`Duplicate paragraph ID detected: ${paraId}. Each paragraph must have a unique ID.`);
+            }
+        }
+        const style = paragraph.getFormatting().style;
+        if (style && !this.stylesManager.hasStyle(style)) {
+            console.warn(`Style "${style}" not found in document. Paragraph will fall back to Normal style.`);
+        }
+        const numbering = paragraph.getFormatting().numbering;
+        if (numbering && !this.numberingManager.hasInstance(numbering.numId)) {
+            console.warn(`Numbering ID ${numbering.numId} not found in document. List formatting will not display.`);
+        }
+    }
+    validateTable(table) {
+        if (!(table instanceof Table_1.Table)) {
+            throw new Error('insertTableAt: parameter must be a Table instance');
+        }
+        const rows = table.getRows();
+        if (rows.length === 0) {
+            throw new Error('insertTableAt: table must have at least one row');
+        }
+        const firstRow = rows[0];
+        if (firstRow && firstRow.getCells().length === 0) {
+            throw new Error('insertTableAt: table rows must have at least one cell');
+        }
+        const tableStyle = table.getFormatting().style;
+        if (tableStyle && !this.stylesManager.hasStyle(tableStyle)) {
+            console.warn(`Table style "${tableStyle}" not found in document. Table will use default formatting.`);
+        }
+    }
+    validateToc(toc) {
+        if (!(toc instanceof TableOfContentsElement_1.TableOfContentsElement)) {
+            throw new Error('insertTocAt: parameter must be a TableOfContentsElement instance');
+        }
+        const hasHeadings = ['Heading1', 'Heading2', 'Heading3', 'Heading4', 'Heading5', 'Heading6', 'Heading7', 'Heading8', 'Heading9']
+            .some(style => this.stylesManager.hasStyle(style));
+        if (!hasHeadings) {
+            console.warn('No heading styles found in document. Table of Contents may not display entries correctly.');
+        }
+    }
+    normalizeIndex(index) {
         if (index < 0) {
-            index = 0;
+            return 0;
         }
         else if (index > this.bodyElements.length) {
-            index = this.bodyElements.length;
+            return this.bodyElements.length;
         }
+        return index;
+    }
+    insertParagraphAt(index, paragraph) {
+        this.validateParagraph(paragraph);
+        index = this.normalizeIndex(index);
         this.bodyElements.splice(index, 0, paragraph);
         return this;
     }
     insertTableAt(index, table) {
-        if (index < 0) {
-            index = 0;
-        }
-        else if (index > this.bodyElements.length) {
-            index = this.bodyElements.length;
-        }
+        this.validateTable(table);
+        index = this.normalizeIndex(index);
         this.bodyElements.splice(index, 0, table);
         return this;
     }
     insertTocAt(index, toc) {
-        if (index < 0) {
-            index = 0;
-        }
-        else if (index > this.bodyElements.length) {
-            index = this.bodyElements.length;
-        }
+        this.validateToc(toc);
+        index = this.normalizeIndex(index);
         this.bodyElements.splice(index, 0, toc);
         return this;
     }
@@ -1710,6 +2146,7 @@ class Document {
         if (index >= 0 && index < this.bodyElements.length) {
             const element = this.bodyElements[index];
             if (element instanceof Paragraph_1.Paragraph) {
+                this.validateParagraph(paragraph);
                 this.bodyElements[index] = paragraph;
                 return true;
             }
@@ -1720,6 +2157,7 @@ class Document {
         if (index >= 0 && index < this.bodyElements.length) {
             const element = this.bodyElements[index];
             if (element instanceof Table_1.Table) {
+                this.validateTable(table);
                 this.bodyElements[index] = table;
                 return true;
             }