@fiduswriter/document 0.1.0-alpha.1

package/src/exporter/pandoc/index.js

@@ -0,0 +1,92 @@
+import {BibLatexExporter} from "biblatex-csl-converter"
+import download from "downloadjs"
+
+import {shortFileTitle} from "../../common/index.js"
+import {fixTables, removeHidden} from "../tools/doc_content.js"
+import {createSlug} from "../tools/file.js"
+import {ZipFileCreator} from "../tools/zip.js"
+import {PandocExporterCitations} from "./citations.js"
+import {PandocExporterConvert} from "./convert.js"
+import {readMe} from "./readme.js"
+/*
+ Exporter to Pandoc JSON
+*/
+
+export class PandocExporter {
+    constructor(doc, bibDB, imageDB, csl, updated) {
+        this.doc = doc
+        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
+        this.bibDB = bibDB
+        this.imageDB = imageDB
+        this.csl = csl
+        this.updated = updated
+
+        this.docContent = false
+        this.zipFileName = ""
+        this.textFiles = []
+        this.httpFiles = []
+    }
+
+    init() {
+        //this.docContent = removeHidden(this.doc.content) //
+        this.docContent = fixTables(removeHidden(this.doc.content))
+        this.citations = new PandocExporterCitations(
+            this,
+            this.bibDB,
+            this.csl,
+            this.docContent
+        )
+        this.converter = new PandocExporterConvert(
+            this,
+            this.imageDB,
+            this.bibDB,
+            this.doc.settings
+        )
+        return this.citations.init().then(() => {
+            this.conversion = this.converter.init(this.docContent)
+            if (Object.keys(this.conversion.usedBibDB).length > 0) {
+                const bibExport = new BibLatexExporter(
+                    this.conversion.usedBibDB
+                )
+                this.textFiles.push({
+                    filename: "bibliography.bib",
+                    contents: bibExport.parse()
+                })
+            }
+
+            this.conversion.imageIds.forEach(id => {
+                this.httpFiles.push({
+                    filename: this.imageDB.db[id].image.split("/").pop(),
+                    url: this.imageDB.db[id].image
+                })
+            })
+            return this.createExport()
+        })
+    }
+
+    createExport() {
+        // Override this function if adding a conversion-through-pandoc step.
+        this.textFiles.push({
+            filename: "document.json",
+            contents: JSON.stringify(this.conversion.json, null, 4)
+        })
+        this.textFiles.push({filename: "README.txt", contents: readMe})
+        this.zipFileName = `${createSlug(this.docTitle)}.pandoc.json.zip`
+        return this.createDownload()
+    }
+
+    createDownload() {
+        // This creates a ZIP file with JSON sources included and then returns a promise for the download of the file.
+        const zipper = new ZipFileCreator(
+            this.textFiles,
+            this.httpFiles,
+            undefined,
+            undefined,
+            this.updated
+        )
+
+        return zipper
+            .init()
+            .then(blob => download(blob, this.zipFileName, "application/zip"))
+    }
+}

package/src/exporter/pandoc/readme.js

@@ -0,0 +1,8 @@
+export const readMe = `Unzip the contents of this file to a folder and convert it then to another format
+using pandoc like this:
+
+pandoc document.json -o document.html
+
+Replace "document.html" with other formats you may want.
+
+`

package/src/exporter/pandoc/tools.js

@@ -0,0 +1,51 @@
+export const convertText = text => {
+    const textContent = []
+    if (!text.length) {
+        return []
+    }
+    const words = text.split(" ")
+    words.forEach((c, index) => {
+        if (c) {
+            textContent.push({
+                t: "Str",
+                c
+            })
+        }
+        if (index < words.length - 1) {
+            textContent.push({
+                t: "Space"
+            })
+        }
+    })
+    return textContent
+}
+
+export const convertContributor = contributor => {
+    const contributorContent = []
+    if (contributor.firstname || contributor.lastname) {
+        const nameParts = []
+        if (contributor.lastname) {
+            nameParts.push(contributor.lastname)
+        }
+        if (contributor.firstname) {
+            nameParts.push(contributor.firstname)
+        }
+        contributorContent.push(...convertText(nameParts.join(" ")))
+    } else if (contributor.institution) {
+        contributorContent.push(...convertText(contributor.institution))
+    }
+    if (contributor.email) {
+        contributorContent.push({
+            t: "Note",
+            c: [
+                {
+                    t: "Para",
+                    c: convertText(contributor.email)
+                }
+            ]
+        })
+    }
+    return contributorContent.length
+        ? {t: "MetaInlines", c: contributorContent}
+        : false
+}

