@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/html/index.js

@@ -0,0 +1,192 @@
+import download from "downloadjs"
+import pretty from "pretty"
+
+import {shortFileTitle} from "../../common/index.js"
+import {removeHidden} from "../tools/doc_content.js"
+import {createSlug} from "../tools/file.js"
+import {ZipFileCreator} from "../tools/zip.js"
+
+import {HTMLExporterConvert} from "./convert.js"
+import {htmlExportTemplate} from "./templates.js"
+/*
+ Exporter to HTML
+*/
+
+export class HTMLExporter {
+    constructor(
+        doc,
+        bibDB,
+        imageDB,
+        csl,
+        updated,
+        documentStyles,
+        converterOptions = {},
+        template = htmlExportTemplate
+    ) {
+        this.doc = doc
+        this.bibDB = bibDB
+        this.imageDB = imageDB
+        this.csl = csl
+        this.updated = updated
+        this.documentStyles = documentStyles
+        this.converterOptions = converterOptions
+
+        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
+
+        this.docContent = false
+        this.zipFileName = false
+        this.textFiles = []
+        this.httpFiles = []
+        this.includeZips = []
+        this.metaData = {} // Information to be used in sub classes.
+        // To override in subclasses
+        this.htmlExportTemplate = template
+        this.contentFileName = "document.html"
+        this.fileEnding = "html.zip"
+        this.mimeType = "application/zip"
+
+        // Stylesheets will have one of:
+        // * a url - which means they will be fetched before they are included as a separate file
+        // * a filename and contents - which means they will be included as a separate file
+        // * only contents - which means they will be incldued inside <style></style> tags in the document header
+        // * only filename - which means they will be referenced as a separate file. You need to add the file yourself.
+        this.styleSheets = [{url: staticUrl("css/document.css")}]
+    }
+
+    async init() {
+        await this.process()
+        return await this.createZip()
+    }
+
+    async process() {
+        // Process the document and prepare files
+        this.zipFileName = `${createSlug(this.docTitle)}.${this.fileEnding}`
+        this.docContent = removeHidden(this.doc.content)
+
+        const docStyle = this.getDocStyle(this.doc)
+
+        if (docStyle) {
+            this.styleSheets.push(docStyle)
+        }
+        await Promise.all(
+            this.styleSheets.map(async sheet => await this.loadStyle(sheet))
+        )
+
+        this.converter = new HTMLExporterConvert(
+            this.docTitle,
+            this.doc.settings,
+            this.docContent,
+            this.htmlExportTemplate,
+            this.imageDB,
+            this.bibDB,
+            this.csl,
+            this.styleSheets,
+            this.converterOptions
+        )
+        const {html, imageIds, metaData, extraStyleSheets} =
+            await this.converter.init()
+        this.metaData = metaData
+        if (this.converter.features.math) {
+            this.includeZips.push({
+                directory: "css",
+                url: staticUrl("zip/mathlive_style.zip")
+            })
+        }
+        this.addDoc(html)
+        this.addImages(imageIds)
+        await Promise.all(
+            extraStyleSheets.map(async sheet => await this.loadStyle(sheet))
+        )
+    }
+
+    getProcessedFiles() {
+        // Return the processed files and metadata. Used when using the
+        // exporter in a different context than creating a zip file.
+        return {
+            textFiles: this.textFiles,
+            httpFiles: this.httpFiles,
+            includeZips: this.includeZips,
+            metaData: this.metaData,
+            converter: this.converter
+        }
+    }
+
+    addDoc(html) {
+        this.textFiles.push({
+            filename: this.contentFileName,
+            contents: pretty(html, {ocd: true})
+        })
+    }
+
+    addImages(imageIds) {
+        imageIds.forEach(id => {
+            const image = this.imageDB.db[id]
+            this.httpFiles.push({
+                filename: `images/${image.image.split("/").pop()}`,
+                url: image.image
+            })
+        })
+    }
+
+    getDocStyle(doc) {
+        const docStyle = this.documentStyles.find(
+            docStyle => docStyle.slug === doc.settings.documentstyle
+        )
+
+        // The files will be in the base directory. The filenames of
+        // DocumentStyleFiles will therefore not need to replaced with their URLs.
+        if (!docStyle) {
+            return false
+        }
+        let contents = docStyle.contents
+        docStyle.documentstylefile_set.forEach(
+            ([_url, filename]) =>
+                (contents = contents.replace(
+                    new RegExp(filename, "g"),
+                    `media/${filename}`
+                ))
+        )
+        this.httpFiles = this.httpFiles.concat(
+            docStyle.documentstylefile_set.map(([url, filename]) => ({
+                filename: `css/media/${filename}`,
+                url
+            }))
+        )
+        return {contents, filename: `css/${docStyle.slug}.css`}
+    }
+
+    async loadStyle(sheet) {
+        if (sheet.url) {
+            // Use simple fetch without X-Requested-With header and credentials
+            // to avoid CORS preflight redirect issues with CDNs
+            const response = await fetch(sheet.url)
+            if (!response.ok) {
+                throw response
+            }
+            const text = await response.text()
+            sheet.contents = text
+            sheet.filename = `css/${sheet.url.split("/").pop().split("?")[0]}`
+            delete sheet.url
+        }
+        if (sheet.filename) {
+            this.textFiles.push(sheet)
+        }
+        return Promise.resolve(sheet)
+    }
+
+    async createZip() {
+        const zipper = new ZipFileCreator(
+            this.textFiles,
+            this.httpFiles,
+            this.includeZips,
+            this.mimeType,
+            this.updated
+        )
+        const blob = await zipper.init()
+        return this.download(blob)
+    }
+
+    download(blob) {
+        return download(blob, this.zipFileName, this.mimeType)
+    }
+}

