@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/docx/tables.js

@@ -0,0 +1,112 @@
+const DEFAULT_TABLENORMAL_XML = `
+    <w:style w:type="table" w:default="1" w:styleId="TableNormal">
+        <w:name w:val="Normal Table"/>
+        <w:uiPriority w:val="99"/>
+        <w:semiHidden/>
+        <w:unhideWhenUsed/>
+        <w:tblPr>
+          <w:tblInd w:w="0" w:type="dxa"/>
+          <w:tblCellMar>
+            <w:top w:w="0" w:type="dxa"/>
+            <w:left w:w="108" w:type="dxa"/>
+            <w:bottom w:w="0" w:type="dxa"/>
+            <w:right w:w="108" w:type="dxa"/>
+          </w:tblCellMar>
+        </w:tblPr>
+    </w:style>
+    `
+
+const DEFAULT_TABLEGRID_XML = tableNormalStyle => `
+    <w:style w:type="table" w:styleId="TableGrid">
+        <w:name w:val="Table Grid"/>
+        <w:basedOn w:val="${tableNormalStyle}"/>
+        <w:uiPriority w:val="39"/>
+        <w:pPr>
+            <w:spacing w:after="0" w:line="240" w:lineRule="auto"/>
+        </w:pPr>
+        <w:tblPr>
+            <w:hMerge/>
+            <w:vMerge/>
+            <w:tblBorders>
+                <w:top w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+                <w:left w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+                <w:bottom w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+                <w:right w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+                <w:insideH w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+                <w:insideV w:val="single" w:sz="4" w:space="0" w:color="auto"/>
+
+            </w:tblBorders>
+        </w:tblPr>
+
+
+    </w:style>
+    `
+
+export class DOCXExporterTables {
+    constructor(xml) {
+        this.xml = xml
+        this.sideMargins = false
+        this.tableGridStyle = false
+        this.tableNormalStyle = false
+        this.styleXML = false
+        this.styleFilePath = "word/styles.xml"
+    }
+
+    init() {
+        return this.xml.getXml(this.styleFilePath).then(styleXML => {
+            this.styleXML = styleXML
+            return Promise.resolve()
+        })
+    }
+
+    addTableNormalStyle() {
+        if (this.tableNormalStyle) {
+            // already added
+            return
+        }
+        const tableNormalEl = this.styleXML.query("w:style", {
+            "w:type": "table",
+            "w:default": "1"
+        })
+        if (tableNormalEl) {
+            this.tableNormalStyle = tableNormalEl.getAttribute("w:styleId")
+        } else {
+            const stylesEl = this.styleXML.query("w:styles")
+            stylesEl.appendXML(DEFAULT_TABLENORMAL_XML)
+            this.tableNormalStyle = "TableNormal"
+        }
+    }
+
+    addTableGridStyle() {
+        if (this.tableGridStyle) {
+            // already added
+            return
+        }
+        this.addTableNormalStyle()
+        const tableGridEl = this.styleXML.query("w:style", {
+            "w:type": "table",
+            "w:customStyle": "1"
+        })
+        if (tableGridEl) {
+            this.tableGridStyle = tableGridEl.getAttribute("w:styleId")
+        } else {
+            const stylesEl = this.styleXML.query("w:styles")
+            stylesEl.appendXML(DEFAULT_TABLEGRID_XML(this.tableNormalStyle))
+            this.tableGridStyle = "TableGrid"
+        }
+    }
+
+    getSideMargins() {
+        if (!this.sideMargins) {
+            const marginsEl = this.styleXML.query("w:style", {
+                "w:styleId": this.tableGridStyle
+            })
+            const leftEl = marginsEl.query("w:left")
+            const rightEl = marginsEl.query("w:right")
+            const left = Number.parseInt(leftEl.getAttribute("w:w"))
+            const right = Number.parseInt(rightEl.getAttribute("w:w"))
+            this.sideMargins = (left + right) * 635
+        }
+        return this.sideMargins
+    }
+}

package/src/exporter/docx/tools.js

