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

package/src/exporter/docx/{lists.js → lists.ts}

@@ -1,4 +1,8 @@
 import {descendantNodes} from "../tools/doc_content.js"
+import type {FidusNode} from "../../types.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
+import type {DOCXExporterRels} from "./rels.js"
 
 const DEFAULT_LISTPARAGRAPH_XML = `
     <w:style w:type="paragraph" w:styleId="ListParagraph">
@@ -19,56 +23,68 @@ const DEFAULT_NUMBERING_XML = `<?xml version="1.0" encoding="UTF-8" standalone="
     </w:numbering>`
 
 export class DOCXExporterLists {
-    constructor(docContent, xml, rels) {
+    docContent: FidusNode
+    xml: XmlZip
+    rels: DOCXExporterRels
+    useBulletList: boolean
+    usedNumberedList: number[]
+    styleXML: XMLElement | null
+    numberingXML: XMLElement | null
+    abstractNumIdCounter: number
+    numIdCounter: number
+    // We only need one bulletType for all bullet lists, but a new
+    // numberedType for each numbered list so that the numbering starts in 1
+    // each time.
+    bulletType: number | false
+    bulletAbstractType: number | undefined
+    numberFormat: string | null
+    numberedTypes: number[]
+    numberedAbstractType: number | undefined
+    styleFilePath: string
+    numberingFilePath: string
+    ctFilePath: string
+    ctXML: XMLElement | null
+
+    constructor(docContent: FidusNode, xml: XmlZip, rels: DOCXExporterRels) {
         this.docContent = docContent
         this.xml = xml
         this.rels = rels
         this.useBulletList = false
         this.usedNumberedList = []
-        this.styleXML = false
-        this.numberingXML = false
+        this.styleXML = null
+        this.numberingXML = null
         this.abstractNumIdCounter = 0
         this.numIdCounter = 0
-        // We only need one bulletType for all bullet lists, but a new
-        // numberedType for each numbered list so that the numbering starts in 1
-        // each time.
         this.bulletType = false
         this.numberFormat = "decimal"
         this.numberedTypes = []
         this.styleFilePath = "word/styles.xml"
         this.numberingFilePath = "word/numbering.xml"
         this.ctFilePath = "[Content_Types].xml"
+        this.ctXML = null
     }
 
-    init() {
+    init(): Promise<void> | Promise<undefined> {
         this.findLists()
         if (this.usedNumberedList.length > 0 || this.useBulletList) {
-            const p = []
-
-            p.push(
+            const p: Array<Promise<void>> = [
                 new Promise(resolve => {
                     this.initCt().then(() => resolve())
-                })
-            )
-
-            p.push(
+                }),
                 new Promise(resolve => {
                     this.addNumberingXml().then(() => resolve())
-                })
-            )
-
-            p.push(
+                }),
                 new Promise(resolve => {
                     this.addListParagraphStyle().then(() => resolve())
                 })
-            )
-            return Promise.all(p)
+            ]
+            return Promise.all(p).then(() => undefined)
         } else {
             return Promise.resolve()
         }
     }
 
-    initCt() {
+    initCt(): Promise<void> {
         return this.xml.getXml(this.ctFilePath).then(ctXML => {
             this.ctXML = ctXML
             this.addRelsToCt()
@@ -76,29 +92,32 @@ export class DOCXExporterLists {
         })
     }
 
-    addRelsToCt() {
+    addRelsToCt(): void {
+        if (!this.ctXML) {
+            return
+        }
         const override = this.ctXML.query("Override", {
             PartName: `/${this.numberingFilePath}`
         })
         if (!override) {
             const types = this.ctXML.query("Types")
-            types.appendXML(
+            types?.appendXML(
                 `<Override PartName="/${this.numberingFilePath}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>`
             )
         }
     }
 
