@fiduswriter/editor 0.1.19 → 0.1.21

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

@@ -1,24 +1,30 @@
 import {BIBLIOGRAPHY_HEADERS} from "@fiduswriter/document/schema/i18n"
+import type {Fragment, Schema} from "prosemirror-model"
 import {DOMSerializer} from "prosemirror-model"
+
 import {RenderCitations} from "../../citations/render.js"
 import {createDocCopySchema, fnCopySchema} from "./schema.js"
+import type {Editor} from "../../types.js"
 
 // Wrap around DOMSerializer, allowing post processing.
 class ClipboardDOMSerializer {
-    constructor(nodes, marks, editor) {
+    domSerializer: DOMSerializer
+    editor: Editor
+
+    constructor(nodes: Record<string, any>, marks: Record<string, any>, editor: Editor) {
         this.domSerializer = new DOMSerializer(nodes, marks)
         this.editor = editor
     }
 
-    serializeFragment(fragment, options) {
+    serializeFragment(fragment: Fragment, options?: {document?: Document}): DocumentFragment {
         const domFragment = this.domSerializer.serializeFragment(
             fragment,
             options
         )
-        return this.postProcessFragment(domFragment)
+        return this.postProcessFragment(domFragment as DocumentFragment)
     }
 
-    postProcessFragment(domFragment) {
+    postProcessFragment(domFragment: DocumentFragment): DocumentFragment {
         const citationFormatter = this.renderCitations(domFragment)
         this.renderFootnotes(domFragment, citationFormatter)
         this.removeTrackingData(domFragment)
@@ -27,34 +33,37 @@ class ClipboardDOMSerializer {
         return domFragment
     }
 
-    renderCitations(domFragment) {
-        const settings = this.editor.view.state.doc.attrs,
+    renderCitations(domFragment: DocumentFragment): any {
+        const settings = this.editor.view.state.doc.attrs as Record<string, any>,
             bibliographyHeader =
                 settings.bibliography_header[settings.language] ||
-                BIBLIOGRAPHY_HEADERS[settings.language]
+                (BIBLIOGRAPHY_HEADERS as any)[settings.language]
         const citRenderer = new RenderCitations(
-            domFragment,
+            domFragment as any,
             settings.citationstyle,
             bibliographyHeader,
-            this.editor.mod.db.bibDB,
-            this.editor.app.csl,
+            (this.editor.mod.db as any).bibDB,
+            (this.editor.app as any).csl,
             true // synchronous. Should work as the editor has used the same style previously.
         )
+        const fm = citRenderer.fm as any
         if (citRenderer.init()) {
-            if (citRenderer.fm.bibHTML.length) {
+            if (fm.bibHTML.length) {
                 const bibDiv = document.createElement("div")
                 bibDiv.classList.add("fiduswriter-clipboard-bibliography")
-                bibDiv.innerHTML = citRenderer.fm.bibHTML
-                bibDiv.firstElementChild.innerHTML = gettext("Bibliography")
+                bibDiv.innerHTML = fm.bibHTML
+                ;(bibDiv.firstElementChild as HTMLElement).innerHTML = gettext(
+                    "Bibliography"
+                )
                 domFragment.appendChild(bibDiv)
             }
-            return citRenderer.fm
+            return fm
         } else {
             return false
         }
     }
 
-    renderFootnotes(domFragment, citationFormatter) {
+    renderFootnotes(domFragment: DocumentFragment, citationFormatter: any): void {
         const footnoteSelector =
             citationFormatter && citationFormatter.citationType === "note"
                 ? ".footnote-marker, .citation"
@@ -76,13 +85,13 @@ class ClipboardDOMSerializer {
             const newFootnote = document.createElement("h6") // We use H6 as Wordpress Gutenberg only allows IDs on H1-6 elements.
             newFootnote.setAttribute("role", "doc-footnote")
             newFootnote.innerHTML = footnote.matches(".footnote-marker")
-                ? footnote.dataset.footnote
+                ? (footnote as HTMLElement).dataset.footnote || ""
                 : `<p>${citationFormatter.citationTexts[citationCount++] || " "}</p>`
             if (
                 newFootnote.firstElementChild &&
                 newFootnote.firstElementChild.matches("p")
             ) {
-                newFootnote.firstElementChild.insertAdjacentHTML(
+                ;(newFootnote.firstElementChild as HTMLElement).insertAdjacentHTML(
                     "afterbegin",
                     `${counter}. `
                 )
@@ -100,13 +109,14 @@ class ClipboardDOMSerializer {
         }
     }
 
-    addFigureNumbers(domFragment) {
+    addFigureNumbers(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll(
                 "figure[data-category='figure'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
 
         domFragment
@@ -114,7 +124,8 @@ class ClipboardDOMSerializer {
                 "figure[data-category='photo'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
 
         domFragment
@@ -122,21 +133,22 @@ class ClipboardDOMSerializer {
                 "figure[data-category='table'] figcaption span.label"
             )
             .forEach((el, index) => {
-                el.innerHTML += " " + (index + 1) + ": "
+                ;(el as HTMLElement).innerHTML +=
+                    " " + (index + 1) + ": "
             })
     }
 
-    addBaseUrlToImages(domFragment) {
+    addBaseUrlToImages(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll("img")
             .forEach(el => el.setAttribute("src", el.src))
     }
 
-    getRandomID() {
+    getRandomID(): string {
         return (0 | (Math.random() * 9e6)).toString(36)
     }
 
-    getFootnoteAnchor(counter, id) {
+    getFootnoteAnchor(counter: number, id: string): HTMLElement {
         const footnoteAnchor = document.createElement("a")
         footnoteAnchor.setAttribute("href", `#fn-${id}`)
         footnoteAnchor.classList.add("fn")
@@ -145,11 +157,11 @@ class ClipboardDOMSerializer {
         return footnoteAnchor
     }
 
-    removeTrackingData(domFragment) {
+    removeTrackingData(domFragment: DocumentFragment): void {
         domFragment
             .querySelectorAll(".approved-insertion, .insertion")
             .forEach(el => {
-                const parent = el.parentNode
+                const parent = el.parentNode as any
                 const fragment = document.createDocumentFragment()
                 while (el.firstChild) {
                     fragment.appendChild(el.firstChild)
@@ -158,10 +170,10 @@ class ClipboardDOMSerializer {
             })
         domFragment
             .querySelectorAll(".deletion")
-            .forEach(el => el.parentElement.removeChild(el))
+            .forEach(el => el.parentElement!.removeChild(el))
     }
 
-    static fromSchema(schema, editor) {
+    static fromSchema(schema: Schema, editor: Editor): ClipboardDOMSerializer {
         return new ClipboardDOMSerializer(
             DOMSerializer.nodesFromSchema(schema),
             DOMSerializer.marksFromSchema(schema),
@@ -170,10 +182,10 @@ class ClipboardDOMSerializer {
     }
 }
 
-export const docClipboardSerializer = editor =>
+export const docClipboardSerializer = (editor: Editor): ClipboardDOMSerializer =>
     ClipboardDOMSerializer.fromSchema(
-        createDocCopySchema(editor.schema),
+        createDocCopySchema(editor.schema) as Schema,
         editor
     )
-export const fnClipboardSerializer = editor =>
-    ClipboardDOMSerializer.fromSchema(fnCopySchema, editor)
+export const fnClipboardSerializer = (editor: Editor): ClipboardDOMSerializer =>
+    ClipboardDOMSerializer.fromSchema(fnCopySchema as Schema, editor)

package/src/clipboard/paste/{fidus_writer.js → fidus_writer.ts}

@@ -1,9 +1,11 @@
+import type {Editor} from "../../types.js"
+
 import {GeneralPasteHandler} from "./general.js"
 
 // Fidus Writer paste handler
 export class FidusWriterPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement): HTMLElement {
         node = super.convertNode(node)
         // Replace  nodes with other nodes to not change the number of child nodes
         // <b style="font-weight:normal;">...</b> => <span>...</span>
@@ -13,12 +15,30 @@ export class FidusWriterPasteHandler extends GeneralPasteHandler {
         return node
     }
 
-    verifyCitationNode(node) {
+    verifyCitationNode(node: HTMLElement): HTMLElement {
         try {
-            const bibs = JSON.parse(node.dataset.bibs),
-                references = JSON.parse(node.dataset.references),
-                bibDB = this.editor.mod.db.bibDB,
-                idTranslations = {}
+            const bibs = JSON.parse(node.dataset.bibs || "{}") as Record<
+                    string,
+                    Record<string, unknown>
+                >,
+                references = JSON.parse(node.dataset.references || "[]") as Array<{
+                    id: number | string
+                }>,
+                bibDB = (this.editor as Editor).mod.db?.bibDB as
+                    | {
+                          findReference: (
+                              reference: Record<string, unknown>
+                          ) => string | undefined
+                          addReference: (
+                              reference: Record<string, unknown>,
+                              id: string | number
+                          ) => string | number
+                      }
+                    | undefined,
+                idTranslations: Record<string, number | string> = {}
+            if (!bibDB) {
+                return node
+            }
             Object.keys(bibs).forEach(bibKey => {
                 const reference = bibs[bibKey]
                 const oldKey = bibDB.findReference(reference)
@@ -45,11 +65,11 @@ export class FidusWriterPasteHandler extends GeneralPasteHandler {
         }
     }
 
-    cleanDOM() {
+    cleanDOM(): void {
         // Remove the bibliography that was added by the copy serializer
         const clipboardArtifacts = this.dom.querySelectorAll(
             ".fiduswriter-clipboard-bibliography, .fiduswriter-clipboard-footnotes"
         )
-        clipboardArtifacts.forEach(el => el.parentElement.removeChild(el))
+        clipboardArtifacts.forEach(el => el.parentElement?.removeChild(el))
     }
 }

package/src/clipboard/paste/{general.js → general.ts}

@@ -1,15 +1,29 @@
+import type {Editor} from "../../types.js"
+
 // General Fallback handler for paste
 export class GeneralPasteHandler {
-    constructor(editor, htmlDoc, pmType) {
+    editor: Editor
+    htmlDoc: HTMLElement
+    pmType: string
+    footnoteMarkers: HTMLElement[]
+    footnotes: HTMLElement[]
+    dom: HTMLElement
+    inHTML: string
+    outHTML: string
+
+    constructor(editor: Editor, htmlDoc: HTMLElement, pmType: string) {
         this.editor = editor
         this.htmlDoc = htmlDoc
         this.pmType = pmType
         this.footnoteMarkers = []
         this.footnotes = []
+        this.dom = document.createElement("body")
+        this.inHTML = ""
+        this.outHTML = ""
     }
 
     // Iterate over each node in the body of the pasted content.
-    getOutput() {
+    getOutput(): string {
         this.dom = this.htmlDoc.getElementsByTagName("body")[0]
         this.inHTML = this.dom.innerHTML
         this.iterateNode(this.dom)
@@ -20,17 +34,17 @@ export class GeneralPasteHandler {
     }
 
     // Remove unused content
-    cleanDOM() {}
+    cleanDOM(): void {}
 
     // Iterate over pasted nodes and their children
-    iterateNode(node) {
-        if ((node.tagName === "P") & !node.firstChild) {
-            node.parentNode.removeChild(node)
-            return
+    iterateNode(node: ChildNode): boolean {
+        if ((node as HTMLElement).tagName === "P" && !node.firstChild) {
+            node.parentNode?.removeChild(node)
+            return true
         } else if (node.nodeType === 8) {
             // comment node
-            node.parentNode.removeChild(node)
-            return
+            node.parentNode?.removeChild(node)
+            return true
         } else if (node.nodeType === 1) {
             // element node
             let childNode = node.firstChild
@@ -39,12 +53,13 @@ export class GeneralPasteHandler {
                 this.iterateNode(childNode)
                 childNode = nextChildNode
             }
-            node = this.convertNode(node)
+            node = this.convertNode(node as HTMLElement)
         }
+        return true
     }
 
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement): HTMLElement {
         if (
             node.tagName === "TABLE" &&
             node.firstElementChild?.tagName !== "CAPTION"
@@ -58,7 +73,7 @@ export class GeneralPasteHandler {
 
     // Move footnotes into their markers and turn footnote markers into the
     // required format.
-    convertFootnotes() {
+    convertFootnotes(): void {
         this.footnoteMarkers.forEach((fnM, index) => {
             const footnote = this.footnotes[index]
             const newFnM = document.createElement("span")
@@ -67,7 +82,7 @@ export class GeneralPasteHandler {
             // Remove linebreaks in string (not <BR>)
             // Turn multiple white spaces into single space
             newFnM.dataset.footnote = footnoteContents
-            fnM.parentNode.replaceChild(newFnM, fnM)
+            fnM.parentNode?.replaceChild(newFnM, fnM)
         })
         // Remove all footnotes from document. Some footnotes may have several
         // markers, so only remove each footnote once.

package/src/clipboard/paste/{google_docs.js → google_docs.ts}

@@ -3,23 +3,26 @@ import {GeneralPasteHandler} from "./general.js"
 // Google Docs (the writing component) paste handler
 export class GoogleDocsPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement) {
         node = super.convertNode(node)
         // Replace  nodes with other nodes to not change the number of child nodes
         // <b style="font-weight:normal;">...</b> => <span>...</span>
-        if (node.tagName === "B" && node.style.fontWeight === "normal") {
+        if (
+            node.tagName === "B" &&
+            node.style.fontWeight === "normal"
+        ) {
             node = this.neutralizeInlineNode(node)
         }
         return node
     }
 
     // Replace any type of inline node with a span node.
-    neutralizeInlineNode(node) {
+    neutralizeInlineNode(node: HTMLElement): HTMLElement {
         const newNode = document.createElement("span")
         while (node.firstChild) {
             newNode.appendChild(node.firstChild)
         }
-        node.parentNode.replaceChild(newNode, node)
+        node.parentNode?.replaceChild(newNode, node)
 
         return newNode
     }

package/src/clipboard/paste/{html.js → html.ts}

@@ -5,25 +5,49 @@ import {LibreOfficeWriterPasteHandler} from "./libreoffice_writer.js"
 import {MicrosoftWordPasteHandler} from "./microsoft_word.js"
 
 import {resetPasteRange} from "../../state_plugins/clipboard.js"
+import type {Editor} from "../../types.js"
 
 // Some pasted HTML will need slight conversions to work correctly.
 // We try to sniff whether paste comes from MsWord, LibreOffice or Google Docs
 // and use specialized handlers for these and a general handler everything else.
 
 export class HTMLPaste {
-    constructor(editor, inHTML, pmType, view) {
+    editor: Editor
+    inHTML: string
+    pmType: string
+    view: import("prosemirror-view").EditorView
+    htmlDoc: HTMLElement | undefined
+    handler:
+        | typeof FidusWriterPasteHandler
+        | typeof GeneralPasteHandler
+        | typeof GoogleDocsPasteHandler
+        | typeof LibreOfficeWriterPasteHandler
+        | typeof MicrosoftWordPasteHandler
+    handlerInstance: GeneralPasteHandler
+    outHTML: string
+
+    constructor(
+        editor: Editor,
+        inHTML: string,
+        pmType: string,
+        view: import("prosemirror-view").EditorView
+    ) {
         this.editor = editor
         this.inHTML = inHTML
         this.pmType = pmType
         this.view = view
+        this.htmlDoc = undefined
+        this.handler = GeneralPasteHandler
+        this.handlerInstance = new GeneralPasteHandler(editor, document.createElement("html"), pmType)
+        this.outHTML = ""
     }
 
-    getOutput() {
+    getOutput(): string {
         this.parseHTML()
         this.selectHandler()
         this.handlerInstance = new this.handler(
             this.editor,
-            this.htmlDoc,
+            this.htmlDoc as HTMLElement,
             this.pmType
         )
         this.outHTML = this.handlerInstance.getOutput()
@@ -33,7 +57,7 @@ export class HTMLPaste {
         return this.outHTML
     }
 
-    parseHTML() {
+    parseHTML(): void {
         const parser = new window.DOMParser()
         this.htmlDoc = parser
             .parseFromString(this.inHTML, "text/html")
@@ -42,13 +66,16 @@ export class HTMLPaste {
 
     // Find out what the source of the paste is and choose a corresponding
     // handler.
-    selectHandler() {
+    selectHandler(): void {
+        if (!this.htmlDoc) {
+            return
+        }
         // For LibreOffice
         const head = this.htmlDoc.getElementsByTagName("head")[0]
-        const generatorMetaTag = head.querySelector("meta[name=generator]")
+        const generatorMetaTag = head.querySelector("meta[name=generator]") as HTMLMetaElement | null
         // For Google Docs
         const body = this.htmlDoc.getElementsByTagName("body")[0]
-        const firstB = body.querySelector("b")
+        const firstB = body.querySelector("b") as HTMLElement | null
         // For Fidus Writer
         const pmSlice = this.htmlDoc.querySelector("[data-pm-slice]")
         if (
@@ -68,7 +95,7 @@ export class HTMLPaste {
         }
     }
 
-    resetPasteRange() {
+    resetPasteRange(): void {
         const tr = this.view.state.tr
         resetPasteRange(tr)
         this.view.dispatch(tr)

package/src/clipboard/paste/{libreoffice_writer.js → libreoffice_writer.ts}

@@ -3,7 +3,7 @@ import {GeneralPasteHandler} from "./general.js"
 // LibreOffice Writer paste handler
 export class LibreOfficeWriterPasteHandler extends GeneralPasteHandler {
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement) {
         node = super.convertNode(node)
         // Footnote markers (only in main pm instance):
         if (
@@ -12,15 +12,15 @@ export class LibreOfficeWriterPasteHandler extends GeneralPasteHandler {
             this.pmType === "main"
         ) {
             // Remove "sym" at the end of the selector
-            const href = node.getAttribute("href")
+            const href = node.getAttribute("href") || ""
             const fnSelector =
                 href.length > 3 ? href.substring(0, href.length - 3) : href
-            const footnote = this.dom.querySelector(fnSelector)
+            const footnote = this.dom.querySelector(fnSelector) as HTMLElement | null
             if (footnote) {
                 const footnoteCounter =
                     footnote.querySelector("a.sdfootnotesym")
                 if (footnoteCounter) {
-                    footnoteCounter.parentNode.removeChild(footnoteCounter)
+                    footnoteCounter.parentNode?.removeChild(footnoteCounter)
                 }
                 this.footnoteMarkers.push(node)
                 this.footnotes.push(footnote)

package/src/clipboard/paste/{microsoft_word.js → microsoft_word.ts}

@@ -3,32 +3,32 @@ import {GeneralPasteHandler} from "./general.js"
 // Microsoft Word 2016 paste handler
 export class MicrosoftWordPasteHandler extends GeneralPasteHandler {
     // Remove unused content
-    cleanDOM() {
+    cleanDOM(): void {
         // Remove footnote list container with separator line
         const removableElements = this.dom.querySelectorAll(
             'div[style*="mso-element:footnote-list"]'
         )
 
-        removableElements.forEach(el => el.parentNode.removeChild(el))
+        removableElements.forEach(el => el.parentNode?.removeChild(el))
     }
 
     // Iterate over pasted nodes and their children
-    iterateNode(node) {
-        node = super.convertNode(node)
-        if ((node.tagName === "P") & !node.firstChild) {
-            node.parentNode.removeChild(node)
+    iterateNode(node: ChildNode): boolean {
+        node = super.convertNode(node as HTMLElement)
+        if ((node as HTMLElement).tagName === "P" && !node.firstChild) {
+            node.parentNode?.removeChild(node)
             return true
         } else if (node.nodeType === 8) {
             if (node.textContent === "EndFragment") {
                 // End of paste content. Remove all remaining sibling nodes.
                 while (node) {
                     const nextSibling = node.nextSibling
-                    node.parentNode.removeChild(node)
-                    node = nextSibling
+                    node.parentNode?.removeChild(node)
+                    node = nextSibling as ChildNode
                 }
                 return false
             } else {
-                node.parentNode.removeChild(node)
+                node.parentNode?.removeChild(node)
                 return true
             }
         }
@@ -39,46 +39,47 @@ export class MicrosoftWordPasteHandler extends GeneralPasteHandler {
                 if (this.iterateNode(childNode)) {
                     childNode = nextChildNode
                 } else {
-                    childNode = false
+                    childNode = null
                 }
             }
-            node = this.convertNode(node)
+            node = this.convertNode(node as HTMLElement)
         }
 
         return true
     }
 
     // Convert an existing node to a different node, if needed.
-    convertNode(node) {
+    convertNode(node: HTMLElement): HTMLElement {
         // Footnote markers (only in main pm instance):
         if (
             node.tagName === "A" &&
-            node.firstChild?.tagName === "SPAN" &&
-            node.firstChild?.classList.contains("MsoFootnoteReference") &&
+            node.firstChild?.nodeType === 1 &&
+            (node.firstChild as HTMLElement).tagName === "SPAN" &&
+            (node.firstChild as HTMLElement).classList.contains(
+                "MsoFootnoteReference"
+            ) &&
             this.pmType === "main"
         ) {
             // Remove "#_ftn" from the selector (#_ftn1)
-            const fnSelector = node.getAttribute("href")
-            const fnNumber = node
-                .getAttribute("href")
-                .substring(5, fnSelector.length)
+            const fnSelector = node.getAttribute("href") || ""
+            const fnNumber = fnSelector.substring(5, fnSelector.length)
             const footnote = this.dom.querySelector("#ftn" + fnNumber)
             if (footnote) {
                 const footnoteCounter = footnote.querySelector(
                     'a[href="#_ftnref' + fnNumber + '"]'
                 )
                 if (footnoteCounter) {
+                    footnoteCounter.parentNode?.removeChild(footnoteCounter)
                     const followingNode = footnoteCounter.nextSibling
-                    footnoteCounter.parentNode.removeChild(footnoteCounter)
                     if (followingNode?.nodeType === 3) {
                         // If there is a text string right after the footnote
                         // marker, remove any leading spaces.
                         followingNode.nodeValue =
-                            followingNode.nodeValue.replace(/^\s+/, "")
+                            followingNode.nodeValue?.replace(/^\s+/, "") || ""
                     }
                 }
                 this.footnoteMarkers.push(node)
-                this.footnotes.push(footnote)
+                this.footnotes.push(footnote as HTMLElement)
             }
         }
 

package/src/clipboard/paste/{text.js → text.ts}

@@ -1,23 +1,27 @@
-import {TextSelection} from "prosemirror-state"
-import {__parseFromClipboard} from "prosemirror-view"
-
 import {getPasteRange, resetPasteRange} from "../../state_plugins/clipboard.js"
+import type {Editor} from "../../types.js"
+import type {EditorView} from "prosemirror-view"
 
 export class TextPaste {
-    constructor(editor, text, view) {
+    editor: Editor
+    text: string
+    view: EditorView
+    foundBibEntries: boolean
+
+    constructor(editor: Editor, text: string, view: EditorView) {
         this.editor = editor
         this.text = text
         this.view = view
         this.foundBibEntries = false
     }
 
-    init() {
+    init(): void {
         import("@fiduswriter/bibliography-manager/import").then(
             ({BibliographyImporter}) => {
                 const importer = new BibliographyImporter(
                     this.text,
-                    this.editor.mod.db.bibDB,
-                    newIds => {
+                    this.editor.mod.db?.bibDB,
+                    (newIds: string[]) => {
                         this.foundBibEntries = true
                         const format = "autocite",
                             references = newIds.map(id => ({id}))