package/src/exporter/print/index.js

@@ -0,0 +1,177 @@
+import {printHTML} from "@vivliostyle/print"
+import {addAlert, shortFileTitle} from "../../common/index.js"
+import {PAPER_SIZES} from "../../schema/const.js"
+import {HTMLExporter} from "../html/index.js"
+import {HTMLExporterConvert} from "../html/convert.js"
+import {removeHidden} from "../tools/doc_content.js"
+
+export class PrintExporter extends HTMLExporter {
+    constructor(doc, bibDB, imageDB, csl, updated, documentStyles) {
+        super(doc, bibDB, imageDB, csl, updated, documentStyles, {
+            relativeUrls: false
+        })
+    }
+
+    async init() {
+        addAlert(
+            "info",
+            `${shortFileTitle(this.doc.title, this.doc.path)}: ${gettext("Printing has been initiated.")}`
+        )
+        this.docContent = removeHidden(this.doc.content)
+
+        const styleSheets = [
+            {url: staticUrl("css/document.css")},
+            {
+                contents: `a.footnote, a.affiliation {
+                    -adapt-template: url(data:application/xml,${encodeURI(
+                        '<html xmlns="http://www.w3.org/1999/xhtml" xmlns:s="http://www.pyroxy.com/ns/shadow"><head><style>.footnote-content{float:footnote}</style></head><body><s:template id="footnote"><s:content/><s:include class="footnote-content"/></s:template></body></html>#footnote'
+                    )});
+                    text-decoration: none;
+                    color: inherit;
+                    vertical-align: baseline;
+                    font-size: 70%;
+                    position: relative;
+                    top: -0.3em;
+                }
+                aside.footnote label:first-child, aside.footnote *:nth-child(2),
+                aside.affiliation label:first-child, aside.affiliation *:nth-child(2) {
+                    display: inline;
+                }
+                aside.footnote label:first-child:after,
+                aside.affiliation label:first-child:after  {
+                    content: '. '
+                }
+
+                body, section[role=doc-footnotes] {
+                    counter-reset: cat-figure cat-equation cat-photo cat-table footnote-counter footnote-marker-counter;
+                }
+                section#affiliations, section#footnotes  {
+                    display: none;
+                }
+                section:footnote-content {
+                    display: block;
+                    font-size: small;
+                    font-style: normal;
+                    font-weight: normal;
+                    text-decoration: none;
+                    text-indent: 0;
+                    text-align: initial;
+                }
+                .table-of-contents a {
+                	display: inline-flex;
+                	width: 100%;
+                	text-decoration: none;
+                	color: currentColor;
+                	break-inside: avoid;
+                	align-items: baseline;
+                }
+                .table-of-contents a::before {
+                	margin-left: 1px;
+                	margin-right: 1px;
+                	border-bottom: solid 1px lightgray;
+                	content: "";
+                	order: 1;
+                	flex: auto;
+                }
+                .table-of-contents a::after {
+                	text-align: right;
+                	content: target-counter(attr(href, url), page);
+                	align-self: flex-end;
+                	flex: none;
+                	order: 2;
+                }
+                body {
+                    background-color: white;
+                }
+                @page {
+                    size: ${PAPER_SIZES.find(size => size[0] === this.doc.settings.papersize)[1]};
+                    @top-center {
+                        content: env(doc-title);
+                    }
+                    @bottom-center {
+                        content: counter(page);
+                    }
+                }`
+            }
+        ]
+
+        const docStyle = this.getDocStyle(this.doc)
+
+        if (docStyle) {
+            styleSheets.push(docStyle)
+        }
+
+        await Promise.all(
+            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,
+            styleSheets,
+            {
+                relativeUrls: false
+            }
+        )
+
+        const {html, metaData} = await this.converter.init()
+
+        const config = {title: metaData.title}
+
+        if (navigator.userAgent.includes("Gecko/")) {
+            // Firefox has issues printing images when in iframe. This workaround can be
+            // removed once that has been fixed. TODO: Add gecko bug number if there is one.
+            config.printCallback = iframeWin => {
+                const oldBody = document.body
+                document.body.parentElement.dataset.vivliostylePaginated = true
+                document.body = iframeWin.document.body
+                document.body
+                    .querySelectorAll("figure, table")
+                    .forEach(el => delete el.dataset.category)
+                iframeWin.document
+                    .querySelectorAll("style")
+                    .forEach(el => document.body.appendChild(el))
+                const backgroundStyle = document.createElement("style")
+                backgroundStyle.innerHTML = "body {background-color: white;}"
+                document.body.appendChild(backgroundStyle)
+                window.print()
+                document.body = oldBody
+                delete document.body.parentElement.dataset.vivliostylePaginated
+            }
+        }
+        return printHTML(html, config)
+    }
+
+    getDocStyle(doc) {
+        // Override the default as we need to use the original URLs in print.
+        const docStyle = this.documentStyles.find(
+            docStyle => docStyle.slug === doc.settings.documentstyle
+        )
+        if (!docStyle) {
+            return
+        }
+
+        let contents = docStyle.contents
+        docStyle.documentstylefile_set.forEach(
+            ([url, filename]) =>
+                (contents = contents.replace(
+                    new RegExp(filename, "g"),
+                    new URL(url, window.location).href
+                ))
+        )
+        return {contents}
+    }
+
+    loadStyle(sheet) {
+        if (sheet.url) {
+            sheet.filename = sheet.url
+            delete sheet.url
+        }
+        return Promise.resolve()
+    }
+}

