@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/odt/index.js

@@ -0,0 +1,156 @@
+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 {ODTExporterCitations} from "./citations.js"
+import {ODTExporterFootnotes} from "./footnotes.js"
+import {ODTExporterImages} from "./images.js"
+import {ODTExporterMath} from "./math.js"
+import {ODTExporterMetadata} from "./metadata.js"
+import {ODTExporterRender} from "./render.js"
+import {ODTExporterRichtext} from "./richtext.js"
+import {ODTExporterStyles} from "./styles.js"
+import {ODTExporterTracks} from "./track.js"
+
+/*
+Exporter to Open Document Text (LibreOffice)
+*/
+
+/*
+TODO:
+* - Export tracked changes of block changes and inline format changes
+*    (this feature is lacking in ODT files created with LibreOffice 7.6.7.2)
+*/
+
+export class ODTExporter {
+    constructor(doc, templateUrl, bibDB, imageDB, csl) {
+        this.doc = doc
+        this.templateUrl = templateUrl
+        this.bibDB = bibDB
+        this.imageDB = imageDB
+        this.csl = csl
+
+        this.pmCits = false
+        this.docContent = fixTables(removeHidden(this.doc.content))
+        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
+        this.mimeType = "application/vnd.oasis.opendocument.text"
+    }
+
+    init() {
+        const xml = new XmlZip(this.templateUrl, this.mimeType)
+        const styles = new ODTExporterStyles(xml)
+        const math = new ODTExporterMath(xml)
+        const tracks = new ODTExporterTracks(xml)
+
+        const metadata = new ODTExporterMetadata(
+            xml,
+            styles,
+            this.getBaseMetadata(),
+            this.csl
+        )
+        const citations = new ODTExporterCitations(
+            this.docContent,
+            this.doc.settings,
+            styles,
+            this.bibDB,
+            this.csl
+        )
+        const footnotes = new ODTExporterFootnotes(
+            this.docContent,
+            this.doc.settings,
+            xml,
+            citations,
+            styles,
+            this.bibDB,
+            this.imageDB,
+            this.csl
+        )
+
+        const images = new ODTExporterImages(this.docContent, xml, this.imageDB)
+
+        const richtext = new ODTExporterRichtext(
+            this.doc.comments,
+            this.doc.settings,
+            styles,
+            tracks,
+            footnotes,
+            citations,
+            math,
+            images
+        )
+
+        const render = new ODTExporterRender(xml)
+        return xml
+            .init()
+            .then(() => styles.init())
+            .then(() => tracks.init())
+            .then(() => math.init())
+            .then(() => metadata.init())
+            .then(() => citations.init())
+            .then(() => render.init())
+            .then(() => images.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))
+    }
+
+    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
+        }
+    }
+
+    download(blob) {
+        return download(blob, createSlug(this.docTitle) + ".odt", this.mimeType)
+    }
+}

package/src/exporter/odt/math.js

@@ -0,0 +1,57 @@
+export class ODTExporterMath {
+    constructor(xml) {
+        this.xml = xml
+        this.objectCounter = 1
+        this.manifestXml = false
+        this.domParser = new DOMParser()
+    }
+
+    init() {
+        return this.xml
+            .getXml("META-INF/manifest.xml")
+            .then(manifestXml => {
+                this.manifestXml = manifestXml
+                this.checkObjectCounter()
+                return Promise.resolve()
+            })
+            .then(() => import("mathlive"))
+            .then(MathLive => (this.mathLive = MathLive))
+    }
+
+    checkObjectCounter() {
+        const manifestEl = this.manifestXml.query("manifest:manifest")
+        const fileEntries = manifestEl.queryAll("manifest:file-entry")
+
+        fileEntries.forEach(fileEntry => {
+            const fullPath = fileEntry.getAttribute("manifest:full-path")
+            const dir = fullPath.split("/")[0]
+            const dirParts = dir.split(" ")
+            if (dirParts.length === 2 && dirParts[0] === "Object") {
+                const objectNumber = Number.parseInt(dirParts[1])
+                if (objectNumber >= this.objectCounter) {
+                    this.objectCounter = objectNumber + 1
+                }
+            }
+        })
+    }
+
+    latexToMathML(latex) {
+        return this.mathLive.convertLatexToMathMl(latex)
+    }
+
+    addMath(latex) {
+        const objectNumber = this.objectCounter++
+        this.xml.addExtraFile(
+            `Object ${objectNumber}/content.xml`,
+            `<math xmlns="http://www.w3.org/1998/Math/MathML">${this.latexToMathML(
+                latex
+            )}</math>`
+        )
+        const manifestEl = this.manifestXml.query("manifest:manifest")
+        const stringOne = `<manifest:file-entry manifest:full-path="Object ${objectNumber}/content.xml" manifest:media-type="text/xml"/>`
+        manifestEl.appendXML(stringOne)
+        const stringTwo = `<manifest:file-entry manifest:full-path="Object ${objectNumber}/" manifest:version="1.2" manifest:media-type="application/vnd.oasis.opendocument.formula"/>`
+        manifestEl.appendXML(stringTwo)
+        return objectNumber
+    }
+}

