@fiduswriter/editor 0.1.0

package/src/collab/index.js

@@ -0,0 +1,81 @@
+import {removeCollaboratorSelection} from "../state_plugins"
+import {ModCollabChat} from "./chat"
+import {ModCollabColors} from "./colors"
+import {ModCollabDoc} from "./doc"
+
+export class ModCollab {
+    constructor(editor) {
+        editor.mod.collab = this
+        this.editor = editor
+        this.participants = []
+        this.pastParticipants = [] // Participants who have left comments or tracked changes.
+        this.sessionIds = false
+        this.collaborativeMode = false
+
+        new ModCollabDoc(this)
+        new ModCollabChat(this)
+        new ModCollabColors(this)
+    }
+
+    updateParticipantList(participantArray) {
+        const allSessionIds = [],
+            participantObj = {}
+
+        participantArray.forEach(participant => {
+            const entry = participantObj[participant.id]
+            allSessionIds.push(participant.session_id)
+            if (entry) {
+                entry.sessionIds.push(participant.session_id)
+            } else {
+                participant.sessionIds = [participant.session_id]
+                delete participant.session_id
+                participantObj[participant.id] = participant
+            }
+        })
+
+        this.participants = Object.values(participantObj)
+        if (!this.sessionIds) {
+            if (allSessionIds.length === 1) {
+                // We just connected to the editor and we are the only connected
+                // party. This is a good time to clean up the databases, removing
+                // unused images and bibliography items.
+                if (this.editor.mod.db) {
+                    this.editor.mod.db.clean()
+                }
+            }
+            this.sessionIds = []
+        }
+        // Check if each of the old session IDs is still present in last update.
+        // If not, remove the corresponding carets if any.
+        this.sessionIds.forEach(session_id => {
+            if (!allSessionIds.includes(session_id)) {
+                const tr = removeCollaboratorSelection(this.editor.view.state, {
+                    session_id
+                })
+                const fnTr = removeCollaboratorSelection(
+                    this.editor.mod.footnotes.fnEditor.view.state,
+                    {session_id}
+                )
+                if (tr) {
+                    this.editor.view.dispatch(tr)
+                }
+                if (fnTr) {
+                    this.editor.mod.footnotes.fnEditor.view.dispatch(fnTr)
+                }
+            }
+        })
+        this.sessionIds = allSessionIds
+        if (participantArray.length > 1) {
+            this.collaborativeMode = true
+        } else if (participantArray.length === 1) {
+            this.collaborativeMode = false
+        }
+        this.participants.forEach(participant => {
+            this.colors.ensureUserColor(participant.id)
+        })
+        if (this.editor.menu.headerView) {
+            this.editor.menu.headerView.update()
+        }
+        this.chat.showChat(participantArray)
+    }
+}

package/src/collab/merge/changeset.js

@@ -0,0 +1,103 @@
+import {ChangeSet} from "prosemirror-changeset"
+import {Mapping} from "prosemirror-transform"
+
+export class changeSet {
+    constructor(tr) {
+        this.tr = tr
+    }
+
+    trDoc(tr, index = 0) {
+        return tr.docs.length > index ? tr.docs[index] : tr.doc
+    }
+
+    findConflicts(tr1, tr2) {
+        const conflicts = []
+        const changes1 = this.findContentChanges(tr1)
+        const changes2 = this.findContentChanges(tr2)
+        changes1.deletedsteps.forEach(deleted => {
+            changes2.insertedsteps.forEach(inserted => {
+                if (
+                    inserted.pos >= deleted.from &&
+                    inserted.pos <= deleted.to
+                ) {
+                    conflicts.push([
+                        deleted.data.step,
+                        "deletion",
+                        inserted.data.step,
+                        "insertion"
+                    ])
+                }
+            })
+        })
+
+        changes2.deletedsteps.forEach(deleted => {
+            changes1.insertedsteps.forEach(inserted => {
+                if (
+                    inserted.pos >= deleted.from &&
+                    inserted.pos <= deleted.to
+                ) {
+                    conflicts.push([
+                        inserted.data.step,
+                        "insertion",
+                        deleted.data.step,
+                        "deletion"
+                    ])
+                }
+            })
+        })
+        return conflicts
+    }
+
+    findContentChanges(tr) {
+        const doc = this.trDoc(tr)
+        let changes = ChangeSet.create(doc)
+        tr.steps.forEach((_step, index) => {
+            const doc = this.trDoc(tr, index + 1)
+            changes = changes.addSteps(doc, [tr.mapping.maps[index]], {
+                step: index
+            })
+        })
+        const invertedMapping = new Mapping()
+        invertedMapping.appendMappingInverted(tr.mapping)
+
+        const insertedsteps = [],
+            deletedsteps = [],
+            ins = [],
+            del = []
+        changes.changes.forEach(change => {
+            change.inserted.forEach(inserted => {
+                if (!ins.includes(inserted.data.step)) {
+                    insertedsteps.push({
+                        pos: invertedMapping.map(change.fromB),
+                        data: inserted.data
+                    })
+                    ins.push(inserted.data.step)
+                }
+            })
+            change.deleted.forEach(deleted => {
+                if (!del.includes(deleted.data.step)) {
+                    del.push(deleted.data.step)
+                    deletedsteps.push({
+                        from: change.fromA,
+                        to: change.toA,
+                        data: deleted.data
+                    })
+                }
+            })
+        })
+        return {insertedsteps, deletedsteps}
+    }
+
+    getChangeSet() {
+        const tr = this.tr
+        const doc = this.trDoc(tr)
+        let changes = ChangeSet.create(doc)
+        tr.steps.forEach((_step, index) => {
+            const doc = this.trDoc(tr, index + 1)
+            changes = changes.addSteps(doc, [tr.mapping.maps[index]], {
+                step: index
+            })
+        })
+        return changes
+    }
+}