@manuscripts/track-changes-plugin 0.4.0 → 0.4.1

package/dist/index.js

@@ -171,8 +171,8 @@ class ChangeSet {
     get changes() {
         const iteratedIds = new Set();
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => {
-            const valid = !iteratedIds.has(c.attrs.id) && ChangeSet.isValidTrackedAttrs(c.attrs);
-            iteratedIds.add(c.attrs.id);
+            const valid = !iteratedIds.has(c.dataTracked.id) && ChangeSet.isValidDataTracked(c.dataTracked);
+            iteratedIds.add(c.dataTracked.id);
             return valid;
         });
     }
@@ -207,13 +207,13 @@ class ChangeSet {
         return rootNodes;
     }
     get pending() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.pending);
     }
     get accepted() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.accepted);
     }
     get rejected() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.rejected);
     }
     get textChanges() {
         return this.changes.filter((c) => c.type === 'text-change');
@@ -244,7 +244,7 @@ class ChangeSet {
         });
     }
     get hasIncompleteAttrs() {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidTrackedAttrs(c.attrs));
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidDataTracked(c.dataTracked));
     }
     get(id) {
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id);
@@ -264,29 +264,22 @@ class ChangeSet {
     static flattenTreeToIds(changes) {
         return changes.flatMap((c) => this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id);
     }
-    /**
-     * Determines whether a change should not be deleted when applying it to the document.
-     * @param change
-     */
-    static shouldNotDelete(change) {
-        return !ChangeSet.shouldDeleteChange(change);
-    }
     /**
      * Determines whether a change should be deleted when applying it to the document.
      * @param change
      */
     static shouldDeleteChange(change) {
-        const { status, operation } = change.attrs;
+        const { status, operation } = change.dataTracked;
         return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
             (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
     }
     /**
      * Checks whether change attributes contain all TrackedAttrs keys with non-undefined values
-     * @param attrs
+     * @param dataTracked
      */
-    static isValidTrackedAttrs(attrs = {}) {
-        if ('attrs' in attrs) {
-            log.warn('passed "attrs" as property to isValidTrackedAttrs(attrs)', attrs);
+    static isValidDataTracked(dataTracked = {}) {
+        if ('dataTracked' in dataTracked) {
+            log.warn('passed "dataTracked" as property to isValidTrackedAttrs()', dataTracked);
         }
         const trackedKeys = [
             'id',
@@ -299,12 +292,12 @@ class ChangeSet {
         // reviewedByID is set optional since either ProseMirror or Yjs doesn't like persisting null values inside attributes objects
         // So it can be either omitted completely or at least be null or string
         const optionalKeys = ['reviewedByID'];
-        const entries = Object.entries(attrs).filter(([key, val]) => trackedKeys.includes(key));
-        const optionalEntries = Object.entries(attrs).filter(([key, val]) => optionalKeys.includes(key));
+        const entries = Object.entries(dataTracked).filter(([key, val]) => trackedKeys.includes(key));
+        const optionalEntries = Object.entries(dataTracked).filter(([key, val]) => optionalKeys.includes(key));
         return (entries.length === trackedKeys.length &&
             entries.every(([key, val]) => trackedKeys.includes(key) && val !== undefined) &&
             optionalEntries.every(([key, val]) => optionalKeys.includes(key) && val !== undefined) &&
-            (attrs.id || '').length > 0 // Changes created with undefined id have '' as placeholder
+            (dataTracked.id || '').length > 0 // Changes created with undefined id have '' as placeholder
         );
     }
     static isTextChange(change) {
@@ -350,8 +343,8 @@ function addTrackIdIfDoesntExist(attrs) {
     }
     return attrs;
 }
-function getInlineNodeTrackedMarkData(node, schema) {
-    if (!node || !node.isInline) {
+function getTextNodeTrackedMarkData(node, schema) {
+    if (!node || !node.isText) {
         return undefined;
     }
     const marksTrackedData = [];
@@ -368,12 +361,25 @@ function getInlineNodeTrackedMarkData(node, schema) {
     }
     return marksTrackedData[0] || undefined;
 }
+function getBlockInlineTrackedData(node) {
+    let { dataTracked } = node.attrs;
+    if (dataTracked && !Array.isArray(dataTracked)) {
+        return [dataTracked];
+    }
+    return dataTracked;
+}
 function getNodeTrackedData(node, schema) {
-    return !node
-        ? undefined
-        : node.isText
-            ? getInlineNodeTrackedMarkData(node, schema)
-            : node.attrs.dataTracked;
+    let tracked;
+    if (node && !node.isText) {
+        tracked = getBlockInlineTrackedData(node);
+    }
+    else if (node === null || node === void 0 ? void 0 : node.isText) {
+        tracked = getTextNodeTrackedMarkData(node, schema);
+    }
+    if (tracked && !Array.isArray(tracked)) {
+        tracked = [tracked];
+    }
+    return tracked;
 }
 function equalMarks(n1, n2) {
     return (n1.marks.length === n2.marks.length &&
@@ -392,7 +398,7 @@ function shouldMergeTrackedAttributes(left, right) {
         left.authorID === right.authorID);
 }
 function getMergeableMarkTrackedAttrs(node, attrs, schema) {
-    const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
+    const nodeAttrs = getTextNodeTrackedMarkData(node, schema);
     return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
 }
 
@@ -441,6 +447,29 @@ function deleteNode(node, pos, tr) {
         // child, say some wrapper blockNode, is also deleted the content could be retained. TODO I guess.
         return tr.delete(pos, pos + node.nodeSize);
     }
+}
+/**
+ * Deletes inserted block or inline node, otherwise adds `dataTracked` object with CHANGE_STATUS 'deleted'
+ * @param node
+ * @param pos
+ * @param newTr
+ * @param deleteAttrs
+ */
+function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
+    const dataTracked = getBlockInlineTrackedData(node);
+    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.insert);
+    const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.delete);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
+    if (inserted && inserted.authorID === deleteAttrs.authorID) {
+        return deleteNode(node, pos, newTr);
+    }
+    const newDeleted = deleted
+        ? { ...deleted, updatedAt: deleteAttrs.updatedAt }
+        : addTrackIdIfDoesntExist(deleteAttrs);
+    newTr.setNodeMarkup(pos, undefined, {
+        ...node.attrs,
+        dataTracked: updated ? [newDeleted, updated] : [newDeleted],
+    }, node.marks);
 }
 
 /*!
@@ -486,21 +515,46 @@ function mergeNode(node, pos, tr) {
 function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
-        throw Error('No node at the from of change' + change);
+        log.error('updateChangeAttrs: no node at the from of change ', change);
+        return tr;
+    }
+    const { operation } = trackedAttrs;
+    const oldTrackData = change.type === 'text-change'
+        ? getTextNodeTrackedMarkData(node, schema)
+        : getBlockInlineTrackedData(node);
+    if (!operation) {
+        log.warn('updateChangeAttrs: unable to determine operation of change ', change);
+    }
+    else if (!oldTrackData) {
+        log.warn('updateChangeAttrs: no old dataTracked for change ', change);
+    }
+    if (change.type === 'text-change') {
+        const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
+        if (!oldMark) {
+            log.warn('updateChangeAttrs: no track marks for a text-change ', change);
+            return tr;
+        }
+        // TODO add operation based on mark type if it's undefined?
+        tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked: { ...oldTrackData, ...trackedAttrs } }));
     }
-    const dataTracked = { ...getNodeTrackedData(node, schema), ...trackedAttrs };
-    const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
-    if (change.type === 'text-change' && oldMark) {
-        tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked }));
+    else if (change.type === 'node-change' && !operation) {
+        // Very weird edge-case if this happens
+        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked: null }, node.marks);
     }
     else if (change.type === 'node-change') {
-        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked }, node.marks);
+        const newDataTracked = (getBlockInlineTrackedData(node) || []).map((oldTrack) => {
+            if (oldTrack.operation === operation) {
+                return { ...oldTrack, ...trackedAttrs };
+            }
+            return oldTrack;
+        });
+        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked: newDataTracked.length === 0 ? null : newDataTracked }, node.marks);
     }
     return tr;
 }
 function updateChangeChildrenAttributes(changes, tr, mapping) {
     changes.forEach((c) => {
-        if (c.type === 'node-change' && ChangeSet.shouldNotDelete(c)) {
+        if (c.type === 'node-change' && !ChangeSet.shouldDeleteChange(c)) {
             const from = mapping.map(c.from);
             const node = tr.doc.nodeAt(from);
             if (!node) {
@@ -522,12 +576,12 @@ function updateChangeChildrenAttributes(changes, tr, mapping) {
  */
 function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
     changes.forEach((change) => {
-        if (change.attrs.status === CHANGE_STATUS.pending) {
+        if (change.dataTracked.status === CHANGE_STATUS.pending) {
             return;
         }
         // Map change.from and skip those which dont need to be applied
         // or were already deleted by an applied block delete
-        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || ChangeSet.shouldNotDelete(change);
+        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || !ChangeSet.shouldDeleteChange(change);
         if (!node) {
             !deleted && log.warn('no node found to update for change', change);
             return;
@@ -556,12 +610,12 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mappi
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet.isNodeAttrChange(change) &&
-            change.attrs.status === CHANGE_STATUS.accepted) {
+            change.dataTracked.status === CHANGE_STATUS.accepted) {
             const attrs = { ...node.attrs, dataTracked: null };
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
         }
         else if (ChangeSet.isNodeAttrChange(change) &&
-            change.attrs.status === CHANGE_STATUS.rejected) {
+            change.dataTracked.status === CHANGE_STATUS.rejected) {
             const attrs = { ...change.oldAttrs, dataTracked: null };
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
         }
@@ -583,9 +637,10 @@ function findChanges(state) {
     // Store the last iterated change to join adjacent text changes
     let current;
     state.doc.descendants((node, pos) => {
-        const attrs = getNodeTrackedData(node, state.schema);
-        if (attrs) {
-            const id = (attrs === null || attrs === void 0 ? void 0 : attrs.id) || '';
+        const tracked = getNodeTrackedData(node, state.schema) || [];
+        for (let i = 0; i < tracked.length; i += 1) {
+            const dataTracked = tracked[i];
+            const id = dataTracked.id || '';
             // Join adjacent text changes that have been broken up due to different marks
             // eg <ins><b>bold</b>norm<i>italic</i></ins> -> treated as one continuous change
             // Note the !equalMarks to leave changes separate incase the marks are equal to let fixInconsistentChanges to fix them
@@ -597,38 +652,49 @@ function findChanges(state) {
                 current.change.to = pos + node.nodeSize;
                 // Important to update the node as the text changes might contain multiple parts where some marks equal each other
                 current.node = node;
+                continue;
             }
-            else if (node.isText) {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'text-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        text: node.text,
-                        attrs,
-                    },
-                    node,
+            current && changes.push(current.change);
+            let change;
+            if (node.isText) {
+                change = {
+                    id,
+                    type: 'text-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    text: node.text,
+                };
+            }
+            else if (dataTracked.operation === CHANGE_OPERATION.set_node_attributes) {
+                change = {
+                    id,
+                    type: 'node-attr-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    newAttrs: node.attrs,
+                    oldAttrs: dataTracked.oldAttrs,
                 };
             }
             else {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'node-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        nodeType: node.type.name,
-                        children: [],
-                        attrs,
-                    },
-                    node,
+                change = {
+                    id,
+                    type: 'node-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    children: [],
                 };
             }
+            current = {
+                change,
+                node,
+            };
         }
-        else if (current) {
+        if (tracked.length === 0 && current) {
             changes.push(current.change);
             current = undefined;
         }
@@ -647,22 +713,23 @@ function findChanges(state) {
  * @param schema
  * @return docWasChanged, a boolean
  */
-function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
+function fixInconsistentChanges(changeSet, currentUserID, newTr, schema) {
     const iteratedIds = new Set();
     let changed = false;
     changeSet.invalidChanges.forEach((c) => {
-        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.attrs;
+        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.dataTracked;
         const newAttrs = {
             ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
-            ...(!authorID && { authorID: trackUserID }),
-            ...(!operation && { operation: CHANGE_OPERATION.insert }),
+            ...(!authorID && { authorID: currentUserID }),
+            // Dont add a default operation -> rather have updateChangeAttrs delete the track data
+            // ...(!operation && { operation: CHANGE_OPERATION.insert }),
             ...(!reviewedByID && { reviewedByID: null }),
             ...(!status && { status: CHANGE_STATUS.pending }),
             ...(!createdAt && { createdAt: Date.now() }),
             ...(!updatedAt && { updatedAt: Date.now() }),
         };
         if (Object.keys(newAttrs).length > 0) {
-            updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
+            updateChangeAttrs(newTr, c, { ...c.dataTracked, ...newAttrs }, schema);
             changed = true;
         }
         iteratedIds.add(newAttrs.id || id);
@@ -792,18 +859,43 @@ function markInlineNodeChange(node, newTrackAttrs, schema) {
     });
     return node.mark(filtered.concat(createdMark));
 }
+/**
+ * Iterates over fragment's content and joins pasted text with old track marks
+ *
+ * This is not strictly necessary but it's kinda bad UX if the inserted text is split into parts
+ * even when it's authored by the same user.
+ * @param content
+ * @param newTrackAttrs
+ * @param schema
+ * @returns
+ */
+function loopContentAndMergeText(content, newTrackAttrs, schema) {
+    var _a;
+    const updatedChildren = [];
+    for (let i = 0; i < content.childCount; i += 1) {
+        const recursed = recurseNodeContent(content.child(i), newTrackAttrs, schema);
+        const prev = i > 0 ? updatedChildren[i - 1] : null;
+        if ((prev === null || prev === void 0 ? void 0 : prev.isText) &&
+            recursed.isText &&
+            equalMarks(prev, recursed) &&
+            ((_a = getTextNodeTrackedMarkData(prev, schema)) === null || _a === void 0 ? void 0 : _a.operation) === CHANGE_OPERATION.insert) {
+            updatedChildren.splice(i - 1, 1, schema.text('' + prev.text + recursed.text, prev.marks));
+        }
+        else {
+            updatedChildren.push(recursed);
+        }
+    }
+    return updatedChildren;
+}
 function recurseNodeContent(node, newTrackAttrs, schema) {
     if (node.isText) {
         return markInlineNodeChange(node, newTrackAttrs, schema);
     }
     else if (node.isBlock || node.isInline) {
-        const updatedChildren = [];
-        node.content.forEach((child) => {
-            updatedChildren.push(recurseNodeContent(child, newTrackAttrs, schema));
-        });
+        const updatedChildren = loopContentAndMergeText(node.content, newTrackAttrs, schema);
         return node.type.create({
             ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
+            dataTracked: [addTrackIdIfDoesntExist(newTrackAttrs)],
         }, Fragment.fromArray(updatedChildren), node.marks);
     }
     else {
@@ -813,11 +905,8 @@ function recurseNodeContent(node, newTrackAttrs, schema) {
 }
 function setFragmentAsInserted(inserted, insertAttrs, schema) {
     // Recurse the content in the inserted slice and either mark it tracked_insert or set node attrs
-    const updatedInserted = [];
-    inserted.forEach((n) => {
-        updatedInserted.push(recurseNodeContent(n, insertAttrs, schema));
-    });
-    return updatedInserted.length === 0 ? inserted : Fragment.fromArray(updatedInserted);
+    const updatedInserted = loopContentAndMergeText(inserted, insertAttrs, schema);
+    return updatedInserted.length === 0 ? Fragment.empty : Fragment.fromArray(updatedInserted);
 }
 
 /*!
@@ -846,6 +935,13 @@ function createNewDeleteAttrs(attrs) {
         ...attrs,
         operation: CHANGE_OPERATION.delete,
     };
+}
+function createNewUpdateAttrs(attrs, oldAttrs) {
+    return {
+        ...attrs,
+        operation: CHANGE_OPERATION.set_node_attributes,
+        oldAttrs,
+    };
 }
 
 /*!
@@ -889,13 +985,12 @@ function createNewDeleteAttrs(attrs) {
  * @returns mapping adjusted by the applied operations & modified insert slice
  */
 function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
-    const deleteMap = new Mapping();
     const steps = [];
     // No deletion applied, return default values
     if (from === to) {
         return {
-            deleteMap,
             newSliceContent: insertSlice.content,
+            sliceWasSplit: false,
             steps,
         };
     }
@@ -903,10 +998,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
     const { updatedSliceNodes, firstMergedNode, lastMergedNode } = splitSliceIntoMergedParts(insertSlice, gap !== undefined);
     let mergingStartSide = true;
     startDoc.nodesBetween(from, to, (node, pos) => {
-        const { pos: offsetPos, deleted: nodeWasDeleted } = deleteMap.mapResult(pos, 1);
-        const offsetFrom = deleteMap.map(from, -1);
-        const offsetTo = deleteMap.map(to, 1);
-        const nodeEnd = offsetPos + node.nodeSize;
+        const nodeEnd = pos + node.nodeSize;
         // So this insane boolean checks for ReplaceAroundStep gaps and whether the node should be skipped
         // since the content inside gap should stay unchanged.
         // All other nodes except text nodes consist of one start and end token (or just a single token for atoms).
@@ -917,23 +1009,13 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         // are altered and should not be skipped.
         // @TODO ATM 20.7.2022 there doesn't seem to be tests that capture this.
         const wasWithinGap = gap &&
-            ((!node.isText && offsetPos >= deleteMap.map(gap.start, -1)) ||
-                (node.isText &&
-                    offsetPos <= deleteMap.map(gap.start, -1) &&
-                    nodeEnd >= deleteMap.map(gap.end, -1)));
-        let step = newTr.steps[newTr.steps.length - 1];
+            ((!node.isText && pos >= gap.start) ||
+                (node.isText && pos <= gap.start && nodeEnd >= gap.start));
         // nodeEnd > offsetFrom -> delete touches this node
         // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
-        //
-        // !nodeWasDeleted -> Check node wasn't already deleted by a previous deleteNode
-        // This is quite tricky to wrap your head around and I've forgotten the nitty-gritty details already.
-        // But from what I remember what it safeguards against is, when you've already deleted a node
-        // say an inserted blockquote that had all its children deleted, nodesBetween still iterates over those
-        // nodes and therefore we have to make this check to ensure they still exist in the doc.
-        //
-        if (nodeEnd > offsetFrom && !nodeWasDeleted && !wasWithinGap) {
+        if (nodeEnd > from && !wasWithinGap) {
             // |<p>asdf</p>| -> node deleted completely
-            const nodeCompletelyDeleted = offsetPos >= offsetFrom && nodeEnd <= offsetTo;
+            const nodeCompletelyDeleted = pos >= from && nodeEnd <= to;
             // The end token deleted eg:
             // <p 1>asdf|</p 7><p 7>bye</p 12>| + [<p>]hello</p> -> <p>asdfhello</p>
             // (del 6 12) + (ins [<p>]hello</p> openStart 1 openEnd 0)
@@ -944,14 +1026,14 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
             //
             // What about:
             // <p 1>asdf|</p 7><p 7 op="inserted">|bye</p 12> + empty -> <p>asdfbye</p>
-            const endTokenDeleted = nodeEnd <= offsetTo;
+            const endTokenDeleted = nodeEnd <= to;
             // The start token deleted eg:
             // |<p1 0>hey</p 6><p2 6>|asdf</p 12> + <p3>hello [</p>] -> <p3>hello asdf</p2>
             // (del 0 7) + (ins <p>hello [</p>] openStart 0 openEnd 1)
             // (<p1> pos 0) >= (from 0) && (nodeEnd 6) - 1 > (to 7) == false???
             // (<p2> pos 6) >= (from 0) && (nodeEnd 12) - 1 > (to 7) == true
             //
-            const startTokenDeleted = offsetPos >= offsetFrom; // && nodeEnd - 1 > offsetTo
+            const startTokenDeleted = pos >= from; // && nodeEnd - 1 > offsetTo
             if (node.isText ||
                 (!endTokenDeleted && startTokenDeleted) ||
                 (endTokenDeleted && !startTokenDeleted)) {
@@ -963,7 +1045,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 }
                 // Depth is often 1 when merging paragraphs or 2 for fully open blockquotes.
                 // Incase of merging text within a ReplaceAroundStep the depth might be 1
-                const depth = newTr.doc.resolve(offsetPos).depth;
+                const depth = newTr.doc.resolve(pos).depth;
                 const mergeContent = mergingStartSide
                     ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
                     : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
@@ -981,10 +1063,10 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                     // the paragraph.
                     steps.push({
                         type: 'merge-fragment',
-                        pos: offsetPos,
-                        mergePos: mergeStartNode ? nodeEnd - openStart : offsetPos + openEnd,
-                        from: offsetFrom,
-                        to: offsetTo,
+                        pos,
+                        mergePos: mergeStartNode ? nodeEnd - openStart : pos + openEnd,
+                        from,
+                        to,
                         node,
                         fragment: setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema),
                     });
@@ -1002,9 +1084,9 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                     // (which is basically the case most of the time)
                     steps.push({
                         type: 'delete-text',
-                        pos: offsetPos,
-                        from: Math.max(offsetPos, offsetFrom),
-                        to: Math.min(nodeEnd, offsetTo),
+                        pos,
+                        from: Math.max(pos, from),
+                        to: Math.min(nodeEnd, to),
                         node,
                     });
                 }
@@ -1013,19 +1095,15 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
             else if (nodeCompletelyDeleted) {
                 steps.push({
                     type: 'delete-node',
-                    pos: offsetPos,
-                    nodeEnd: nodeEnd,
+                    pos,
+                    nodeEnd,
                     node,
                 });
             }
         }
-        const newestStep = newTr.steps[newTr.steps.length - 1];
-        if (step !== newestStep) {
-            deleteMap.appendMap(newestStep.getMap());
-        }
     });
     return {
-        deleteMap,
+        sliceWasSplit: !!(firstMergedNode || lastMergedNode),
         newSliceContent: updatedSliceNodes
             ? Fragment.fromArray(updatedSliceNodes)
             : insertSlice.content,
@@ -1119,7 +1197,7 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
     log.info('RETAINED GAP CONTENT', gap);
     // First apply the deleted range and update the insert slice to not include content that was deleted,
     // eg partial nodes in an open-ended slice
-    const { deleteMap, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
     let steps = deleteSteps;
     log.info('TR: new steps after applying delete', [...newTr.steps]);
     log.info('DELETE STEPS: ', deleteSteps);
@@ -1139,15 +1217,16 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
         }
         deleteSteps.push({
             type: 'insert-slice',
-            from: deleteMap.map(gapFrom),
-            to: deleteMap.map(gapTo),
+            from: gapFrom,
+            to: gapTo,
             slice: insertedSlice,
+            sliceWasSplit,
         });
     }
     else {
         // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
+        mergeTrackedMarks(gapFrom, newTr.doc, newTr, oldState.schema);
+        mergeTrackedMarks(gapTo, newTr.doc, newTr, oldState.schema);
     }
     return steps;
 }
@@ -1183,11 +1262,11 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
         log.info('TR: steps before applying delete', [...newTr.steps]);
         // First apply the deleted range and update the insert slice to not include content that was deleted,
         // eg partial nodes in an open-ended slice
-        const { deleteMap, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
+        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
         changeSteps.push(...deleteSteps);
         log.info('TR: steps after applying delete', [...newTr.steps]);
         log.info('DELETE STEPS: ', changeSteps);
-        const adjustedInsertPos = deleteMap.map(toA);
+        const adjustedInsertPos = toA; // deleteMap.map(toA)
         if (newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
             // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
@@ -1198,6 +1277,7 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
                 type: 'insert-slice',
                 from: adjustedInsertPos,
                 to: adjustedInsertPos,
+                sliceWasSplit,
                 slice: new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd),
             });
         }
@@ -1270,21 +1350,6 @@ function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
     }
 }
 
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const mapping = new Mapping();
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
@@ -1295,50 +1360,22 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
         log.info('process change: ', c);
         // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
         if (c.type === 'delete-node') {
-            const dataTracked = c.node.attrs.dataTracked;
-            const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === CHANGE_OPERATION.insert &&
-                dataTracked.authorID === emptyAttrs.authorID;
-            if (wasInsertedBySameUser) {
-                deleteNode(c.node, mapping.map(c.pos), newTr);
-                const newestStep = newTr.steps[newTr.steps.length - 1];
-                if (step !== newestStep) {
-                    mapping.appendMap(newestStep.getMap());
-                    step = newestStep;
-                }
-                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
-            }
-            else {
-                const attrs = {
-                    ...c.node.attrs,
-                    dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
-                };
-                newTr.setNodeMarkup(mapping.map(c.pos), undefined, attrs, c.node.marks);
+            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
+            const newestStep = newTr.steps[newTr.steps.length - 1];
+            if (step !== newestStep) {
+                mapping.appendMap(newestStep.getMap());
+                step = newestStep;
             }
+            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
         }
         else if (c.type === 'delete-text') {
-            const from = mapping.map(c.from, -1);
-            const to = mapping.map(c.to, 1);
             const node = newTr.doc.nodeAt(mapping.map(c.pos));
-            if (node === null || node === void 0 ? void 0 : node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
-                newTr.replaceWith(from, to, Fragment.empty);
-                mergeTrackedMarks(from, newTr.doc, newTr, schema);
-            }
-            else {
-                const leftNode = newTr.doc.resolve(from).nodeBefore;
-                const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
-                const rightNode = newTr.doc.resolve(to).nodeAfter;
-                const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
-                const fromStartOfMark = from - (leftNode && leftMarks ? leftNode.nodeSize : 0);
-                const toEndOfMark = to + (rightNode && rightMarks ? rightNode.nodeSize : 0);
-                const dataTracked = addTrackIdIfDoesntExist({
-                    ...leftMarks,
-                    ...rightMarks,
-                    ...deleteAttrs,
-                });
-                newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
-                    dataTracked,
-                }));
+            if (!node) {
+                log.error(`processChangeSteps: no text node found for text-change`, c);
+                return;
             }
+            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+            mergeTrackedMarks(where, newTr.doc, newTr, schema);
         }
         else if (c.type === 'merge-fragment') {
             let insertPos = mapping.map(c.mergePos);
@@ -1364,7 +1401,7 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
             const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
             const stepResult = newTr.maybeStep(newStep);
             if (stepResult.failed) {
-                log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
+                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
                 return;
             }
             mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
@@ -1372,17 +1409,29 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
             selectionPos = mapping.map(c.to) + c.slice.size;
         }
         else if (c.type === 'update-node-attrs') {
-            const oldDataTracked = c.oldAttrs.dataTracked;
-            const oldAttrs = (oldDataTracked === null || oldDataTracked === void 0 ? void 0 : oldDataTracked.operation) === CHANGE_OPERATION.set_node_attributes
-                ? oldDataTracked.oldAttrs
-                : c.oldAttrs;
-            const dataTracked = addTrackIdIfDoesntExist({
-                ...oldDataTracked,
-                oldAttrs,
-                ...emptyAttrs,
-                operation: CHANGE_OPERATION.set_node_attributes,
-            });
-            newTr.setNodeMarkup(mapping.map(c.pos), undefined, { ...c.newAttrs, dataTracked });
+            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+            const oldUpdate = oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
+            let newDataTracked = oldDataTracked;
+            if (oldUpdate) {
+                newDataTracked = [
+                    ...oldDataTracked.filter((d) => d === oldUpdate),
+                    {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    },
+                ];
+            }
+            else if (oldDataTracked.length === 0 ||
+                oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.delete)) {
+                newDataTracked = [
+                    ...oldDataTracked,
+                    addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, c.node.attrs)),
+                ];
+            }
+            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                ...c.newAttrs,
+                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+            }, c.node.marks);
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
         if (step !== newestStep) {
@@ -1407,25 +1456,26 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function matchInserted(inDeleted, deleted, inserted, newTr, schema) {
+function matchInserted(matchedDeleted, deleted, inserted, newTr, schema) {
     var _a;
+    let matched = [matchedDeleted, deleted];
     for (let i = 0;; i += 1) {
         if (inserted.childCount === i)
-            return [inDeleted, deleted];
-        const child = inserted.child(i);
+            return matched;
+        const insNode = inserted.child(i);
         // @ts-ignore
-        let adjDeleted = deleted.find((d) => (d.type === 'delete-text' && d.to === inDeleted) ||
-            (d.type === 'delete-node' && d.nodeEnd === inDeleted));
-        if (child.type !== ((_a = adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node) === null || _a === void 0 ? void 0 : _a.type)) {
-            return [inDeleted, deleted];
+        let adjDeleted = matched[1].find((d) => (d.type === 'delete-text' && Math.max(d.pos, d.from) === matched[0]) ||
+            (d.type === 'delete-node' && d.pos === matched[0]));
+        if (insNode.type !== ((_a = adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node) === null || _a === void 0 ? void 0 : _a.type)) {
+            return matched;
         }
-        else if (child.isText && (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node)) {
+        else if (insNode.isText && (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node)) {
             adjDeleted = adjDeleted;
-            const { pos, from, to, node } = adjDeleted;
-            let j = 0, d = from - pos, maxSteps = Math.max(pos, from) - to;
+            const { pos, from, to, node: delNode } = adjDeleted;
+            let j = 0, d = from - pos, maxSteps = to - Math.max(pos, from);
             // Match text inside the inserted text node to the deleted text node
-            for (; maxSteps !== j && child.text[j] === node.text[d]; j += 1, d += 1) {
-                inDeleted -= 1;
+            for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
+                matched[0] += 1;
             }
             // this is needed incase diffing tr.doc
             // deleted.push({
@@ -1435,46 +1485,108 @@ function matchInserted(inDeleted, deleted, inserted, newTr, schema) {
             //   oldAttrs: adjDeleted.node.attrs || {},
             //   newAttrs: child.attrs || {},
             // })
+            matched = [matched[0], matched[1].filter((d) => d !== adjDeleted)];
             if (maxSteps !== j) {
-                deleted.push({
+                matched[1].push({
                     pos,
                     from: Math.max(pos, from) + j,
                     to,
                     type: 'delete-text',
-                    node,
+                    node: delNode,
                 });
+                return matched;
             }
-            return [inDeleted, deleted.filter((d) => d !== adjDeleted)];
+            continue;
         }
-        else if (child.content.size > 0 || (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node.content.size) > 0) {
-            // Move the inDeleted inside the block node's boundary
-            return matchInserted(inDeleted - 1, deleted.filter((d) => d !== adjDeleted), child.content);
+        else if (insNode.content.size > 0 || (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node.content.size) > 0) {
+            // Move the inDeleted inside the block/inline node's boundary
+            matched = matchInserted(matched[0] + 1, matched[1].filter((d) => d !== adjDeleted), insNode.content);
         }
-        deleted.push({
+        else {
+            matched = [matched[0] + insNode.nodeSize, matched[1].filter((d) => d !== adjDeleted)];
+        }
+        matched[1].push({
             pos: adjDeleted.pos,
             type: 'update-node-attrs',
+            node: adjDeleted.node,
             // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
-            oldAttrs: adjDeleted.node.attrs || {},
-            newAttrs: child.attrs || {},
+            newAttrs: insNode.attrs || {},
         });
-        deleted = deleted.filter((d) => d !== adjDeleted);
-        inDeleted -= child.nodeSize;
     }
 }
+/**
+ * Cuts a fragment similar to Fragment.cut but also removes the parent node.
+ *
+ * @TODO there is however, some silly calculation mistake so that I need to use matched - deleted + 1 > 0
+ * inside it to check whether to actually cut a text node. The offset might be cascading, therefore it should
+ * be fixed at some point.
+ * @param matched
+ * @param deleted
+ * @param content
+ * @returns
+ */
+function cutFragment(matched, deleted, content) {
+    let newContent = [];
+    for (let i = 0; matched <= deleted && i < content.childCount; i += 1) {
+        const child = content.child(i);
+        if (!child.isText && child.content.size > 0) {
+            const cut = cutFragment(matched + 1, deleted, child.content);
+            matched = cut[0];
+            newContent.push(...cut[1].content);
+        }
+        else if (child.isText && matched + child.nodeSize > deleted) {
+            if (matched - deleted + 1 > 0) {
+                newContent.push(child.cut(0, matched - deleted + 1));
+            }
+            else {
+                newContent.push(child);
+            }
+            matched = deleted + 1;
+        }
+        else {
+            matched += child.nodeSize;
+        }
+    }
+    return [matched, Fragment.fromArray(newContent)];
+}
 function diffChangeSteps(deleted, inserted, newTr, schema) {
     const updated = [];
     let updatedDeleted = [...deleted];
     inserted.forEach((ins) => {
-        const [inDeleted, updatedDel] = matchInserted(ins.from, updatedDeleted, ins.slice.content);
-        if (inDeleted === ins.from) {
+        log.info('DIFF ins ', ins);
+        //
+        // @TODO this is a temporary workaround to prevent duplicated diffing between splitSliceIntoMergedParts and
+        // matchInserted.
+        //
+        // As originally authored splitSliceIntoMergedParts splits open slices into their merged parts
+        // leaving out the need to insert the possibly deleted nodes into the doc. However, as matchInserted now
+        // traverses the deleted range checking it against the inserted slice this behaves quite in a same way
+        // where the opened block nodes are traversed but left unmodified. With an openStart > 0 though the
+        // node-attr-updates would additionally have to be filtered out in the processChangeSteps.
+        //
+        // The old logic is still left as it's as refactoring is painful and would probably break something and just
+        // in general, take a lot of time. Therefore, this sliceWasSplit boolean is used to just skip diffing.
+        if (ins.sliceWasSplit) {
+            updated.push(ins);
+            return;
+        }
+        // Start diffing from the start of the deleted range
+        const deleteStart = deleted.reduce((acc, cur) => {
+            if (cur.type === 'delete-node') {
+                return Math.min(acc, cur.pos);
+            }
+            else if (cur.type === 'delete-text') {
+                return Math.min(acc, cur.from);
+            }
+            return acc;
+        }, Number.MAX_SAFE_INTEGER);
+        const [inDeleted, updatedDel] = matchInserted(deleteStart, updatedDeleted, ins.slice.content);
+        if (inDeleted === deleteStart) {
             updated.push(ins);
             return;
         }
         updatedDeleted = updatedDel;
-        const newInsertedA = ins.slice.content.cut(ins.from - inDeleted);
-        const newInsertedB = ins.slice.content.cut(ins.from - inDeleted + 1);
-        // Super hax to cut over block node boundaries in the inserted fragment
-        const newInserted = newInsertedA.size === newInsertedB.size + 2 ? newInsertedB : newInsertedA;
+        const newInserted = cutFragment(0, inDeleted, ins.slice.content)[1];
         if (newInserted.size > 0) {
             updated.push({
                 ...ins,
@@ -1482,6 +1594,7 @@ function diffChangeSteps(deleted, inserted, newTr, schema) {
             });
         }
     });
+    log.info('FINISH DIFF: ', [...updatedDeleted, ...updated]);
     return [...updatedDeleted, ...updated];
 }
 
@@ -1697,10 +1810,10 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                     ids.forEach((changeId) => {
                         const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
                         if (change) {
-                            createdTr = updateChangeAttrs(createdTr, change, { status, reviewedByID: userID }, oldState.schema);
-                            setAction(createdTr, TrackChangesAction.updateChanges, [change.id]);
+                            createdTr = updateChangeAttrs(createdTr, change, { ...change.dataTracked, status, reviewedByID: userID }, oldState.schema);
                         }
                     });
+                    setAction(createdTr, TrackChangesAction.updateChanges, ids);
                 }
                 else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
                     const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);