@fiduswriter/document 0.1.0-alpha.4 → 0.1.0-alpha.5

package/src/exporter/native/zip.ts

@@ -0,0 +1,85 @@
+import {ZipFileCreator} from "../tools/zip.js"
+import {FW_DOCUMENT_VERSION} from "../../schema/index.js"
+
+import type {TemplateFiles} from "../../types.js"
+
+export class ZipFidus {
+    docId: string | number
+    doc: Record<string, unknown>
+    shrunkImageDB: Record<string, Record<string, unknown>>
+    shrunkBibDB: Record<string, Record<string, unknown>>
+    httpFiles: Array<{url: string; filename: string}>
+    includeTemplate: boolean
+    token: string | boolean
+    getTemplateFiles?: (
+        docId: string | number,
+        token: string | boolean
+    ) => Promise<TemplateFiles>
+
+    textFiles: Array<{filename: string; contents: string}> = []
+
+    constructor(
+        docId: string | number,
+        doc: Record<string, unknown>,
+        shrunkImageDB: Record<string, Record<string, unknown>>,
+        shrunkBibDB: Record<string, Record<string, unknown>>,
+        httpFiles: Array<{url: string; filename: string}>,
+        includeTemplate = true,
+        token: string | boolean = false,
+        getTemplateFiles?: (
+            docId: string | number,
+            token: string | boolean
+        ) => Promise<TemplateFiles>
+    ) {
+        this.docId = docId
+        this.doc = doc
+        this.shrunkImageDB = shrunkImageDB
+        this.shrunkBibDB = shrunkBibDB
+        this.httpFiles = httpFiles
+        this.includeTemplate = includeTemplate
+        this.token = token
+        this.getTemplateFiles = getTemplateFiles
+
+        this.textFiles = [
+            {
+                filename: "document.json",
+                contents: JSON.stringify(this.doc)
+            },
+            {
+                filename: "images.json",
+                contents: JSON.stringify(this.shrunkImageDB)
+            },
+            {
+                filename: "bibliography.json",
+                contents: JSON.stringify(this.shrunkBibDB)
+            },
+            {
+                filename: "filetype-version",
+                contents: FW_DOCUMENT_VERSION
+            }
+        ]
+    }
+
+    init(): Promise<Blob> {
+        if (!this.includeTemplate || !this.getTemplateFiles) {
+            return this.createZip()
+        }
+        return this.getTemplateFiles(this.docId, this.token).then(
+            ({textFiles, httpFiles}) => {
+                this.textFiles = this.textFiles.concat(textFiles)
+                this.httpFiles = this.httpFiles.concat(httpFiles)
+                return this.createZip()
+            }
+        )
+    }
+
+    createZip(): Promise<Blob> {
+        const zipper = new ZipFileCreator(
+            this.textFiles,
+            this.httpFiles,
+            [],
+            "application/fidus+zip"
+        )
+        return zipper.init()
+    }
+}

package/src/exporter/odt/{citations.js → citations.ts}

@@ -3,10 +3,26 @@ import {DOMParser, DOMSerializer} from "prosemirror-model"
 import {cslBibSchema} from "../../bibliography/csl_bib.js"
 import {FormatCitations} from "../../citations/format.js"
 import {fnSchema} from "../../schema/footnotes.js"
+import type {BibDB, CSL, DocSettings, FidusNode} from "../../types.js"
 import {descendantNodes} from "../tools/doc_content.js"
