@fiduswriter/editor 0.1.0

package/src/collab/merge/recreate_transform.js

@@ -0,0 +1,326 @@
+// See https://gitlab.com/mpapp-public/prosemirror-recreate-steps/blob/master/src/recreate.js
+// We only need this file from the prosemirror-recreate-steps (apache) project, so it's copied
+// in here.
+
+import {diffChars, diffWordsWithSpace} from "diff"
+import {ReplaceStep, Transform} from "prosemirror-transform"
+import {applyPatch, createPatch} from "rfc6902"
+
+function getReplaceStep(fromDoc, toDoc) {
+    let start = toDoc.content.findDiffStart(fromDoc.content)
+    if (start === null) {
+        return false
+    }
+    let {a: endA, b: endB} = toDoc.content.findDiffEnd(fromDoc.content)
+    const overlap = start - Math.min(endA, endB)
+    if (overlap > 0) {
+        if (
+            // If there is an overlap, there is some freedom of choise in how to calculate the start/end boundary.
+            // for an inserted/removed slice. We choose the extreme with the lowest depth value.
+            fromDoc.resolve(start - overlap).depth <
+            toDoc.resolve(endA + overlap).depth
+        ) {
+            start -= overlap
+        } else {
+            endA += overlap
+            endB += overlap
+        }
+    }
+    return new ReplaceStep(start, endB, toDoc.slice(start, endA))
+}
+
+class RecreateTransform {
+    constructor(fromDoc, toDoc, complexSteps, wordDiffs) {
+        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)
+    }
+
+    init() {
+        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
+            // any mapping changes anyway.
+            this.currentJSON = this.marklessDoc(this.fromDoc).toJSON()
+            this.finalJSON = this.marklessDoc(this.toDoc).toJSON()
+            this.ops = createPatch(this.currentJSON, this.finalJSON)
+            this.recreateChangeContentSteps()
+            this.recreateChangeMarkSteps()
+        } else {
+            // We don't differentiate between mark changes and other changes.
+            this.currentJSON = this.fromDoc.toJSON()
+            this.finalJSON = this.toDoc.toJSON()
+            this.ops = createPatch(this.currentJSON, this.finalJSON)
+            this.recreateChangeContentSteps()
+        }
+
+        this.simplifyTr()
+
+        return this.tr
+    }
+
+    recreateChangeContentSteps() {
+        // First step: find content changing steps.
+        let ops = [],
+            afterStepJSON = JSON.parse(JSON.stringify(this.currentJSON))
+        while (this.ops.length) {
+            let op = this.ops.shift(),
+                toDoc = false
+            const pathParts = op.path.split("/")
+            ops.push(op)
+            while (!toDoc) {
+                applyPatch(afterStepJSON, [op])
+                try {
+                    toDoc = this.schema.nodeFromJSON(afterStepJSON)
+                    toDoc.check()
+                } catch (error) {
+                    toDoc = false
+                    if (this.ops.length) {
+                        op = this.ops.shift()
+                        ops.push(op)
+                    } else {
+                        throw error
+                    }
+                }
+            }
+
+            if (
+                this.complexSteps &&
+                ops.length === 1 &&
+                (pathParts.includes("attrs") || pathParts.includes("type"))
+            ) {
+                // Node markup is changing
+                this.addSetNodeMarkup()
+                ops = []
+                afterStepJSON = JSON.parse(JSON.stringify(this.currentJSON))
+            } else if (
+                ops.length === 1 &&
+                op.op === "replace" &&
+                pathParts[pathParts.length - 1] === "text"
+            ) {
+                // Text is being replaced, we apply text diffing to find the smallest possible diffs.
+                this.addReplaceTextSteps(op, afterStepJSON)
+                ops = []
+                afterStepJSON = JSON.parse(JSON.stringify(this.currentJSON))
+            } else {
+                if (this.addReplaceStep(toDoc, afterStepJSON)) {
+                    ops = []
+                    afterStepJSON = JSON.parse(JSON.stringify(this.currentJSON))
+                }
+            }
+        }
+    }
+
+    recreateChangeMarkSteps() {
+        // 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) => {
+            if (!tNode.isInline) {
+                return true
+            }
+
+            this.tr.doc.nodesBetween(
+                tPos,
+                tPos + tNode.nodeSize,
+                (fNode, fPos) => {
+                    if (!fNode.isInline) {
+                        return true
+                    }
+                    const from = Math.max(tPos, fPos),
+                        to = Math.min(
+                            tPos + tNode.nodeSize,
+                            fPos + fNode.nodeSize
+                        )
+                    fNode.marks.forEach(nodeMark => {
+                        if (!nodeMark.isInSet(tNode.marks)) {
+                            this.tr.removeMark(from, to, nodeMark)
+                        }
+                    })
+                    tNode.marks.forEach(nodeMark => {
+                        if (!nodeMark.isInSet(fNode.marks)) {
+                            this.tr.addMark(from, to, nodeMark)
+                        }
+                    })
+                }
+            )
+        })
+    }
+
+    marklessDoc(doc) {
+        const tr = new Transform(doc)
+        tr.removeMark(0, doc.nodeSize - 2)
+        return tr.doc
+    }
+
+    // From http://prosemirror.net/examples/footnote/
+    addReplaceStep(toDoc, afterStepJSON) {
+        const fromDoc = this.schema.nodeFromJSON(this.currentJSON),
+            step = getReplaceStep(fromDoc, toDoc)
+        if (!step) {
+            return false
+        } else if (!this.tr.maybeStep(step).failed) {
+            this.currentJSON = afterStepJSON
+            return true
+        } else {
+            throw new Error("No valid step found.")
+        }
+    }
+
+    addSetNodeMarkup() {
+        const fromDoc = this.schema.nodeFromJSON(this.currentJSON),
+            toDoc = this.schema.nodeFromJSON(this.finalJSON)
+        let updatedSettings = false
+        Object.entries(fromDoc.attrs).forEach(([key, value]) => {
+            if (toDoc.attrs[key] !== value) {
+                this.tr.setDocAttribute(key, toDoc.attrs[key])
+                updatedSettings = true
+            }
+        })
+        if (updatedSettings) {
+            this.currentJSON = this.marklessDoc(this.tr.doc).toJSON()
+            this.ops = createPatch(this.currentJSON, this.finalJSON)
+        }
+        const start = toDoc.content.findDiffStart(fromDoc.content)
+        if (start !== null) {
+            const fromNode = fromDoc.nodeAt(start),
+                toNode = toDoc.nodeAt(start)
+            try {
+                this.tr.setNodeMarkup(
+                    start,
+                    fromNode.type === toNode.type ? null : toNode.type,
+                    toNode.attrs,
+                    toNode.marks
+                )
+            } catch (_error) {
+                return
+            }
+            this.currentJSON = this.marklessDoc(this.tr.doc).toJSON()
+            // Setting the node markup may have invalidated more ops, so we calculate them again.
+            this.ops = createPatch(this.currentJSON, this.finalJSON)
+        }
+    }
+
+    addReplaceTextSteps(op, afterStepJSON) {
+        // 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"})
+
+        const afterOP1JSON = JSON.parse(JSON.stringify(this.currentJSON)),
+            afterOP2JSON = JSON.parse(JSON.stringify(this.currentJSON)),
+            pathParts = op.path.split("/")
+
+        let obj = this.currentJSON
+
+        applyPatch(afterOP1JSON, [op1])
+        applyPatch(afterOP2JSON, [op2])
+
+        const op1Doc = this.schema.nodeFromJSON(afterOP1JSON),
+            op2Doc = this.schema.nodeFromJSON(afterOP2JSON)
+
+        let offset = op1Doc.content.findDiffStart(op2Doc.content)
+        const marks = op1Doc.resolve(offset + 1).marks()
+
+        pathParts.shift()
+
+        while (pathParts.length) {
+            const pathPart = pathParts.shift()
+            obj = obj[pathPart]
+        }
+
+        const finalText = op.value,
+            currentText = obj
+
+        const textDiffs = this.wordDiffs
+            ? diffWordsWithSpace(currentText, finalText)
+            : diffChars(currentText, finalText)
+
+        while (textDiffs.length) {
+            const diff = textDiffs.shift()
+            if (diff.added) {
+                if (textDiffs[0]?.removed) {
+                    const nextDiff = textDiffs.shift()
+                    this.tr.replaceWith(
+                        offset,
+                        offset + nextDiff.value.length,
+                        this.schema
+                            .nodeFromJSON({type: "text", text: diff.value})
+                            .mark(marks)
+                    )
+                } else {
+                    this.tr.insert(
+                        offset,
+                        this.schema
+                            .nodeFromJSON({type: "text", text: diff.value})
+                            .mark(marks)
+                    )
+                }
+                offset += diff.value.length
+            } else if (diff.removed) {
+                if (textDiffs[0]?.added) {
+                    const nextDiff = textDiffs.shift()
+                    this.tr.replaceWith(
+                        offset,
+                        offset + diff.value.length,
+                        this.schema
+                            .nodeFromJSON({type: "text", text: nextDiff.value})
+                            .mark(marks)
+                    )
+                    offset += nextDiff.value.length
+                } else {
+                    this.tr.delete(offset, offset + diff.value.length)
+                }
+            } else {
+                offset += diff.value.length
+            }
+        }
+        this.currentJSON = afterStepJSON
+    }
+
+    // join adjacent ReplaceSteps
+    simplifyTr() {
+        if (!this.tr.steps.length) {
+            return
+        }
+
+        const newTr = new Transform(this.tr.docs[0]),
+            oldSteps = this.tr.steps.slice()
+        while (oldSteps.length) {
+            let step = oldSteps.shift()
+            while (oldSteps.length && step.merge(oldSteps[0])) {
+                const addedStep = oldSteps.shift()
+                if (
+                    step instanceof ReplaceStep &&
+                    addedStep instanceof ReplaceStep
+                ) {
+                    step =
+                        getReplaceStep(
+                            newTr.doc,
+                            addedStep.apply(step.apply(newTr.doc).doc).doc
+                        ) || step.merge(addedStep)
+                } else {
+                    step = step.merge(addedStep)
+                }
+            }
+            newTr.step(step)
+        }
+        this.tr = newTr
+    }
+}
+
+export function recreateTransform(
+    fromDoc,
+    toDoc,
+    complexSteps = true,
+    wordDiffs = true
+) {
+    const recreator = new RecreateTransform(
+        fromDoc,
+        toDoc,
+        complexSteps,
+        wordDiffs
+    )
+    return recreator.init()
+}