package/src/exporter/tools/doc_content.js

@@ -0,0 +1,144 @@
+// Return a json that is the same as the existing json, but with all parts
+// marked as hidden removed.
+
+export const removeHidden = (
+    node,
+    // Whether to leave the outer part of the removed node.
+    // True for tree-walking exporters, false for DOM-changing exporters.
+    leaveStub = true,
+    removeTableCaption = false,
+    removeTableCaptionText = false,
+    removeFigureCaption = false,
+    removeFigureCaptionText = false
+) => {
+    const returnNode = {}
+
+    Object.keys(node).forEach(key => {
+        if (key !== "content") {
+            returnNode[key] = node[key]
+        }
+    })
+    if (node.attrs?.hidden) {
+        return leaveStub ? returnNode : false
+    } else if ("table_caption" === node.type) {
+        if (removeTableCaption) {
+            return leaveStub ? returnNode : false
+        } else if (removeTableCaptionText) {
+            return returnNode
+        }
+    } else if ("figure_caption" === node.type) {
+        if (removeFigureCaption) {
+            return leaveStub ? returnNode : false
+        } else if (removeFigureCaptionText) {
+            return returnNode
+        }
+    }
+    if (node.attrs?.caption === false) {
+        if (node.attrs.category === "none") {
+            if (node.type === "figure") {
+                removeFigureCaption = true
+            } else {
+                removeTableCaption = true
+            }
+        } else {
+            if (node.type === "figure") {
+                removeFigureCaptionText = true
+            } else {
+                removeTableCaptionText = true
+            }
+        }
+    }
+    if (node.content) {
+        returnNode.content = []
+        node.content.forEach(child => {
+            const cleanedChild = removeHidden(
+                child,
+                leaveStub,
+                removeTableCaption,
+                removeTableCaptionText,
+                removeFigureCaption,
+                removeFigureCaptionText
+            )
+            if (cleanedChild) {
+                returnNode.content.push(cleanedChild)
+            }
+        })
+    }
+    return returnNode
+}
+
+export const descendantNodes = node => {
+    let returnValue = [node]
+    if (node.content) {
+        node.content.forEach(childNode => {
+            returnValue = returnValue.concat(descendantNodes(childNode))
+        })
+    }
+    return returnValue
+}
+
+export const textContent = node =>
+    descendantNodes(node).reduce((returnString, subNode) => {
+        if (subNode.text) {
+            returnString += subNode.text
+        }
+        return returnString
+    }, "")
+
+// PM/HTML don't have cells that have been covered, but in ODT/DOCX, these cells
+// need to be present. So we add them.
+
+const addCoveredTableCells = node => {
+    const columns = node.content[0].content.reduce(
+        (columns, cell) => columns + cell.attrs.colspan,
+        0
+    )
+    const rows = node.content.length
+    // Add empty cells for col/rowspan
+    const fixedTableMatrix = Array.apply(0, {length: rows}).map(_item => ({
+        type: "table_row",
+        content: Array.apply(0, {length: columns})
+    }))
+    let rowIndex = -1
+    node.content.forEach(row => {
+        let columnIndex = 0
+        rowIndex++
+        if (!row.content) {
+            return
+        }
+        row.content.forEach(cell => {
+            while (fixedTableMatrix[rowIndex].content[columnIndex]) {
+                columnIndex++
+            }
+            for (let i = 0; i < cell.attrs.rowspan; i++) {
+                for (let j = 0; j < cell.attrs.colspan; j++) {
+                    let fixedCell
+                    if (i === 0 && j === 0) {
+                        fixedCell = cell
+                    } else {
+                        fixedCell = {
+                            type: "table_cell",
+                            attrs: {
+                                rowspan: cell.attrs.rowspan > 1 ? 0 : 1,
+                                colspan: cell.attrs.colspan > 1 ? 0 : 1
+                            }
+                        }
+                    }
+                    fixedTableMatrix[rowIndex + i].content[columnIndex + j] =
+                        fixedCell
+                }
+            }
+        })
+    })
+    node.content = fixedTableMatrix
+}
+
+export const fixTables = node => {
+    if (node.type === "table_body") {
+        addCoveredTableCells(node)
+    }
+    if (node.content) {
+        node.content.forEach(child => fixTables(child))
+    }
+    return node
+}