package/src/exporter/html/templates.js

@@ -0,0 +1,34 @@
+import {escapeText} from "../../common/index.js"
+
+/** A template for HTML export of a document. */
+export const htmlExportTemplate = ({
+    head,
+    body,
+    back,
+    settings,
+    lang,
+    xhtml,
+    epub
+}) =>
+    `${xhtml ? '<?xml version="1.0" encoding="UTF-8"?>' : "<!DOCTYPE html>"}
+    <html ${xhtml ? `xmlns="http://www.w3.org/1999/xhtml" ${epub ? 'xmlns:epub="http://www.idpf.org/2007/ops"' : ""}` : ""} lang="${lang}"${xhtml ? ` xml:lang="${lang}"` : ""}>
+    <head>
+        <meta charset="UTF-8"${xhtml ? " /" : ""}>
+        ${settings.copyright && settings.copyright.holder ? `<meta name="copyright" content="© ${settings.copyright.year ? settings.copyright.year : new Date().getFullYear()} ${escapeText(settings.copyright.holder)}"${xhtml ? " /" : ""}>` : ""}
+        ${head}
+    </head>
+    <body class="doc user-contents">
+        ${body}
+        ${back}
+        ${
+            settings.copyright && settings.copyright.holder
+                ? `<div>© ${settings.copyright.year ? settings.copyright.year : new Date().getFullYear()} ${escapeText(settings.copyright.holder)}</div>`
+                : ""
+        }
+        ${
+            settings.copyright && settings.copyright.licenses.length
+                ? `<div>${settings.copyright.licenses.map(license => `<a rel="license" href="${escapeText(license.url)}">${escapeText(license.title)}${license.start ? ` (${license.start})` : ""}</a>`).join("</div><div>")}</div>`
+                : ""
+        }
+    </body>
+</html>`

package/src/exporter/html/tools.js

@@ -0,0 +1,50 @@
+const numberToRoman = number => {
+    let roman = ""
+    const romanNumList = {
+        M: 1000,
+        CM: 900,
+        D: 500,
+        CD: 400,
+        C: 100,
+        XC: 90,
+        L: 50,
+        XL: 40,
+        X: 10,
+        IX: 9,
+        V: 5,
+        IV: 4,
+        I: 1
+    }
+    let a
+    for (const key in romanNumList) {
+        a = Math.floor(number / romanNumList[key])
+        if (a >= 0) {
+            for (let i = 0; i < a; i++) {
+                roman += key
+            }
+        }
+        number = number % romanNumList[key]
+    }
+    return roman
+}
+
+const numberToAlpha = number => {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    let alpha = ""
+    let a
+    for (let i = 0; i < number; i++) {
+        a = i % 26
+        alpha += alphabet[a]
+    }
+    return alpha
+}
+
+export const displayNumber = (number, system) => {
+    if (system === "roman") {
+        return numberToRoman(number)
+    }
+    if (system === "alpha") {
+        return numberToAlpha(number)
+    }
+    return number
+}

package/src/exporter/jats/bibliography.js

