docxmlater 0.5.0 → 0.7.0

package/dist/core/Document.js

@@ -38,6 +38,7 @@ const ZipHandler_1 = require("../zip/ZipHandler");
 const types_1 = require("../zip/types");
 const Paragraph_1 = require("../elements/Paragraph");
 const Table_1 = require("../elements/Table");
+const TableCell_1 = require("../elements/TableCell");
 const Section_1 = require("../elements/Section");
 const ImageManager_1 = require("../elements/ImageManager");
 const HeaderFooterManager_1 = require("../elements/HeaderFooterManager");
@@ -47,15 +48,19 @@ const BookmarkManager_1 = require("../elements/BookmarkManager");
 const Revision_1 = require("../elements/Revision");
 const RevisionManager_1 = require("../elements/RevisionManager");
 const CommentManager_1 = require("../elements/CommentManager");
+const FootnoteManager_1 = require("../elements/FootnoteManager");
+const EndnoteManager_1 = require("../elements/EndnoteManager");
 const Run_1 = require("../elements/Run");
 const Hyperlink_1 = require("../elements/Hyperlink");
 const StylesManager_1 = require("../formatting/StylesManager");
+const Style_1 = require("../formatting/Style");
 const NumberingManager_1 = require("../formatting/NumberingManager");
 const RelationshipManager_1 = require("./RelationshipManager");
 const DocumentParser_1 = require("./DocumentParser");
 const DocumentGenerator_1 = require("./DocumentGenerator");
 const DocumentValidator_1 = require("./DocumentValidator");
 class ImageRun extends Run_1.Run {
+    imageElement;
     constructor(image) {
         super('');
         this.imageElement = image;
@@ -69,8 +74,24 @@ class ImageRun extends Run_1.Run {
     }
 }
 class Document {
+    zipHandler;
+    bodyElements = [];
+    properties;
+    stylesManager;
+    numberingManager;
+    section;
+    imageManager;
+    relationshipManager;
+    headerFooterManager;
+    bookmarkManager;
+    revisionManager;
+    commentManager;
+    _footnoteManager;
+    _endnoteManager;
+    parser;
+    generator;
+    validator;
     constructor(zipHandler, options = {}, initDefaults = true) {
-        this.bodyElements = [];
         this.zipHandler = zipHandler || new ZipHandler_1.ZipHandler();
         const strictParsing = options.strictParsing ?? false;
         const memoryPercent = options.maxMemoryUsagePercent ?? 80;
@@ -95,6 +116,8 @@ class Document {
         this.bookmarkManager = BookmarkManager_1.BookmarkManager.create();
         this.revisionManager = RevisionManager_1.RevisionManager.create();
         this.commentManager = CommentManager_1.CommentManager.create();
+        this._footnoteManager = FootnoteManager_1.FootnoteManager.create();
+        this._endnoteManager = EndnoteManager_1.EndnoteManager.create();
         if (initDefaults) {
             this.relationshipManager.addStyles();
             this.relationshipManager.addNumbering();
@@ -284,6 +307,7 @@ class Document {
     }
     addStyle(style) {
         this.stylesManager.addStyle(style);
+        this.updateStylesXml();
         return this;
     }
     getStyle(styleId) {
@@ -292,6 +316,31 @@ class Document {
     hasStyle(styleId) {
         return this.stylesManager.hasStyle(styleId);
     }
+    getStyles() {
+        return this.stylesManager.getAllStyles();
+    }
+    removeStyle(styleId) {
+        return this.stylesManager.removeStyle(styleId);
+    }
+    updateStyle(styleId, properties) {
+        const style = this.stylesManager.getStyle(styleId);
+        if (!style) {
+            return false;
+        }
+        const currentProps = style.getProperties();
+        const updatedProps = { ...currentProps, ...properties, styleId };
+        const updatedStyle = Style_1.Style.create(updatedProps);
+        this.stylesManager.addStyle(updatedStyle);
+        return true;
+    }
+    getStylesXml() {
+        const stylesFile = this.zipHandler.getFileAsString(types_1.DOCX_PATHS.STYLES);
+        return stylesFile || this.stylesManager.generateStylesXml();
+    }
+    setStylesXml(xml) {
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.STYLES, xml);
+        this.stylesManager.clear();
+    }
     getZipHandler() {
         return this.zipHandler;
     }
@@ -555,13 +604,20 @@ class Document {
                     const currentUrl = content.getUrl();
                     if (currentUrl && urlMap.has(currentUrl)) {
                         const newUrl = urlMap.get(currentUrl);
-                        updates.push({ hyperlink: content, newUrl });
+                        updates.push({
+                            hyperlink: content,
+                            newUrl,
+                            relationshipId: content.getRelationshipId()
+                        });
                     }
                 }
             }
         }
-        for (const { hyperlink, newUrl } of updates) {
+        for (const { hyperlink, newUrl, relationshipId } of updates) {
             hyperlink.setUrl(newUrl);
+            if (relationshipId) {
+                this.relationshipManager.updateHyperlinkTarget(relationshipId, newUrl);
+            }
         }
         return updates.length;
     }
@@ -584,6 +640,484 @@ class Document {
     getSizeStats() {
         return this.validator.getSizeStats(this.bodyElements, this.imageManager);
     }
+    async getPart(partName) {
+        try {
+            const file = this.zipHandler.getFile(partName);
+            if (!file) {
+                return null;
+            }
+            return {
+                name: partName,
+                content: file.content,
+                contentType: this.getContentTypeForPart(partName),
+                isBinary: file.isBinary,
+                size: file.size,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async setPart(partName, content) {
+        const isBinary = Buffer.isBuffer(content);
+        this.zipHandler.addFile(partName, content, { binary: isBinary });
+    }
+    async removePart(partName) {
+        return this.zipHandler.removeFile(partName);
+    }
+    async listParts() {
+        return this.zipHandler.getFilePaths();
+    }
+    async partExists(partName) {
+        return this.zipHandler.hasFile(partName);
+    }
+    async getContentTypes() {
+        const contentTypes = new Map();
+        try {
+            const contentTypesXml = this.zipHandler.getFileAsString('[Content_Types].xml');
+            if (!contentTypesXml) {
+                return contentTypes;
+            }
+            const defaultPattern = /<Default\s+Extension="([^"]+)"\s+ContentType="([^"]+)"/g;
+            let match;
+            while ((match = defaultPattern.exec(contentTypesXml)) !== null) {
+                if (match[1] && match[2]) {
+                    contentTypes.set(`.${match[1]}`, match[2]);
+                }
+            }
+            const overridePattern = /<Override\s+PartName="([^"]+)"\s+ContentType="([^"]+)"/g;
+            while ((match = overridePattern.exec(contentTypesXml)) !== null) {
+                if (match[1] && match[2]) {
+                    contentTypes.set(match[1], match[2]);
+                }
+            }
+        }
+        catch (error) {
+        }
+        return contentTypes;
+    }
+    async addContentType(partNameOrExtension, contentType) {
+        try {
+            let contentTypesXml = this.zipHandler.getFileAsString('[Content_Types].xml');
+            if (!contentTypesXml) {
+                return false;
+            }
+            const isExtension = partNameOrExtension.startsWith('.');
+            if (isExtension) {
+                const extension = partNameOrExtension.substring(1);
+                const existingPattern = new RegExp(`<Default\\s+Extension="${extension}"\\s+ContentType="[^"]+"/?>`, 'g');
+                if (existingPattern.test(contentTypesXml)) {
+                    contentTypesXml = contentTypesXml.replace(existingPattern, `<Default Extension="${extension}" ContentType="${contentType}"/>`);
+                }
+                else {
+                    contentTypesXml = contentTypesXml.replace('</Types>', `  <Default Extension="${extension}" ContentType="${contentType}"/>\n</Types>`);
+                }
+            }
+            else {
+                const partName = partNameOrExtension.startsWith('/') ? partNameOrExtension : `/${partNameOrExtension}`;
+                const existingPattern = new RegExp(`<Override\\s+PartName="${partName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\s+ContentType="[^"]+"/?>`, 'g');
+                if (existingPattern.test(contentTypesXml)) {
+                    contentTypesXml = contentTypesXml.replace(existingPattern, `<Override PartName="${partName}" ContentType="${contentType}"/>`);
+                }
+                else {
+                    contentTypesXml = contentTypesXml.replace('</Types>', `  <Override PartName="${partName}" ContentType="${contentType}"/>\n</Types>`);
+                }
+            }
+            this.zipHandler.updateFile('[Content_Types].xml', contentTypesXml);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getAllRelationships() {
+        const relationships = new Map();
+        try {
+            const relsPaths = this.zipHandler.getFilePaths().filter(path => path.endsWith('.rels'));
+            for (const relsPath of relsPaths) {
+                const relsContent = this.zipHandler.getFileAsString(relsPath);
+                if (relsContent) {
+                    const rels = [];
+                    const relPattern = /<Relationship\s+([^>]+)\/>/g;
+                    let match;
+                    while ((match = relPattern.exec(relsContent)) !== null) {
+                        const attrs = match[1];
+                        if (!attrs)
+                            continue;
+                        const rel = {};
+                        const idMatch = attrs.match(/Id="([^"]+)"/);
+                        const typeMatch = attrs.match(/Type="([^"]+)"/);
+                        const targetMatch = attrs.match(/Target="([^"]+)"/);
+                        const modeMatch = attrs.match(/TargetMode="([^"]+)"/);
+                        if (idMatch)
+                            rel.id = idMatch[1];
+                        if (typeMatch)
+                            rel.type = typeMatch[1];
+                        if (targetMatch)
+                            rel.target = targetMatch[1];
+                        if (modeMatch)
+                            rel.targetMode = modeMatch[1];
+                        rels.push(rel);
+                    }
+                    relationships.set(relsPath, rels);
+                }
+            }
+        }
+        catch (error) {
+        }
+        return relationships;
+    }
+    getContentTypeForPart(partName) {
+        try {
+            const contentTypesXml = this.zipHandler.getFileAsString('[Content_Types].xml');
+            if (!contentTypesXml) {
+                return undefined;
+            }
+            const overridePattern = new RegExp(`<Override\\s+PartName="${partName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\s+ContentType="([^"]+)"`, 'i');
+            const overrideMatch = contentTypesXml.match(overridePattern);
+            if (overrideMatch) {
+                return overrideMatch[1];
+            }
+            const ext = partName.substring(partName.lastIndexOf('.'));
+            if (ext) {
+                const defaultPattern = new RegExp(`<Default\\s+Extension="${ext.substring(1)}"\\s+ContentType="([^"]+)"`, 'i');
+                const defaultMatch = contentTypesXml.match(defaultPattern);
+                if (defaultMatch) {
+                    return defaultMatch[1];
+                }
+            }
+        }
+        catch (error) {
+        }
+        return undefined;
+    }
+    findText(text, options) {
+        const results = [];
+        const caseSensitive = options?.caseSensitive ?? false;
+        const wholeWord = options?.wholeWord ?? false;
+        const searchText = caseSensitive ? text : text.toLowerCase();
+        const paragraphs = this.getParagraphs();
+        for (let pIndex = 0; pIndex < paragraphs.length; pIndex++) {
+            const paragraph = paragraphs[pIndex];
+            if (!paragraph)
+                continue;
+            const runs = paragraph.getRuns();
+            for (let rIndex = 0; rIndex < runs.length; rIndex++) {
+                const run = runs[rIndex];
+                if (!run)
+                    continue;
+                const runText = run.getText();
+                const compareText = caseSensitive ? runText : runText.toLowerCase();
+                if (wholeWord) {
+                    const wordPattern = new RegExp(`\\b${searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, caseSensitive ? 'g' : 'gi');
+                    let match;
+                    while ((match = wordPattern.exec(runText)) !== null) {
+                        results.push({
+                            paragraph,
+                            paragraphIndex: pIndex,
+                            run,
+                            runIndex: rIndex,
+                            text: match[0],
+                            startIndex: match.index,
+                        });
+                    }
+                }
+                else {
+                    let startIndex = 0;
+                    while ((startIndex = compareText.indexOf(searchText, startIndex)) !== -1) {
+                        results.push({
+                            paragraph,
+                            paragraphIndex: pIndex,
+                            run,
+                            runIndex: rIndex,
+                            text: runText.substr(startIndex, text.length),
+                            startIndex,
+                        });
+                        startIndex += text.length;
+                    }
+                }
+            }
+        }
+        for (const table of this.getTables()) {
+            for (const row of table.getRows()) {
+                for (const cell of row.getCells()) {
+                    if (cell instanceof TableCell_1.TableCell) {
+                        const cellParagraphs = cell.getParagraphs();
+                        for (let pIndex = 0; pIndex < cellParagraphs.length; pIndex++) {
+                            const paragraph = cellParagraphs[pIndex];
+                            if (!paragraph)
+                                continue;
+                            const runs = paragraph.getRuns();
+                            for (let rIndex = 0; rIndex < runs.length; rIndex++) {
+                                const run = runs[rIndex];
+                                if (!run)
+                                    continue;
+                                const runText = run.getText();
+                                const compareText = caseSensitive ? runText : runText.toLowerCase();
+                                if (wholeWord) {
+                                    const wordPattern = new RegExp(`\\b${searchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, caseSensitive ? 'g' : 'gi');
+                                    let match;
+                                    while ((match = wordPattern.exec(runText)) !== null) {
+                                        results.push({
+                                            paragraph,
+                                            paragraphIndex: -1,
+                                            run,
+                                            runIndex: rIndex,
+                                            text: match[0],
+                                            startIndex: match.index,
+                                        });
+                                    }
+                                }
+                                else {
+                                    let startIndex = 0;
+                                    while ((startIndex = compareText.indexOf(searchText, startIndex)) !== -1) {
+                                        results.push({
+                                            paragraph,
+                                            paragraphIndex: -1,
+                                            run,
+                                            runIndex: rIndex,
+                                            text: runText.substr(startIndex, text.length),
+                                            startIndex,
+                                        });
+                                        startIndex += text.length;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    replaceText(find, replace, options) {
+        let replacementCount = 0;
+        const caseSensitive = options?.caseSensitive ?? false;
+        const wholeWord = options?.wholeWord ?? false;
+        const paragraphs = this.getParagraphs();
+        for (const paragraph of paragraphs) {
+            const runs = paragraph.getRuns();
+            for (const run of runs) {
+                const originalText = run.getText();
+                let newText = originalText;
+                if (wholeWord) {
+                    const wordPattern = new RegExp(`\\b${find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, caseSensitive ? 'g' : 'gi');
+                    const matches = originalText.match(wordPattern);
+                    if (matches) {
+                        replacementCount += matches.length;
+                        newText = originalText.replace(wordPattern, replace);
+                    }
+                }
+                else {
+                    const searchPattern = new RegExp(find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), caseSensitive ? 'g' : 'gi');
+                    const matches = originalText.match(searchPattern);
+                    if (matches) {
+                        replacementCount += matches.length;
+                        newText = originalText.replace(searchPattern, replace);
+                    }
+                }
+                if (newText !== originalText) {
+                    run.setText(newText);
+                }
+            }
+        }
+        return replacementCount;
+    }
+    getWordCount() {
+        let totalWords = 0;
+        const paragraphs = this.getParagraphs();
+        for (const paragraph of paragraphs) {
+            const text = paragraph.getText().trim();
+            if (text) {
+                const words = text.split(/\s+/).filter(word => word.length > 0);
+                totalWords += words.length;
+            }
+        }
+        const tables = this.getTables();
+        for (const table of tables) {
+            const rows = table.getRows();
+            for (const row of rows) {
+                const cells = row.getCells();
+                for (const cell of cells) {
+                    const cellParas = cell.getParagraphs();
+                    for (const para of cellParas) {
+                        const text = para.getText().trim();
+                        if (text) {
+                            const words = text.split(/\s+/).filter(word => word.length > 0);
+                            totalWords += words.length;
+                        }
+                    }
+                }
+            }
+        }
+        return totalWords;
+    }
+    getCharacterCount(includeSpaces = true) {
+        let totalChars = 0;
+        const paragraphs = this.getParagraphs();
+        for (const paragraph of paragraphs) {
+            const text = paragraph.getText();
+            if (includeSpaces) {
+                totalChars += text.length;
+            }
+            else {
+                totalChars += text.replace(/\s/g, '').length;
+            }
+        }
+        const tables = this.getTables();
+        for (const table of tables) {
+            const rows = table.getRows();
+            for (const row of rows) {
+                const cells = row.getCells();
+                for (const cell of cells) {
+                    const cellParas = cell.getParagraphs();
+                    for (const para of cellParas) {
+                        const text = para.getText();
+                        if (includeSpaces) {
+                            totalChars += text.length;
+                        }
+                        else {
+                            totalChars += text.replace(/\s/g, '').length;
+                        }
+                    }
+                }
+            }
+        }
+        return totalChars;
+    }
+    removeParagraph(paragraphOrIndex) {
+        let index;
+        if (typeof paragraphOrIndex === 'number') {
+            index = paragraphOrIndex;
+        }
+        else {
+            index = this.bodyElements.indexOf(paragraphOrIndex);
+        }
+        if (index >= 0 && index < this.bodyElements.length) {
+            const element = this.bodyElements[index];
+            if (element instanceof Paragraph_1.Paragraph) {
+                this.bodyElements.splice(index, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    removeTable(tableOrIndex) {
+        let index;
+        if (typeof tableOrIndex === 'number') {
+            const tables = this.getTables();
+            if (tableOrIndex >= 0 && tableOrIndex < tables.length) {
+                const table = tables[tableOrIndex];
+                if (!table)
+                    return false;
+                index = this.bodyElements.indexOf(table);
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            index = this.bodyElements.indexOf(tableOrIndex);
+        }
+        if (index >= 0 && index < this.bodyElements.length) {
+            const element = this.bodyElements[index];
+            if (element instanceof Table_1.Table) {
+                this.bodyElements.splice(index, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    insertParagraphAt(index, paragraph) {
+        if (index < 0) {
+            index = 0;
+        }
+        else if (index > this.bodyElements.length) {
+            index = this.bodyElements.length;
+        }
+        this.bodyElements.splice(index, 0, paragraph);
+        return this;
+    }
+    getHyperlinks() {
+        const hyperlinks = [];
+        for (const paragraph of this.getParagraphs()) {
+            for (const content of paragraph.getContent()) {
+                if (content instanceof Hyperlink_1.Hyperlink) {
+                    hyperlinks.push({ hyperlink: content, paragraph });
+                }
+            }
+        }
+        for (const table of this.getTables()) {
+            for (const row of table.getRows()) {
+                for (const cell of row.getCells()) {
+                    const cellParagraphs = cell.getParagraphs?.() || [];
+                    for (const para of cellParagraphs) {
+                        for (const content of para.getContent()) {
+                            if (content instanceof Hyperlink_1.Hyperlink) {
+                                hyperlinks.push({ hyperlink: content, paragraph: para });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return hyperlinks;
+    }
+    getBookmarks() {
+        const bookmarks = [];
+        for (const paragraph of this.getParagraphs()) {
+            for (const bookmark of paragraph.getBookmarksStart()) {
+                bookmarks.push({ bookmark, paragraph });
+            }
+        }
+        for (const table of this.getTables()) {
+            for (const row of table.getRows()) {
+                for (const cell of row.getCells()) {
+                    for (const para of cell.getParagraphs()) {
+                        for (const bookmark of para.getBookmarksStart()) {
+                            bookmarks.push({ bookmark, paragraph: para });
+                        }
+                    }
+                }
+            }
+        }
+        return bookmarks;
+    }
+    getImages() {
+        return this.imageManager.getAllImages();
+    }
+    setLanguage(language) {
+        if (!this.properties) {
+            this.properties = {};
+        }
+        this.properties.language = language;
+        this.stylesManager.setDefaultLanguage?.(language);
+        return this;
+    }
+    getLanguage() {
+        return this.properties?.language;
+    }
+    static createEmpty() {
+        const doc = new Document(undefined, {}, false);
+        const zipHandler = doc.getZipHandler();
+        zipHandler.addFile('[Content_Types].xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">\n' +
+            '  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>\n' +
+            '  <Default Extension="xml" ContentType="application/xml"/>\n' +
+            '  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>\n' +
+            '</Types>');
+        zipHandler.addFile('_rels/.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n' +
+            '  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>\n' +
+            '</Relationships>');
+        zipHandler.addFile('word/document.xml', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">\n' +
+            '  <w:body/>\n' +
+            '</w:document>');
+        zipHandler.addFile('word/_rels/document.xml.rels', '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>');
+        return doc;
+    }
 }
 exports.Document = Document;
 //# sourceMappingURL=Document.js.map