@@ -0,0 +1,50 @@
+import {descendantNodes} from "../tools/doc_content.js"
+
+export const moveFootnoteComments = topNode => {
+    // DOCX doesn't support comments in footnotes. So we copy all comment marks from footnote
+    // to parent node.
+    descendantNodes(topNode).forEach(node => {
+        if (node.type === "footnote") {
+            descendantNodes({
+                type: "footnotecontainer",
+                content: node.attrs.footnote
+            }).forEach(fnNode => {
+                if (fnNode.marks) {
+                    fnNode.marks
+                        .filter(mark => mark.type === "comment")
+                        .forEach(mark => {
+                            if (!node.marks) {
+                                node.marks = []
+                            }
+                            node.marks.push(mark)
+                        })
+                }
+            })
+        }
+    })
+
+    return topNode
+}
+
+export const translateBlockType = blockType => {
+    switch (blockType) {
+        case "heading1":
+            return "Heading1"
+        case "heading2":
+            return "Heading2"
+        case "heading3":
+            return "Heading3"
+        case "heading4":
+            return "Heading4"
+        case "heading5":
+            return "Heading5"
+        case "heading6":
+            return "Heading6"
+        case "code_block":
+            return "Code"
+        case "blockquote":
+            return "Quote"
+        default:
+            return "Normal"
+    }
+}

package/src/exporter/epub/index.js

@@ -0,0 +1,142 @@
+import pretty from "pretty"
+import {HTMLExporter} from "../html/index.js"
+
+import {
+    containerTemplate,
+    navTemplate,
+    ncxTemplate,
+    opfTemplate
+} from "./templates.js"
+import {
+    buildHierarchy,
+    getFontMimeType,
+    getImageMimeType,
+    getTimestamp
+} from "./tools.js"
+
+export class EpubExporter extends HTMLExporter {
+    constructor(doc, bibDB, imageDB, csl, updated, documentStyles) {
+        super(doc, bibDB, imageDB, csl, updated, documentStyles, {
+            xhtml: true,
+            epub: true
+        })
+        // Overriden properties
+        this.documentFileName = "document.xhtml"
+        this.fileEnding = "epub"
+        this.mimeType = "application/epub+zip"
+    }
+
+    createZip() {
+        this.prefixFiles()
+        this.createEPUBFiles()
+        return super.createZip()
+    }
+
+    prefixFiles() {
+        // prefix all files with "EPUB/"
+        this.textFiles = this.textFiles.map(file =>
+            Object.assign({}, file, {filename: `EPUB/${file.filename}`})
+        )
+        this.httpFiles = this.httpFiles.map(file =>
+            Object.assign({}, file, {filename: `EPUB/${file.filename}`})
+        )
+        this.includeZips = this.includeZips.map(file =>
+            Object.assign({}, file, {directory: `EPUB/${file.directory}`})
+        )
+    }
+
+    createEPUBFiles() {
+        // Generate the required EPUB-specific files using the converted content
+        this.textFiles.push(
+            {
+                filename: "META-INF/container.xml",
+                contents: pretty(containerTemplate(), {ocd: true})
+            },
+            {
+                filename: "EPUB/document.opf",
+                contents: pretty(this.createOPF(), {ocd: true})
+            },
+            {
+                filename: "EPUB/document.ncx",
+                contents: pretty(this.createNCX(), {ocd: true})
+            },
+            {
+                filename: "EPUB/document-nav.xhtml",
+                contents: pretty(this.createNav(), {ocd: true})
+            }
+        )
+    }
+
+    createOPF() {
+        const timestamp = getTimestamp(this.updated)
+        const images = this.httpFiles
+            .map(file =>
+                Object.assign({mimeType: getImageMimeType(file.filename)}, file)
+            )
+            .filter(image => image.mimeType)
+
+        const fontFiles = this.httpFiles
+            .map(file =>
+                Object.assign({mimeType: getFontMimeType(file.filename)}, file)
+            )
+            .filter(file => file.mimeType)
+
+        const styleSheets = this.textFiles.filter(file =>
+            file.filename.endsWith(".css")
+        )
+
+        // Extract authors and keywords from metaData
+        const authors = this.converter.metaData.authors.map(
+            ({attrs: author}) => {
+                if (author.firstname || author.lastname) {
+                    const nameParts = []
+                    if (author.firstname) {
+                        nameParts.push(author.firstname)
+                    }
+                    if (author.lastname) {
+                        nameParts.push(author.lastname)
+                    }
+                    return nameParts.join(" ")
+                } else if (author.institution) {
+                    return author.institution
+                }
+            }
+        )
+        return opfTemplate({
+            language: this.lang,
+            title: this.docTitle,
+            authors,
+            keywords: this.converter.metaData.keywords,
+            idType: "fidus",
+            id: this.doc.id,
+            date: timestamp.slice(0, 10),
+            modified: timestamp,
+            styleSheets,
+            math: this.converter.features.math,
+            images,
+            fontFiles,
+            copyright: this.doc.settings.copyright
+        })
+    }
+
+    createNCX() {
+        return ncxTemplate({
+            shortLang: this.shortLang,
+            title: this.docTitle,
+            idType: "fidus",
+            id: this.doc.id,
+            toc: buildHierarchy(this.converter.metaData.toc)
+        })
+    }
+
+    createNav() {
+        const styleSheets = this.textFiles.filter(file =>
+            file.filename.endsWith(".css")
+        )
+        return navTemplate({
+            shortLang: this.shortLang,
+            toc: buildHierarchy(this.converter.metaData.toc),
+            styleSheets
+        })
+    }
+}