@@ -0,0 +1,183 @@
+import {escapeText} from "../../common/index.js"
+import {convertTexts} from "./text.js"
+
+// This list is based on values listed at https://jats.nlm.nih.gov/archiving/tag-library/1.2/attribute/publication-type.html
+// And the advice given here: https://jats4r.org/citations/#recommendation
+const PUBLICATION_TYPES = {
+    article: "journal",
+    "article-journal": "journal",
+    "article-magazine": "journal",
+    "article-newspaper": "journal",
+    book: "book",
+    bookinbook: "book",
+    booklet: "book",
+    chapter: "book",
+    collection: "standard",
+    dataset: "dataset",
+    "entry-dictionary": "standard",
+    "entry-encyclopedia": "standard",
+    inbook: "book",
+    incollection: "book",
+    inproceedings: "standard",
+    inreference: "standard",
+    manual: "book",
+    misc: "standard",
+    mvbook: "book",
+    mvcollection: "standard",
+    mvproceedings: "book",
+    mvreference: "standard",
+    online: "standard",
+    patent: "patent",
+    periodical: "book",
+    post: "standards",
+    "post-weblog": "standard",
+    proceedings: "book",
+    reference: "standard",
+    report: "report",
+    review: "review",
+    suppbook: "book",
+    suppcollection: "book",
+    suppperiodical: "journal",
+    thesis: "standard",
+    unpublished: "standard"
+}
+
+export function jatsBib(bib, id) {
+    let start = "",
+        end = ""
+    start += `<ref id="ref-${id}">`
+    end = "</ref>" + end
+    // Type
+    const publicationType = PUBLICATION_TYPES[bib.bib_type] ?? "standard"
+    start += `<element-citation publication-type="${publicationType}">`
+    end = "</element-citation>" + end
+
+    // authors
+    if (bib.fields.author && bib.fields.author.length) {
+        start += `<person-group person-group-type="author">${bib.fields.author
+            .map(author => {
+                if (author.literal) {
+                    return `<collab>${convertTexts(author.literal)}</collab>`
+                }
+                let nameStart = `<name><surname>${convertTexts(author.family)}</surname> <given-names>${convertTexts(author.given)}</given-names>`
+                if (author.prefix && author.prefix.length) {
+                    nameStart += ` <prefix>${convertTexts(author.prefix)}</prefix>`
+                }
+                if (author.suffix && author.suffix.length) {
+                    nameStart += ` <suffix>${convertTexts(author.suffix)}</suffix>`
+                }
+                const nameEnd = "</name>"
+                return nameStart + nameEnd
+            })
+            .join(", ")}</person-group>`
+    }
+
+    // title && container title
+    if (bib.fields.title) {
+        if (
+            bib.fields.shortjournal ||
+            bib.fields.booktitle ||
+            bib.fields.journaltitle
+        ) {
+            start += `<source>${convertTexts(bib.fields.shortjournal || bib.fields.booktitle || bib.fields.journaltitle)}</source>`
+            start += `<article-title>${convertTexts(bib.fields.title)}</article-title>`
+        } else {
+            start += `<source>${convertTexts(bib.fields.title)}</source>`
+        }
+    }
+
+    // editors
+    if (bib.fields.editor && bib.fields.editor.length) {
+        start += `<person-group person-group-type="editor">${bib.fields.editor
+            .map(editor => {
+                if (editor.literal) {
+                    return `<collab>${convertTexts(editor.literal)}</collab>`
+                }
+                let nameStart = `<name><surname>${convertTexts(editor.family)}</surname> <given-names>${convertTexts(editor.given)}</given-names>`
+                const nameEnd = "</name>"
+                if (editor.prefix && editor.prefix.length) {
+                    nameStart = `<prefix>${convertTexts(editor.prefix)}</prefix>`
+                }
+                if (editor.suffix && editor.suffix.length) {
+                    nameStart = `<suffix>${convertTexts(editor.suffix)}</suffix>`
+                }
+                return nameStart + nameEnd
+            })
+            .join(", ")}</person-group>`
+    }
+
+    // publisher
+    if (bib.fields.publisher && bib.fields.publisher.length) {
+        start += bib.fields.publisher
+            .map(
+                publisher =>
+                    `<publisher-name>${convertTexts(publisher)}</publisher-name>`
+            )
+            .join("")
+    }
+
+    // location
+    if (bib.fields.location && bib.fields.location.length) {
+        start += bib.fields.location
+            .map(
+                location =>
+                    `<publisher-loc>${convertTexts(location)}</publisher-loc>`
+            )
+            .join("")
+    }
+
+    // date
+    if (bib.fields.date && bib.fields.date.length) {
+        const date = bib.fields.date
+        const dateParts = date.split("-")
+        start += `<date iso-8601-date="${date}" date-type="published">${
+            dateParts.length > 2 ? `<day>${dateParts[2]}</day>` : ""
+        }${
+            dateParts.length > 1 ? `<month>${dateParts[1]}</month>` : ""
+        }<year>${dateParts[0]}</year></date>`
+    }
+
+    // volume
+    if (bib.fields.volume && bib.fields.volume.length) {
+        start += `<volume>${convertTexts(bib.fields.volume)}</volume>`
+    }
+
+    // issue
+    if (bib.fields.issue && bib.fields.issue.length) {
+        start += `<issue>${convertTexts(bib.fields.issue)}</issue>`
+    }
+
+    // pages
+    if (bib.fields.pages && bib.fields.pages.length) {
+        start += `<fpage>${convertTexts(bib.fields.pages[0][0])}</fpage>`
+        start += `<lpage>${convertTexts(bib.fields.pages.slice(-1)[0].slice(-1)[0])}</lpage>`
+        if (bib.fields.pages.length > 1) {
+            start += `<page-range>${bib.fields.pages
+                .map(pages => pages.map(page => convertTexts(page)).join("-"))
+                .join(", ")}</page-range>`
+        }
+    }
+
+    // doi
+    if (bib.fields.doi && bib.fields.doi.length) {
+        start += `<pub-id pub-id-type="doi">${escapeText(bib.fields.doi)}</pub-id>`
+    }
+
+    // url
+    if (bib.fields.url && bib.fields.url.length) {
+        start += `<ext-link ext-link-type="web" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="${escapeText(bib.fields.url)}"/>`
+    }
+
+    // url date
+    if (bib.fields.urldate && bib.fields.urldate.length) {
+        const date = bib.fields.urldate
+        const dateParts = date.split("-")
+        start += `<date-in-citation content-type="access-date" iso-8601-date="${date}">${
+            dateParts.length > 2 ? `<day>${dateParts[2]}</day>` : ""
+        }${
+            dateParts.length > 1 ? `<month>${dateParts[1]}</month>` : ""
+        }<year>${dateParts[0]}</year></date-in-citation>`
+    }
+
+    return start + end
+}

