@fiduswriter/editor 0.1.20 → 0.1.21

package/src/collab/merge/{footnotes.js → footnotes.ts}

@@ -2,10 +2,27 @@ import {fnSchema} from "@fiduswriter/document/schema/footnotes"
 import {htmlToFnNode} from "@fiduswriter/document/schema/footnotes_convert"
 import {EditorState} from "prosemirror-state"
 import {EditorView} from "prosemirror-view"
+import type {Node} from "prosemirror-model"
+import type {Transaction} from "prosemirror-state"
+
+import type {Editor} from "../../types.js"
 import {trackedTransaction} from "../../track/index.js"
 
 export class FootnoteView {
-    constructor(node, view, getPos, editor) {
+    node: Node
+    outerView: EditorView
+    getPos: () => number
+    editor: Editor
+    dom: HTMLElement
+    innerView: EditorView | null
+    updatedMainEditor: boolean
+
+    constructor(
+        node: Node,
+        view: EditorView,
+        getPos: () => number,
+        editor: Editor
+    ) {
         // We'll need these later
         this.node = node
         this.outerView = view
@@ -21,21 +38,21 @@ export class FootnoteView {
         this.updatedMainEditor = false
     }
 
-    selectNode() {
+    selectNode(): void {
         this.dom.classList.add("ProseMirror-selectednode")
         if (!this.innerView) {
             this.open()
         }
     }
 
-    deselectNode() {
+    deselectNode(): void {
         this.dom.classList.remove("ProseMirror-selectednode")
         if (this.innerView) {
             this.close()
         }
     }
 
-    open() {
+    open(): void {
         // Append a tooltip to the outer node
         const tooltip = this.dom.appendChild(document.createElement("div"))
         tooltip.className = "footnote-tooltip"
@@ -67,14 +84,14 @@ export class FootnoteView {
             handleDOMEvents: {
                 mousedown: () => {
                     if (this.outerView.hasFocus()) {
-                        this.innerView.focus()
+                        this.innerView?.focus()
                     }
                 }
             }
         })
     }
 
-    close() {
+    close(): void {
         if (!this.updatedMainEditor && this.outerView) {
             this.updateMainEditor()
         }
@@ -86,9 +103,9 @@ export class FootnoteView {
         }
     }
 
-    updateMainEditor() {
+    updateMainEditor(): void {
         const outerTr = this.outerView.state.tr
-        const footnoteContent = this.innerView.state.doc
+        const footnoteContent = this.innerView?.state.doc
             .child(0)
             .toJSON().content
         const pos = this.getPos()
@@ -105,48 +122,52 @@ export class FootnoteView {
         }
     }
 
-    dispatchInner(tr) {
+    dispatchInner(tr: Transaction): void {
         const trackedTr = trackedTransaction(
             tr,
-            this.innerView.state,
+            this.innerView?.state as EditorState,
             this.editor.user,
             !this.outerView.state.doc.attrs.tracked &&
                 !["write-tracked", "review-tracked"].includes(
-                    this.editor.docInfo.access_rights
+                    this.editor.docInfo.access_rights as string
                 ),
             Date.now() - this.editor.clientTimeAdjustment
         )
-        const {state} = this.innerView.state.applyTransaction(trackedTr)
-        this.innerView.updateState(state)
+        const {state} = (this.innerView as EditorView).state.applyTransaction(
+            trackedTr
+        )
+        ;(this.innerView as EditorView).updateState(state)
     }
 
-    update(node) {
+    update(node: Node): boolean {
         this.node = node
         return true
     }
 
-    destroy() {
-        this.outerView = null
+    destroy(): void {
+        this.outerView = null as unknown as EditorView
         if (this.innerView) {
             this.close()
         }
     }
 
-    stopEvent(event) {
-        return this.innerView && this.innerView.dom.contains(event.target)
+    stopEvent(event: Event): boolean {
+        return this.innerView
+            ? this.innerView.dom.contains(event.target as globalThis.Node)
+            : false
     }
 
-    ignoreMutation() {
+    ignoreMutation(): boolean {
         return true
     }
 }
 
-export const readOnlyFnEditor = footnoteElement => {
+export const readOnlyFnEditor = (footnoteElement: HTMLElement): HTMLElement => {
     // This function creates a read only footnote editor for the purpose of showing the
     // footnote nodes which are drawn as part of deletion decoration.
     const newFnElement = document.createElement("div")
     newFnElement.className = "footnote-view"
-    newFnElement.dataset.footnote = footnoteElement.dataset.footnote
+    newFnElement.dataset.footnote = footnoteElement.dataset.footnote as string
     const tooltip = newFnElement.appendChild(document.createElement("div"))
     tooltip.className = "footnote-tooltip"
     tooltip.classList.add("render-arrow")
@@ -158,7 +179,7 @@ export const readOnlyFnEditor = footnoteElement => {
         content: [
             {
                 type: "footnotecontainer",
-                content: htmlToFnNode(footnoteElement.dataset.footnote)
+                content: htmlToFnNode(footnoteElement.dataset.footnote as string)
             }
         ]
     })

package/src/collab/merge/{index.js → index.ts}

@@ -1,33 +1,57 @@
+import type {Node} from "prosemirror-model"
+import {EditorState, type Selection, type Transaction} from "prosemirror-state"
+import {Mapping, Step, StepMap, Transform} from "prosemirror-transform"
+import type {BibDB, ExportDoc, ImageDB} from "@fiduswriter/document"
 import {getSettings} from "@fiduswriter/document/schema/convert"
 import {Dialog, addAlert, showSystemMessage} from "fwtoolkit"
 import {receiveTransaction, sendableSteps} from "prosemirror-collab"
-import {EditorState} from "prosemirror-state"
-import {Mapping, Step, Transform} from "prosemirror-transform"
-import {WRITE_ROLES} from "../..//index.js"
+
+import {WRITE_ROLES} from "../../index.js"
 import {ExportFidusFile} from "../../exporter/native/index.js"
 import {acceptAllNoInsertions, trackedTransaction} from "../../track/index.js"
 import {changeSet} from "./changeset.js"
 import {MergeEditor} from "./editor.js"
+import {ModCollab} from "../index.js"
 import {recreateTransform} from "./recreate_transform.js"
 import {simplifyTransform} from "./tools.js"
 
+interface MergeMessage {
+    ds?: unknown[]
+    cid?: number
+}
+
+interface MergeData {
+    doc: {
+        v: number
+        content: Record<string, unknown>
+        comments: Record<string, unknown>
+        bibliography: BibDB
+        images: ImageDB
+    }
+    m?: MergeMessage[]
+}
+
 export class Merge {
-    constructor(mod) {
+    mod: ModCollab
+    trackOfflineLimit: number
+    remoteTrackOfflineLimit: number
+
+    constructor(mod: ModCollab) {
         this.mod = mod
         this.trackOfflineLimit = 50 // Limit of local changes while offline for tracking to kick in when multiple users edit
         this.remoteTrackOfflineLimit = 50 // Limit of remote changes while offline for tracking to kick in when multiple users edit
     }
 
-    adjustDocument(data) {
+    adjustDocument(data: MergeData): void {
         // Adjust the document when reconnecting after offline and many changes
         // happening on server.
         if (
-            this.mod.editor.docInfo.version < data.doc.v &&
+            this.mod.editor.docInfo.version! < data.doc.v &&
             sendableSteps(this.mod.editor.view.state)
         ) {
             this.mod.doc.receiving = true
             const confirmedState = EditorState.create({
-                doc: this.mod.editor.docInfo.confirmedDoc
+                doc: this.mod.editor.docInfo.confirmedDoc as Node
             })
             const unconfirmedTr = confirmedState.tr
             const sendable = sendableSteps(this.mod.editor.view.state)
@@ -52,19 +76,19 @@ export class Merge {
                 receiveTransaction(
                     this.mod.editor.view.state,
                     unconfirmedTr.steps,
-                    unconfirmedTr.steps.map(_step => this.mod.editor.client_id)
+                    unconfirmedTr.steps.map(() => this.mod.editor.client_id)
                 )
             )
             this.mod.editor.view.dispatch(
                 receiveTransaction(
                     this.mod.editor.view.state,
                     rollbackTr.steps,
-                    rollbackTr.steps.map(_step => "remote")
+                    rollbackTr.steps.map(() => "remote")
                 ).setMeta("remote", true)
             )
             const toDoc = this.mod.editor.schema.nodeFromJSON(data.doc.content)
             // Apply the online Transaction
-            let lostTr
+            let lostTr: Transform
             if (data.m) {
                 lostTr = new Transform(this.mod.editor.view.state.doc)
                 data.m.forEach(message => {
@@ -97,29 +121,35 @@ export class Merge {
                 receiveTransaction(
                     this.mod.editor.view.state,
                     lostTr.steps,
-                    lostTr.steps.map(_step => "remote")
+                    lostTr.steps.map(() => "remote")
                 ).setMeta("remote", true)
             )
 
             // We split the complex steps that delete and insert into simple steps so that finding conflicts is more pronounced.
-            const modifiedLostTr = simplifyTransform(lostTr)
-            const lostChangeSet = new changeSet(modifiedLostTr)
+            const modifiedLostTr = simplifyTransform(
+                lostTr as unknown as Transaction
+            )
+            const lostChangeSet = new changeSet(
+                modifiedLostTr as unknown as Transaction
+            )
             const conflicts = lostChangeSet.findConflicts(
-                unconfirmedTr,
-                modifiedLostTr
+                unconfirmedTr as unknown as Transaction,
+                modifiedLostTr as unknown as Transaction
             )
             // Set the version
             this.mod.editor.docInfo.version = data.doc.v
 
             // Before starting the merge process update the fn editor to be in sync
             // with main editor
-            this.mod.editor.mod.footnotes.fnEditor.renderAllFootnotes()
+            ;(this.mod.editor.mod.footnotes as any).fnEditor.renderAllFootnotes()
 
             // Load all the newly added comments from online users.
-            this.mod.editor.mod.comments.store.loadComments(data.doc.comments)
+            ;((this.mod.editor.mod.comments as any).store as any).loadComments(
+                data.doc.comments
+            )
 
             // If no conflicts arises auto-merge the document
-            let editor
+            let editor: MergeEditor | undefined
             if (conflicts.length > 0) {
                 try {
                     editor = new MergeEditor(
@@ -128,7 +158,7 @@ export class Merge {
                         unconfirmedTr.doc,
                         toDoc,
                         unconfirmedTr,
-                        lostTr,
+                        lostTr as unknown as Transaction,
                         {
                             bibliography: data.doc.bibliography,
                             images: data.doc.images
@@ -137,7 +167,7 @@ export class Merge {
                     editor.init()
                 } catch (error) {
                     this.handleMergeFailure(
-                        error,
+                        error as Error,
                         unconfirmedTr.doc,
                         toDoc,
                         editor
@@ -152,7 +182,11 @@ export class Merge {
                         this.mod.editor.view.state.selection
                     )
                 } catch (error) {
-                    this.handleMergeFailure(error, unconfirmedTr.doc, toDoc)
+                    this.handleMergeFailure(
+                        error as Error,
+                        unconfirmedTr.doc,
+                        toDoc
+                    )
                 }
             }
 
@@ -163,11 +197,16 @@ export class Merge {
             data.m.forEach(message => this.mod.doc.receiveDiff(message, true))
         } else {
             // The server seems to have lost some data. We reset.
-            this.mod.doc.loadDocument(data)
+            this.mod.doc.loadDocument(data as any)
         }
     }
 
-    autoMerge(unconfirmedTr, lostTr, data, selection) {
+    autoMerge(
+        unconfirmedTr: Transform,
+        lostTr: Transform,
+        data: MergeData,
+        selection: Selection
+    ): void {
         /* This automerges documents incase of no conflicts */
         const toDoc = this.mod.editor.schema.nodeFromJSON(data.doc.content)
         const rebasedTr = EditorState.create({
@@ -175,7 +214,7 @@ export class Merge {
             selection
         }).tr.setMeta("remote", true)
         const maps = new Mapping(
-            []
+            ([] as StepMap[])
                 .concat(
                     unconfirmedTr.mapping.maps
                         .slice()
@@ -191,7 +230,7 @@ export class Merge {
             )
             if (mapped && !rebasedTr.maybeStep(mapped).failed) {
                 maps.appendMap(mapped.getMap())
-                maps.setMirror(
+                ;(maps as unknown as {setMirror(a: number, b: number): void}).setMirror(
                     unconfirmedTr.steps.length - index - 1,
                     unconfirmedTr.steps.length +
                         lostTr.steps.length +
@@ -201,10 +240,12 @@ export class Merge {
             }
         })
 
-        let tracked
-        let rebasedTrackedTr // offline steps to be tracked
+        let tracked: boolean
+        let rebasedTrackedTr: Transaction // offline steps to be tracked
         if (
-            WRITE_ROLES.includes(this.mod.editor.docInfo.access_rights) &&
+            WRITE_ROLES.includes(
+                this.mod.editor.docInfo.access_rights as string
+            ) &&
             (unconfirmedTr.steps.length > this.trackOfflineLimit ||
                 lostTr.steps.length > this.remoteTrackOfflineLimit)
         ) {
@@ -224,14 +265,18 @@ export class Merge {
             rebasedTrackedTr = rebasedTr
         }
 
-        let usedImages = []
-        const usedBibs = []
-        const footnoteFind = (node, usedImages, usedBibs) => {
+        let usedImages: (number | string)[] = []
+        const usedBibs: (number | string)[] = []
+        const footnoteFind = (
+            node: {name?: string; attrs?: {references?: {id: string | number}[]; image?: number | string; footnote?: any[]}; content?: any[]},
+            usedImages: (number | string)[],
+            usedBibs: (number | string)[]
+        ) => {
             if (node.name === "citation") {
-                node.attrs.references.forEach(ref =>
-                    usedBibs.push(Number.parseInt(ref.id))
+                node.attrs?.references?.forEach(ref =>
+                    usedBibs.push(Number.parseInt(String(ref.id)))
                 )
-            } else if (node.name === "image" && node.attrs.image) {
+            } else if (node.name === "image" && node.attrs?.image) {
                 usedImages.push(node.attrs.image)
             } else if (node.content) {
                 node.content.forEach(subNode =>
@@ -241,50 +286,71 @@ export class Merge {
         }
         rebasedTr.doc.descendants(node => {
             if (node.type.name === "citation") {
-                node.attrs.references.forEach(ref =>
-                    usedBibs.push(Number.parseInt(ref.id))
+                node.attrs.references.forEach(
+                    (ref: {id: string | number}) => {
+                        usedBibs.push(Number.parseInt(String(ref.id)))
+                    }
                 )
             } else if (node.type.name === "image" && node.attrs.image) {
                 usedImages.push(node.attrs.image)
-            } else if (node.type.name === "footnote" && node.attrs.footnote) {
-                node.attrs.footnote.forEach(subNode =>
-                    footnoteFind(subNode, usedImages, usedBibs)
+            } else if (
+                node.type.name === "footnote" &&
+                node.attrs.footnote
+            ) {
+                node.attrs.footnote.forEach((subNode: unknown) =>
+                    footnoteFind(subNode as any, usedImages, usedBibs)
                 )
             }
         })
-        const oldBibDB = this.mod.editor.mod.db.bibDB.db
-        this.mod.editor.mod.db.bibDB.setDB(data.doc.bibliography)
+        const oldBibDB = this.mod.editor.mod.db!.bibDB.db
+        this.mod.editor.mod.db!.bibDB.setDB(data.doc.bibliography)
         usedBibs.forEach(id => {
-            if (!this.mod.editor.mod.db.bibDB.db[id] && oldBibDB[id]) {
-                this.mod.editor.mod.db.bibDB.updateReference(id, oldBibDB[id])
+            if (
+                !this.mod.editor.mod.db!.bibDB.db[id] &&
+                oldBibDB[id]
+            ) {
+                ;(this.mod.editor.mod.db!.bibDB as any).updateReference(
+                    id,
+                    oldBibDB[id]
+                )
             }
         })
-        const oldImageDB = this.mod.editor.mod.db.imageDB.db
-        this.mod.editor.mod.db.imageDB.setDB(data.doc.images)
+        const oldImageDB = this.mod.editor.mod.db!.imageDB.db
+        this.mod.editor.mod.db!.imageDB.setDB(data.doc.images)
         // Remove the Duplicated image ID's
-        usedImages = new Set(usedImages)
-        usedImages = Array.from(usedImages)
+        const uniqueImages = new Set(usedImages)
+        usedImages = Array.from(uniqueImages)
         usedImages.forEach(id => {
-            if (!this.mod.editor.mod.db.imageDB.db[id] && oldImageDB[id]) {
+            if (
+                !this.mod.editor.mod.db!.imageDB.db[id] &&
+                oldImageDB[id]
+            ) {
                 // If the image was uploaded by the offline user we know that he may not have deleted it so we can resend it normally
-                if (Object.keys(this.mod.editor.app.imageDB.db).includes(id)) {
-                    this.mod.editor.mod.db.imageDB.setImage(id, oldImageDB[id])
+                if (
+                    Object.keys(this.mod.editor.app.imageDB.db).includes(
+                        String(id)
+                    )
+                ) {
+                    ;(this.mod.editor.mod.db!.imageDB as any).setImage(
+                        id as number,
+                        oldImageDB[id]
+                    )
                 } else {
                     // If the image was uploaded by someone else , to set the image we have to reupload it again as there is backend check to associate who can add an image with the image owner.
-                    this.mod.editor.mod.db.imageDB
+                    ;(this.mod.editor.mod.db!.imageDB as any)
                         .reUploadImage(
-                            id,
-                            oldImageDB[id].image,
-                            oldImageDB[id].title,
+                            id as number,
+                            String(oldImageDB[id].image),
+                            String(oldImageDB[id].title),
                             oldImageDB[id].copyright
                         )
                         .then(
                             () => {},
-                            id => {
+                            (id: number) => {
                                 const transaction =
                                     this.mod.editor.view.state.tr
                                 this.mod.editor.view.state.doc.descendants(
-                                    (node, pos) => {
+                                    (node: Node, pos: number) => {
                                         if (
                                             node.type.name === "image" &&
                                             node.attrs.image == id
@@ -292,7 +358,7 @@ export class Merge {
                                             const attrs = Object.assign(
                                                 {},
                                                 node.attrs
-                                            )
+                                            ) as Record<string, unknown>
                                             attrs["image"] = false
                                             const nodeType =
                                                 this.mod.editor.currentView
@@ -329,30 +395,38 @@ export class Merge {
                 )
             )
         }
-        this.mod.editor.mod.footnotes.fnEditor.renderAllFootnotes()
+        ;(this.mod.editor.mod.footnotes as any).fnEditor.renderAllFootnotes()
     }
 
-    getDocData(offlineDoc) {
+    getDocData(offlineDoc: Node): ExportDoc {
         const pmArticle = acceptAllNoInsertions(offlineDoc).firstChild
         let title = ""
-        pmArticle.firstChild.forEach(child => {
+        pmArticle?.firstChild?.forEach(child => {
             if (!child.marks.find(mark => mark.type.name === "deletion")) {
                 title += child.textContent
             }
         })
 
         return {
-            content: pmArticle.toJSON(),
-            settings: getSettings(pmArticle),
+            content: (pmArticle?.toJSON() || {type: "article"}) as {
+                type: string
+            },
+            settings: getSettings(pmArticle as Node),
             title: title,
-            version: this.mod.editor.docInfo.version,
-            comments: this.mod.editor.mod.comments.store.comments,
+            version: String(this.mod.editor.docInfo.version),
+            comments: ((this.mod.editor.mod.comments as any).store as any)
+                .comments as ExportDoc["comments"],
             id: this.mod.editor.docInfo.id,
             updated: this.mod.editor.docInfo.updated
-        }
+        } as ExportDoc
     }
 
-    handleMergeFailure(error, offlineDoc, _onlineDoc, mergeEditor = false) {
+    handleMergeFailure(
+        error: Error,
+        offlineDoc: Node,
+        _onlineDoc: Node,
+        mergeEditor: MergeEditor | false = false
+    ): void {
         // In case the auto-merge or manual merge failed due to JS Errors,
         // make a copy of the offline doc available for download.
 
@@ -360,16 +434,19 @@ export class Merge {
         if (mergeEditor && document.querySelector("#editor-merge-view")) {
             mergeEditor.mergeDialog.close()
             // Close merge resolution warning if open
-            if (document.querySelector("#merge-res-warning")) {
-                mergeEditor.warningDialog.close()
+            if (
+                document.querySelector("#merge-res-warning") &&
+                mergeEditor.warningDialog
+            ) {
+                ;(mergeEditor.warningDialog as unknown as Dialog).close()
             }
         }
 
         // Prepare Export
         new ExportFidusFile(
             this.getDocData(offlineDoc),
-            this.mod.editor.mod.db.bibDB,
-            this.mod.editor.mod.db.imageDB
+            this.mod.editor.mod.db!.bibDB,
+            this.mod.editor.mod.db!.imageDB
         )
 
         // Show up proper message