@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/docx/comments.js

@@ -0,0 +1,165 @@
+import {escapeText} from "../../common/index.js"
+import {descendantNodes} from "../tools/doc_content.js"
+
+const DEFAULT_COMMENTS_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    <w:comments xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" mc:Ignorable="w14 wp14 w15">
+    </w:comments>`
+
+const DEFAULT_COMMENTS_EXTENDED_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    <w15:commentsEx xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" mc:Ignorable="w15">
+    </w15:commentsEx>`
+
+export class DOCXExporterComments {
+    constructor(docContent, commentsDB, xml, rels, richtext) {
+        this.docContent = docContent
+        this.commentsDB = commentsDB
+        this.xml = xml
+        this.rels = rels
+        this.richtext = richtext
+
+        this.usedComments = []
+        this.commentsXML = false
+        this.commentsExtendedXML = false
+        this.commentsFilePath = "word/comments.xml"
+        this.commentsExtendedFilePath = "word/commentsExtended.xml"
+        this.commentIdCounter = -1
+    }
+
+    init() {
+        let useExtended = false
+        descendantNodes(this.docContent).forEach(node => {
+            if (node.marks) {
+                const comments = node.marks.filter(
+                    mark => mark.type === "comment"
+                )
+                comments.forEach(comment => {
+                    if (
+                        !this.usedComments.includes(comment.attrs.id) &&
+                        this.commentsDB[comment.attrs.id]
+                    ) {
+                        this.usedComments.push(comment.attrs.id)
+                        if (
+                            this.commentsDB[comment.attrs.id].resolved ||
+                            this.commentsDB[comment.attrs.id].answers?.length
+                        ) {
+                            useExtended = true
+                        }
+                    }
+                })
+            }
+        })
+        if (!this.usedComments.length) {
+            return Promise.resolve()
+        }
+        this.rels.addCommentsRel()
+        const addCommentXMLs = [
+            this.xml
+                .getXml(this.commentsFilePath, DEFAULT_COMMENTS_XML)
+                .then(commentsXML => (this.commentsXML = commentsXML))
+        ]
+        if (useExtended) {
+            this.rels.addCommentsExtendedRel()
+            addCommentXMLs.push(
+                this.xml
+                    .getXml(
+                        this.commentsExtendedFilePath,
+                        DEFAULT_COMMENTS_EXTENDED_XML
+                    )
+                    .then(
+                        commentsExtendedXML =>
+                            (this.commentsExtendedXML = commentsExtendedXML)
+                    )
+            )
+        }
+        return Promise.all(addCommentXMLs).then(() => {
+            this.commentsXML.queryAll("w:comment").forEach(el => {
+                const id = Number.parseInt(el.getAttribute("w:id"))
+                if (id > this.commentIdCounter) {
+                    this.commentIdCounter = id
+                }
+            })
+            return this.exportComments()
+        })
+    }
+
+    addComment(id) {
+        const commentId = ++this.commentIdCounter
+        this.richtext.comments[id] = commentId
+        const commentDBEntry = this.commentsDB[id]
+        const comments = this.commentsXML.query("w:comments")
+        let string = `<w:comment w:id="${commentId}" w:author="${escapeText(commentDBEntry.username)}" w:date="${new Date(commentDBEntry.date).toISOString().split(".")[0]}Z" w:initials="${escapeText(
+            commentDBEntry.username
+                .split(" ")
+                .map(n => n[0])
+                .join("")
+                .toUpperCase()
+        )}">`
+        let parentParagraphId = ""
+        string += commentDBEntry.comment
+            .map((node, index) => {
+                const options = {section: "CommentText"}
+                if (
+                    (commentDBEntry.resolved ||
+                        commentDBEntry.answers?.length) &&
+                    index === commentDBEntry.comment.length - 1
+                ) {
+                    // If comment has been resolved or there are answers, we need to add an id to the last paragraph
+                    // of the comment and add an entry into commentsExtended.xml.
+                    parentParagraphId = (++this.richtext.paragraphIdCounter)
+                        .toString(16)
+                        .padStart(8, "0")
+                    options.paragraphId = parentParagraphId
+                    const extendedString = `<w15:commentEx w15:paraId="${parentParagraphId}" w15:done="${commentDBEntry.resolved ? "1" : "0"}"/>`
+                    const extendedComments =
+                        this.commentsExtendedXML.query("w15:commentsEx")
+                    extendedComments.appendXML(extendedString)
+                }
+                if (!index) {
+                    options.commentReference = true
+                }
+                return this.richtext.transformRichtext(node, options)
+            })
+            .join("")
+        string += "</w:comment>"
+        commentDBEntry.answers?.forEach(answer => {
+            const answerId = ++this.commentIdCounter
+            string += `<w:comment w:id="${answerId}" w:author="${escapeText(answer.username)}" w:date="${new Date(answer.date).toISOString().split(".")[0]}Z" w:initials="${escapeText(
+                answer.username
+                    .split(" ")
+                    .map(n => n[0])
+                    .join("")
+                    .toUpperCase()
+            )}">`
+            string += answer.answer
+                .map((node, index) => {
+                    const options = {section: "CommentText"}
+                    if (index === answer.answer.length - 1) {
+                        // We need to add an id to the last paragraph of the comment and add an entry
+                        // into commentsExtended.xml pointing to the last paragraph of the parent comment.
+                        const paragraphId = (++this.richtext.paragraphIdCounter)
+                            .toString(16)
+                            .padStart(8, "0")
+                        options.paragraphId = paragraphId
+                        const extendedString = `<w15:commentEx w15:paraId="${paragraphId}" w15:done="${commentDBEntry.resolved ? "1" : "0"}" w15:paraIdParent="${parentParagraphId}"/>`
+                        const extendedComments =
+                            this.commentsExtendedXML.query("w15:commentsEx")
+                        extendedComments.appendXML(extendedString)
+                    }
+                    if (!index) {
+                        options.commentReference = true
+                    }
+                    return this.richtext.transformRichtext(node, options)
+                })
+                .join("")
+            string += "</w:comment>"
+        })
+        comments.appendXML(string)
+    }
+
+    exportComments() {
+        this.usedComments.forEach(comment => {
+            this.addComment(comment)
+        })
+        return Promise.resolve()
+    }
+}

