@fiduswriter/editor 0.1.0

package/src/track/mod.js

@@ -0,0 +1,116 @@
+import {findTarget} from "fwtoolkit"
+import {
+    deactivateAllSelectedChanges,
+    setSelectedChanges
+} from "../state_plugins"
+
+import {accept} from "./accept"
+import {acceptAll} from "./accept_all"
+import {reject} from "./reject"
+import {rejectAll} from "./reject_all"
+
+// Helper functions related to tracked changes
+export class ModTrack {
+    constructor(editor) {
+        editor.mod.track = this
+        this.editor = editor
+        this.bindEvents()
+    }
+
+    bindEvents() {
+        // Bind all the click events related to track changes
+        document.body.addEventListener("click", event => {
+            const el = {}
+            switch (true) {
+                case findTarget(event, ".track-accept", el): {
+                    let boxNumber = 0
+                    let seekItem = el.target.closest(".margin-box")
+                    while (seekItem.previousElementSibling) {
+                        boxNumber += 1
+                        seekItem = seekItem.previousElementSibling
+                    }
+                    const box =
+                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    accept(
+                        el.target.dataset.type,
+                        box.pos,
+                        box.view === "main"
+                            ? this.editor.view
+                            : this.editor.mod.footnotes.fnEditor.view
+                    )
+                    // Activate the next margin box with the same number
+                    const newBox =
+                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    if (newBox) {
+                        this.editor.mod.track.activateTrack(
+                            newBox.view,
+                            newBox.type,
+                            newBox.pos
+                        )
+                    }
+                    break
+                }
+                case findTarget(event, ".track-reject", el): {
+                    let boxNumber = 0
+                    let seekItem = el.target.closest(".margin-box")
+                    while (seekItem.previousElementSibling) {
+                        boxNumber += 1
+                        seekItem = seekItem.previousElementSibling
+                    }
+                    const box =
+                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    reject(
+                        el.target.dataset.type,
+                        box.pos,
+                        box.view === "main"
+                            ? this.editor.view
+                            : this.editor.mod.footnotes.fnEditor.view
+                    )
+                    // Activate the next margin box with the same number
+                    const newBox =
+                        this.editor.mod.marginboxes.marginBoxes[boxNumber]
+                    if (newBox) {
+                        this.editor.mod.track.activateTrack(
+                            newBox.view,
+                            newBox.type,
+                            newBox.pos
+                        )
+                    }
+                    break
+                }
+                default:
+                    break
+            }
+        })
+    }
+
+    activateTrack(viewName, type, pos) {
+        this.editor.mod.comments.interactions.deactivateAll()
+        const view =
+            viewName === "main"
+                ? this.editor.view
+                : this.editor.mod.footnotes.fnEditor.view
+        const otherView =
+            viewName === "main"
+                ? this.editor.mod.footnotes.fnEditor.view
+                : this.editor.view
+        // remove all selected changes in other view
+        otherView.dispatch(deactivateAllSelectedChanges(otherView.state.tr))
+        // activate selected change in relevant view
+        const tr = setSelectedChanges(view.state, type, pos)
+        if (tr) {
+            this.editor.currentView = view
+            view.dispatch(tr)
+        }
+    }
+
+    rejectAll() {
+        rejectAll(this.editor.mod.footnotes.fnEditor.view)
+        rejectAll(this.editor.view)
+    }
+
+    acceptAll() {
+        acceptAll(this.editor.mod.footnotes.fnEditor.view)
+        acceptAll(this.editor.view)
+    }
+}

package/src/track/reject.js

@@ -0,0 +1,116 @@
+import {AddMarkStep, Mapping, RemoveMarkStep} from "prosemirror-transform"
+
+import {deactivateAllSelectedChanges} from "../state_plugins"
+import {deleteNode} from "./delete"
+
+export const reject = (type, pos, view) => {
+    const tr = view.state.tr.setMeta("track", true),
+        map = new Mapping()
+    let reachedEnd = false,
+        inlineChange = false
+    const trackMark = view.state.doc
+        .nodeAt(pos)
+        .marks.find(mark => mark.type.name === type)
+    view.state.doc.nodesBetween(
+        pos,
+        view.state.doc.nodeSize - 2,
+        (node, nodePos) => {
+            if (nodePos < pos) {
+                return true
+            }
+            if (reachedEnd) {
+                return false
+            }
+            if (!node.isInline) {
+                reachedEnd = true // Changes on inline nodes are applied/reject until next non-inline node. Non-inline node changes are only applied that one node by default.
+                if (inlineChange) {
+                    // Change has already affected inline node. Don't apply to block level.
+                    return false
+                }
+            } else if (!trackMark.isInSet(node.marks)) {
+                reachedEnd = true
+                return false
+            } else {
+                inlineChange = true
+            }
+            if (type === "insertion") {
+                deleteNode(tr, node, nodePos, map, false)
+            } else if (type === "deletion") {
+                if (node.attrs.track) {
+                    const track = node.attrs.track.filter(
+                        track => track.type !== "deletion"
+                    )
+                    tr.setNodeMarkup(
+                        map.map(nodePos),
+                        null,
+                        Object.assign({}, node.attrs, {track}),
+                        node.marks
+                    )
+                    reachedEnd = true
+                } else {
+                    tr.removeMark(
+                        map.map(nodePos),
+                        map.map(nodePos + node.nodeSize),
+                        view.state.schema.marks.deletion
+                    )
+                }
+            } else if (type === "format_change") {
+                trackMark.attrs.before.forEach(oldMark =>
+                    tr.step(
+                        new AddMarkStep(
+                            map.map(nodePos),
+                            map.map(nodePos + node.nodeSize),
+                            view.state.schema.marks[oldMark].create()
+                        )
+                    )
+                )
+                trackMark.attrs.after.forEach(newMark => {
+                    tr.step(
+                        new RemoveMarkStep(
+                            map.map(nodePos),
+                            map.map(nodePos + node.nodeSize),
+                            node.marks.find(mark => mark.type.name === newMark)
+                        )
+                    )
+                })
+                tr.step(
+                    new RemoveMarkStep(
+                        map.map(nodePos),
+                        map.map(nodePos + node.nodeSize),
+                        trackMark
+                    )
+                )
+            } else if (type === "block_change") {
+                const blockChangeTrack = node.attrs.track?.find(
+                        track => track.type === "block_change"
+                    ),
+                    track = node.attrs.track?.filter(
+                        track => track !== blockChangeTrack
+                    )
+                if (!blockChangeTrack) {
+                    return true
+                }
+                tr.setNodeMarkup(
+                    map.map(nodePos),
+                    view.state.schema.nodes[blockChangeTrack.before.type],
+                    Object.assign(
+                        {},
+                        node.attrs,
+                        blockChangeTrack.before.attrs,
+                        {
+                            track
+                        }
+                    ),
+                    node.marks
+                )
+            }
+            return true
+        }
+    )
+
+    deactivateAllSelectedChanges(tr)
+
+    if (tr.steps.length) {
+        view.dispatch(tr)
+    }
+}