package/src/collab/merge/schema.js

@@ -0,0 +1,135 @@
+import {Schema} from "prosemirror-model"
+
+export function parseDiff(str) {
+    if (!str) {
+        return []
+    }
+    let tracks
+    try {
+        tracks = JSON.parse(str)
+    } catch (_error) {
+        return []
+    }
+    if (!Array.isArray(tracks)) {
+        return []
+    }
+}
+
+export const createDiffSchema = docSchema => {
+    let specNodes = docSchema.spec.nodes
+
+    specNodes.forEach(nodeTypeName => {
+        const nodeType = specNodes.get(nodeTypeName)
+        if (nodeType.group !== "block") {
+            return
+        }
+        const attrs = nodeType.attrs
+        specNodes = specNodes.update(
+            nodeTypeName,
+            Object.assign({}, nodeType, {
+                attrs: Object.assign({diffdata: {default: []}}, attrs),
+                toDOM: node => {
+                    let dom = nodeType.toDOM(node)
+                    if (node.attrs.diffdata && node.attrs.diffdata.length) {
+                        if (dom[1].class) {
+                            dom[1].class =
+                                dom[1].class + " " + node.attrs.diffdata[0].type
+                        } else {
+                            dom[1]["class"] = node.attrs.diffdata[0].type
+                        }
+                        dom = [
+                            dom[0],
+                            Object.assign(
+                                {
+                                    "data-diffdata": JSON.stringify(
+                                        node.attrs.diffdata
+                                    )
+                                },
+                                dom[1]
+                            ),
+                            dom[2]
+                        ]
+                    }
+                    return dom
+                },
+                parseDOM: nodeType.parseDOM.map(tag => ({
+                    tag: tag.tag,
+                    getAttrs: dom => {
+                        const attrs = tag.getAttrs(dom)
+                        return Object.assign(
+                            {
+                                diffdata: parseDiff(dom.dataset.diffdata)
+                            },
+                            attrs
+                        )
+                    }
+                }))
+            })
+        )
+    })
+
+    const diffdata = {
+        attrs: {
+            diff: {
+                default: ""
+            },
+            steps: {
+                default: []
+            },
+            from: {
+                default: ""
+            },
+            to: {
+                default: ""
+            },
+            markOnly: false
+        },
+        inclusive: false,
+        parseDOM: [
+            {
+                tag: "span.diff",
+                getAttrs(dom) {
+                    return {
+                        diff: dom.dataset.diff,
+                        steps: dom.dataset.steps
+                    }
+                }
+            }
+        ],
+        toDOM(node) {
+            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
+                }
+            ]
+        }
+    }
+
+    const spec = {
+        nodes: specNodes,
+        marks: docSchema.spec.marks.addToEnd("diffdata", diffdata)
+    }
+
+    // Update link mark toDom to render a span instead of anchor tag
+    // 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
+            }
+        })
+    )
+
+    return new Schema(spec)
+}

