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

package/src/citations/{format.js → format.ts}

@@ -1,16 +1,42 @@
 import {escapeText} from "fwtoolkit"
+
+import type {
+    BibDB,
+    BibliographyResult,
+    CiteprocInstance,
+    CSL
+} from "../types.js"
 import {citeprocSys} from "./citeproc_sys.js"
-/*
- * Use CSL and bibDB to format all citations for the given prosemirror json citation nodes
- */
 
+interface CitationInfo {
+    format: string
+    references: Array<{id: number; [key: string]: unknown}>
+}
+
+/**
+ * Use CSL and bibDB to format all citations for the given ProseMirror JSON citation nodes.
+ */
 export class FormatCitations {
+    csl: CSL
+    allCitationInfos: CitationInfo[]
+    citationStyle: string
+    bibliographyHeader: string
+    bibDB: BibDB
+    synchronous: boolean
+    lang: string
+
+    bibliography: BibliographyResult | false
+    citations: Array<{citationItems: unknown[]; properties: {noteIndex: number}}>
+    bibFormats: string[]
+    citationTexts: string[]
+    citationType: string
+
     constructor(
-        csl,
-        allCitationInfos,
-        citationStyle,
-        bibliographyHeader,
-        bibDB,
+        csl: CSL,
+        allCitationInfos: CitationInfo[],
+        citationStyle: string,
+        bibliographyHeader: string,
+        bibDB: BibDB,
         synchronous = false,
         lang = "en-US"
     ) {
@@ -21,9 +47,15 @@ export class FormatCitations {
         this.bibDB = bibDB
         this.synchronous = synchronous
         this.lang = lang
+
+        this.bibliography = false
+        this.citations = []
+        this.bibFormats = []
+        this.citationTexts = []
+        this.citationType = ""
     }
 
-    init() {
+    init(): boolean | Promise<void> {
         this.bibliography = false
         this.citations = []
         this.bibFormats = []
@@ -33,7 +65,7 @@ export class FormatCitations {
         return this.getFormattedCitations()
     }
 
-    formatAllCitations() {
+    formatAllCitations(): void {
         this.allCitationInfos.forEach(cInfo => {
             this.bibFormats.push(cInfo.format)
             this.citations.push({
@@ -45,7 +77,7 @@ export class FormatCitations {
         })
     }
 
-    get bibHTML() {
+    get bibHTML(): string {
         if (!this.bibliography || !this.bibliography[0].entry_ids.length) {
             return ""
         }
@@ -55,7 +87,7 @@ export class FormatCitations {
     }
 
     // CSS
-    get bibCSS() {
+    get bibCSS(): string {
         if (!this.bibliography || !this.bibliography[0].entry_ids.length) {
             return ""
         }
@@ -86,7 +118,7 @@ export class FormatCitations {
         return css
     }
 
-    reloadCitations(missingItems) {
+    reloadCitations(missingItems: string[]): Promise<void> {
         // Not all citations could be found in the database.
         // Reload the database if possible, but don't cycle if no new matches are found.
         if (!this.bibDB.getDB) {
@@ -95,16 +127,19 @@ export class FormatCitations {
 
         return this.bibDB.getDB().then(() => {
             if (missingItems.some(item => this.bibDB.db.hasOwnProperty(item))) {
-                return this.init()
+                return this.init() as Promise<void>
             } else {
                 return Promise.resolve()
             }
         })
     }
 
-    getFormattedCitations() {
+    getFormattedCitations(): boolean | Promise<void> {
         const citeprocConnector = new citeprocSys(this.bibDB)
         if (this.synchronous) {
+            if (!this.csl.getEngineSync) {
+                return false
+            }
             const citeprocInstance = this.csl.getEngineSync(
                 citeprocConnector,
                 this.citationStyle,
@@ -116,6 +151,9 @@ export class FormatCitations {
             this.process(citeprocInstance)
             return true
         } else {
+            if (!this.csl.getEngine) {
+                return Promise.resolve()
+            }
             return this.csl
                 .getEngine(citeprocConnector, this.citationStyle, this.lang)
                 .then(citeprocInstance => {
@@ -131,10 +169,10 @@ export class FormatCitations {
         }
     }
 
-    process(citeprocInstance) {
-        const allIds = []
+    process(citeprocInstance: CiteprocInstance): void {
+        const allIds: string[] = []
         this.citations.forEach(cit =>
-            cit.citationItems.forEach(item => allIds.push(String(item.id)))
+            cit.citationItems.forEach(item => allIds.push(String((item as {id: number}).id)))
         )
         citeprocInstance.updateItems(allIds)
 
@@ -147,18 +185,32 @@ export class FormatCitations {
                     true
                 )
             if (inText && "textcite" == this.bibFormats[i]) {
-                const items = citation.citationItems
+                const items = citation.citationItems as Array<{
+                    id: number
+                    locator?: string
+                    prefix?: string
+                }>
                 let newCiteText = ""
 
                 for (let j = 0; j < items.length; j++) {
-                    const onlyNameOption = [
+                    const onlyNameOption: Array<{
+                        id: number
+                        "author-only": number
+                        locator?: string
+                        prefix?: string
+                    }> = [
                         {
                             id: items[j].id,
                             "author-only": 1
                         }
                     ]
 
-                    const onlyDateOption = [
+                    const onlyDateOption: Array<{
+                        id: number
+                        "suppress-author": number
+                        locator?: string
+                        prefix?: string
+                    }> = [
                         {
                             id: items[j].id,
                             "suppress-author": 1
@@ -180,8 +232,12 @@ export class FormatCitations {
                     }
                     newCiteText += `${citeprocInstance.makeCitationCluster(onlyNameOption)} ${citeprocInstance.makeCitationCluster(onlyDateOption)}`
                 }
-                citationTexts.find(citationText => citationText[0] === i)[1] =
-                    newCiteText
+                const target = citationTexts.find(
+                    citationText => citationText[0] === i
+                )
+                if (target) {
+                    target[1] = newCiteText
+                }
             }
             citationTexts.forEach(
                 ([index, citationText]) =>
@@ -189,6 +245,6 @@ export class FormatCitations {
             )
         }
         this.citationType = citeprocInstance.cslXml.dataObj.attrs.class
-        this.bibliography = citeprocInstance.makeBibliography()
+        this.bibliography = citeprocInstance.makeBibliography() as BibliographyResult
     }
 }

package/src/editor/e2ee/{encryptor.js → encryptor.ts}

@@ -17,11 +17,11 @@ export class E2EEEncryptor {
     /**
      * Encrypt a string with AES-GCM.
      *
-     * @param {string} plaintext - The plaintext string to encrypt
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} Base64-encoded string (iv + ciphertext + auth tag)
+     * @param plaintext - The plaintext string to encrypt
+     * @param key - An AES-GCM key (from E2EEKeyManager.deriveKey)
+     * @returns Base64-encoded string (iv + ciphertext + auth tag)
      */
-    static async encrypt(plaintext, key) {
+    static async encrypt(plaintext: string, key: CryptoKey): Promise<string> {
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const encoded = new TextEncoder().encode(plaintext)
         const ciphertext = await crypto.subtle.encrypt(
@@ -39,11 +39,14 @@ export class E2EEEncryptor {
     /**
      * Decrypt a Base64-encoded AES-GCM ciphertext.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded (iv + ciphertext + auth tag)
-     * @param {CryptoKey} key - An AES-GCM key (from E2EEKeyManager.deriveKey)
-     * @returns {Promise<string>} The decrypted plaintext string
+     * @param ciphertextBase64 - Base64-encoded (iv + ciphertext + auth tag)
+     * @param key - An AES-GCM key (from E2EEKeyManager.deriveKey)
+     * @returns The decrypted plaintext string
      */
-    static async decrypt(ciphertextBase64, key) {
+    static async decrypt(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<string> {
         const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
         const iv = combined.slice(0, 12)
         const ciphertext = combined.slice(12)
@@ -60,11 +63,14 @@ export class E2EEEncryptor {
      *
      * Serializes the object to JSON, then encrypts the JSON string.
      *
-     * @param {Object} obj - A JSON-serializable object
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data
+     * @param obj - A JSON-serializable object
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded encrypted data
      */
-    static encryptObject(obj, key) {
+    static encryptObject(
+        obj: Record<string, unknown> | unknown[],
+        key: CryptoKey
+    ): Promise<string> {
         return E2EEEncryptor.encrypt(JSON.stringify(obj), key)
     }
 
@@ -73,11 +79,14 @@ export class E2EEEncryptor {
      *
      * Decrypts the Base64-encoded ciphertext, then parses the result as JSON.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Object>} The decrypted and parsed object
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns The decrypted and parsed object
      */
-    static async decryptObject(ciphertextBase64, key) {
+    static async decryptObject(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<unknown> {
         const plaintext = await E2EEEncryptor.decrypt(ciphertextBase64, key)
         return JSON.parse(plaintext)
     }
@@ -85,11 +94,14 @@ export class E2EEEncryptor {
     /**
      * Encrypt an ArrayBuffer (for images and other binary data).
      *
-     * @param {ArrayBuffer} buffer - The binary data to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded encrypted data (iv + ciphertext)
+     * @param buffer - The binary data to encrypt
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded encrypted data (iv + ciphertext)
      */
-    static async encryptBuffer(buffer, key) {
+    static async encryptBuffer(
+        buffer: ArrayBuffer,
+        key: CryptoKey
+    ): Promise<string> {
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const ciphertext = await crypto.subtle.encrypt(
             {name: "AES-GCM", iv: iv},
@@ -106,15 +118,22 @@ export class E2EEEncryptor {
     /**
      * Decrypt to an ArrayBuffer.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted binary data
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns The decrypted binary data
      */
-    static decryptBuffer(ciphertextBase64, key) {
+    static decryptBuffer(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<ArrayBuffer> {
         const combined = E2EEEncryptor._base64ToUint8Array(ciphertextBase64)
         const iv = combined.slice(0, 12)
         const ciphertext = combined.slice(12)
-        return crypto.subtle.decrypt({name: "AES-GCM", iv: iv}, key, ciphertext)
+        return crypto.subtle.decrypt(
+            {name: "AES-GCM", iv: iv},
+            key,
+            ciphertext
+        )
     }
 
     /**
@@ -124,11 +143,14 @@ export class E2EEEncryptor {
      * a Blob with application/octet-stream type (since the encrypted
      * data is opaque binary).
      *
-     * @param {File|Blob} file - The image file to encrypt
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<Blob>} An encrypted Blob with type application/octet-stream
+     * @param file - The image file to encrypt
+     * @param key - An AES-GCM key
+     * @returns An encrypted Blob with type application/octet-stream
      */
-    static async encryptImage(file, key) {
+    static async encryptImage(
+        file: Blob,
+        key: CryptoKey
+    ): Promise<Blob> {
         const buffer = await file.arrayBuffer()
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const ciphertext = await crypto.subtle.encrypt(
@@ -146,11 +168,14 @@ export class E2EEEncryptor {
     /**
      * Decrypt an encrypted image back to an ArrayBuffer.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted image data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<ArrayBuffer>} The decrypted image data
+     * @param ciphertextBase64 - Base64-encoded encrypted image data
+     * @param key - An AES-GCM key
+     * @returns The decrypted image data
      */
-    static decryptImage(ciphertextBase64, key) {
+    static decryptImage(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<ArrayBuffer> {
         return E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
     }
 
@@ -160,11 +185,14 @@ export class E2EEEncryptor {
      * Useful for decrypting encrypted images that need to be stored
      * as Base64 data URLs or re-exported.
      *
-     * @param {string} ciphertextBase64 - Base64-encoded encrypted data
-     * @param {CryptoKey} key - An AES-GCM key
-     * @returns {Promise<string>} Base64-encoded decrypted data
+     * @param ciphertextBase64 - Base64-encoded encrypted data
+     * @param key - An AES-GCM key
+     * @returns Base64-encoded decrypted data
      */
-    static async decryptBufferToBase64(ciphertextBase64, key) {
+    static async decryptBufferToBase64(
+        ciphertextBase64: string,
+        key: CryptoKey
+    ): Promise<string> {
         const buffer = await E2EEEncryptor.decryptBuffer(ciphertextBase64, key)
         const bytes = new Uint8Array(buffer)
         let binary = ""
@@ -180,12 +208,16 @@ export class E2EEEncryptor {
      * Fetches the encrypted image file from the given URL, decrypts it,
      * and creates a temporary object URL that can be used as an img src.
      *
-     * @param {string} imageUrl - The URL of the encrypted image file
-     * @param {CryptoKey} key - An AES-GCM key
-     * @param {string} mimeType - The MIME type of the decrypted image
-     * @returns {Promise<string>} A blob URL for the decrypted image
+     * @param imageUrl - The URL of the encrypted image file
+     * @param key - An AES-GCM key
+     * @param mimeType - The MIME type of the decrypted image
+     * @returns A blob URL for the decrypted image
      */
-    static async decryptImageToUrl(imageUrl, key, mimeType = "image/png") {
+    static async decryptImageToUrl(
+        imageUrl: string,
+        key: CryptoKey,
+        mimeType = "image/png"
+    ): Promise<string> {
         const response = await fetch(imageUrl)
         const arrayBuffer = await response.arrayBuffer()
         const bytes = new Uint8Array(arrayBuffer)
@@ -205,7 +237,7 @@ export class E2EEEncryptor {
      * Convert a Uint8Array to a Base64-encoded string.
      * @private
      */
-    static _uint8ArrayToBase64(bytes) {
+    private static _uint8ArrayToBase64(bytes: Uint8Array): string {
         let binary = ""
         for (let i = 0; i < bytes.length; i++) {
             binary += String.fromCharCode(bytes[i])
@@ -217,7 +249,7 @@ export class E2EEEncryptor {
      * Convert a Base64-encoded string to a Uint8Array.
      * @private
      */
-    static _base64ToUint8Array(base64) {
+    private static _base64ToUint8Array(base64: string): Uint8Array {
         const binary = atob(base64)
         const bytes = new Uint8Array(binary.length)
         for (let i = 0; i < binary.length; i++) {

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

@@ -3,10 +3,28 @@ 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 {XMLElement} from "../tools/xml.js"
+import type {XmlZip} from "../tools/xml_zip.js"
 
 export class DOCXExporterCitations {
-    constructor(docContent, settings, bibDB, csl, xml, origCitInfos = []) {
+    docContent: FidusNode
+    settings: DocSettings
+    bibDB: BibDB
+    csl: CSL
+    xml: XmlZip
+    origCitInfos: Record<string, unknown>[]
+
+    citInfos: Record<string, unknown>[]
+    citationTexts: string[]
+    pmCits: FidusNode[]
+    citFm: FormatCitations | false
+    pmBib: FidusNode | false
+    styleXML: XMLElement | null
+    styleFilePath: string
+
+    constructor(docContent: FidusNode, settings: DocSettings, bibDB: BibDB, csl: CSL, xml: XmlZip, origCitInfos: Record<string, unknown>[] = []) {
         this.docContent = docContent
         this.settings = settings
         this.bibDB = bibDB
@@ -19,11 +37,11 @@ export class DOCXExporterCitations {
         this.pmCits = []
         this.citFm = false
         this.pmBib = false
-        this.styleXML = false
+        this.styleXML = null
         this.styleFilePath = "word/styles.xml"
     }
 
-    init() {
+    init(): Promise<void> {
         return this.xml
             .getXml(this.styleFilePath)
             .then(styleXML => {
@@ -35,7 +53,7 @@ export class DOCXExporterCitations {
 
     // 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 citation entries for the given document.
@@ -44,21 +62,22 @@ export class DOCXExporterCitations {
         }
 
         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)
@@ -68,7 +87,10 @@ export class DOCXExporterCitations {
         })
     }
 
-    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.
@@ -83,30 +105,36 @@ export class DOCXExporterCitations {
 
             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[]
         }
 
         // 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.addReferenceStyle(cslBib[0])
             const bibNode = cslBibSchema.nodeFromJSON({type: "cslbib"})
             const cslSerializer = DOMSerializer.fromSchema(cslBibSchema)
             const dom = cslSerializer.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
         }
     }
 
-    addReferenceStyle(bibInfo) {
-        const stylesEl = this.styleXML.query("w:styles")
+    addReferenceStyle(bibInfo: {
+        linespacing: number
+        entryspacing: number
+        hangingindent?: boolean
+        maxoffset: number
+        "second-field-align"?: "margin" | "flush"
+    }): void {
+        const stylesEl = this.styleXML!.query("w:styles")
         if (
-            !this.styleXML.query("w:style", {
+            !this.styleXML!.query("w:style", {
                 "w:styleId": "BibliographyHeading"
             })
         ) {
@@ -126,15 +154,15 @@ export class DOCXExporterCitations {
                         <w:szCs w:val="32"/>
                     </w:rPr>
                 </w:style>`
-            stylesEl.appendXML(headingStyleDef)
+            stylesEl?.appendXML(headingStyleDef)
         }
         // The style called "Bibliography" will override any previous style
         // of the same name.
-        const stylesParStyle = this.styleXML.query("w:style", {
+        const stylesParStyle = this.styleXML!.query("w:style", {
             "w:styleId": "Bibliography"
         })
         if (stylesParStyle) {
-            stylesParStyle.parentElement.removeChild(stylesParStyle)
+            stylesParStyle.parentElement!.removeChild(stylesParStyle)
         }
 
         const lineHeight = 240 * bibInfo.linespacing
@@ -172,6 +200,6 @@ export class DOCXExporterCitations {
                 <w:rPr></w:rPr>
             </w:style>`
 
-        stylesEl.appendXML(styleDef)
+        stylesEl?.appendXML(styleDef)
     }
 }