@fiduswriter/editor 0.1.20 → 0.1.21

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

@@ -1,16 +1,33 @@
+import type {Node as ProseMirrorNode} from "prosemirror-model"
 import {BIBLIOGRAPHY_HEADERS} from "@fiduswriter/document/schema/i18n"
 import {Dialog, cancelPromise} from "fwtoolkit"
+
+import type {Editor} from "../types.js"
 import {RenderCitations} from "./render.js"
 
+interface DialogButtonSpec {
+    text?: string
+    classes?: string
+    click?: () => void
+    type?: "cancel" | "close" | "ok"
+    icon?: string
+}
+
 export class ModCitations {
-    constructor(editor) {
+    editor: Editor
+    citationType: string
+    fnOverrideElement: HTMLElement | null
+    citRenderer: any
+
+    constructor(editor: Editor) {
         editor.mod.citations = this
         this.editor = editor
         this.citationType = ""
-        this.fnOverrideElement = false
+        this.fnOverrideElement = false as unknown as null
+        this.citRenderer = false
     }
 
-    init() {
+    init(): void {
         /* Add a style to hold dynamic CSS info about footnote numbering overrides.
          * Because we need footnotes in the editor and footnotes added through
          * citations to be numbered but they aren't in the same order in the DOM,
@@ -25,7 +42,7 @@ export class ModCitations {
         )
     }
 
-    resetCitations() {
+    resetCitations(): void {
         const citations = document.querySelectorAll(
             "#paper-editable span.citation"
         )
@@ -46,7 +63,7 @@ export class ModCitations {
         this.layoutCitations()
     }
 
-    layoutCitations() {
+    layoutCitations(): void {
         if (!this.editor.mod.db?.bibDB.db) {
             // bibliography hasn't been loaded yet
             return
@@ -57,10 +74,10 @@ export class ModCitations {
         if (emptyCitations.length) {
             const settings = this.editor.view.state.doc.attrs,
                 bibliographyHeader =
-                    settings.bibliography_header[settings.language] ||
-                    BIBLIOGRAPHY_HEADERS[settings.language]
+                    settings.bibliography_header[settings.language as string] ||
+                    BIBLIOGRAPHY_HEADERS[settings.language as keyof typeof BIBLIOGRAPHY_HEADERS]
             this.citRenderer = new RenderCitations(
-                document.getElementById("paper-editable"),
+                document.getElementById("paper-editable") as HTMLElement,
                 settings.citationstyle,
                 bibliographyHeader,
                 this.editor.mod.db.bibDB,
@@ -75,7 +92,7 @@ export class ModCitations {
         }
     }
 
-    recoverAfterCiteProcCrash() {
+    recoverAfterCiteProcCrash(): Promise<void> {
         console.warn(
             "CitationProcessor crashed. Falling back to simplified citation rendering."
         )
@@ -88,7 +105,7 @@ export class ModCitations {
             try {
                 // Get citation data from dataset
                 const referencesData = JSON.parse(
-                    citation.dataset.references || "[]"
+                    (citation as HTMLElement).dataset.references || "[]"
                 )
                 if (!referencesData.length) {
                     citation.innerHTML = "[?]"
@@ -97,9 +114,11 @@ export class ModCitations {
 
                 // Create a basic fallback citation text
                 const citationText = referencesData
-                    .map(ref => {
+                    .map((ref: {id?: number; locator?: string}) => {
                         const entryId = ref.id
-                        const item = this.editor.mod.db.bibDB.db[entryId]
+                        const item = ((this.editor.mod.db as any).bibDB.db as any)[
+                            entryId as number
+                        ]
 
                         if (!item) {
                             return `[${entryId || "?"}]`
@@ -115,7 +134,7 @@ export class ModCitations {
                                     author.firstname ||
                                     author.literal
                                 )
-                                    ?.map(part => part.text || "")
+                                    ?.map((part: {text?: string}) => part.text || "")
                                     .join("") || "Unknown Author"
                             if (item.fields.author.length > 1) {
                                 authorText += " et al."
@@ -149,8 +168,8 @@ export class ModCitations {
             try {
                 const settings = this.editor.view.state.doc.attrs
                 const bibliographyHeader =
-                    settings.bibliography_header[settings.language] ||
-                    BIBLIOGRAPHY_HEADERS[settings.language]
+                    settings.bibliography_header[settings.language as string] ||
+                    BIBLIOGRAPHY_HEADERS[settings.language as keyof typeof BIBLIOGRAPHY_HEADERS]
 
                 let bibHTML = `<h1 class="doc-bibliography-header">${bibliographyHeader}</h1><div class="csl-bib-body">`
 
@@ -158,21 +177,21 @@ export class ModCitations {
                 const allCitations = Array.from(
                     document.querySelectorAll("#paper-editable span.citation")
                 )
-                const allRefs = new Set()
+                const allRefs = new Set<number>()
 
                 allCitations.forEach(citation => {
                     try {
                         const refs = JSON.parse(
-                            citation.dataset.references || "[]"
+                            (citation as HTMLElement).dataset.references || "[]"
                         )
-                        refs.forEach(ref => allRefs.add(ref.id))
+                        refs.forEach((ref: {id: number}) => allRefs.add(ref.id))
                     } catch (_error) {
                         // Skip invalid references
                     }
                 })
 
                 // Create simple bibliography entries
-                const bibDB = this.editor.mod.db.bibDB.db
+                const bibDB = (this.editor.mod.db as any).bibDB.db as any
                 Array.from(allRefs)
                     .sort()
                     .forEach(id => {
@@ -185,14 +204,14 @@ export class ModCitations {
                         let authors = ""
                         if (item.fields.author && item.fields.author.length) {
                             authors = item.fields.author
-                                .map(author => {
+                                .map((author: any) => {
                                     return (
                                         (
                                             author.lastName ||
                                             author.firstname ||
                                             author.literal
                                         )
-                                            ?.map(part => part.text || "")
+                                            ?.map((part: {text?: string}) => part.text || "")
                                             .join("") || "Unknown"
                                     )
                                 })
@@ -204,14 +223,12 @@ export class ModCitations {
                         const year = item.fields.date
                             ? `(${item.fields.date.substring(0, 4)})`
                             : "(n.d.)"
-                        const title =
-                            item.fields.title
-                                ?.map(part => part.text || "")
-                                .join("") || "Untitled"
-                        const publisher =
-                            item.fields.publisher
-                                ?.map(part => part.text || "")
-                                .join("") || ""
+                        const title = item.fields.title
+                            ?.map((part: {text?: string}) => part.text || "")
+                            .join("") || "Untitled"
+                        const publisher = item.fields.publisher
+                            ?.map((part: {text?: string}) => part.text || "")
+                            .join("") || ""
                         const itemType = item.bib_type || "misc"
 
                         bibHTML += `<div class="csl-entry" data-reference="${id}">${authors} ${year}. <i>${title}</i>. ${publisher}. [${itemType}]</div>`
@@ -235,7 +252,7 @@ export class ModCitations {
                     div.csl-entry { cursor: pointer; }
                     div.csl-entry:hover { background-color: #f0f0f0; }
                 `
-                styleEl.innerHTML = basicCSS
+                ;(styleEl as HTMLElement).innerHTML = basicCSS
 
                 // Rebind click handlers for bibliography entries
                 if (this.editor.docInfo.access_rights === "write") {
@@ -254,20 +271,20 @@ export class ModCitations {
         return Promise.resolve()
     }
 
-    bindBibliographyClicks() {
+    bindBibliographyClicks(): void {
         document.querySelectorAll("div.csl-entry").forEach((el, index) => {
             el.addEventListener("click", () => {
                 const eID = Number.parseInt(
-                    this.citRenderer.fm.bibliography[0]?.entry_ids[index][0] ||
-                        el.dataset.reference
+                    (this.citRenderer.fm.bibliography[0]?.entry_ids[index][0] ||
+                        (el as HTMLElement).dataset.reference) as string
                 )
                 this.checkTrackingDialog()
                     .then(() => import("@fiduswriter/bibliography-manager/form"))
                     .then(({BibEntryForm}) => {
                         const form = new BibEntryForm(
-                            this.editor.mod.db.bibDB,
+                            (this.editor.mod.db as any).bibDB,
                             false,
-                            eID
+                            eID as any
                         )
                         form.init()
                     })
@@ -275,29 +292,30 @@ export class ModCitations {
         })
     }
 
-    checkTrackingDialog() {
+    checkTrackingDialog(): Promise<void> {
         if (!this.editor.view.state.doc.attrs.tracked) {
             return Promise.resolve()
         }
-        const buttons = [],
-            promise = new Promise(resolve => {
-                buttons.push({
-                    type: "cancel",
-                    click: () => {
-                        dialog.close()
-                        resolve(cancelPromise())
-                    }
-                })
-                buttons.push({
-                    type: "ok",
-                    click: () => {
-                        dialog.close()
-                        resolve()
-                    }
-                })
+        const buttons: DialogButtonSpec[] = []
+        let dialog: InstanceType<typeof Dialog>
+        const promise = new Promise<void>(resolve => {
+            buttons.push({
+                type: "cancel",
+                click: () => {
+                    dialog.close()
+                    resolve(cancelPromise() as unknown as void)
+                }
+            })
+            buttons.push({
+                type: "ok",
+                click: () => {
+                    dialog.close()
+                    resolve()
+                }
             })
+        })
 
-        const dialog = new Dialog({
+        dialog = new Dialog({
             title: gettext("No tracking"),
             body: gettext("Changes to citation sources are not being tracked!"),
             icon: "exclamation-triangle",
@@ -309,7 +327,7 @@ export class ModCitations {
         return promise
     }
 
-    layoutCitationsTwo() {
+    layoutCitationsTwo(): void {
         const citRenderer = this.citRenderer
         let needFootnoteLayout = false
         if (this.citationType !== citRenderer.fm.citationType) {
@@ -342,8 +360,8 @@ export class ModCitations {
                     background-color: grey;
                 }`
         }
-        if (styleEl.innerHTML !== css) {
-            styleEl.innerHTML = css
+        if ((styleEl as HTMLElement).innerHTML !== css) {
+            ;(styleEl as HTMLElement).innerHTML = css
         }
 
         const citationsContainer = document.getElementById(
@@ -361,12 +379,12 @@ export class ModCitations {
                     citationsHTML = citRenderer.fm.citationTexts
                         .slice(0, citationNodes.length)
                         .map(
-                            citText =>
+                            (citText: string) =>
                                 `<div class="footnote-citation">${citText}</div>`
                         )
                         .join("")
-                if (citationsContainer.innerHTML !== citationsHTML) {
-                    citationsContainer.innerHTML = citationsHTML
+                if (citationsContainer!.innerHTML !== citationsHTML) {
+                    citationsContainer!.innerHTML = citationsHTML
                 }
                 // The citations have not been filled, so we do so manually.
                 citationNodes.forEach(
@@ -382,7 +400,7 @@ export class ModCitations {
                     citationNodes.length
                 )
 
-                footnoteCitTexts.forEach((citText, index) => {
+                footnoteCitTexts.forEach((citText: string, index: number) => {
                     const citationNode = footnoteCitationNodes[index]
                     if (citationNode) {
                         citationNode.innerHTML = citText
@@ -390,18 +408,18 @@ export class ModCitations {
                 })
             }
         } else {
-            if (citationsContainer.innerHTML !== "") {
-                citationsContainer.innerHTML = ""
+            if (citationsContainer!.innerHTML !== "") {
+                citationsContainer!.innerHTML = ""
             }
         }
 
         this.footnoteNumberOverride()
         if (needFootnoteLayout) {
-            this.editor.mod.footnotes.layout.updateDOM()
+            ;((this.editor.mod as any).footnotes.layout as any).updateDOM()
         }
     }
 
-    footnoteNumberOverride() {
+    footnoteNumberOverride(): void {
         /* Find the order of footnotes and citations in the document and
          * write CSS to number all the citation footnotes and other footnotes
          * correspondingly. Update footnote-numbering-override correspondingly.
@@ -414,30 +432,32 @@ export class ModCitations {
                 citationFootnoteCounter = 1,
                 footnoteCounter = 1
 
-            this.editor.view.state.doc.descendants(node => {
-                if (
-                    node.isInline &&
-                    (node.type.name === "footnote" ||
-                        node.type.name === "citation")
-                ) {
-                    if (node.type.name === "footnote") {
-                        outputCSS += `#footnote-box-container .footnote-container:nth-of-type(${editorFootnoteCounter}) > *:first-child::before {
+            this.editor.view.state.doc.descendants(
+                (node: ProseMirrorNode) => {
+                    if (
+                        node.isInline &&
+                        (node.type.name === "footnote" ||
+                            node.type.name === "citation")
+                    ) {
+                        if (node.type.name === "footnote") {
+                            outputCSS += `#footnote-box-container .footnote-container:nth-of-type(${editorFootnoteCounter}) > *:first-child::before {
                              content: "${footnoteCounter} ";
                          }\n`
-                        editorFootnoteCounter++
-                    } else {
-                        outputCSS += `.footnote-citation:nth-of-type(${citationFootnoteCounter})::before {
+                            editorFootnoteCounter++
+                        } else {
+                            outputCSS += `.footnote-citation:nth-of-type(${citationFootnoteCounter})::before {
                              content: "${footnoteCounter} ";
                          }\n`
-                        citationFootnoteCounter++
+                            citationFootnoteCounter++
+                        }
+                        footnoteCounter++
                     }
-                    footnoteCounter++
                 }
-            })
+            )
         }
 
-        if (this.fnOverrideElement.innerHTML !== outputCSS) {
-            this.fnOverrideElement.innerHTML = outputCSS
+        if (this.fnOverrideElement!.innerHTML !== outputCSS) {
+            this.fnOverrideElement!.innerHTML = outputCSS
         }
     }
 }

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

@@ -1,15 +1,36 @@
 import {FormatCitations} from "@fiduswriter/document/citations/format"
+import type {BibDB, CSL} from "@fiduswriter/document"
+
+interface CitationInfo {
+    format: string
+    references: Array<{
+        id: number
+        [key: string]: unknown
+    }>
+}
+
 /**
  * Render citations into the DOM.
  */
 
 export class RenderCitations {
+    contentElement: HTMLElement
+    citationStyle: string
+    bibliographyHeader: string
+    bibDB: BibDB
+    csl: CSL
+    synchronous: boolean
+    lang: string
+    allCitationNodes: NodeListOf<HTMLElement>
+    allCitationInfos: CitationInfo[]
+    fm: FormatCitations | false
+
     constructor(
-        contentElement,
-        citationStyle,
-        bibliographyHeader,
-        bibDB,
-        csl,
+        contentElement: HTMLElement,
+        citationStyle: string,
+        bibliographyHeader: string,
+        bibDB: BibDB,
+        csl: CSL,
         synchronous = false,
         lang = "en-US"
     ) {
@@ -21,17 +42,19 @@ export class RenderCitations {
         this.synchronous = synchronous
         this.lang = lang
 
-        this.allCitationNodes = []
+        this.allCitationNodes = document.querySelectorAll("span.citation")
         this.allCitationInfos = []
         this.fm = false
     }
 
-    init() {
+    init(): boolean | Promise<void> {
         this.allCitationNodes =
             this.contentElement.querySelectorAll("span.citation")
         this.allCitationNodes.forEach(cElement => {
-            const citeInfo = Object.assign({}, cElement.dataset)
-            citeInfo.references = JSON.parse(citeInfo.references)
+            const citeInfo: CitationInfo = {
+                format: cElement.dataset.format || "",
+                references: JSON.parse(cElement.dataset.references || "[]")
+            }
             this.allCitationInfos.push(citeInfo)
         })
         this.fm = new FormatCitations(
@@ -50,15 +73,20 @@ export class RenderCitations {
             this.renderCitations()
             return true
         } else {
-            return this.fm.init().then(() => {
-                this.renderCitations()
-                return Promise.resolve()
-            })
+            const initResult = this.fm.init()
+            if (initResult instanceof Promise) {
+                return initResult.then(() => {
+                    this.renderCitations()
+                    return Promise.resolve()
+                })
+            }
+            this.renderCitations()
+            return Promise.resolve()
         }
     }
 
-    renderCitations() {
-        if ("note" !== this.fm.citationType) {
+    renderCitations(): void {
+        if (this.fm && "note" !== this.fm.citationType) {
             this.fm.citationTexts.forEach(
                 (citationText, index) =>
                     (this.allCitationNodes[index].innerHTML = citationText)

package/src/clipboard/copy/{schema.js → schema.ts}

@@ -4,13 +4,22 @@ import {DOMSerializer, Node, Schema} from "prosemirror-model"
 import {citation} from "@fiduswriter/document/schema/common/index"
 import {footnote} from "@fiduswriter/document/schema/document/content"
 import {fnSchema} from "@fiduswriter/document/schema/footnotes"
+import type {BibDB} from "@fiduswriter/document"
+
+interface CachedSchema {
+    cached: {bibDB: BibDB}
+}
+
+const asCached = (schema: Schema): CachedSchema => schema as unknown as CachedSchema
 
 const copyCitation = Object.assign({}, citation)
 
 copyCitation.toDOM = node => {
-    const bibDB = node.type.schema.cached.bibDB,
-        bibs = {}
-    node.attrs.references.forEach(ref => (bibs[ref.id] = bibDB.db[ref.id]))
+    const bibDB = asCached(node.type.schema).cached.bibDB,
+        bibs: Record<string, Record<string, unknown>> = {}
+    ;(node.attrs.references as Array<{id: number | string}>).forEach(
+        ref => (bibs[ref.id] = bibDB.db[ref.id])
+    )
     return [
         "span",
         {
@@ -35,8 +44,8 @@ export const fnCopySchema = new Schema({
 const copyFootnote = Object.assign({}, footnote)
 
 copyFootnote.toDOM = node => {
-    if (!fnCopySchema.cached.bibDB) {
-        fnCopySchema.cached.bibDB = fnSchema.cached.bibDB
+    if (!asCached(fnCopySchema).cached.bibDB) {
+        asCached(fnCopySchema).cached.bibDB = asCached(fnSchema).cached.bibDB
     }
     const fnCopySerializer = DOMSerializer.fromSchema(fnCopySchema)
     const dom = document.createElement("span")
@@ -45,18 +54,20 @@ copyFootnote.toDOM = node => {
         type: "footnotecontainer",
         content: node.attrs.footnote
     })
-    dom.dataset.footnote = fnCopySerializer.serializeNode(pmNode).innerHTML
+    dom.dataset.footnote = (
+        fnCopySerializer.serializeNode(pmNode) as HTMLElement
+    ).innerHTML
     dom.innerHTML = "&nbsp;"
     return dom
 }
 
-export const createDocCopySchema = docSchema => {
+export const createDocCopySchema = (docSchema: Schema): Schema => {
     const newSchema = new Schema({
         marks: docSchema.spec.marks,
         nodes: docSchema.spec.nodes
             .update("citation", copyCitation)
             .update("footnote", copyFootnote)
     })
-    newSchema.cached.bibDB = docSchema.cached.bibDB
+    asCached(newSchema).cached.bibDB = asCached(docSchema).cached.bibDB
     return newSchema
 }