package/src/track/reject_all.js

@@ -0,0 +1,121 @@
+import {Slice} from "prosemirror-model"
+import {
+    AddMarkStep,
+    Mapping,
+    RemoveMarkStep,
+    ReplaceStep
+} from "prosemirror-transform"
+
+import {deactivateAllSelectedChanges} from "../state_plugins"
+
+import {deleteNode} from "./delete"
+
+export const rejectAll = (view, from = 0, to = false) => {
+    if (!to) {
+        to = view.state.doc.content.size
+    }
+    const tr = view.state.tr.setMeta("track", true),
+        map = new Mapping()
+    view.state.doc.nodesBetween(from, to, (node, pos) => {
+        if (pos < from && !node.isInline) {
+            return true
+        }
+        let deletedNode = false
+        if (node.attrs.track?.find(track => track.type === "insertion")) {
+            deleteNode(tr, node, pos, map, false)
+            deletedNode = true
+        } else if (
+            node.marks?.find(
+                mark => mark.type.name === "insertion" && !mark.attrs.approved
+            )
+        ) {
+            const delStep = new ReplaceStep(
+                map.map(Math.max(pos, from)),
+                map.map(Math.min(pos + node.nodeSize, to)),
+                Slice.empty
+            )
+            tr.step(delStep)
+            map.appendMap(delStep.getMap())
+            deletedNode = true
+        } else if (node.attrs.track?.find(track => track.type === "deletion")) {
+            const track = node.attrs.track.filter(
+                track => track.type !== "deletion"
+            )
+            tr.setNodeMarkup(
+                map.map(pos),
+                null,
+                Object.assign({}, node.attrs, {track}),
+                node.marks
+            )
+        } else if (node.marks?.find(mark => mark.type.name === "deletion")) {
+            tr.removeMark(
+                map.map(Math.max(pos, from)),
+                map.map(Math.min(pos + node.nodeSize, to)),
+                view.state.schema.marks.deletion
+            )
+        }
+        const formatChangeMark = node.marks.find(
+            mark => mark.type.name === "format_change"
+        )
+
+        if (node.isInline && !deletedNode && formatChangeMark) {
+            formatChangeMark.attrs.before.forEach(oldMark =>
+                tr.step(
+                    new AddMarkStep(
+                        map.map(Math.max(pos, from)),
+                        map.map(Math.min(pos + node.nodeSize, to)),
+                        view.state.schema.marks[oldMark].create()
+                    )
+                )
+            )
+            formatChangeMark.attrs.after.forEach(newMark => {
+                tr.step(
+                    new RemoveMarkStep(
+                        map.map(Math.max(pos, from)),
+                        map.map(Math.min(pos + node.nodeSize, to)),
+                        node.marks.find(mark => mark.type.name === newMark)
+                    )
+                )
+            })
+
+            tr.step(
+                new RemoveMarkStep(
+                    map.map(Math.max(pos, from)),
+                    map.map(Math.min(pos + node.nodeSize, to)),
+                    formatChangeMark
+                )
+            )
+        }
+        if (!node.isInline && !deletedNode && node.attrs.track) {
+            const blockChangeTrack = node.attrs.track.find(
+                track => track.type === "block_change"
+            )
+            if (blockChangeTrack) {
+                const track = node.attrs.track.filter(
+                    track => track !== blockChangeTrack
+                )
+                tr.setNodeMarkup(
+                    map.map(pos),
+                    view.state.schema.nodes[blockChangeTrack.before.type],
+                    Object.assign(
+                        {},
+                        node.attrs,
+                        blockChangeTrack.before.attrs,
+                        {
+                            track
+                        }
+                    ),
+                    node.marks
+                )
+            }
+        }
+
+        return true
+    })
+
+    deactivateAllSelectedChanges(tr)
+
+    if (tr.steps.length) {
+        view.dispatch(tr)
+    }
+}