package/src/collab/merge/state_plugins/action.js

@@ -0,0 +1,171 @@
+import {showSystemMessage} from "fwtoolkit"
+import {TextSelection} from "prosemirror-state"
+import {AddMarkStep, Mapping, RemoveMarkStep, Step} from "prosemirror-transform"
+import {dispatchRemoveDiffdata} from "../tools"
+
+export const copyChange = (view, from, to) => {
+    /* 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
+    tr.setSelection(sel)
+    view.dispatch(tr)
+    view.focus()
+
+    const slice = view.state.selection.content()
+    const {dom} = view.serializeForClipboard(slice)
+
+    // Copy data to clipboard!!
+    document.body.appendChild(dom)
+    const range = document.createRange()
+    range.selectNode(dom)
+    window.getSelection().addRange(range)
+    try {
+        document.execCommand("copy") // Security exception may be thrown by some browsers.
+        document.body.removeChild(dom)
+        showSystemMessage(gettext("Change copied to clipboard."))
+    } catch (_ex) {
+        showSystemMessage(
+            gettext("Copy to clipboard failed. Please copy manually.")
+        )
+    }
+    window.getSelection().removeAllRanges()
+}
+
+export const acceptChanges = (merge, mark, mergeView, originalView, tr) => {
+    /* 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 stepMaps = tr.mapping.maps
+        .slice()
+        .reverse()
+        .map(map => map.invert())
+    const rebasedMapping = new Mapping(stepMaps)
+    rebasedMapping.appendMapping(mergedDocMap)
+    for (const stepIndex of steps) {
+        const maps = rebasedMapping.slice(tr.steps.length - stepIndex)
+        let mappedStep = tr.steps[stepIndex].map(maps)
+        if (mappedStep) {
+            mappedStep = Step.fromJSON(
+                // Switch from main editor schema to merge editor schema
+                insertionTr.doc.type.schema,
+                mappedStep.toJSON()
+            )
+        }
+        if (mappedStep && !insertionTr.maybeStep(mappedStep).failed) {
+            mergedDocMap.appendMap(mappedStep.getMap())
+            rebasedMapping.appendMap(mappedStep.getMap())
+            rebasedMapping.setMirror(
+                tr.steps.length - stepIndex - 1,
+                tr.steps.length + mergedDocMap.maps.length - 1
+            )
+        }
+    }
+    // Make sure that all the content steps are present in the new transaction
+    if (insertionTr.steps.length < steps.length) {
+        showSystemMessage(
+            gettext(
+                "The change could not be applied automatically. Please consider using the copy option to copy the changes."
+            )
+        )
+    } else {
+        dispatchRemoveDiffdata(originalView, from, to)
+        merge.mergedDocMap = mergedDocMap
+        insertionTr.setMeta("mapAppended", true)
+        insertionTr.setMeta("notrack", true)
+        mergeView.dispatch(insertionTr)
+    }
+}
+
+export const removeDecoration = (view, decorationId) => {
+    const tr = view.state.tr
+    tr.setMeta("decorationId", decorationId)
+    view.dispatch(tr)
+}
+
+export const deleteContent = (merge, view, diffMark, mappingNeeded = true) => {
+    // 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)
+    if (rebasedFrom && rebasedTo) {
+        tr.delete(rebasedFrom, rebasedTo)
+        merge.mergedDocMap.appendMapping(tr.mapping)
+        tr.setMeta("mapAppended", true)
+        tr.setMeta("notrack", true)
+        view.dispatch(tr)
+        return true
+    }
+    showSystemMessage(
+        gettext(
+            "The change could not be applied automatically. Please consider using the copy option to copy the changes."
+        )
+    )
+    return false
+}
+
+export const addDeletedContentBack = (merge, view, diffMark) => {
+    const commonDoc = merge.cpDoc
+    const tr = view.state.tr
+    const slice = commonDoc.slice(diffMark.attrs.from, diffMark.attrs.to)
+    const rebasedMapping = new Mapping()
+    rebasedMapping.appendMapping(merge.mergedDocMap)
+    const insertionPoint = rebasedMapping.map(diffMark.attrs.from)
+    if (insertionPoint) {
+        tr.insert(insertionPoint, slice.content)
+        tr.setMeta("mapAppended", true)
+        tr.setMeta("notrack", true)
+        view.dispatch(tr)
+        merge.mergedDocMap.appendMapping(tr.mapping)
+        return true
+    }
+    showSystemMessage(
+        gettext(
+            "The change could not be applied automatically. Please consider using the copy option to copy the changes."
+        )
+    )
+    return false
+}
+
+export const handleMarks = (view, mark, tr, schema) => {
+    // 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 = []
+    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)
+            }
+        }
+    })
+    marksToBeRemoved.forEach(removalMark =>
+        newTr.removeMark(
+            mark.attrs.from,
+            mark.attrs.to,
+            schema.marks[removalMark]
+        )
+    )
+    marksToBeAdded.forEach(AddMark =>
+        newTr.addMark(mark.attrs.from, mark.attrs.to, AddMark)
+    )
+    newTr.setMeta("notrack", true)
+    newTr.setMeta("mapAppended", true)
+    view.dispatch(newTr)
+}

package/src/collab/merge/state_plugins/clipboard.js

@@ -0,0 +1,32 @@
+import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
+import {docClipboardSerializer} from "../../../clipboard/copy"
+
+const key = new PluginKey("clipboard")
+export const clipboardPlugin = options => {
+    return new Plugin({
+        key,
+        props: {
+            handleDrop: (view, event, slice, moved) => {
+                if (moved || (slice && slice.size)) {
+                    return false // Something other than en empty plain text string from outside. Handled by PM already.
+                }
+                const eventPos = view.posAtCoords({
+                    left: event.clientX,
+                    top: event.clientY
+                })
+                if (!eventPos) {
+                    return false
+                }
+                const $mouse = view.state.doc.resolve(eventPos.pos)
+                if (!$mouse) {
+                    return false
+                }
+                const tr = view.state.tr
+                tr.setSelection(new TextSelection($mouse))
+                view.dispatch(tr)
+                return true
+            },
+            clipboardSerializer: docClipboardSerializer(options.editor)
+        }
+    })
+}