@manuscripts/track-changes-plugin 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -94,11 +94,11 @@ exports.CHANGE_OPERATION = void 0;
 (function (CHANGE_OPERATION) {
     CHANGE_OPERATION["insert"] = "insert";
     CHANGE_OPERATION["delete"] = "delete";
-    CHANGE_OPERATION["set_node_attributes"] = "set_node_attributes";
-    CHANGE_OPERATION["wrap_with_node"] = "wrap_with_node";
-    CHANGE_OPERATION["unwrap_from_node"] = "unwrap_from_node";
-    CHANGE_OPERATION["add_mark"] = "add_mark";
-    CHANGE_OPERATION["remove_mark"] = "remove_mark";
+    CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+    // wrap_with_node = 'wrap_with_node',
+    // unwrap_from_node = 'unwrap_from_node',
+    // add_mark = 'add_mark',
+    // remove_mark = 'remove_mark',
 })(exports.CHANGE_OPERATION || (exports.CHANGE_OPERATION = {}));
 exports.CHANGE_STATUS = void 0;
 (function (CHANGE_STATUS) {
@@ -199,16 +199,13 @@ class ChangeSet {
                 rootNodes.push(currentNodeChange);
                 currentNodeChange = undefined;
             }
-            if (c.type === 'node-change' && currentNodeChange && c.from < currentNodeChange.to) {
+            if (currentNodeChange && c.from < currentNodeChange.to) {
                 currentNodeChange.children.push(c);
             }
             else if (c.type === 'node-change') {
                 currentNodeChange = { ...c, children: [] };
             }
-            else if (c.type === 'text-change' && currentNodeChange && c.from < currentNodeChange.to) {
-                currentNodeChange.children.push(c);
-            }
-            else if (c.type === 'text-change') {
+            else {
                 rootNodes.push(c);
             }
         });
@@ -232,6 +229,9 @@ class ChangeSet {
     get nodeChanges() {
         return this.changes.filter((c) => c.type === 'node-change');
     }
+    get nodeAttrChanges() {
+        return this.changes.filter((c) => c.type === 'node-attr-change');
+    }
     get isEmpty() {
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
     }
@@ -277,9 +277,7 @@ class ChangeSet {
      * @param change
      */
     static shouldNotDelete(change) {
-        const { status, operation } = change.attrs;
-        return ((operation === exports.CHANGE_OPERATION.insert && status === exports.CHANGE_STATUS.accepted) ||
-            (operation === exports.CHANGE_OPERATION.delete && status === exports.CHANGE_STATUS.rejected));
+        return !ChangeSet.shouldDeleteChange(change);
     }
     /**
      * Determines whether a change should be deleted when applying it to the document.
@@ -307,7 +305,7 @@ class ChangeSet {
             'updatedAt',
         ];
         // 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 null or string
+        // 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));
@@ -323,9 +321,89 @@ class ChangeSet {
     static isNodeChange(change) {
         return change.type === 'node-change';
     }
+    static isNodeAttrChange(change) {
+        return change.type === 'node-attr-change';
+    }
 }
 _ChangeSet_changes = new WeakMap();
 
+/*!
+ * © 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 uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+
+function addTrackIdIfDoesntExist(attrs) {
+    if (!attrs.id) {
+        return {
+            id: uuidv4(),
+            ...attrs,
+        };
+    }
+    return attrs;
+}
+function getInlineNodeTrackedMarkData(node, schema) {
+    if (!node || !node.isInline) {
+        return undefined;
+    }
+    const marksTrackedData = [];
+    node.marks.forEach((mark) => {
+        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
+            const operation = mark.type === schema.marks.tracked_insert
+                ? exports.CHANGE_OPERATION.insert
+                : exports.CHANGE_OPERATION.delete;
+            marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
+        }
+    });
+    if (marksTrackedData.length > 1) {
+        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
+    }
+    return marksTrackedData[0] || undefined;
+}
+function getNodeTrackedData(node, schema) {
+    return !node
+        ? undefined
+        : node.isText
+            ? getInlineNodeTrackedMarkData(node, schema)
+            : node.attrs.dataTracked;
+}
+function equalMarks(n1, n2) {
+    return (n1.marks.length === n2.marks.length &&
+        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
+}
+function shouldMergeTrackedAttributes(left, right) {
+    if (!left || !right) {
+        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
+            left,
+            right,
+        });
+        return false;
+    }
+    return (left.status === right.status &&
+        left.operation === right.operation &&
+        left.authorID === right.authorID);
+}
+function getMergeableMarkTrackedAttrs(node, attrs, schema) {
+    const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
+    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
+}
+
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -413,83 +491,6 @@ function mergeNode(node, pos, tr) {
     return undefined;
 }
 
-/*!
- * © 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 uuidv4() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-
-function addTrackIdIfDoesntExist(attrs) {
-    if (!attrs.id) {
-        return {
-            id: uuidv4(),
-            ...attrs,
-        };
-    }
-    return attrs;
-}
-function getInlineNodeTrackedMarkData(node, schema) {
-    if (!node || !node.isInline) {
-        return undefined;
-    }
-    const marksTrackedData = [];
-    node.marks.forEach((mark) => {
-        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
-            const operation = mark.type === schema.marks.tracked_insert
-                ? exports.CHANGE_OPERATION.insert
-                : exports.CHANGE_OPERATION.delete;
-            marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
-        }
-    });
-    if (marksTrackedData.length > 1) {
-        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
-    }
-    return marksTrackedData[0] || undefined;
-}
-function getNodeTrackedData(node, schema) {
-    return !node
-        ? undefined
-        : node.isText
-            ? getInlineNodeTrackedMarkData(node, schema)
-            : node.attrs.dataTracked;
-}
-function equalMarks(n1, n2) {
-    return (n1.marks.length === n2.marks.length &&
-        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
-}
-function shouldMergeTrackedAttributes(left, right) {
-    if (!left || !right) {
-        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
-            left,
-            right,
-        });
-        return false;
-    }
-    return (left.status === right.status &&
-        left.operation === right.operation &&
-        left.authorID === right.authorID);
-}
-function getMergeableMarkTrackedAttrs(node, attrs, schema) {
-    const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
-    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
-}
-
 function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
@@ -562,6 +563,16 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prose
             }
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
+        else if (ChangeSet.isNodeAttrChange(change) &&
+            change.attrs.status === exports.CHANGE_STATUS.accepted) {
+            const attrs = { ...node.attrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
+        else if (ChangeSet.isNodeAttrChange(change) &&
+            change.attrs.status === exports.CHANGE_STATUS.rejected) {
+            const attrs = { ...change.oldAttrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
     });
     return deleteMap;
 }
@@ -667,87 +678,6 @@ function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
     return changed;
 }
 
-/*!
- * © 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 markInlineNodeChange(node, newTrackAttrs, schema) {
-    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
-    const mark = newTrackAttrs.operation === exports.CHANGE_OPERATION.insert
-        ? schema.marks.tracked_insert
-        : schema.marks.tracked_delete;
-    const createdMark = mark.create({
-        dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-    });
-    return node.mark(filtered.concat(createdMark));
-}
-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));
-        });
-        return node.type.create({
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-        }, prosemirrorModel.Fragment.fromArray(updatedChildren), node.marks);
-    }
-    else {
-        log.error(`unhandled node type: "${node.type.name}"`, node);
-        return node;
-    }
-}
-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 : prosemirrorModel.Fragment.fromArray(updatedInserted);
-}
-
-/*!
- * © 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 createNewInsertAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: exports.CHANGE_OPERATION.insert,
-    };
-}
-function createNewDeleteAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: exports.CHANGE_OPERATION.delete,
-    };
-}
-
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -843,73 +773,104 @@ function splitSliceIntoMergedParts(insertSlice, mergeEqualSides = false) {
         firstMergedNode,
         lastMergedNode,
     };
-}
-/**
- * Deletes inserted text directly, otherwise wraps it with tracked_delete mark
+}
+
+/*!
+ * © 2021 Atypon Systems LLC
  *
- * This would work for general inline nodes too, but since node marks don't work properly
- * with Yjs, attributes are used instead.
- * @param node
- * @param pos
- * @param newTr
- * @param schema
- * @param deleteAttrs
- * @param from
- * @param to
+ * 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 deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
-    const start = from ? Math.max(pos, from) : pos;
-    const nodeEnd = pos + node.nodeSize;
-    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
-    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
-        // Math.max(pos, from) is for picking always the start of the node,
-        // not the start of the change (which might span multiple nodes).
-        // Pos can be less than from as nodesBetween iterates through all nodes starting from the top block node
-        newTr.replaceWith(start, end, prosemirrorModel.Fragment.empty);
-        return start;
+function markInlineNodeChange(node, newTrackAttrs, schema) {
+    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
+    const mark = newTrackAttrs.operation === exports.CHANGE_OPERATION.insert
+        ? schema.marks.tracked_insert
+        : schema.marks.tracked_delete;
+    const createdMark = mark.create({
+        dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
+    });
+    return node.mark(filtered.concat(createdMark));
+}
+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));
+        });
+        return node.type.create({
+            ...node.attrs,
+            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
+        }, prosemirrorModel.Fragment.fromArray(updatedChildren), node.marks);
     }
     else {
-        const leftNode = newTr.doc.resolve(start).nodeBefore;
-        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
-        const rightNode = newTr.doc.resolve(end).nodeAfter;
-        const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
-        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
-        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
-        const createdAt = Math.min((leftMarks === null || leftMarks === void 0 ? void 0 : leftMarks.createdAt) || Number.MAX_VALUE, (rightMarks === null || rightMarks === void 0 ? void 0 : rightMarks.createdAt) || Number.MAX_VALUE, deleteAttrs.createdAt);
-        const dataTracked = addTrackIdIfDoesntExist({
-            ...leftMarks,
-            ...rightMarks,
-            ...deleteAttrs,
-            createdAt,
-        });
-        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
-            dataTracked,
-        }));
-        return toEndOfMark;
+        log.error(`unhandled node type: "${node.type.name}"`, node);
+        return node;
     }
 }
-/**
- * Deletes inserted block or inline node, otherwise adds `dataTracked` object with CHANGE_STATUS 'deleted'
- * @param node
- * @param pos
- * @param newTr
- * @param deleteAttrs
+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 : prosemirrorModel.Fragment.fromArray(updatedInserted);
+}
+
+/*!
+ * © 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 deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
-    const dataTracked = node.attrs.dataTracked;
-    const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === exports.CHANGE_OPERATION.insert &&
-        dataTracked.authorID === deleteAttrs.authorID;
-    if (wasInsertedBySameUser) {
-        deleteNode(node, pos, newTr);
-    }
-    else {
-        const attrs = {
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
-        };
-        newTr.setNodeMarkup(pos, undefined, attrs, node.marks);
-    }
+function createNewInsertAttrs(attrs) {
+    return {
+        ...attrs,
+        operation: exports.CHANGE_OPERATION.insert,
+    };
 }
+function createNewDeleteAttrs(attrs) {
+    return {
+        ...attrs,
+        operation: exports.CHANGE_OPERATION.delete,
+    };
+}
+
+/*!
+ * © 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.
+ */
 /**
  * Applies deletion to the doc without actually deleting nodes that have not been inserted
  *
@@ -937,18 +898,17 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
  */
 function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
     const deleteMap = new prosemirrorTransform.Mapping();
-    const mergedInsertPos = undefined;
+    const steps = [];
     // No deletion applied, return default values
     if (from === to) {
         return {
             deleteMap,
-            mergedInsertPos,
             newSliceContent: insertSlice.content,
+            steps,
         };
     }
     const { openStart, openEnd } = insertSlice;
     const { updatedSliceNodes, firstMergedNode, lastMergedNode } = splitSliceIntoMergedParts(insertSlice, gap !== undefined);
-    const deleteAttrs = createNewDeleteAttrs(trackAttrs);
     let mergingStartSide = true;
     startDoc.nodesBetween(from, to, (node, pos) => {
         const { pos: offsetPos, deleted: nodeWasDeleted } = deleteMap.mapResult(pos, 1);
@@ -1024,24 +984,18 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 // ProseMirror node semantics as start tokens are considered to contain the actual node itself.
                 const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent !== undefined;
                 if (mergeStartNode || mergeEndNode) {
-                    // The default insert position for block nodes is either the start of the merged content or the end.
-                    // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-                    // actual position of the merge. Currently the inserted content is inserted at the start or end
-                    // of the merged content, TODO reverse the start/end when end/start token?
-                    let insertPos = mergeStartNode ? nodeEnd - openStart : offsetPos + openEnd;
-                    if (node.isText) {
-                        // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                        // the text node.
-                        insertPos = deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
-                        deleteMap.appendMap(newTr.steps[newTr.steps.length - 1].getMap());
-                        step = newTr.steps[newTr.steps.length - 1];
-                    }
                     // Just as a fun fact that I found out while debugging this. Inserting text at paragraph position wraps
                     // it into a new paragraph(!). So that's why you always offset your positions to insert it _inside_
                     // the paragraph.
-                    if (mergeContent.size !== 0) {
-                        newTr.insert(insertPos, setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema));
-                    }
+                    steps.push({
+                        type: 'merge-fragment',
+                        pos: offsetPos,
+                        mergePos: mergeStartNode ? nodeEnd - openStart : offsetPos + openEnd,
+                        from: offsetFrom,
+                        to: offsetTo,
+                        node,
+                        fragment: setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema),
+                    });
                     // Okay this is a bit ridiculous but it's used to adjust the insert pos when track changes prevents deletions
                     // of merged nodes & content, as just using mapped toA in that case isn't the same.
                     // The calculation is a bit mysterious, I admit.
@@ -1054,12 +1008,23 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 else if (node.isText) {
                     // Text deletion is handled even when the deletion doesn't completely wrap the text node
                     // (which is basically the case most of the time)
-                    deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
+                    steps.push({
+                        type: 'delete-text',
+                        pos: offsetPos,
+                        from: Math.max(offsetPos, offsetFrom),
+                        to: Math.min(nodeEnd, offsetTo),
+                        node,
+                    });
                 }
                 else ;
             }
             else if (nodeCompletelyDeleted) {
-                deleteOrSetNodeDeleted(node, offsetPos, newTr, deleteAttrs);
+                steps.push({
+                    type: 'delete-node',
+                    pos: offsetPos,
+                    nodeEnd: nodeEnd,
+                    node,
+                });
             }
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
@@ -1069,10 +1034,10 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
     });
     return {
         deleteMap,
-        mergedInsertPos,
         newSliceContent: updatedSliceNodes
             ? prosemirrorModel.Fragment.fromArray(updatedSliceNodes)
             : insertSlice.content,
+        steps,
     };
 }
 
@@ -1100,8 +1065,7 @@ function mergeTrackedMarks(pos, doc, newTr, schema) {
     if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
         return;
     }
-    const isLeftOlder = (leftDataTracked.createdAt || Number.MAX_VALUE) <
-        (rightDataTracked.createdAt || Number.MAX_VALUE);
+    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
     const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
     const dataTracked = {
         ...ancestorAttrs,
@@ -1157,14 +1121,16 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
     const stepResult = newTr.maybeStep(newStep);
     if (stepResult.failed) {
         log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
-        return;
+        return [];
     }
     const gap = oldState.doc.slice(gapFrom, gapTo);
     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 } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    const { deleteMap, 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);
     // We only want to insert when there something inside the gap (actually would this be always true?)
     // or insert slice wasn't just start/end tokens (which we already merged inside deleteAndMergeSplitBlockNodes)
     if (gap.size > 0 || (!structure && newSliceContent.size > 0)) {
@@ -1179,21 +1145,19 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
             insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
             log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        const newStep = new prosemirrorTransform.ReplaceStep(deleteMap.map(gapFrom), deleteMap.map(gapTo), insertedSlice, false);
-        const stepResult = newTr.maybeStep(newStep);
-        if (stepResult.failed) {
-            log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
-            return;
-        }
-        log.info('new steps after applying insert', [...newTr.steps]);
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
+        deleteSteps.push({
+            type: 'insert-slice',
+            from: deleteMap.map(gapFrom),
+            to: deleteMap.map(gapTo),
+            slice: insertedSlice,
+        });
     }
     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);
     }