package/src/exporter/tools/file.js

@@ -0,0 +1,9 @@
+export const createSlug = str => {
+    if (str === "") {
+        str = gettext("Untitled")
+    }
+    str = str.replace(/[^a-zA-Z0-9\s]/g, "")
+    str = str.toLowerCase()
+    str = str.replace(/\s/g, "-")
+    return str
+}

package/src/exporter/tools/json.js

@@ -0,0 +1,73 @@
+/** Same functionality as objToNode/nodeToObj in diffDOM.js, but also offers output in XHTML format (obj2Node) and without form support. */
+export const obj2Node = (obj, docType) => {
+    let parser
+    if (obj === undefined) {
+        return false
+    }
+    if (docType === "xhtml") {
+        parser = new window.DOMParser().parseFromString("<xml/>", "text/xml")
+    } else {
+        parser = document
+    }
+
+    function inner(obj, insideSvg) {
+        let node
+        if (obj.hasOwnProperty("t")) {
+            node = parser.createTextNode(obj.t)
+        } else if (obj.hasOwnProperty("co")) {
+            node = parser.createComment(obj.co)
+        } else {
+            if (obj.nn === "svg" || insideSvg) {
+                node = parser.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    obj.nn
+                )
+                insideSvg = true
+            } else if (obj.nn === "script") {
+                // Do not allow scripts
+                return parser.createTextNode("")
+            } else {
+                node = parser.createElement(obj.nn.toLowerCase())
+            }
+            if (obj.a) {
+                for (let i = 0; i < obj.a.length; i++) {
+                    node.setAttribute(obj.a[i][0], obj.a[i][1])
+                }
+            }
+            if (obj.c) {
+                for (let i = 0; i < obj.c.length; i++) {
+                    node.appendChild(inner(obj.c[i], insideSvg))
+                }
+            }
+        }
+        return node
+    }
+    return inner(obj)
+}
+
+export const node2Obj = node => {
+    const obj = {}
+
+    if (node.nodeType === 3) {
+        obj.t = node.data
+    } else if (node.nodeType === 8) {
+        obj.co = node.data
+    } else {
+        obj.nn = node.nodeName
+        if (node.attributes?.length > 0) {
+            obj.a = []
+            for (let i = 0; i < node.attributes.length; i++) {
+                obj.a.push([node.attributes[i].name, node.attributes[i].value])
+            }
+        }
+        if (node.childNodes?.length > 0) {
+            obj.c = []
+            for (let i = 0; i < node.childNodes.length; i++) {
+                if (node.childNodes[i]) {
+                    obj.c.push(node2Obj(node.childNodes[i]))
+                }
+            }
+        }
+    }
+    return obj
+}

package/src/exporter/tools/svg.js

@@ -0,0 +1,29 @@
+import {convertDataURIToBlob} from "../../common/index.js"
+
+export function svg2png(blob) {
+    const img = document.createElement("img")
+    const src = URL.createObjectURL(blob)
+    img.src = src
+    img.setAttribute("style", "position:fixed;left:-200vw;")
+    return new Promise(resolve => {
+        img.onload = function onload() {
+            const canvas = document.createElement("canvas")
+            const ctx = canvas.getContext("2d")
+            const ratio = Math.min(
+                Math.min(img.width, img.height) / img.width,
+                Math.min(img.width, img.height) / img.height
+            )
+            const width = img.width * ratio
+            const height = img.height * ratio
+            canvas.width = width
+            canvas.height = height
+            ctx.drawImage(img, 0, 0, width, height)
+            const src = canvas.toDataURL("image/png")
+            img.parentElement.removeChild(img)
+            URL.revokeObjectURL(src)
+            const pngBlob = convertDataURIToBlob(src)
+            resolve({blob: pngBlob, width, height})
+        }
+        document.body.appendChild(img)
+    })
+}