package/src/exporter/jats/citations.js

@@ -0,0 +1,109 @@
+import {FormatCitations} from "../../citations/format.js"
+
+import {jatsBib} from "./bibliography.js"
+
+export class JATSExporterCitations {
+    constructor(doc, bibDB, csl) {
+        this.doc = doc
+        this.bibDB = bibDB
+        this.csl = csl
+
+        this.citationTexts = []
+        this.citFm = false
+        this.jatsBib = ""
+        this.jatsIdConvert = {}
+    }
+
+    init(citInfos) {
+        this.citInfos = citInfos
+        if (!citInfos.length) {
+            return Promise.resolve()
+        }
+        return this.formatCitations()
+    }
+
+    // Citations are highly interdependent -- so we need to format them all
+    // together before laying out the document.
+    // We disregard the styling of the bibliography and instead create our own, JATS-specific bibliography.
+    formatCitations() {
+        return this.csl
+            .getStyle(this.doc.settings.citationstyle)
+            .then(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.doc.settings.language
+                )
+                return Promise.all([
+                    Promise.resolve(origCitationLayout),
+                    this.citFm.init()
+                ])
+            })
+            .then(([origCitationLayout]) => {
+                // We need to add xref-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 jats bibliography are 1 and up in this order
+                this.citFm.bibliography[0].entry_ids.forEach((id, index) => {
+                    this.jatsIdConvert[id] = index + 1
+                    this.jatsBib += jatsBib(this.bibDB.db[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 jatsId = this.jatsIdConvert[citId]
+                                return `${prefix}<xref ref-type="bibr" rid="ref-${jatsId}">${citationText}</xref>${suffix}`
+                            })
+                            .join(origCitationLayout.delimiter || "")
+                        return content
+                            .replace(/<b>/g, "<bold>")
+                            .replace(/<\/b>/g, "</bold>")
+                            .replace(/<i>/g, "<italic>")
+                            .replace(/<\/i>/g, "</italic>")
+                            .replace(
+                                /<span style="font-variant:small-caps;">/g,
+                                "<sc>"
+                            )
+                            .replace(/<\/span>/g, "</sc>")
+                    }
+                )
+                return Promise.resolve()
+            })
+    }
+}