package/src/exporter/epub/templates.js

@@ -0,0 +1,140 @@
+import {escapeText} from "../../common/index.js"
+import {mathliveOpfIncludes} from "../../mathlive/opf_includes.js"
+
+/** A template for the OPF file of an epub. */
+export const opfTemplate = ({
+    id,
+    idType,
+    title,
+    language,
+    authors,
+    keywords,
+    date,
+    modified,
+    images,
+    fontFiles,
+    styleSheets,
+    math,
+    copyright
+}) =>
+    `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="${idType}" xml:lang="${language}" prefix="cc: http://creativecommons.org/ns#">
+    <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+        <dc:identifier id="${idType}">${id}</dc:identifier>
+            <dc:title>${escapeText(title)}</dc:title>
+${authors
+    .map(author => `\t\t<dc:creator>${escapeText(author)}</dc:creator>\n`)
+    .join("")}${keywords
+    .map(keyword => `\t\t<dc:subject>${escapeText(keyword)}</dc:subject>\n`)
+    .join("")}
+        <dc:language>${language}</dc:language>
+        <dc:date>${date}</dc:date>
+        ${copyright && copyright.holder ? `<dc:rights>© ${copyright.year ? copyright.year : new Date().getFullYear()} ${escapeText(copyright.holder)}</dc:rights>` : ""}
+        <meta property="dcterms:modified">${modified}</meta>
+    </metadata>
+    <manifest>
+        <item id="t1" href="document.xhtml" media-type="application/xhtml+xml" />
+        <item id="nav" href="document-nav.xhtml" properties="nav" media-type="application/xhtml+xml" />
+${images
+    .map(
+        (image, index) =>
+            `\t\t\t<item ${
+                image.coverImage
+                    ? 'id="cover-image" properties="cover-image"'
+                    : `id="img${index}"`
+            } href="${image.filename}" media-type="${image.mimeType}" />\n`
+    )
+    .join("")}${fontFiles
+    .map(
+        (fontFile, index) =>
+            `\t\t\t<item ${`id="font${index}"`} href="${
+                fontFile.filename
+            }" media-type="${fontFile.mimeType}" />\n`
+    )
+    .join("")}${styleSheets
+    .map(
+        (sheet, index) =>
+            `\t\t\t<item id="css${index}" href="${sheet.filename}" media-type="text/css" />\n`
+    )
+    .join("")}${math ? mathliveOpfIncludes : ""}
+        <!-- ncx included for 2.0 reading system compatibility: -->
+        <item id="ncx" href="document.ncx" media-type="application/x-dtbncx+xml" />
+    </manifest>
+    <spine toc="ncx">
+        <itemref idref="t1" />
+    </spine>
+</package>`
+
+/** A template for the contianer XML of an epub file. */
+export const containerTemplate = () =>
+    `<?xml version="1.0" encoding="UTF-8"?>
+<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">
+    <rootfiles>
+        <rootfile full-path="EPUB/document.opf" media-type="application/oebps-package+xml"/>
+    </rootfiles>
+</container>`
+
+/** A template of the NCX file of an epub. */
+export const ncxTemplate = ({shortLang, idType, id, title, toc}) =>
+    `<?xml version="1.0" encoding="UTF-8"?>
+<ncx xmlns:ncx="http://www.daisy.org/z3986/2005/ncx/" xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1" xml:lang="${shortLang}">
+    <head>
+        <meta name="dtb:${idType}" content="${id}" />
+    </head>
+    <docTitle>
+        <text>${escapeText(title)}</text>
+    </docTitle>
+    <navMap>
+        <!-- 2.01 NCX: playOrder is optional -->
+${toc.map(item => ncxItemTemplate({item})).join("")}
+    </navMap>
+</ncx>`
+
+/** A template for each list item in the navMap of an epub's NCX file. */
+export const ncxItemTemplate = ({item}) =>
+    `        <navPoint id="t${item.docNum ? `${item.id}-${item.docNum}` : item.id}">
+            <navLabel><text>${escapeText(item.title)}</text></navLabel>
+            <content src="${item.link ? item.link : item.docNum ? `document-${item.docNum}.xhtml#${item.id}` : `document.xhtml#${item.id}`}"/>
+${item.children?.map(item => ncxItemTemplate({item})).join("") || ""}
+        </navPoint>\n`
+
+/** A template for each item in an epub's navigation document. */
+const navItemTemplate = ({item}) =>
+    `\t\t\t\t<li><a href="${
+        item.link
+            ? item.link
+            : item.docNum
+              ? `document-${item.docNum}.xhtml#${item.id}`
+              : `document.xhtml#${item.id}`
+    }">${escapeText(item.title)}</a>
+${
+    item.children.length
+        ? `<ol>
+        ${item.children.map(item => navItemTemplate({item})).join("")}
+    </ol>`
+        : ""
+}
+</li>`
+
+/** A template for an epub's navigation document. */
+export const navTemplate = ({shortLang, toc, styleSheets}) =>
+    `<?xml version="1.0" encoding="UTF-8"?>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="${shortLang}" lang="${shortLang}" xmlns:epub="http://www.idpf.org/2007/ops">
+    <head>
+        <meta charset="utf-8" />
+        <title>Navigation</title>
+        ${styleSheets
+            .map(
+                sheet =>
+                    `<link rel="stylesheet" type="text/css" href="${sheet.filename}" />\n`
+            )
+            .join("")}
+    </head>
+    <body class="epub navigation">
+        <nav epub:type="toc" id="toc">
+            <ol>
+${toc.map(item => navItemTemplate({item})).join("")}
+            </ol>
+        </nav>
+    </body>
+</html>`

package/src/exporter/epub/tools.js

@@ -0,0 +1,96 @@
+export function getTimestamp(date) {
+    let second = date.getUTCSeconds()
+    let minute = date.getUTCMinutes()
+    let hour = date.getUTCHours()
+    let day = date.getUTCDate()
+    let month = date.getUTCMonth() + 1 //January is 0!
+    const year = date.getUTCFullYear()
+
+    if (second < 10) {
+        second = "0" + second
+    }
+    if (minute < 10) {
+        minute = "0" + minute
+    }
+    if (hour < 10) {
+        hour = "0" + hour
+    }
+    if (day < 10) {
+        day = "0" + day
+    }
+    if (month < 10) {
+        month = "0" + month
+    }
+
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`
+}
+
+export function getFontMimeType(filename) {
+    // Define a mapping of font file extensions to MIME types
+    const fontMimeTypes = {
+        ttf: "font/ttf",
+        otf: "font/otf",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        eot: "application/vnd.ms-fontobject"
+    }
+
+    // Extract the file extension from the filename
+    const extension = filename.split(".").pop().toLowerCase()
+
+    // Check if the extension matches a known font type and return the MIME type
+    return fontMimeTypes[extension] || null // Return null if it's not a font file
+}
+
+export function getImageMimeType(filename) {
+    // Define a mapping of image file extensions to MIME types
+    const imageMimeTypes = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        bmp: "image/bmp",
+        tiff: "image/tiff",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+        ico: "image/vnd.microsoft.icon",
+        avif: "image/avif"
+    }
+
+    // Extract the file extension from the filename
+    const extension = filename.split(".").pop().toLowerCase()
+
+    // Check if the extension matches a known image type and return the MIME type
+    return imageMimeTypes[extension] || null // Return null if it's not an image file
+}
+
+export function buildHierarchy(flatList) {
+    const hierarchy = []
+    const levelMap = {}
+
+    flatList.forEach(item => {
+        // Ensure there's an array for the current level in the map
+        levelMap[item.level] = levelMap[item.level] || []
+
+        // Add the current item to its level in the map
+        levelMap[item.level].push({...item, children: []})
+
+        if (item.level === 0) {
+            // Top-level items are added directly to the hierarchy
+            hierarchy.push(
+                levelMap[item.level][levelMap[item.level].length - 1]
+            )
+        } else {
+            // Non-top-level items are added as children of the last item at the previous level
+            const parentLevel = levelMap[item.level - 1]
+            if (parentLevel) {
+                const parent = parentLevel[parentLevel.length - 1]
+                parent.children.push(
+                    levelMap[item.level][levelMap[item.level].length - 1]
+                )
+            }
+        }
+    })
+
+    return hierarchy
+}