+import type {ODTExporterStyles} from "./styles.js"
 
 export class ODTExporterCitations {
-    constructor(docContent, settings, styles, bibDB, csl, origCitInfos = []) {
+    docContent: FidusNode
+    settings: DocSettings
+    styles: ODTExporterStyles
+    bibDB: BibDB
+    csl: CSL
+    // If citInfos were found in a previous run, they are stored here
+    // (for example: first citations in main document, then in footnotes)
+    origCitInfos: Record<string, unknown>[]
+    citInfos: Record<string, unknown>[]
+    citationTexts: string[]
+    pmCits: FidusNode[]
+    citFm: FormatCitations | false
+    pmBib: FidusNode | false
+
+    constructor(docContent: FidusNode, settings: DocSettings, styles: ODTExporterStyles, bibDB: BibDB, csl: CSL, origCitInfos: Record<string, unknown>[] = []) {
         this.docContent = docContent
         this.settings = settings
         this.styles = styles
@@ -22,13 +38,13 @@ export class ODTExporterCitations {
         this.pmBib = false
     }
 
-    init() {
+    init(): Promise<void> {
         return this.formatCitations()
     }
 
     // Citations are highly interdependent -- so we need to format them all
     // together before laying out the document.
-    formatCitations() {
+    formatCitations(): Promise<void> {
         if (this.origCitInfos.length) {
             // Initial citInfos are taken from a previous run to include in
             // bibliography, and they are removed before spitting out the
@@ -38,21 +54,22 @@ export class ODTExporterCitations {
         }
 
         descendantNodes(this.docContent).forEach(node => {
-            if (node.type === "citation") {
+            if (node.type === "citation" && node.attrs) {
                 this.citInfos.push(JSON.parse(JSON.stringify(node.attrs)))
             }
         })
-        this.citFm = new FormatCitations(
+        const citFm = new FormatCitations(
             this.csl,
-            this.citInfos,
-            this.settings.citationstyle,
+            this.citInfos as any,
+            this.settings.citationstyle || "",
             "",
             this.bibDB,
             false,
             this.settings.language
         )
-        return this.citFm.init().then(() => {
-            this.citationTexts = this.citFm.citationTexts
+        this.citFm = citFm
+        return (citFm.init() as Promise<void>).then(() => {
+            this.citationTexts = citFm.citationTexts
             if (this.origCitInfos.length) {
                 // Remove all citation texts originating from original starting citInfos
                 this.citationTexts.splice(0, this.origCitInfos.length)
@@ -62,7 +79,10 @@ export class ODTExporterCitations {
         })
     }
 
-    convertCitations() {
+    convertCitations(): void {
+        if (!this.citFm) {
+            return
+        }
         // There could be some formatting in the citations, so we parse them through the PM schema for final formatting.
         // We need to put the citations each in a paragraph so that it works with
         // the fiduswriter schema and so that the converter doesn't mash them together.
@@ -77,25 +97,25 @@ export class ODTExporterCitations {
             const fnNode = fnSchema.nodeFromJSON({type: "footnotecontainer"})
             const serializer = DOMSerializer.fromSchema(fnSchema)
             const dom = serializer.serializeNode(fnNode)
-            dom.innerHTML = citationsHTML
+            ;(dom as HTMLElement).innerHTML = citationsHTML
             this.pmCits = DOMParser.fromSchema(fnSchema)
                 .parse(dom, {topNode: fnNode})
-                .toJSON().content
+                .toJSON().content as FidusNode[]
         } else {
             this.pmCits = []
         }
 
         // Now we do the same for the bibliography.
-        const cslBib = this.citFm.bibliography
+        const cslBib = this.citFm!.bibliography
         if (cslBib && cslBib[1].length > 0) {
             this.styles.addReferenceStyle(cslBib[0])
             const bibNode = cslBibSchema.nodeFromJSON({type: "cslbib"})
             const serializer = DOMSerializer.fromSchema(cslBibSchema)
             const dom = serializer.serializeNode(bibNode)
-            dom.innerHTML = cslBib[1].join("")
+            ;(dom as HTMLElement).innerHTML = cslBib[1].join("")
             this.pmBib = DOMParser.fromSchema(cslBibSchema)
                 .parse(dom, {topNode: bibNode})
-                .toJSON()
+                .toJSON() as FidusNode
         }
     }
 }

package/src/exporter/odt/{footnotes.js → footnotes.ts}

@@ -1,6 +1,10 @@
 import {descendantNodes} from "../tools/doc_content.js"
+import type {BibDB, CSL, DocSettings, FidusNode, ImageDB} from "../../types.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
 import {ODTExporterCitations} from "./citations.js"
 import {ODTExporterImages} from "./images.js"
+import type {ODTExporterStyles} from "./styles.js"
 
 const DEFAULT_STYLE_FOOTNOTE = `
     <style:style style:name="Footnote" style:family="paragraph" style:parent-style-name="Standard" style:class="extra">
@@ -23,15 +27,32 @@ const DEFAULT_STYLE_FOOTNOTE_CONFIGURATION = `
     `
 
 export class ODTExporterFootnotes {
+    docContent: FidusNode
+    settings: DocSettings
+    xml: XmlZip
+    bodyCitations: ODTExporterCitations
+    styles: ODTExporterStyles
+    bibDB: BibDB
+    imageDB: ImageDB
+    csl: CSL
+
+    pmBib: FidusNode | false
+    fnPmJSON: FidusNode | false
+    images: ODTExporterImages | null
+    citations: ODTExporterCitations | null
+    footnotes: FidusNode[][]
+    styleFilePath: string
+    styleXml: XMLElement | null
+
     constructor(
-        docContent,
-        settings,
-        xml,
-        bodyCitations,
-        styles,
-        bibDB,
-        imageDB,
-        csl
+        docContent: FidusNode,
+        settings: DocSettings,
+        xml: XmlZip,
+        bodyCitations: ODTExporterCitations,
+        styles: ODTExporterStyles,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        csl: CSL
     ) {
         this.docContent = docContent
         this.settings = settings
@@ -44,24 +65,26 @@ export class ODTExporterFootnotes {
 
         this.pmBib = false
         this.fnPmJSON = false
-        this.images = false
-        this.citations = false
+        this.images = null
+        this.citations = null
         this.footnotes = []
         this.styleFilePath = "styles.xml"
+        this.styleXml = null
     }
 
-    init() {
+    init(): Promise<void> | Promise<undefined> {
         this.findFootnotes()
         if (
             this.footnotes.length ||
-            (this.bodyCitations.citFm.citationType === "note" &&
+            (this.bodyCitations.citFm &&
+                this.bodyCitations.citFm.citationType === "note" &&
                 this.bodyCitations.citInfos.length)
         ) {
             this.convertFootnotes()
             // Include the citinfos from the main document so that they will be
             // used for calculating the bibliography as well
             this.citations = new ODTExporterCitations(
-                this.fnPmJSON,
+                this.fnPmJSON as FidusNode,
                 this.settings,
                 this.styles,
                 this.bibDB,
@@ -69,7 +92,7 @@ export class ODTExporterFootnotes {
                 this.bodyCitations.citInfos
             )
             this.images = new ODTExporterImages(
-                this.fnPmJSON,
+                this.fnPmJSON as FidusNode,
                 this.xml,
                 this.imageDB
             )
@@ -79,8 +102,8 @@ export class ODTExporterFootnotes {
                 .then(() => {
                     // Replace the main bibliography with the new one that includes
                     // both citations in main document and in the footnotes.
-                    this.pmBib = this.citations.pmBib
-                    return this.images.init()
+                    this.pmBib = this.citations!.pmBib
+                    return this.images!.init()
                 })
                 .then(() => {
                     return this.addStyles()
@@ -91,7 +114,7 @@ export class ODTExporterFootnotes {
         }
     }
 
-    addStyles() {
+    addStyles(): Promise<void> {
         return this.xml.getXml(this.styleFilePath).then(styleXml => {
             this.styleXml = styleXml
             this.addStyle("Footnote", DEFAULT_STYLE_FOOTNOTE)
@@ -102,37 +125,37 @@ export class ODTExporterFootnotes {
         })
     }
 
-    addStyle(styleName, xml) {
-        if (!this.styleXml.query("style:style", {"style:name": styleName})) {
-            const stylesEl = this.styleXml.query("office:styles")
-            stylesEl.appendXML(xml)
+    addStyle(styleName: string, xml: string): void {
+        if (!this.styleXml!.query("style:style", {"style:name": styleName})) {
+            const stylesEl = this.styleXml!.query("office:styles")
+            stylesEl?.appendXML(xml)
         }
     }
 
-    setStyleConfig() {
-        const oldFnStyleConfigEl = this.styleXml.query(
+    setStyleConfig(): void {
+        const oldFnStyleConfigEl = this.styleXml!.query(
             "text:notes-configuration",
             {
                 "text:note-class": "footnote"
             }
         )
         if (oldFnStyleConfigEl) {
-            oldFnStyleConfigEl.parentElement.removeChild(oldFnStyleConfigEl)
+            oldFnStyleConfigEl.parentElement!.removeChild(oldFnStyleConfigEl)
         }
-        const stylesEl = this.styleXml.query("office:styles")
-        stylesEl.appendXML(DEFAULT_STYLE_FOOTNOTE_CONFIGURATION)
+        const stylesEl = this.styleXml!.query("office:styles")
+        stylesEl?.appendXML(DEFAULT_STYLE_FOOTNOTE_CONFIGURATION)
     }
 
-    findFootnotes() {
+    findFootnotes(): void {
         descendantNodes(this.docContent).forEach(node => {
             if (node.type === "footnote") {
-                this.footnotes.push(node.attrs.footnote)
+                this.footnotes.push(node.attrs?.footnote as FidusNode[])
             }
         })
     }
 
-    convertFootnotes() {
-        const fnContent = []
+    convertFootnotes(): void {
+        const fnContent: FidusNode[] = []
         this.footnotes.forEach(footnote => {
             fnContent.push({
                 type: "footnotecontainer",

package/src/exporter/odt/images.ts

@@ -0,0 +1,135 @@
+import {get} from "fwtoolkit"
+
+import type {FidusNode, ImageDB} from "../../types.js"
+import {descendantNodes} from "../tools/doc_content.js"
+import {svg2png} from "../tools/svg.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
+
+interface ImageInfo {
+    id: string
+    width: number
+    height: number
+    title?: string
+    type: string
+    svg: string | null
+}
+
+export class ODTExporterImages {
+    docContent: FidusNode
+    xml: XmlZip
+    imageDB: ImageDB
+    images: Record<string, ImageInfo>
+    manifestXml: XMLElement | null
+
+    constructor(docContent: FidusNode, xml: XmlZip, imageDB: ImageDB) {
+        this.docContent = docContent
+        this.xml = xml
+        this.imageDB = imageDB
+        this.images = {}
+        this.manifestXml = null
+    }
+
+    init(): Promise<void> {
+        return this.xml.getXml("META-INF/manifest.xml").then(manifestXml => {
+            this.manifestXml = manifestXml
+            return this.exportImages()
+        })
+    }
+
+    // add an image to the list of files
+    addImage(imgFileName: string, image: Blob): string {
+        imgFileName = this.addFileToManifest(imgFileName)
+        this.xml.addExtraFile(`Pictures/${imgFileName}`, image)
+        return imgFileName
+    }
+
+    // add a an image file to the manifest
+    addFileToManifest(imgFileName: string): string {
+        const fileNameParts = imgFileName.split(".")
+        const fileNameEnding = fileNameParts.pop() || ""
+        const fileNameStart = fileNameParts.join(".")
+        const manifestEl = this.manifestXml!.query("manifest:manifest")
+        let imgManifest = manifestEl?.query("manifest:file-entry", {
+            "manifest:full-path": `Pictures/${imgFileName}`
+        })
+        let counter = 0
+        while (imgManifest) {
+            // Name exists already, we change the name until we get a file name not yet included in manifest.
+            imgFileName = `${fileNameStart}_${counter++}.${fileNameEnding}`
+            imgManifest = manifestEl?.query("manifest:file-entry", {
+                "manifest:full-path": `Pictures/${imgFileName}`
+            })
+        }
+        const string = `  <manifest:file-entry manifest:full-path="Pictures/${imgFileName}" manifest:media-type="image/${fileNameEnding}"/>`
+        manifestEl?.appendXML(string)
+        return imgFileName
+    }
+
+    // Find all images used in file and add these to the export zip.
+    // TODO: This will likely fail on image types odt doesn't support such as
+    // SVG. Try out and fix.
+    exportImages(): Promise<void> {
+        const usedImgs: (string | number)[] = []
+
+        descendantNodes(this.docContent).forEach(node => {
+            if (node.type === "image" && node.attrs?.image !== false) {
+                const imageId = node.attrs?.image as string | number | undefined
+                if (imageId !== undefined && !usedImgs.includes(imageId)) {
+                    usedImgs.push(imageId)
+                }
+            }
+        })
+
+        return new Promise(resolveExportImages => {
+            const p: Array<Promise<void>> = []
+
+            usedImgs.forEach(image => {
+                const imgDBEntry = this.imageDB.db[String(image)]
+                if (!imgDBEntry || !imgDBEntry.image) {
+                    return
+                }
+                p.push(
+                    get(imgDBEntry.image as string)
+                        .then(response => response.blob())
+                        .then(async blob => {
+                            const wImgId = this.addImage(
+                                (imgDBEntry.image as string).split("/").pop()!,
+                                blob
+                            )
+                            if (blob.type === "image/svg+xml") {
+                                // Add PNG version in addition to SVG
+                                const {blob: pngBlob, width, height} = await svg2png(blob)
+                                const pngWImgId = this.addImage(
+                                    (imgDBEntry.image as string)
+                                        .split("/")
+                                        .pop()!
+                                        .replace(/.svg$/g, ".png"),
+                                    pngBlob
+                                )
+                                this.images[String(image)] = {
+                                    id: pngWImgId,
+                                    width,
+                                    height,
+                                    title: imgDBEntry.title as string | undefined,
+                                    type: blob.type,
+                                    svg: wImgId
+                                }
+                            } else {
+                                this.images[String(image)] = {
+                                    id: wImgId,
+                                    width: imgDBEntry.width as number,
+                                    height: imgDBEntry.height as number,
+                                    title: imgDBEntry.title as string | undefined,
+                                    type: blob.type,
+                                    svg: null
+                                }
+                            }
+                        })
+                )
+            })
+
+            Promise.all(p).then(() => resolveExportImages())
+        })
+    }
+}

package/src/exporter/odt/{index.js → index.ts}

@@ -1,11 +1,11 @@
 import download from "downloadjs"
 
 import {shortFileTitle} from "fwtoolkit"
-
+import type {BibDB, CSL, ExportDoc, FidusNode, ImageDB} from "../../types.js"
 import {fixTables, removeHidden, textContent} from "../tools/doc_content.js"
 import {createSlug} from "../tools/file.js"
-import {XmlZip} from "../tools/xml_zip.js"
-
+import type {XmlZip} from "../tools/xml_zip.js"
+import {XmlZip as XmlZipImpl} from "../tools/xml_zip.js"
 import {ODTExporterCitations} from "./citations.js"
 import {ODTExporterFootnotes} from "./footnotes.js"
 import {ODTExporterImages} from "./images.js"
@@ -27,7 +27,24 @@ TODO:
 */
 
 export class ODTExporter {
-    constructor(doc, templateUrl, bibDB, imageDB, csl) {
+    doc: ExportDoc
+    templateUrl: string
+    bibDB: BibDB
+    imageDB: ImageDB
+    csl: CSL
+
+    pmCits: any
+    docContent: any
+    docTitle: string
+    mimeType: string
+
+    constructor(
+        doc: ExportDoc,
+        templateUrl: string,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        csl: CSL
+    ) {
         this.doc = doc
         this.templateUrl = templateUrl
         this.bibDB = bibDB
@@ -35,13 +52,13 @@ export class ODTExporter {
         this.csl = csl
 
         this.pmCits = false
-        this.docContent = fixTables(removeHidden(this.doc.content))
-        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
+        this.docContent = fixTables(removeHidden(this.doc.content) as FidusNode)
+        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)
+    init(): Promise<void> {
+        const xml: XmlZip = new XmlZipImpl(this.templateUrl, this.mimeType)
         const styles = new ODTExporterStyles(xml)
         const math = new ODTExporterMath(xml)
         const tracks = new ODTExporterTracks(xml)
@@ -73,7 +90,7 @@ export class ODTExporter {
         const images = new ODTExporterImages(this.docContent, xml, this.imageDB)
 
         const richtext = new ODTExporterRichtext(
-            this.doc.comments,
+            this.doc.comments || {},
             this.doc.settings,
             styles,
             tracks,
@@ -108,16 +125,16 @@ export class ODTExporter {
             .then(blob => this.download(blob))
     }
 
-    getBaseMetadata() {
+    getBaseMetadata(): any {
         const contributors = this.docContent.content.reduce(
-            (contributors, part) => {
+            (contributors: any[], part: any) => {
                 if (
                     part.type === "contributors_part" &&
                     part.attrs.metadata &&
                     part.content
                 ) {
                     return contributors.concat(
-                        part.content.map(node => ({
+                        part.content.map((node: any) => ({
                             ...node.attrs,
                             role: part.attrs.metadata
                         }))
@@ -129,28 +146,33 @@ export class ODTExporter {
             []
         )
         return {
-            authors: contributors.filter(c => c.role === "authors"),
+            authors: contributors.filter((c: any) => 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
-                }
-            }, []),
+            keywords: this.docContent.content.reduce(
+                (keywords: string[], part: any) => {
+                    if (
+                        part.type === "tags_part" &&
+                        part.attrs.metadata === "keywords" &&
+                        part.content
+                    ) {
+                        return keywords.concat(
+                            part.content.map(
+                                (keywordNode: any) => keywordNode.attrs.tag
+                            )
+                        )
+                    } else {
+                        return keywords
+                    }
+                },
+                []
+            ),
             title: textContent(this.docContent.content[0]),
             language: this.doc.settings.language,
             citationStyle: this.doc.settings.citationstyle
         }
     }
 
-    download(blob) {
+    download(blob: Blob): void {
         return download(blob, createSlug(this.docTitle) + ".odt", this.mimeType)
     }
 }