+    return steps;
 }
 
 /*!
@@ -1213,7 +1177,7 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
  */
 function trackReplaceStep(step, oldState, newTr, attrs) {
     log.info('###### ReplaceStep ######');
-    let selectionPos = 0;
+    let selectionPos = 0, changeSteps = [];
     step.getMap().forEach((fromA, toA, fromB, toB) => {
         log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
         const { slice } = step;
@@ -1227,34 +1191,306 @@ 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, mergedInsertPos, newSliceContent } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
+        const { deleteMap, 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]);
-        const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : deleteMap.map(toA);
+        log.info('DELETE STEPS: ', changeSteps);
+        const adjustedInsertPos = deleteMap.map(toA);
         if (newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
             // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
             // the sides should be equal. TODO can they be other than 0?
             const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
             const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
-            const insertedSlice = new prosemirrorModel.Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
-            const newStep = new prosemirrorTransform.ReplaceStep(adjustedInsertPos, adjustedInsertPos, insertedSlice);
+            changeSteps.push({
+                type: 'insert-slice',
+                from: adjustedInsertPos,
+                to: adjustedInsertPos,
+                slice: new prosemirrorModel.Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd),
+            });
+        }
+        else {
+            // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
+            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
+            selectionPos = fromA;
+        }
+    });
+    return [changeSteps, selectionPos];
+}
+
+/*!
+ * © 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.
+ */
+/**
+ * Deletes inserted text directly, otherwise wraps it with tracked_delete mark
+ *
+ * This would work for general inline nodes too, but since node marks don't work properly
+ * with Yjs, attributes are used instead.
+ * @param node
+ * @param pos
+ * @param newTr
+ * @param schema
+ * @param deleteAttrs
+ * @param from
+ * @param to
+ */
+function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
+    const start = from ? Math.max(pos, from) : pos;
+    const nodeEnd = pos + node.nodeSize;
+    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
+    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
+        // Math.max(pos, from) is for picking always the start of the node,
+        // not the start of the change (which might span multiple nodes).
+        // Pos can be less than from as nodesBetween iterates through all nodes starting from the top block node
+        newTr.replaceWith(start, end, prosemirrorModel.Fragment.empty);
+        return start;
+    }
+    else {
+        const leftNode = newTr.doc.resolve(start).nodeBefore;
+        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
+        const rightNode = newTr.doc.resolve(end).nodeAfter;
+        const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
+        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
+        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
+        const createdAt = Math.min((leftMarks === null || leftMarks === void 0 ? void 0 : leftMarks.createdAt) || Number.MAX_VALUE, (rightMarks === null || rightMarks === void 0 ? void 0 : rightMarks.createdAt) || Number.MAX_VALUE, deleteAttrs.createdAt);
+        const dataTracked = addTrackIdIfDoesntExist({
+            ...leftMarks,
+            ...rightMarks,
+            ...deleteAttrs,
+            createdAt,
+        });
+        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
+            dataTracked,
+        }));
+        return toEndOfMark;
+    }
+}
+
+/*!
+ * © 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 prosemirrorTransform.Mapping();
+    const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
+    let selectionPos = startPos;
+    // @TODO add custom handler / condition?
+    changes.forEach((c) => {
+        let step = newTr.steps[newTr.steps.length - 1];
+        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) === exports.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);
+            }
+        }
+        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, prosemirrorModel.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,
+                }));
+            }
+        }
+        else if (c.type === 'merge-fragment') {
+            let insertPos = mapping.map(c.mergePos);
+            // The default insert position for block nodes is either the start of the merged content or the end.
+            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+            // actual position of the merge. Currently the inserted content is inserted at the start or end
+            // of the merged content, TODO reverse the start/end when end/start token?
+            if (c.node.isText) {
+                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                // the text node.
+                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                const newestStep = newTr.steps[newTr.steps.length - 1];
+                if (step !== newestStep) {
+                    mapping.appendMap(newestStep.getMap());
+                    step = newestStep;
+                }
+            }
+            if (c.fragment.size > 0) {
+                newTr.insert(insertPos, c.fragment);
+            }
+        }
+        else if (c.type === 'insert-slice') {
+            const newStep = new prosemirrorTransform.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);
                 return;
             }
-            log.info('new steps after applying insert', [...newTr.steps]);
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            mergeTrackedMarks(adjustedInsertPos + insertedSlice.size, newTr.doc, newTr, oldState.schema);
-            selectionPos = adjustedInsertPos + insertedSlice.size;
+            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+            mergeTrackedMarks(mapping.map(c.to), newTr.doc, newTr, schema);
+            selectionPos = mapping.map(c.to) + c.slice.size;
         }
-        else {
-            // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            selectionPos = fromA;
+        else if (c.type === 'update-node-attrs') {
+            const oldDataTracked = c.oldAttrs.dataTracked;
+            const oldAttrs = (oldDataTracked === null || oldDataTracked === void 0 ? void 0 : oldDataTracked.operation) === exports.CHANGE_OPERATION.set_node_attributes
+                ? oldDataTracked.oldAttrs
+                : c.oldAttrs;
+            const dataTracked = addTrackIdIfDoesntExist({
+                ...oldDataTracked,
+                oldAttrs,
+                ...emptyAttrs,
+                operation: exports.CHANGE_OPERATION.set_node_attributes,
+            });
+            newTr.setNodeMarkup(mapping.map(c.pos), undefined, { ...c.newAttrs, dataTracked });
+        }
+        const newestStep = newTr.steps[newTr.steps.length - 1];
+        if (step !== newestStep) {
+            mapping.appendMap(newestStep.getMap());
+        }
+    });
+    return [mapping, selectionPos];
+}
+
+/*!
+ * © 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 matchInserted(inDeleted, deleted, inserted, newTr, schema) {
+    var _a;
+    for (let i = 0;; i += 1) {
+        if (inserted.childCount === i)
+            return [inDeleted, deleted];
+        const child = 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];
+        }
+        else if (child.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;
+            // 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;
+            }
+            // this is needed incase diffing tr.doc
+            // deleted.push({
+            //   pos: pos,
+            //   type: 'update-node-attrs',
+            //   // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
+            //   oldAttrs: adjDeleted.node.attrs || {},
+            //   newAttrs: child.attrs || {},
+            // })
+            if (maxSteps !== j) {
+                deleted.push({
+                    pos,
+                    from: Math.max(pos, from) + j,
+                    to,
+                    type: 'delete-text',
+                    node,
+                });
+            }
+            return [inDeleted, deleted.filter((d) => d !== adjDeleted)];
+        }
+        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);
+        }
+        deleted.push({
+            pos: adjDeleted.pos,
+            type: 'update-node-attrs',
+            // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
+            oldAttrs: adjDeleted.node.attrs || {},
+            newAttrs: child.attrs || {},
+        });
+        deleted = deleted.filter((d) => d !== adjDeleted);
+        inDeleted -= child.nodeSize;
+    }
+}
+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) {
+            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;
+        if (newInserted.size > 0) {
+            updated.push({
+                ...ins,
+                slice: new prosemirrorModel.Slice(newInserted, ins.slice.openStart, ins.slice.openEnd),
+            });
         }
     });
-    return selectionPos;
+    return [...updatedDeleted, ...updated];
 }
 
 /**
@@ -1308,7 +1544,14 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             return;
         }
         else if (step instanceof prosemirrorTransform.ReplaceStep) {
-            const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+            let [steps, startPos] = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+            log.info('CHANGES: ', steps);
+            // deleted and merged really...
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = processChangeSteps(steps, startPos, newTr, emptyAttrs, oldState.schema);
             if (!wasNodeSelection) {
                 const sel = getSelectionStaticConstructor(tr.selection);
                 // Use Selection.near to fix selections that point to a block node instead of inline content
@@ -1319,10 +1562,16 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             }
         }
         else if (step instanceof prosemirrorTransform.ReplaceAroundStep) {
-            trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
-            // } else if (step instanceof AddMarkStep) {
-            // } else if (step instanceof RemoveMarkStep) {
+            let steps = trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            log.info('INSERT STEPS: ', inserted);
+            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            log.info('DIFFED STEPS: ', steps);
+            processChangeSteps(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
+        // } else if (step instanceof AddMarkStep) {
+        // } else if (step instanceof RemoveMarkStep) {
         // TODO: here we could check whether adjacent inserts & deletes cancel each other out.
         // However, this should not be done by diffing and only matching node or char by char instead since
         // it's A easier and B more intuitive to user.
@@ -1481,21 +1730,6 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
     });
 };
 
-/*!
- * © 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.
- */
 /**
  * Sets track-changes plugin's status to any of: 'enabled' 'disabled' 'viewSnapshots'. Passing undefined will
  * set 'enabled' status to 'disabled' and 'disabled' | 'viewSnapshots' status to 'enabled'.