package/src/exporter/odt/metadata.js

@@ -0,0 +1,251 @@
+import {escapeText} from "../../common/index.js"
+
+export class ODTExporterMetadata {
+    constructor(xml, styles, metadata, csl = null) {
+        this.xml = xml
+        this.styles = styles
+        this.metadata = metadata
+        this.csl = csl
+        this.metaXml = false
+    }
+
+    init() {
+        return this.xml.getXml("meta.xml").then(metaXml => {
+            this.metaXml = metaXml
+            this.addMetadata()
+            this.addContributorMetadata()
+            return this.addZoteroPrefs()
+        })
+    }
+
+    async hasBibliography() {
+        if (!this.csl || !this.metadata.citationStyle) {
+            return "0"
+        }
+        try {
+            const style = await this.csl.getStyle(this.metadata.citationStyle)
+            // Check if the style has a bibliography section
+            const hasBib = style.children.some(
+                section => section.name === "bibliography"
+            )
+            return hasBib ? "1" : "0"
+        } catch (_error) {
+            return "0"
+        }
+    }
+
+    addMetadata() {
+        const metaEl = this.metaXml.query("office:meta")
+
+        // Title
+        const titleEl = this.metaXml.query("dc:title")
+        if (titleEl) {
+            titleEl.innerXML = escapeText(this.metadata.title)
+        } else {
+            metaEl.appendXML(
+                `<dc:title>${escapeText(this.metadata.title)}</dc:title>`
+            )
+        }
+
+        // Authors
+        const authors = this.metadata.authors.map(author => {
+            const nameParts = []
+            if (author.firstname) {
+                nameParts.push(author.firstname)
+            }
+            if (author.lastname) {
+                nameParts.push(author.lastname)
+            }
+            if (!nameParts.length && author.institution) {
+                // We have an institution but no names. Use institution as name.
+                nameParts.push(author.institution)
+            }
+            return nameParts.join(" ")
+        })
+
+        const initialAuthor = authors.length
+            ? escapeText(authors[0])
+            : gettext("Unknown")
+        // TODO: We likely want to differentiate between first and last author.
+        const lastAuthor = initialAuthor
+
+        const lastAuthorEl = this.metaXml.query("dc:creator")
+        if (lastAuthorEl) {
+            lastAuthorEl.innerXML = lastAuthor
+        } else {
+            metaEl.appendXML(`<dc:creator>${lastAuthor}</dc:creator>`)
+        }
+        const initialAuthorEl = this.metaXml.query("meta:initial-creator")
+        if (initialAuthorEl) {
+            initialAuthorEl.innerXML = initialAuthor
+        } else {
+            metaEl.appendXML(
+                `<meta:initial-creator>${initialAuthor}</meta:initial-creator>`
+            )
+        }
+
+        // Keywords
+        // Remove all existing keywords
+        const keywordEls = this.metaXml.queryAll("meta:keywords")
+        keywordEls.forEach(keywordEl =>
+            keywordEl.parentElement.removeChild(keywordEl)
+        )
+        // Add new keywords
+        const keywords = this.metadata.keywords
+        keywords.forEach(keyword =>
+            metaEl.appendXML(
+                `<meta:keyword>${escapeText(keyword)}</meta:keyword>`
+            )
+        )
+
+        // language
+        // LibreOffice seems to ignore the value set in metadata and instead uses
+        // the one set in default styles. So we set both.
+        this.styles.setLanguage(this.metadata.language)
+        const languageEl = this.metaXml.query("dc:language")
+        if (languageEl) {
+            languageEl.innerXML = this.metadata.language
+        } else {
+            metaEl.appendXML(
+                `<dc:language>${this.metadata.language}</dc:language>`
+            )
+        }
+        // time
+        const date = new Date()
+        const dateString = date.toISOString().split(".")[0]
+        const createdEl = metaEl.query("meta:creation-date")
+        createdEl.innerXML = dateString
+        const dateEl = this.metaXml.query("dc:date")
+        if (dateEl) {
+            dateEl.innerXML = `${dateString}.000000000`
+        } else {
+            metaEl.appendXML(`<dc:date>${dateString}.000000000</dc:date>`)
+        }
+    }
+
+    async addZoteroPrefs() {
+        // Add citation style property to meta.xml
+        if (!this.metadata.citationStyle) {
+            return Promise.resolve()
+        }
+
+        const metaEl = this.metaXml.query("office:meta")
+
+        // Remove any existing ZOTERO_PREF_ properties
+        const existingZoteroProps = this.metaXml
+            .queryAll("meta:user-defined")
+            .filter(
+                prop =>
+                    prop.getAttribute("meta:name") &&
+                    prop.getAttribute("meta:name").startsWith("ZOTERO_PREF_")
+            )
+        existingZoteroProps.forEach(prop =>
+            prop.parentElement.removeChild(prop)
+        )
+
+        // Determine if the citation style has a bibliography
+        const hasBib = await this.hasBibliography()
+
+        // Create the data content
+        const citationStyleUrl = `http://www.zotero.org/styles/${escapeText(this.metadata.citationStyle)}`
+        const dataContent = escapeText(
+            `<data data-version="3" zotero-version="8.0.2"><session id=""/><style id="${citationStyleUrl}" locale="${escapeText(this.metadata.language || "en-US")}" hasBibliography="${hasBib}" bibliographyStyleHasBeenSet="1"/><prefs><pref name="fieldType" value="ReferenceMark"/><pref name="automaticJournalAbbreviations" value="true"/></prefs></data>`
+        )
+
+        // Split content into chunks of 378 characters (ODT limit)
+        const chunkSize = 378
+        const chunks = []
+        for (let i = 0; i < dataContent.length; i += chunkSize) {
+            chunks.push(dataContent.substring(i, i + chunkSize))
+        }
+
+        // Create meta:user-defined elements for each chunk
+        chunks.forEach((chunk, index) => {
+            const propName = `ZOTERO_PREF_${index + 1}`
+            const userDefinedEl = `<meta:user-defined meta:name="${propName}">${chunk}</meta:user-defined>`
+            metaEl.appendXML(userDefinedEl)
+        })
+
+        return Promise.resolve()
+    }
+
+    addContributorMetadata() {
+        if (!this.metadata.contributors || !this.metadata.contributors.length) {
+            return
+        }
+
+        const metaEl = this.metaXml.query("office:meta")
+
+        // Remove any existing fidus_contributor_ properties
+        const existingContributorProps = this.metaXml
+            .queryAll("meta:user-defined")
+            .filter(
+                prop =>
+                    prop.getAttribute("meta:name") &&
+                    prop
+                        .getAttribute("meta:name")
+                        .startsWith("fidus_contributor_")
+            )
+        existingContributorProps.forEach(prop =>
+            prop.parentElement.removeChild(prop)
+        )
+
+        const contributors = this.metadata.contributors
+
+        // Add contributor count
+        metaEl.appendXML(
+            `<meta:user-defined meta:name="fidus_contributor_count" meta:value-type="float">${contributors.length}</meta:user-defined>`
+        )
+
+        // Add metadata for each contributor
+        contributors.forEach((contributor, index) => {
+            const num = index + 1
+            const nameParts = []
+            if (contributor.firstname) {
+                nameParts.push(contributor.firstname)
+            }
+            if (contributor.lastname) {
+                nameParts.push(contributor.lastname)
+            }
+            const fullName =
+                nameParts.join(" ") || contributor.institution || ""
+
+            const fields = [
+                {
+                    name: `fidus_contributor_${num}_role`,
+                    value: contributor.role || ""
+                },
+                {name: `fidus_contributor_${num}_name`, value: fullName},
+                {
+                    name: `fidus_contributor_${num}_firstname`,
+                    value: contributor.firstname || ""
+                },
+                {
+                    name: `fidus_contributor_${num}_lastname`,
+                    value: contributor.lastname || ""
+                },
+                {
+                    name: `fidus_contributor_${num}_institution`,
+                    value: contributor.institution || ""
+                },
+                {
+                    name: `fidus_contributor_${num}_email`,
+                    value: contributor.email || ""
+                },
+                {
+                    name: `fidus_contributor_${num}_id_type`,
+                    value: contributor.id_type || ""
+                },
+                {
+                    name: `fidus_contributor_${num}_id_value`,
+                    value: contributor.id_value || ""
+                }
+            ]
+
+            fields.forEach(field => {
+                const userDefinedEl = `<meta:user-defined meta:name="${field.name}">${escapeText(field.value)}</meta:user-defined>`
+                metaEl.appendXML(userDefinedEl)
+            })
+        })
+    }
+}