package/src/exporter/html/citations.js

@@ -0,0 +1,121 @@
+import {FormatCitations} from "../../citations/format.js"
+import {escapeText} from "../../common/index.js"
+import {BIBLIOGRAPHY_HEADERS} from "../../schema/i18n.js"
+
+export class HTMLExporterCitations {
+    constructor(docSettings, bibDB, csl) {
+        this.docSettings = docSettings
+        this.bibDB = bibDB
+        this.csl = csl
+
+        this.citationTexts = []
+        this.citFm = false
+        this.bibHTML = ""
+        this.bibCSS = ""
+        this.htmlIdConvert = {}
+    }
+
+    async init(citInfos) {
+        this.citInfos = citInfos
+        if (!citInfos.length) {
+            return this.getOutput()
+        }
+        await this.formatCitations()
+        return this.getOutput()
+    }
+
+    getOutput() {
+        return {
+            type: this.citFm ? this.citFm.citationType : "",
+            bibCSS: this.bibCSS,
+            bibHTML: this.bibHTML,
+            citationTexts: this.citationTexts
+        }
+    }
+
+    // Citations are highly interdependent -- so we need to format them all
+    // together before laying out the document.
+    async formatCitations() {
+        const citationstyle = await this.csl.getStyle(
+            this.docSettings.citationstyle
+        )
+
+        const modStyle = JSON.parse(JSON.stringify(citationstyle))
+        const citationLayout = modStyle.children
+            .find(section => section.name === "citation")
+            .children.find(section => section.name === "layout").attrs
+        const origCitationLayout = JSON.parse(JSON.stringify(citationLayout))
+        citationLayout.prefix = "{{prefix}}"
+        citationLayout.suffix = "{{suffix}}"
+        citationLayout.delimiter = "{{delimiter}}"
+        this.citFm = new FormatCitations(
+            this.csl,
+            this.citInfos,
+            modStyle,
+            "",
+            this.bibDB,
+            false,
+            this.docSettings.language
+        )
+
+        await this.citFm.init()
+
+        // We need to add links to the bibliography items. And there may be more than one work cited
+        // so we need to first split, then add the links and eventually put the citation back together
+        // again.
+        // The IDs used in the html bibliography are 1 and up in this order
+        this.citFm.bibliography[0].entry_ids.forEach(
+            (id, index) => (this.htmlIdConvert[id] = index + 1)
+        )
+        this.citationTexts = this.citFm.citationTexts.map((ref, index) => {
+            const content = ref
+                .split("{{delimiter}}")
+                .map((citationText, conIndex) => {
+                    const prefixSplit = citationText.split("{{prefix}}")
+                    const prefix =
+                        prefixSplit.length > 1
+                            ? prefixSplit.shift() +
+                              (origCitationLayout.prefix || "")
+                            : ""
+                    citationText = prefixSplit[0]
+                    const suffixSplit = citationText.split("{{suffix}}")
+                    const suffix =
+                        suffixSplit.length > 1
+                            ? (origCitationLayout.suffix || "") +
+                              suffixSplit.pop()
+                            : ""
+                    citationText = suffixSplit[0]
+                    const citId =
+                        this.citFm.citations[index].sortedItems[conIndex][1].id
+                    const htmlId = this.htmlIdConvert[citId]
+                    return `${prefix}<a class="bibliography" href="#ref-${htmlId}">${citationText}</a>${suffix}`
+                })
+                .join(origCitationLayout.delimiter || "")
+            return content
+        })
+
+        if (
+            this.citFm.bibliography?.length &&
+            this.citFm.bibliography[0].entry_ids.length
+        ) {
+            this.assembleBib()
+        }
+    }
+
+    assembleBib() {
+        const bibliographyHeader =
+            this.docSettings.bibliography_header[this.docSettings.language] ||
+            BIBLIOGRAPHY_HEADERS[this.docSettings.language]
+        let bibHTML = `<h1 class="doc-bibliography-header">${escapeText(bibliographyHeader)}</h1>`
+        bibHTML += this.citFm.bibliography[0].bibstart
+        bibHTML += this.citFm.bibliography[1]
+            .map(
+                (reference, index) =>
+                    `<div id="ref-${index + 1}">${reference}</div>`
+            )
+            .join("")
+        bibHTML += this.citFm.bibliography[0].bibend
+        this.bibHTML = bibHTML
+        this.bibCSS = this.citFm.bibCSS
+    }
+}