@fiduswriter/editor 0.1.19 → 0.1.21

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

@@ -3,15 +3,18 @@
 // in here.
 
 import {diffChars, diffWordsWithSpace} from "diff"
+import type {Node, Schema, Slice} from "prosemirror-model"
 import {ReplaceStep, Transform} from "prosemirror-transform"
 import {applyPatch, createPatch} from "rfc6902"
 
-function getReplaceStep(fromDoc, toDoc) {
+function getReplaceStep(fromDoc: Node, toDoc: Node): ReplaceStep | false {
     let start = toDoc.content.findDiffStart(fromDoc.content)
     if (start === null) {
         return false
     }
-    let {a: endA, b: endB} = toDoc.content.findDiffEnd(fromDoc.content)
+    let {a: endA, b: endB} = toDoc.content.findDiffEnd(
+        fromDoc.content
+    ) as {a: number; b: number}
     const overlap = start - Math.min(endA, endB)
     if (overlap > 0) {
         if (
@@ -26,20 +29,38 @@ function getReplaceStep(fromDoc, toDoc) {
             endB += overlap
         }
     }
-    return new ReplaceStep(start, endB, toDoc.slice(start, endA))
+    return new ReplaceStep(start, endB, toDoc.slice(start, endA) as Slice)
 }
 
 class RecreateTransform {
-    constructor(fromDoc, toDoc, complexSteps, wordDiffs) {
+    fromDoc: Node
+    toDoc: Node
+    complexSteps: boolean
+    wordDiffs: boolean
+    schema: Schema
+    tr: Transform
+    currentJSON: any
+    finalJSON: any
+    ops: any[]
+
+    constructor(
+        fromDoc: Node,
+        toDoc: Node,
+        complexSteps: boolean,
+        wordDiffs: boolean
+    ) {
         this.fromDoc = fromDoc
         this.toDoc = toDoc
         this.complexSteps = complexSteps // Whether to return steps other than ReplaceSteps
         this.wordDiffs = wordDiffs // Whether to make text diffs cover entire words
         this.schema = fromDoc.type.schema
         this.tr = new Transform(fromDoc)
+        this.currentJSON = null
+        this.finalJSON = null
+        this.ops = []
     }
 
-    init() {
+    init(): Transform {
         if (this.complexSteps) {
             // For First steps: we create versions of the documents without marks as
             // these will only confuse the diffing mechanism and marks won't cause
@@ -62,13 +83,13 @@ class RecreateTransform {
         return this.tr
     }
 
-    recreateChangeContentSteps() {
+    recreateChangeContentSteps(): void {
         // First step: find content changing steps.
-        let ops = [],
+        let ops: any[] = [],
             afterStepJSON = JSON.parse(JSON.stringify(this.currentJSON))
         while (this.ops.length) {
             let op = this.ops.shift(),
-                toDoc = false
+                toDoc: Node | false = false
             const pathParts = op.path.split("/")
             ops.push(op)
             while (!toDoc) {
@@ -76,13 +97,13 @@ class RecreateTransform {
                 try {
                     toDoc = this.schema.nodeFromJSON(afterStepJSON)
                     toDoc.check()
-                } catch (error) {
+                } catch (_error) {
                     toDoc = false
                     if (this.ops.length) {
                         op = this.ops.shift()
                         ops.push(op)
                     } else {
-                        throw error
+                        throw _error
                     }
                 }
             }
@@ -114,7 +135,7 @@ class RecreateTransform {
         }
     }
 
-    recreateChangeMarkSteps() {
+    recreateChangeMarkSteps(): void {
         // Now the documents should be the same, except their marks, so everything should map 1:1.
         // Second step: Iterate through the toDoc and make sure all marks are the same in tr.doc
         this.toDoc.descendants((tNode, tPos) => {
@@ -144,19 +165,21 @@ class RecreateTransform {
                             this.tr.addMark(from, to, nodeMark)
                         }
                     })
+                    return undefined
                 }
             )
+            return undefined
         })
     }
 
-    marklessDoc(doc) {
+    marklessDoc(doc: Node): Node {
         const tr = new Transform(doc)
         tr.removeMark(0, doc.nodeSize - 2)
         return tr.doc
     }
 
     // From http://prosemirror.net/examples/footnote/
-    addReplaceStep(toDoc, afterStepJSON) {
+    addReplaceStep(toDoc: Node, afterStepJSON: any): boolean {
         const fromDoc = this.schema.nodeFromJSON(this.currentJSON),
             step = getReplaceStep(fromDoc, toDoc)
         if (!step) {
@@ -169,7 +192,7 @@ class RecreateTransform {
         }
     }
 
-    addSetNodeMarkup() {
+    addSetNodeMarkup(): void {
         const fromDoc = this.schema.nodeFromJSON(this.currentJSON),
             toDoc = this.schema.nodeFromJSON(this.finalJSON)
         let updatedSettings = false
@@ -185,8 +208,8 @@ class RecreateTransform {
         }
         const start = toDoc.content.findDiffStart(fromDoc.content)
         if (start !== null) {
-            const fromNode = fromDoc.nodeAt(start),
-                toNode = toDoc.nodeAt(start)
+            const fromNode = fromDoc.nodeAt(start) as Node,
+                toNode = toDoc.nodeAt(start) as Node
             try {
                 this.tr.setNodeMarkup(
                     start,
@@ -203,7 +226,7 @@ class RecreateTransform {
         }
     }
 
-    addReplaceTextSteps(op, afterStepJSON) {
+    addReplaceTextSteps(op: any, afterStepJSON: any): void {
         // We find the position number of the first character in the string
         const op1 = Object.assign({}, op, {value: "xx"}),
             op2 = Object.assign({}, op, {value: "yy"})
@@ -220,14 +243,16 @@ class RecreateTransform {
         const op1Doc = this.schema.nodeFromJSON(afterOP1JSON),
             op2Doc = this.schema.nodeFromJSON(afterOP2JSON)
 
-        let offset = op1Doc.content.findDiffStart(op2Doc.content)
+        let offset = op1Doc.content.findDiffStart(
+            op2Doc.content
+        ) as number
         const marks = op1Doc.resolve(offset + 1).marks()
 
         pathParts.shift()
 
         while (pathParts.length) {
             const pathPart = pathParts.shift()
-            obj = obj[pathPart]
+            obj = obj[pathPart as string]
         }
 
         const finalText = op.value,
@@ -239,12 +264,15 @@ class RecreateTransform {
 
         while (textDiffs.length) {
             const diff = textDiffs.shift()
+            if (!diff) {
+                continue
+            }
             if (diff.added) {
                 if (textDiffs[0]?.removed) {
                     const nextDiff = textDiffs.shift()
                     this.tr.replaceWith(
                         offset,
-                        offset + nextDiff.value.length,
+                        offset + (nextDiff?.value.length || 0),
                         this.schema
                             .nodeFromJSON({type: "text", text: diff.value})
                             .mark(marks)
@@ -265,10 +293,13 @@ class RecreateTransform {
                         offset,
                         offset + diff.value.length,
                         this.schema
-                            .nodeFromJSON({type: "text", text: nextDiff.value})
+                            .nodeFromJSON({
+                                type: "text",
+                                text: nextDiff?.value || ""
+                            })
                             .mark(marks)
                     )
-                    offset += nextDiff.value.length
+                    offset += nextDiff?.value.length || 0
                 } else {
                     this.tr.delete(offset, offset + diff.value.length)
                 }
@@ -280,7 +311,7 @@ class RecreateTransform {
     }
 
     // join adjacent ReplaceSteps
-    simplifyTr() {
+    simplifyTr(): void {
         if (!this.tr.steps.length) {
             return
         }
@@ -288,9 +319,9 @@ class RecreateTransform {
         const newTr = new Transform(this.tr.docs[0]),
             oldSteps = this.tr.steps.slice()
         while (oldSteps.length) {
-            let step = oldSteps.shift()
+            let step: any = oldSteps.shift()
             while (oldSteps.length && step.merge(oldSteps[0])) {
-                const addedStep = oldSteps.shift()
+                const addedStep: any = oldSteps.shift()
                 if (
                     step instanceof ReplaceStep &&
                     addedStep instanceof ReplaceStep
@@ -298,7 +329,7 @@ class RecreateTransform {
                     step =
                         getReplaceStep(
                             newTr.doc,
-                            addedStep.apply(step.apply(newTr.doc).doc).doc
+                            addedStep.apply(step.apply(newTr.doc).doc!).doc!
                         ) || step.merge(addedStep)
                 } else {
                     step = step.merge(addedStep)
@@ -311,11 +342,11 @@ class RecreateTransform {
 }
 
 export function recreateTransform(
-    fromDoc,
-    toDoc,
+    fromDoc: Node,
+    toDoc: Node,
     complexSteps = true,
     wordDiffs = true
-) {
+): Transform {
     const recreator = new RecreateTransform(
         fromDoc,
         toDoc,

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

@@ -1,6 +1,7 @@
 import {Schema} from "prosemirror-model"
+import type {Node, NodeSpec, NodeType, MarkSpec, Mark} from "prosemirror-model"
 
-export function parseDiff(str) {
+export function parseDiff(str: string | undefined): unknown[] {
     if (!str) {
         return []
     }
@@ -13,29 +14,38 @@ export function parseDiff(str) {
     if (!Array.isArray(tracks)) {
         return []
     }
+    return tracks
 }
 
-export const createDiffSchema = docSchema => {
+export const createDiffSchema = (docSchema: Schema): Schema => {
     let specNodes = docSchema.spec.nodes
 
-    specNodes.forEach(nodeTypeName => {
-        const nodeType = specNodes.get(nodeTypeName)
-        if (nodeType.group !== "block") {
+    specNodes.forEach((nodeTypeName: string) => {
+        const nodeType = specNodes.get(nodeTypeName) as NodeType
+        if (nodeType.spec.group !== "block") {
             return
         }
-        const attrs = nodeType.attrs
+        const attrs = nodeType.spec.attrs
         specNodes = specNodes.update(
             nodeTypeName,
-            Object.assign({}, nodeType, {
+            Object.assign({}, nodeType.spec, {
                 attrs: Object.assign({diffdata: {default: []}}, attrs),
-                toDOM: node => {
-                    let dom = nodeType.toDOM(node)
+                toDOM: (node: Node) => {
+                    let dom = nodeType.spec.toDOM?.(node) as [
+                        string,
+                        Record<string, unknown>,
+                        number
+                    ]
                     if (node.attrs.diffdata && node.attrs.diffdata.length) {
                         if (dom[1].class) {
                             dom[1].class =
-                                dom[1].class + " " + node.attrs.diffdata[0].type
+                                dom[1].class +
+                                " " +
+                                (node.attrs.diffdata[0] as {type: string}).type
                         } else {
-                            dom[1]["class"] = node.attrs.diffdata[0].type
+                            dom[1]["class"] = (node.attrs.diffdata[0] as {
+                                type: string
+                            }).type
                         }
                         dom = [
                             dom[0],
@@ -52,10 +62,12 @@ export const createDiffSchema = docSchema => {
                     }
                     return dom
                 },
-                parseDOM: nodeType.parseDOM.map(tag => ({
+                parseDOM: nodeType.spec.parseDOM?.map(tag => ({
                     tag: tag.tag,
-                    getAttrs: dom => {
-                        const attrs = tag.getAttrs(dom)
+                    getAttrs: (dom: HTMLElement) => {
+                        const attrs = tag.getAttrs
+                            ? tag.getAttrs(dom)
+                            : {}
                         return Object.assign(
                             {
                                 diffdata: parseDiff(dom.dataset.diffdata)
@@ -64,11 +76,11 @@ export const createDiffSchema = docSchema => {
                         )
                     }
                 }))
-            })
+            }) as NodeSpec
         )
     })
 
-    const diffdata = {
+    const diffdata: MarkSpec = {
         attrs: {
             diff: {
                 default: ""
@@ -82,13 +94,15 @@ export const createDiffSchema = docSchema => {
             to: {
                 default: ""
             },
-            markOnly: false
+            markOnly: {
+                default: false
+            }
         },
         inclusive: false,
         parseDOM: [
             {
                 tag: "span.diff",
-                getAttrs(dom) {
+                getAttrs(dom: HTMLElement) {
                     return {
                         diff: dom.dataset.diff,
                         steps: dom.dataset.steps
@@ -96,16 +110,16 @@ export const createDiffSchema = docSchema => {
                 }
             }
         ],
-        toDOM(node) {
+        toDOM(mark: Mark) {
             return [
                 "span",
                 {
-                    class: `diff ${node.attrs.diff}`,
-                    "data-diff": node.attrs.diff,
-                    "data-steps": node.attrs.steps,
-                    "data-from": node.attrs.from,
-                    "data-to": node.attrs.to,
-                    "data-markOnly": node.attrs.markOnly
+                    class: `diff ${mark.attrs.diff}`,
+                    "data-diff": mark.attrs.diff,
+                    "data-steps": mark.attrs.steps,
+                    "data-from": mark.attrs.from,
+                    "data-to": mark.attrs.to,
+                    "data-markOnly": mark.attrs.markOnly
                 }
             ]
         }
@@ -120,16 +134,22 @@ export const createDiffSchema = docSchema => {
     // Since editable false PM Editor treats anchor tag as a normal a tag
     // and redirects
     const linkMarkSpec = spec.marks.get("link")
-    spec.marks = spec.marks.update(
-        "link",
-        Object.assign({}, linkMarkSpec, {
-            toDOM: node => {
-                const dom = linkMarkSpec.toDOM(node)
-                dom[0] = "span"
-                return dom
-            }
-        })
-    )
+    if (linkMarkSpec) {
+        spec.marks = spec.marks.update(
+            "link",
+            Object.assign({}, linkMarkSpec, {
+                toDOM: (mark: Mark, inline: boolean) => {
+                    const dom = linkMarkSpec.toDOM!(mark, inline) as [
+                        string,
+                        Record<string, unknown>,
+                        number
+                    ]
+                    dom[0] = "span"
+                    return dom
+                }
+            })
+        )
+    }
 
     return new Schema(spec)
 }

package/src/collab/merge/state_plugins/{action.js → action.ts}

@@ -1,16 +1,29 @@
 import {showSystemMessage} from "fwtoolkit"
 import {TextSelection} from "prosemirror-state"
 import {AddMarkStep, Mapping, RemoveMarkStep, Step} from "prosemirror-transform"
+import type {Transaction} from "prosemirror-state"
+import type {EditorView} from "prosemirror-view"
+import type {Mark, Schema} from "prosemirror-model"
+
 import {dispatchRemoveDiffdata} from "../tools.js"
 
-export const copyChange = (view, from, to) => {
+interface Merge {
+    mergedDocMap: Mapping
+    cpDoc: import("prosemirror-model").Node
+}
+
+export const copyChange = (
+    view: EditorView,
+    from: number,
+    to: number
+): void => {
     /* when a certain change cannot be applied automatically,
     we give users the ability to copy a change */
     const tr = view.state.tr
     const resolvedFrom = view.state.doc.resolve(from)
     const resolvedTo = view.state.doc.resolve(to)
     const sel = new TextSelection(resolvedFrom, resolvedTo)
-    sel.visible = false
+    ;(sel as {visible?: boolean}).visible = false
     tr.setSelection(sel)
     view.dispatch(tr)
     view.focus()
@@ -22,7 +35,7 @@ export const copyChange = (view, from, to) => {
     document.body.appendChild(dom)
     const range = document.createRange()
     range.selectNode(dom)
-    window.getSelection().addRange(range)
+    window.getSelection()?.addRange(range)
     try {
         document.execCommand("copy") // Security exception may be thrown by some browsers.
         document.body.removeChild(dom)
@@ -32,22 +45,28 @@ export const copyChange = (view, from, to) => {
             gettext("Copy to clipboard failed. Please copy manually.")
         )
     }
-    window.getSelection().removeAllRanges()
+    window.getSelection()?.removeAllRanges()
 }
 
-export const acceptChanges = (merge, mark, mergeView, originalView, tr) => {
+export const acceptChanges = (
+    merge: Merge,
+    mark: Mark,
+    mergeView: EditorView,
+    originalView: EditorView,
+    tr: Transaction
+): void => {
     /* This is used to accept a change either from the offline/online version or
     incase of deletion from the middle editor */
     const mergedDocMap = new Mapping()
     mergedDocMap.appendMapping(merge.mergedDocMap)
     const insertionTr = mergeView.state.tr
-    const from = mark.attrs.from
-    const to = mark.attrs.to
-    const steps = JSON.parse(mark.attrs.steps)
+    const from = mark.attrs.from as number
+    const to = mark.attrs.to as number
+    const steps = JSON.parse(mark.attrs.steps as string) as number[]
     const stepMaps = tr.mapping.maps
         .slice()
         .reverse()
-        .map(map => map.invert())
+        .map((map: import("prosemirror-transform").StepMap) => map.invert())
     const rebasedMapping = new Mapping(stepMaps)
     rebasedMapping.appendMapping(mergedDocMap)
     for (const stepIndex of steps) {
@@ -62,8 +81,7 @@ export const acceptChanges = (merge, mark, mergeView, originalView, tr) => {
         }
         if (mappedStep && !insertionTr.maybeStep(mappedStep).failed) {
             mergedDocMap.appendMap(mappedStep.getMap())
-            rebasedMapping.appendMap(mappedStep.getMap())
-            rebasedMapping.setMirror(
+            ;(rebasedMapping as unknown as {setMirror: (a: number, b: number) => void}).setMirror(
                 tr.steps.length - stepIndex - 1,
                 tr.steps.length + mergedDocMap.maps.length - 1
             )
@@ -85,21 +103,29 @@ export const acceptChanges = (merge, mark, mergeView, originalView, tr) => {
     }
 }
 
-export const removeDecoration = (view, decorationId) => {
+export const removeDecoration = (
+    view: EditorView,
+    decorationId: string
+): void => {
     const tr = view.state.tr
     tr.setMeta("decorationId", decorationId)
     view.dispatch(tr)
 }
 
-export const deleteContent = (merge, view, diffMark, mappingNeeded = true) => {
+export const deleteContent = (
+    merge: Merge,
+    view: EditorView,
+    diffMark: Mark,
+    mappingNeeded = true
+): boolean => {
     // const originalOnlineMapping = merge.onlineTr.mapping
     const rebasedMapping = new Mapping()
     const tr = view.state.tr
     if (mappingNeeded) {
         rebasedMapping.appendMapping(merge.mergedDocMap)
     }
-    const rebasedFrom = rebasedMapping.map(diffMark.attrs.from),
-        rebasedTo = rebasedMapping.map(diffMark.attrs.to)
+    const rebasedFrom = rebasedMapping.map(diffMark.attrs.from as number),
+        rebasedTo = rebasedMapping.map(diffMark.attrs.to as number)
     if (rebasedFrom && rebasedTo) {
         tr.delete(rebasedFrom, rebasedTo)
         merge.mergedDocMap.appendMapping(tr.mapping)
@@ -116,13 +142,20 @@ export const deleteContent = (merge, view, diffMark, mappingNeeded = true) => {
     return false
 }
 
-export const addDeletedContentBack = (merge, view, diffMark) => {
+export const addDeletedContentBack = (
+    merge: Merge,
+    view: EditorView,
+    diffMark: Mark
+): boolean => {
     const commonDoc = merge.cpDoc
     const tr = view.state.tr
-    const slice = commonDoc.slice(diffMark.attrs.from, diffMark.attrs.to)
+    const slice = commonDoc.slice(
+        diffMark.attrs.from as number,
+        diffMark.attrs.to as number
+    )
     const rebasedMapping = new Mapping()
     rebasedMapping.appendMapping(merge.mergedDocMap)
-    const insertionPoint = rebasedMapping.map(diffMark.attrs.from)
+    const insertionPoint = rebasedMapping.map(diffMark.attrs.from as number)
     if (insertionPoint) {
         tr.insert(insertionPoint, slice.content)
         tr.setMeta("mapAppended", true)
@@ -139,31 +172,36 @@ export const addDeletedContentBack = (merge, view, diffMark) => {
     return false
 }
 
-export const handleMarks = (view, mark, tr, schema) => {
+export const handleMarks = (
+    view: EditorView,
+    mark: Mark,
+    tr: Transaction,
+    schema: Schema
+): void => {
     // This function is used to remove the marks that have been applied in the online editor
     const newTr = view.state.tr
-    const steps = JSON.parse(mark.attrs.steps)
-    const marksToBeRemoved = [],
-        marksToBeAdded = []
+    const steps = JSON.parse(mark.attrs.steps as string) as number[]
+    const marksToBeRemoved: string[] = [],
+        marksToBeAdded: Mark[] = []
     steps.forEach(index => {
         const JSONStep = tr.steps[index].toJSON()
         if (JSONStep.mark && JSONStep.mark.type) {
             if (tr.steps[index] instanceof AddMarkStep) {
                 marksToBeRemoved.push(JSONStep.mark.type)
             } else if (tr.steps[index] instanceof RemoveMarkStep) {
-                marksToBeAdded.push(tr.steps[index].mark)
+                marksToBeAdded.push((tr.steps[index] as RemoveMarkStep).mark)
             }
         }
     })
     marksToBeRemoved.forEach(removalMark =>
         newTr.removeMark(
-            mark.attrs.from,
-            mark.attrs.to,
+            mark.attrs.from as number,
+            mark.attrs.to as number,
             schema.marks[removalMark]
         )
     )
-    marksToBeAdded.forEach(AddMark =>
-        newTr.addMark(mark.attrs.from, mark.attrs.to, AddMark)
+    marksToBeAdded.forEach(addMark =>
+        newTr.addMark(mark.attrs.from as number, mark.attrs.to as number, addMark)
     )
     newTr.setMeta("notrack", true)
     newTr.setMeta("mapAppended", true)

package/src/collab/merge/state_plugins/{clipboard.js → clipboard.ts}

@@ -1,12 +1,22 @@
 import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
+import {DOMSerializer} from "prosemirror-model"
+import type {Slice} from "prosemirror-model"
+import type {EditorView} from "prosemirror-view"
+
 import {docClipboardSerializer} from "../../../clipboard/copy/index.js"
+import type {Editor} from "../../../types.js"
 
 const key = new PluginKey("clipboard")
-export const clipboardPlugin = options => {
+export const clipboardPlugin = (options: {editor: Editor}) => {
     return new Plugin({
         key,
         props: {
-            handleDrop: (view, event, slice, moved) => {
+            handleDrop: (
+                view: EditorView,
+                event: DragEvent,
+                slice: Slice,
+                moved: boolean
+            ) => {
                 if (moved || (slice && slice.size)) {
                     return false // Something other than en empty plain text string from outside. Handled by PM already.
                 }
@@ -26,7 +36,7 @@ export const clipboardPlugin = options => {
                 view.dispatch(tr)
                 return true
             },
-            clipboardSerializer: docClipboardSerializer(options.editor)
+            clipboardSerializer: docClipboardSerializer(options.editor) as unknown as DOMSerializer
         }
     })
 }