package/src/exporter/docx/footnotes.js

@@ -0,0 +1,240 @@
+import {descendantNodes} from "../tools/doc_content.js"
+import {DOCXExporterCitations} from "./citations.js"
+import {DOCXExporterImages} from "./images.js"
+import {DOCXExporterLists} from "./lists.js"
+import {DOCXExporterRels} from "./rels.js"
+import {DOCXExporterRichtext} from "./richtext.js"
+
+const DEFAULT_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    <w:footnotes xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" mc:Ignorable="w14 wp14">
+        <w:footnote w:id="0" w:type="separator">
+            <w:p>
+                <w:r>
+                    <w:separator />
+                </w:r>
+            </w:p>
+        </w:footnote>
+        <w:footnote w:id="1" w:type="continuationSeparator">
+            <w:p>
+                <w:r>
+                    <w:continuationSeparator />
+                </w:r>
+            </w:p>
+        </w:footnote>
+    </w:footnotes>`
+
+const DEFAULT_SETTINGS_XML = `<w:footnotePr>
+        <w:numFmt w:val="decimal"/>
+        <w:footnote w:id="0"/>
+        <w:footnote w:id="1"/>
+    </w:footnotePr>`
+
+const DEFAULT_STYLE_FOOTNOTE = `<w:style w:type="paragraph" w:styleId="Footnote">
+        <w:name w:val="Footnote Text" />
+        <w:basedOn w:val="Normal" />
+        <w:pPr>
+            <w:suppressLineNumbers />
+            <w:ind w:left="339" w:hanging="339" />
+        </w:pPr>
+        <w:rPr>
+            <w:sz w:val="20" />
+            <w:szCs w:val="20" />
+        </w:rPr>
+    </w:style>`
+
+const DEFAULT_STYLE_FOOTNOTE_ANCHOR = `
+    <w:style w:type="character" w:styleId="FootnoteAnchor">
+        <w:name w:val="Footnote Anchor" />
+        <w:rPr>
+            <w:vertAlign w:val="superscript" />
+        </w:rPr>
+    </w:style>
+    `
+
+export class DOCXExporterFootnotes {
+    constructor(
+        doc,
+        docContent,
+        settings,
+        imageDB,
+        bibDB,
+        xml,
+        citations,
+        csl,
+        lists,
+        math,
+        tables,
+        rels
+    ) {
+        this.doc = doc
+        this.docContent = docContent
+        this.settings = settings
+        this.imageDB = imageDB
+        this.bibDB = bibDB
+        this.xml = xml
+        this.citations = citations
+        this.csl = csl
+        this.lists = lists
+        this.math = math
+        this.tables = tables
+        this.rels = rels
+
+        this.pmBib = false
+        this.fnPmJSON = false
+        this.images = false
+        this.augmentedCitations = false
+        this.footnotes = [] // footnotes
+        this.fnXML = false
+        this.ctXML = false
+        this.styleXML = false
+        this.filePath = "word/footnotes.xml"
+        this.ctFilePath = "[Content_Types].xml"
+        this.settingsFilePath = "word/settings.xml"
+        this.styleFilePath = "word/styles.xml"
+    }
+
+    init() {
+        this.findFootnotes()
+        if (
+            this.footnotes.length ||
+            (this.citations.citFm.citationType === "note" &&
+                this.citations.citInfos.length)
+        ) {
+            this.convertFootnotes()
+            this.fnRels = new DOCXExporterRels(this.xml, "footnotes")
+            // Include the citinfos from the main body document so that they will be
+            // used for calculating the bibliography as well
+            this.augmentedCitations = new DOCXExporterCitations(
+                this.fnPmJSON,
+                this.settings,
+                this.bibDB,
+                this.csl,
+                this.xml,
+                this.citations.citInfos
+            )
+
+            this.images = new DOCXExporterImages(
+                this.fnPmJSON,
+                this.imageDB,
+                this.xml,
+                this.fnRels
+            )
+            this.lists = new DOCXExporterLists(
+                this.fnPmJSON,
+                this.xml,
+                this.fnRels
+            )
+
+            return this.augmentedCitations
+                .init()
+                .then(() => {
+                    // Replace the main bibliography with the new one that
+                    // includes both citations in main document
+                    // and in the footnotes.
+                    this.pmBib = this.augmentedCitations.pmBib
+                    return this.fnRels.init()
+                })
+                .then(() => this.images.init())
+                .then(() => this.lists.init())
+                .then(() => this.initCt())
+                .then(() => this.setSettings())
+                .then(() => this.addStyles())
+                .then(() => this.createXml())
+        } else {
+            // No footnotes were found.
+            return Promise.resolve()
+        }
+    }
+
+    initCt() {
+        return this.xml.getXml(this.ctFilePath).then(ctXML => {
+            this.ctXML = ctXML
+            this.addRelsToCt()
+            return Promise.resolve()
+        })
+    }
+
+    addRelsToCt() {
+        const override = this.ctXML.query("Override", {
+            PartName: `/${this.filePath}`
+        })
+        if (!override) {
+            const types = this.ctXML.query("Types")
+            types.appendXML(
+                `<Override PartName="/${this.filePath}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"/>`
+            )
+        }
+    }
+
+    addStyles() {
+        return this.xml.getXml(this.styleFilePath).then(styleXML => {
+            this.styleXML = styleXML
+            this.addStyle("Footnote", DEFAULT_STYLE_FOOTNOTE)
+            this.addStyle("FootnoteAnchor", DEFAULT_STYLE_FOOTNOTE_ANCHOR)
+            return Promise.resolve()
+        })
+    }
+
+    addStyle(styleName, xml) {
+        if (!this.styleXML.query("w:style", {"w:styleId": styleName})) {
+            const stylesEl = this.styleXML.query("w:styles")
+            stylesEl.appendXML(xml)
+        }
+    }
+
+    findFootnotes() {
+        descendantNodes(this.docContent).forEach(node => {
+            if (node.type === "footnote") {
+                this.footnotes.push(node.attrs.footnote)
+            }
+        })
+    }
+
+    convertFootnotes() {
+        const fnContent = []
+        this.footnotes.forEach(footnote => {
+            fnContent.push({
+                type: "footnotecontainer",
+                content: footnote
+            })
+        })
+        this.fnPmJSON = {
+            type: "doc",
+            content: fnContent
+        }
+    }
+
+    createXml() {
+        this.richtext = new DOCXExporterRichtext(
+            this.doc,
+            this.lists,
+            this,
+            this.settings,
+            this.math,
+            this.tables,
+            this.fnRels,
+            this.augmentedCitations,
+            this.images
+        )
+        this.fnXML = this.richtext.transformRichtext(this.fnPmJSON)
+        // TODO: add max dimensions
+        this.rels.addFootnoteRel()
+        return this.xml.getXml(this.filePath, DEFAULT_XML).then(xml => {
+            const footnotesEl = xml.query("w:footnotes")
+            footnotesEl.appendXML(this.fnXML)
+            this.xml = xml
+        })
+    }
+
+    setSettings() {
+        return this.xml.getXml(this.settingsFilePath).then(settingsXML => {
+            const footnotePr = settingsXML.query("w:footnotePr")
+            if (!footnotePr) {
+                const settingsEl = settingsXML.query("w:settings")
+                settingsEl.appendXML(DEFAULT_SETTINGS_XML)
+            }
+            this.settingsXML = settingsXML
+            return Promise.resolve()
+        })
+    }
+}

package/src/exporter/docx/images.js

@@ -0,0 +1,101 @@
+import {get} from "../../common/index.js"
+import {descendantNodes} from "../tools/doc_content.js"
+import {svg2png} from "../tools/svg.js"
+
+export class DOCXExporterImages {
+    constructor(docContent, imageDB, xml, rels) {
+        this.docContent = docContent
+        this.imageDB = imageDB
+        this.xml = xml
+        this.rels = rels
+
+        this.images = {}
+        this.ctXML = false
+    }
+
+    init() {
+        return this.xml.getXml("[Content_Types].xml").then(ctXML => {
+            this.ctXML = ctXML
+            return this.exportImages()
+        })
+    }
+
+    // add an image to the list of files
+    addImage(imgFileName, image) {
+        const rId = this.rels.addImageRel(imgFileName)
+        this.addContentType(imgFileName.split(".").pop())
+        this.xml.addExtraFile(`word/media/${imgFileName}`, image)
+        return rId
+    }
+
+    // add a global contenttype declaration for an image type (if needed)
+    addContentType(fileEnding) {
+        const types = this.ctXML.query("Types")
+        const contentDec = types.query("Default", {Extension: fileEnding})
+        if (!contentDec) {
+            const string = `<Default ContentType="image/${fileEnding}" Extension="${fileEnding}"/>`
+            types.appendXML(string)
+        }
+    }
+
+    // Find all images used in file and add these to the export zip.
+    // TODO: This will likely fail on image types docx doesn't support such as SVG.
+    // Try out and fix.
+    exportImages() {
+        const usedImgs = []
+        descendantNodes(this.docContent).forEach(node => {
+            if (node.type === "image" && node.attrs.image !== false) {
+                if (!usedImgs.includes(node.attrs.image)) {
+                    usedImgs.push(node.attrs.image)
+                }
+            }
+        })
+        return new Promise(resolveExportImages => {
+            const p = []
+            usedImgs.forEach(image => {
+                const imgDBEntry = this.imageDB.db[image]
+                p.push(
+                    get(imgDBEntry.image)
+                        .then(response => response.blob())
+                        .then(blob => {
+                            if (blob.type === "image/svg+xml") {
+                                // DOCX doesn't support SVG. Convert to PNG.
+                                return svg2png(blob).then(
+                                    ({blob: pngBlob, width, height}) => {
+                                        const wImgId = this.addImage(
+                                            imgDBEntry.image
+                                                .split("/")
+                                                .pop()
+                                                .replace(/.svg$/g, ".png"),
+                                            pngBlob
+                                        )
+                                        this.images[image] = {
+                                            id: wImgId,
+                                            width,
+                                            height,
+                                            title: imgDBEntry.title
+                                        }
+                                    }
+                                )
+                            } else {
+                                const wImgId = this.addImage(
+                                    imgDBEntry.image.split("/").pop(),
+                                    blob
+                                )
+                                this.images[image] = {
+                                    id: wImgId,
+                                    width: imgDBEntry.width,
+                                    height: imgDBEntry.height,
+                                    title: imgDBEntry.title
+                                }
+                            }
+                        })
+                )
+            })
+
+            Promise.all(p).then(() => {
+                resolveExportImages()
+            })
+        })
+    }
+}

package/src/exporter/docx/index.js

@@ -0,0 +1,185 @@
+import download from "downloadjs"
+
+import {shortFileTitle} from "../../common/index.js"
+import {fixTables, removeHidden, textContent} from "../tools/doc_content.js"
+import {createSlug} from "../tools/file.js"
+import {XmlZip} from "../tools/xml_zip.js"
+import {DOCXExporterCitations} from "./citations.js"
+import {DOCXExporterComments} from "./comments.js"
+import {DOCXExporterFootnotes} from "./footnotes.js"
+import {DOCXExporterImages} from "./images.js"
+import {DOCXExporterLists} from "./lists.js"
+import {DOCXExporterMath} from "./math.js"
+import {DOCXExporterMetadata} from "./metadata.js"
+import {DOCXExporterRels} from "./rels.js"
+import {DOCXExporterRender} from "./render.js"
+import {DOCXExporterRichtext} from "./richtext.js"
+import {DOCXExporterTables} from "./tables.js"
+import {moveFootnoteComments} from "./tools.js"
+
+/*
+Exporter to Office Open XML docx (Microsoft Word)
+*/
+
+/*
+TODO:
+* - Remove comments
+* - Export document language
+* - Templating of tag/contributor output
+*/
+
+export class DOCXExporter {
+    constructor(doc, templateUrl, bibDB, imageDB, csl) {
+        this.doc = doc
+        this.templateUrl = templateUrl
+        this.bibDB = bibDB
+        this.imageDB = imageDB
+        this.csl = csl
+
+        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
+        this.mimeType =
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        this.docContent = moveFootnoteComments(
+            fixTables(removeHidden(this.doc.content))
+        )
+    }
+
+    init() {
+        const xml = new XmlZip(this.templateUrl, this.mimeType)
+
+        const tables = new DOCXExporterTables(xml)
+        const math = new DOCXExporterMath(xml)
+        const render = new DOCXExporterRender(xml)
+        const rels = new DOCXExporterRels(xml, "document")
+        const metadata = new DOCXExporterMetadata(
+            xml,
+            this.getBaseMetadata(),
+            this.csl
+        )
+
+        const images = new DOCXExporterImages(
+            this.docContent,
+            this.imageDB,
+            xml,
+            rels
+        )
+        const lists = new DOCXExporterLists(this.docContent, xml, rels)
+        const citations = new DOCXExporterCitations(
+            this.docContent,
+            this.doc.settings,
+            this.bibDB,
+            this.csl,
+            xml
+        )
+
+        const footnotes = new DOCXExporterFootnotes(
+            this.doc,
+            this.docContent,
+            this.doc.settings,
+            this.imageDB,
+            this.bibDB,
+            xml,
+            citations,
+            this.csl,
+            lists,
+            math,
+            tables,
+            rels
+        )
+
+        const richtext = new DOCXExporterRichtext(
+            this.doc,
+            this.doc.settings,
+            lists,
+            footnotes,
+            math,
+            tables,
+            rels,
+            citations,
+            images
+        )
+
+        const comments = new DOCXExporterComments(
+            this.docContent,
+            this.doc.comments,
+            xml,
+            rels,
+            richtext
+        )
+
+        return xml
+            .init()
+            .then(() => citations.init())
+            .then(() => metadata.init())
+            .then(() => tables.init())
+            .then(() => math.init())
+            .then(() => render.init())
+            .then(() => rels.init())
+            .then(() => images.init())
+            .then(() => comments.init())
+            .then(() => lists.init())
+            .then(() => footnotes.init())
+            .then(() => {
+                const pmBib = footnotes.pmBib || citations.pmBib
+                render.render(
+                    this.docContent,
+                    pmBib,
+                    this.doc.settings,
+                    richtext,
+                    citations
+                )
+                return xml.prepareBlob()
+            })
+            .then(blob => this.download(blob))
+    }
+
+    download(blob) {
+        return download(
+            blob,
+            createSlug(this.docTitle) + ".docx",
+            this.mimeType
+        )
+    }
+
+    getBaseMetadata() {
+        const contributors = this.docContent.content.reduce(
+            (contributors, part) => {
+                if (
+                    part.type === "contributors_part" &&
+                    part.attrs.metadata &&
+                    part.content
+                ) {
+                    return contributors.concat(
+                        part.content.map(node => ({
+                            ...node.attrs,
+                            role: part.attrs.metadata
+                        }))
+                    )
+                } else {
+                    return contributors
+                }
+            },
+            []
+        )
+        return {
+            authors: contributors.filter(c => c.role === "authors"),
+            contributors,
+            keywords: this.docContent.content.reduce((keywords, part) => {
+                if (
+                    part.type === "tags_part" &&
+                    part.attrs.metadata === "keywords" &&
+                    part.content
+                ) {
+                    return keywords.concat(
+                        part.content.map(keywordNode => keywordNode.attrs.tag)
+                    )
+                } else {
+                    return keywords
+                }
+            }, []),
+            title: textContent(this.docContent.content[0]),
+            language: this.doc.settings.language,
+            citationStyle: this.doc.settings.citationstyle
+        }
+    }
+}