-    findLists() {
+    findLists(): void {
         descendantNodes(this.docContent).forEach(node => {
             if (node.type === "bullet_list") {
                 this.useBulletList = true
             } else if (node.type === "ordered_list") {
-                this.usedNumberedList.push(node.attrs.order)
+                this.usedNumberedList.push(node.attrs?.order as number)
             }
         })
     }
 
-    addNumberingXml() {
+    addNumberingXml(): Promise<void> {
         return this.xml
             .getXml(this.numberingFilePath, DEFAULT_NUMBERING_XML)
             .then(numberingXML => {
@@ -109,20 +128,23 @@ export class DOCXExporterLists {
             })
     }
 
-    addListParagraphStyle() {
+    addListParagraphStyle(): Promise<void> {
         return this.xml.getXml(this.styleFilePath).then(styleXML => {
             this.styleXML = styleXML
             if (
                 !this.styleXML.query("w:style", {"w:styleId": "ListParagraph"})
             ) {
                 const stylesEl = this.styleXML.query("w:styles")
-                stylesEl.appendXML(DEFAULT_LISTPARAGRAPH_XML)
+                stylesEl?.appendXML(DEFAULT_LISTPARAGRAPH_XML)
             }
             return Promise.resolve()
         })
     }
 
-    addUsedListTypes() {
+    addUsedListTypes(): void {
+        if (!this.numberingXML) {
+            return
+        }
         const allAbstractNum = this.numberingXML.queryAll("w:abstractNum")
         allAbstractNum.forEach(abstractNum => {
             // We check the format for the lowest level list and use the first
@@ -130,18 +152,24 @@ export class DOCXExporterLists {
             // This means that if a list is defined using anything else than
             // bullets, it will be accepted as the format of
             // the numeric list.
-            const levelZeroFormat = abstractNum
+            const levelZeroFormatEl = abstractNum
                 .query("w:lvl", {"w:ilvl": "0"})
-                .query("w:numFmt")
-                .getAttribute("w:val")
+                ?.query("w:numFmt")
+            const levelZeroFormat = levelZeroFormatEl
+                ? String(levelZeroFormatEl.getAttribute("w:val"))
+                : ""
             const abstractNumId = Number.parseInt(
-                abstractNum.getAttribute("w:abstractNumId")
+                String(abstractNum.getAttribute("w:abstractNumId"))
             )
             if (levelZeroFormat === "bullet" && !this.bulletAbstractType) {
-                const numEl = this.numberingXML.query("w:abstractNumId", {
-                    "w:val": abstractNumId
-                }).parentElement
-                const numId = Number.parseInt(numEl.getAttribute("w:numId"))
+                const numEl = this.numberingXML!
+                    .query("w:abstractNumId", {
+                        "w:val": abstractNumId
+                    })
+                    ?.parentElement
+                const numId = numEl
+                    ? Number.parseInt(String(numEl.getAttribute("w:numId")))
+                    : NaN
                 this.bulletType = numId
             } else if (levelZeroFormat !== "bullet" && !this.numberFormat) {
                 this.numberFormat = levelZeroFormat
@@ -152,7 +180,7 @@ export class DOCXExporterLists {
         })
         const allNum = this.numberingXML.queryAll("w:num")
         allNum.forEach(numEl => {
-            const numId = Number.parseInt(numEl.getAttribute("w:val"))
+            const numId = Number.parseInt(String(numEl.getAttribute("w:val")))
             if (this.numIdCounter < numId) {
                 this.numIdCounter = numId
             }
@@ -177,17 +205,20 @@ export class DOCXExporterLists {
         }
     }
 
-    getBulletType() {
+    getBulletType(): number | false {
         return this.bulletType
     }
 
-    getNumberedType() {
+    getNumberedType(): number | undefined {
         return this.numberedTypes.shift()
     }
 
-    addBulletNumType(numId, abstractNumId) {
+    addBulletNumType(numId: number, abstractNumId: number): void {
+        if (!this.numberingXML) {
+            return
+        }
         const numberingEl = this.numberingXML.query("w:numbering")
-        numberingEl.appendXML(`
+        numberingEl?.appendXML(`
             <w:abstractNum w:abstractNumId="${abstractNumId}" w15:restartNumberingAfterBreak="0">
                 <w:nsid w:val="3620195A" />
                 <w:multiLevelType w:val="hybridMultilevel" />
@@ -200,6 +231,9 @@ export class DOCXExporterLists {
         const newAbstractNum = this.numberingXML.query("w:abstractNum", {
             "w:abstractNumId": String(abstractNumId)
         })
+        if (!newAbstractNum) {
+            return
+        }
         // Definition seem to always define 9 levels (0-8).
         for (let level = 0; level < 9; level++) {
             newAbstractNum.appendXML(`
@@ -219,20 +253,26 @@ export class DOCXExporterLists {
         }
     }
 
-    addNumberedNumType(numId, start) {
+    addNumberedNumType(numId: number, start: number): void {
         this.abstractNumIdCounter++
         this.addNumberedAbstractNumType(this.abstractNumIdCounter, start)
+        if (!this.numberingXML) {
+            return
+        }
         const numberingEl = this.numberingXML.query("w:numbering")
-        numberingEl.appendXML(`
+        numberingEl?.appendXML(`
             <w:num w:numId="${numId}">
                 <w:abstractNumId w:val="${this.abstractNumIdCounter}" />
             </w:num>
         `)
     }
 
-    addNumberedAbstractNumType(abstractNumId, start) {
+    addNumberedAbstractNumType(abstractNumId: number, start: number): void {
+        if (!this.numberingXML) {
+            return
+        }
         const numberingEl = this.numberingXML.query("w:numbering")
-        numberingEl.appendXML(`
+        numberingEl?.appendXML(`
             <w:abstractNum w:abstractNumId="${abstractNumId}" w15:restartNumberingAfterBreak="0">
                 <w:nsid w:val="7F6635F3" />
                 <w:multiLevelType w:val="hybridMultilevel" />
@@ -242,6 +282,9 @@ export class DOCXExporterLists {
         const newAbstractNum = this.numberingXML.query("w:abstractNum", {
             "w:abstractNumId": String(abstractNumId)
         })
+        if (!newAbstractNum) {
+            return
+        }
         // Definition seem to always define 9 levels (0-8).
         for (let level = 0; level < 9; level++) {
             newAbstractNum.appendXML(`

package/src/exporter/docx/{math.js → math.ts}

@@ -1,7 +1,9 @@
 import {mml2omml} from "mathml2omml"
 
+import type {XmlZip} from "../tools/xml_zip.js"
+
 // Not entirely sure if we need this font here. This is included whenever Word
-// itself adds a formula, but our ooml doesn't refer to the font, so it may be pointless.
+// itself adds a formula, but our omml doesn't refer to the font, so it may be pointless.
 const CAMBRIA_MATH_FONT_DECLARATION = `
     <w:font w:name="Cambria Math">
         <w:panose1 w:val="02040503050406030204" />
@@ -12,35 +14,53 @@ const CAMBRIA_MATH_FONT_DECLARATION = `
     </w:font>`
 
 export class DOCXExporterMath {
-    constructor(xml) {
+    xml: XmlZip
+    fontTablesXML: import("../tools/xml.js").XMLElement | false
+    addedCambriaMath: boolean
+    domParser: DOMParser
+    mathLive: typeof import("mathlive") | null
+
+    constructor(xml: XmlZip) {
         this.xml = xml
-        this.fontTableXML = false
+        this.fontTablesXML = false
         this.addedCambriaMath = false
         this.domParser = new DOMParser()
+        this.mathLive = null
     }
 
-    init() {
+    init(): Promise<typeof import("mathlive")> {
         return this.xml
             .getXml("word/fontTable.xml")
             .then(fontTablesXML => {
                 this.fontTablesXML = fontTablesXML
                 return import("mathlive")
             })
-            .then(MathLive => (this.mathLive = MathLive))
+            .then(MathLive => {
+                this.mathLive = MathLive
+                return MathLive
+            })
     }
 
-    latexToMathML(latex) {
+    latexToMathML(latex: string): string {
+        if (!this.mathLive) {
+            throw new Error("MathLive not initialised")
+        }
         return this.mathLive.convertLatexToMathMl(latex)
     }
 
-    getOmml(latex) {
+    getOmml(latex: string): string {
+        if (!this.fontTablesXML) {
+            throw new Error("Font table XML not loaded")
+        }
         if (!this.addedCambriaMath) {
             const fontsEl = this.fontTablesXML.query("w:fonts")
+            if (!fontsEl) {
+                throw new Error("No w:fonts element found in font table")
+            }
             fontsEl.appendXML(CAMBRIA_MATH_FONT_DECLARATION)
             this.addedCambriaMath = true
         }
         const mathmlString = `<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics>${this.latexToMathML(latex)}</semantics></math>`
-        const ommlString = mml2omml(mathmlString)
-        return ommlString
+        return mml2omml(mathmlString)
     }
 }

package/src/exporter/docx/{metadata.js → metadata.ts}

@@ -1,15 +1,25 @@
 import {escapeText} from "fwtoolkit"
 
+import type {CSL, CSLStyle, ExportMetadata} from "../../types.js"
+import type {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
+
 export class DOCXExporterMetadata {
-    constructor(xml, metadata, csl = null) {
+    xml: XmlZip
+    metadata: ExportMetadata
+    csl: CSL | null
+    coreXML: XMLElement | null
+    customXML: XMLElement | null
+
+    constructor(xml: XmlZip, metadata: ExportMetadata, csl: CSL | null = null) {
         this.xml = xml
         this.metadata = metadata
         this.csl = csl
-        this.coreXML = false
-        this.customXML = false
+        this.coreXML = null
+        this.customXML = null
     }
 
-    init() {
+    init(): Promise<void> {
         return this.xml.getXml("docProps/core.xml").then(coreXML => {
             this.coreXML = coreXML
             this.addMetadata()
@@ -17,8 +27,8 @@ export class DOCXExporterMetadata {
         })
     }
 
-    async hasBibliography() {
-        if (!this.csl || !this.metadata.citationStyle) {
+    async hasBibliography(): Promise<string> {
+        if (!this.csl || !this.metadata.citationStyle || !this.csl.getStyle) {
             return "0"
         }
         try {
@@ -33,20 +43,28 @@ export class DOCXExporterMetadata {
         }
     }
 
-    addMetadata() {
+    addMetadata(): void {
+        if (!this.coreXML) {
+            return
+        }
         const corePropertiesEl = this.coreXML.query("cp:coreProperties")
+        if (!corePropertiesEl) {
+            return
+        }
 
         // Title
-        let titleEl = this.coreXML.query("dc:title")
+        let titleEl: XMLElement | null = this.coreXML.query("dc:title") ?? null
         if (!titleEl) {
             corePropertiesEl.appendXML("<dc:title></dc:title>")
             titleEl = corePropertiesEl.lastElementChild
         }
-        titleEl.innerXML = escapeText(this.metadata.title)
+        if (titleEl) {
+            titleEl.innerXML = escapeText(this.metadata.title)
+        }
         // Authors
 
         const authors = this.metadata.authors.map(author => {
-            const nameParts = []
+            const nameParts: string[] = []
             if (author.firstname) {
                 nameParts.push(author.firstname)
             }
@@ -61,55 +79,65 @@ export class DOCXExporterMetadata {
         })
         const lastAuthor = authors.length
             ? escapeText(authors[0])
-            : gettext("Unknown")
+            : "Unknown"
         const allAuthors = authors.length
             ? escapeText(authors.join(";"))
-            : gettext("Unknown")
-        let allAuthorsEl = this.coreXML.query("dc:creator")
+            : "Unknown"
+        let allAuthorsEl: XMLElement | null = this.coreXML.query("dc:creator") ?? null
 
         if (!allAuthorsEl) {
             corePropertiesEl.appendXML("<dc:creator></dc:creator>")
             allAuthorsEl = corePropertiesEl.lastElementChild
         }
-        allAuthorsEl.innerXML = allAuthors
-        let lastAuthorEl = this.coreXML.query("dc:lastModifiedBy")
+        if (allAuthorsEl) {
+            allAuthorsEl.innerXML = allAuthors
+        }
+        let lastAuthorEl: XMLElement | null = this.coreXML.query("dc:lastModifiedBy") ?? null
         if (!lastAuthorEl) {
             corePropertiesEl.appendXML(
                 "<dc:lastModifiedBy></dc:lastModifiedBy>"
             )
             lastAuthorEl = corePropertiesEl.lastElementChild
         }
-        lastAuthorEl.innerXML = lastAuthor
+        if (lastAuthorEl) {
+            lastAuthorEl.innerXML = lastAuthor
+        }
         // Keywords
         if (this.metadata.keywords.length) {
             // It is not really clear how keywords should be separated in DOCX files,
             // so we use ", ".
             const keywordsString = escapeText(this.metadata.keywords.join(", "))
 
-            let keywordsEl = this.coreXML.query("cp:keywords")
+            let keywordsEl: XMLElement | null = this.coreXML.query("cp:keywords") ?? null
             if (!keywordsEl) {
                 corePropertiesEl.appendXML("<cp:keywords></cp:keywords>")
                 keywordsEl = corePropertiesEl.lastElementChild
             }
-            keywordsEl.innerXML = keywordsString
+            if (keywordsEl) {
+                keywordsEl.innerXML = keywordsString
+            }
         }
 
         // time
         const date = new Date()
         const dateString = date.toISOString().split(".")[0] + "Z"
         const createdEl = this.coreXML.query("dcterms:created")
-        createdEl.innerXML = dateString
-        let modifiedEl = this.coreXML.query("dcterms:modified")
+        if (createdEl) {
+            createdEl.innerXML = dateString
+        }
+        let modifiedEl: XMLElement | null = this.coreXML.query("dcterms:modified") ?? null
         if (!modifiedEl) {
             corePropertiesEl.appendXML(
                 '<dcterms:modified xsi:type="dcterms:W3CDTF"></dcterms:modified>'
             )
             modifiedEl = corePropertiesEl.lastElementChild
         }
-        modifiedEl.innerXML = dateString
+        if (modifiedEl) {
+            modifiedEl.innerXML = dateString
+        }
     }
 
-    async addCustomProperties() {
+    async addCustomProperties(): Promise<void> {
         // Create or update docProps/custom.xml with citation style information
         const customXmlContent = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
@@ -117,31 +145,35 @@ export class DOCXExporterMetadata {
 
         const customXML = await this.xml.getXml(
             "docProps/custom.xml",
-            Promise.resolve(customXmlContent)
+            customXmlContent
         )
         this.customXML = customXML
 
         // Add citation style property
         if (this.metadata.citationStyle) {
             const propertiesEl = this.customXML.query("Properties")
+            if (!propertiesEl) {
+                return Promise.resolve()
+            }
 
             // Remove any existing ZOTERO_PREF_ properties
             const existingZoteroProps = this.customXML
                 .queryAll("property")
                 .filter(
-                    prop =>
-                        prop.getAttribute("name") &&
-                        prop.getAttribute("name").startsWith("ZOTERO_PREF_")
+                    prop => {
+                        const name = String(prop.getAttribute("name"))
+                        return name && name.startsWith("ZOTERO_PREF_")
+                    }
                 )
             existingZoteroProps.forEach(prop =>
-                prop.parentElement.removeChild(prop)
+                prop.parentElement!.removeChild(prop)
             )
 
             // Find the highest pid to determine the next one
             const existingProperties = this.customXML.queryAll("property")
             let maxPid = 0
             existingProperties.forEach(prop => {
-                const pid = parseInt(prop.getAttribute("pid"))
+                const pid = parseInt(String(prop.getAttribute("pid")))
                 if (pid > maxPid) {
                     maxPid = pid
                 }
@@ -156,7 +188,7 @@ export class DOCXExporterMetadata {
 
             // Split content into chunks of 255 characters (DOCX limit)
             const chunkSize = 255
-            const chunks = []
+            const chunks: string[] = []
             for (let i = 0; i < dataContent.length; i += chunkSize) {
                 chunks.push(dataContent.substring(i, i + chunkSize))
             }
@@ -170,7 +202,7 @@ export class DOCXExporterMetadata {
                 propertiesEl.appendXML(propertyXML)
                 // Set the text content after appending (textContent escapes XML characters)
                 const lpwstrEl =
-                    propertiesEl.lastElementChild.query("vt:lpwstr")
+                    propertiesEl.lastElementChild?.query("vt:lpwstr")
                 if (lpwstrEl) {
                     lpwstrEl.textContent = chunk
                 }
@@ -183,30 +215,34 @@ export class DOCXExporterMetadata {
         return Promise.resolve()
     }
 
-    async addContributorProperties() {
+    async addContributorProperties(): Promise<void> {
         if (!this.metadata.contributors || !this.metadata.contributors.length) {
             return Promise.resolve()
         }
 
-        const propertiesEl = this.customXML.query("Properties")
+        const propertiesEl = this.customXML!.query("Properties")
+        if (!propertiesEl) {
+            return Promise.resolve()
+        }
 
         // Remove any existing fidus_contributor_ properties
-        const existingContributorProps = this.customXML
+        const existingContributorProps = this.customXML!
             .queryAll("property")
             .filter(
-                prop =>
-                    prop.getAttribute("name") &&
-                    prop.getAttribute("name").startsWith("fidus_contributor_")
+                prop => {
+                    const name = String(prop.getAttribute("name"))
+                    return name && name.startsWith("fidus_contributor_")
+                }
             )
         existingContributorProps.forEach(prop =>
-            prop.parentElement.removeChild(prop)
+            prop.parentElement!.removeChild(prop)
         )
 
         // Find the highest pid
-        const existingProperties = this.customXML.queryAll("property")
+        const existingProperties = this.customXML!.queryAll("property")
         let maxPid = 0
         existingProperties.forEach(prop => {
-            const pid = parseInt(prop.getAttribute("pid"))
+            const pid = parseInt(String(prop.getAttribute("pid")))
             if (pid > maxPid) {
                 maxPid = pid
             }
@@ -220,7 +256,7 @@ export class DOCXExporterMetadata {
 <vt:i4></vt:i4>
 </property>`
         propertiesEl.appendXML(countXML)
-        const countEl = propertiesEl.lastElementChild.query("vt:i4")
+        const countEl = propertiesEl.lastElementChild?.query("vt:i4")
         if (countEl) {
             countEl.textContent = String(contributors.length)
         }
@@ -228,7 +264,7 @@ export class DOCXExporterMetadata {
         // Add property for each contributor
         contributors.forEach((contributor, index) => {
             const num = index + 1
-            const nameParts = []
+            const nameParts: string[] = []
             if (contributor.firstname) {
                 nameParts.push(contributor.firstname)
             }
@@ -277,7 +313,7 @@ export class DOCXExporterMetadata {
 </property>`
                 propertiesEl.appendXML(propertyXML)
                 const lpwstrEl =
-                    propertiesEl.lastElementChild.query("vt:lpwstr")
+                    propertiesEl.lastElementChild?.query("vt:lpwstr")
                 if (lpwstrEl) {
                     lpwstrEl.textContent = field.value
                 }