@manuscripts/track-changes-plugin 0.1.1 → 0.4.0

package/dist/{index.es.js → index.cjs}

@@ -1,7 +1,15 @@
-import { PluginKey, Plugin } from 'prosemirror-state';
-import debug from 'debug';
-import { liftTarget, canJoin, Mapping, ReplaceStep, ReplaceAroundStep } from 'prosemirror-transform';
-import { Fragment, Slice } from 'prosemirror-model';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var prosemirrorState = require('prosemirror-state');
+var debug = require('debug');
+var prosemirrorTransform = require('prosemirror-transform');
+var prosemirrorModel = require('prosemirror-model');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 
 var TrackChangesAction;
 (function (TrackChangesAction) {
@@ -30,7 +38,14 @@ function getAction(tr, action) {
  */
 function setAction(tr, action, payload) {
     return tr.setMeta(action, payload);
-}
+}
+/**
+ * Skip tracking for a transaction, use this with caution to avoid race-conditions or just to otherwise
+ * omitting applying of track attributes or marks.
+ * @param tr
+ * @returns
+ */
+const skipTracking = (tr) => setAction(tr, TrackChangesAction.skipTrack, true);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -75,22 +90,22 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var CHANGE_OPERATION;
+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 || (CHANGE_OPERATION = {}));
-var CHANGE_STATUS;
+    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) {
     CHANGE_STATUS["accepted"] = "accepted";
     CHANGE_STATUS["rejected"] = "rejected";
     CHANGE_STATUS["pending"] = "pending";
-})(CHANGE_STATUS || (CHANGE_STATUS = {}));
+})(exports.CHANGE_STATUS || (exports.CHANGE_STATUS = {}));
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -107,7 +122,7 @@ var CHANGE_STATUS;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const logger = debug('track');
+const logger = debug__default["default"]('track');
 const log = {
     info(str, obj) {
         if (obj) {
@@ -140,10 +155,10 @@ const log = {
  */
 const enableDebug = (enabled) => {
     if (enabled) {
-        debug.enable('track');
+        debug__default["default"].enable('track');
     }
     else {
-        debug.disable();
+        debug__default["default"].disable();
     }
 };
 
@@ -184,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);
             }
         });
@@ -203,13 +215,13 @@ class ChangeSet {
         return rootNodes;
     }
     get pending() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
+        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.pending);
     }
     get accepted() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
+        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.accepted);
     }
     get rejected() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
+        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.rejected);
     }
     get textChanges() {
         return this.changes.filter((c) => c.type === 'text-change');
@@ -217,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;
     }
@@ -262,9 +277,7 @@ class ChangeSet {
      * @param change
      */
     static shouldNotDelete(change) {
-        const { status, operation } = change.attrs;
-        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.accepted) ||
-            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.rejected));
+        return !ChangeSet.shouldDeleteChange(change);
     }
     /**
      * Determines whether a change should be deleted when applying it to the document.
@@ -272,8 +285,8 @@ class ChangeSet {
      */
     static shouldDeleteChange(change) {
         const { status, operation } = change.attrs;
-        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
-            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
+        return ((operation === exports.CHANGE_OPERATION.insert && status === exports.CHANGE_STATUS.rejected) ||
+            (operation === exports.CHANGE_OPERATION.delete && status === exports.CHANGE_STATUS.accepted));
     }
     /**
      * Checks whether change attributes contain all TrackedAttrs keys with non-undefined values
@@ -283,10 +296,22 @@ class ChangeSet {
         if ('attrs' in attrs) {
             log.warn('passed "attrs" as property to isValidTrackedAttrs(attrs)', attrs);
         }
-        const trackedKeys = ['id', 'userID', 'operation', 'status', 'createdAt'];
-        const entries = Object.entries(attrs);
+        const trackedKeys = [
+            'id',
+            'authorID',
+            'operation',
+            'status',
+            'createdAt',
+            '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 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));
         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
         );
     }
@@ -296,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
  *
@@ -327,15 +432,17 @@ function deleteNode(node, pos, tr) {
     var _a;
     const startPos = tr.doc.resolve(pos + 1);
     const range = startPos.blockRange(tr.doc.resolve(startPos.pos - 2 + node.nodeSize));
-    const targetDepth = range && liftTarget(range);
-    // Check with typeof since with old prosemirror-transform targetDepth is undefined
+    const targetDepth = range && prosemirrorTransform.liftTarget(range);
+    // Check with typeof since with prosemirror-transform pre 1.6.0 targetDepth is undefined
     if (range && typeof targetDepth === 'number') {
         return tr.lift(range, targetDepth);
     }
     const resPos = tr.doc.resolve(pos);
-    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
+    // Block nodes can be deleted by just removing their start token which should then merge the text
+    // content to above node's content (if there is one)
+    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && node.isBlock && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
     if (canMergeToNodeAbove) {
-        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
+        return tr.replaceWith(pos - 1, pos + 1, prosemirrorModel.Fragment.empty);
     }
     else {
         // NOTE: there's an edge case where moving content is not possible but because the immediate
@@ -368,98 +475,22 @@ function deleteNode(node, pos, tr) {
  */
 function mergeNode(node, pos, tr) {
     var _a;
-    if (canJoin(tr.doc, pos)) {
+    if (prosemirrorTransform.canJoin(tr.doc, pos)) {
         return tr.join(pos);
     }
-    else if (canJoin(tr.doc, pos + node.nodeSize)) {
+    else if (prosemirrorTransform.canJoin(tr.doc, pos + node.nodeSize)) {
+        // TODO should copy the attributes from the merged node below
         return tr.join(pos + node.nodeSize);
     }
-    // TODO is this the same thing as join?
+    // TODO is this the same thing as join to above?
     const resPos = tr.doc.resolve(pos);
     const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
     if (canMergeToNodeAbove) {
-        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
+        return tr.replaceWith(pos - 1, pos + 1, prosemirrorModel.Fragment.empty);
     }
     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
-                ? CHANGE_OPERATION.insert
-                : 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.userID === right.userID);
-}
-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) {
@@ -497,9 +528,9 @@ function updateChangeChildrenAttributes(changes, tr, mapping) {
  * @param changes
  * @param deleteMap
  */
-function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
+function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prosemirrorTransform.Mapping()) {
     changes.forEach((change) => {
-        if (change.attrs.status === CHANGE_STATUS.pending) {
+        if (change.attrs.status === exports.CHANGE_STATUS.pending) {
             return;
         }
         // Map change.from and skip those which dont need to be applied
@@ -532,6 +563,16 @@ 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 === 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;
 }
@@ -573,6 +614,7 @@ function findChanges(state) {
                         type: 'text-change',
                         from: pos,
                         to: pos + node.nodeSize,
+                        text: node.text,
                         attrs,
                     },
                     node,
@@ -617,13 +659,15 @@ function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
     const iteratedIds = new Set();
     let changed = false;
     changeSet.invalidChanges.forEach((c) => {
-        const { id, userID, operation, status, createdAt } = c.attrs;
+        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.attrs;
         const newAttrs = {
             ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
-            ...(!userID && { userID: trackUserID }),
-            ...(!operation && { operation: CHANGE_OPERATION.insert }),
-            ...(!status && { status: CHANGE_STATUS.pending }),
+            ...(!authorID && { authorID: trackUserID }),
+            ...(!operation && { operation: exports.CHANGE_OPERATION.insert }),
+            ...(!reviewedByID && { reviewedByID: null }),
+            ...(!status && { status: exports.CHANGE_STATUS.pending }),
             ...(!createdAt && { createdAt: Date.now() }),
+            ...(!updatedAt && { updatedAt: Date.now() }),
         };
         if (Object.keys(newAttrs).length > 0) {
             updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
@@ -634,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 === 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),
-        }, 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 : 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: CHANGE_OPERATION.insert,
-    };
-}
-function createNewDeleteAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.delete,
-    };
-}
-
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -754,7 +717,7 @@ function getMergedNode(node, currentDepth, depth, first) {
         };
     }
     const result = [];
-    let merged = Fragment.empty;
+    let merged = prosemirrorModel.Fragment.empty;
     node.content.forEach((n, _, i) => {
         if ((first && i === 0) || (!first && i === node.childCount - 1)) {
             const { mergedNodeContent, unmergedContent } = getMergedNode(n, currentDepth + 1, depth, first);
@@ -769,7 +732,7 @@ function getMergedNode(node, currentDepth, depth, first) {
     });
     return {
         mergedNodeContent: merged,
-        unmergedContent: result.length > 0 ? Fragment.fromArray(result) : undefined,
+        unmergedContent: result.length > 0 ? prosemirrorModel.Fragment.fromArray(result) : undefined,
     };
 }
 /**
@@ -810,70 +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, 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 {
-        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 dataTracked = addTrackIdIfDoesntExist({
-            ...leftMarks,
-            ...rightMarks,
-            ...deleteAttrs,
+    else if (node.isBlock || node.isInline) {
+        const updatedChildren = [];
+        node.content.forEach((child) => {
+            updatedChildren.push(recurseNodeContent(child, newTrackAttrs, schema));
         });
-        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
-            dataTracked,
-        }));
-        return toEndOfMark;
-    }
-}
-/**
- * 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 = node.attrs.dataTracked;
-    const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === CHANGE_OPERATION.insert && dataTracked.userID === deleteAttrs.userID;
-    if (wasInsertedBySameUser) {
-        deleteNode(node, pos, newTr);
+        return node.type.create({
+            ...node.attrs,
+            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
+        }, prosemirrorModel.Fragment.fromArray(updatedChildren), node.marks);
     }
     else {
-        const attrs = {
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
-        };
-        newTr.setNodeMarkup(pos, undefined, attrs, node.marks);
+        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
+ *
+ * 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
  *
@@ -900,28 +897,39 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
  * @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 mergedInsertPos = undefined;
+    const deleteMap = new prosemirrorTransform.Mapping();
+    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);
         const offsetFrom = deleteMap.map(from, -1);
         const offsetTo = deleteMap.map(to, 1);
-        const wasWithinGap = gap && offsetPos >= deleteMap.map(gap.start, -1);
         const nodeEnd = offsetPos + 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).
+        // For them we can just check whether the start token is within the gap eg pos is 10 when gap (8, 18) to
+        // determine whether it should be skipped.
+        // For text nodes though, since they are continous, they might only partially be enclosed in the gap
+        // eg. pos 10 when gap is (8, 18) BUT if their nodeEnd goes past the gap's end eg nodeEnd 20 they actually
+        // 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];
-        // debugger
         // nodeEnd > offsetFrom -> delete touches this node
         // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
         //
@@ -976,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.
@@ -1006,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];
@@ -1021,10 +1034,10 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
     });
     return {
         deleteMap,
-        mergedInsertPos,
         newSliceContent: updatedSliceNodes
-            ? Fragment.fromArray(updatedSliceNodes)
+            ? prosemirrorModel.Fragment.fromArray(updatedSliceNodes)
             : insertSlice.content,
+        steps,
     };
 }
 
@@ -1047,18 +1060,20 @@ function mergeTrackedMarks(pos, doc, newTr, schema) {
     if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
         return;
     }
-    const leftAttrs = leftMark.attrs;
-    const rightAttrs = rightMark.attrs;
-    if (!shouldMergeTrackedAttributes(leftAttrs.dataTracked, rightAttrs.dataTracked)) {
+    const leftDataTracked = leftMark.attrs.dataTracked;
+    const rightDataTracked = rightMark.attrs.dataTracked;
+    if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
         return;
     }
-    const newAttrs = {
-        ...leftAttrs,
-        createdAt: Math.max(leftAttrs.createdAt || 0, rightAttrs.createdAt || 0) || Date.now(),
+    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
+    const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
+    const dataTracked = {
+        ...ancestorAttrs,
+        updatedAt: Date.now(),
     };
     const fromStartOfMark = pos - nodeBefore.nodeSize;
     const toEndOfMark = pos + nodeAfter.nodeSize;
-    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create(newAttrs));
+    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create({ ...leftMark.attrs, dataTracked }));
 }
 
 /*!
@@ -1106,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)) {
@@ -1122,27 +1139,25 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
         // the sides should be equal. TODO can they be other than 0?
         const openStart = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openStart;
         const openEnd = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openEnd;
-        let insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
+        let insertedSlice = new prosemirrorModel.Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
         if (gap.size > 0) {
             log.info('insertedSlice before inserted gap', insertedSlice);
             insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
             log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        const newStep = new 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;
 }
 
 /*!
@@ -1162,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;
@@ -1173,36 +1188,309 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
             log.error(`invert ReplaceStep failed: "${stepResult.failed}"`, newStep);
             return;
         }
+        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);
-        log.info('TR: new steps after applying delete', [...newTr.steps]);
-        const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : deleteMap.map(toA);
+        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]);
+        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 Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
-            const newStep = new 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];
 }
 
 /**
@@ -1226,15 +1514,16 @@ const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constr
  * @param tr Original transaction
  * @param oldState State before transaction
  * @param newTr Transaction created from the new editor state
- * @param userID User id
+ * @param authorID User id
  * @returns newTr that inverts the initial tr and applies track attributes/marks
  */
-function trackTransaction(tr, oldState, newTr, userID) {
-    var _a;
+function trackTransaction(tr, oldState, newTr, authorID) {
     const emptyAttrs = {
-        userID,
+        authorID,
+        reviewedByID: null,
         createdAt: tr.time,
-        status: CHANGE_STATUS.pending,
+        updatedAt: tr.time,
+        status: exports.CHANGE_STATUS.pending,
     };
     // Must use constructor.name instead of instanceof as aliasing prosemirror-state is a lot more
     // difficult than prosemirror-transform
@@ -1249,13 +1538,20 @@ function trackTransaction(tr, oldState, newTr, userID) {
                 'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
             return;
         }
-        else if (!(step instanceof ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+        else if (!(step instanceof prosemirrorTransform.ReplaceStep) && step.constructor.name === 'ReplaceStep') {
             console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
                 'or instanceof checks fail as well as creating new steps');
             return;
         }
-        else if (step instanceof ReplaceStep) {
-            const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+        else if (step instanceof prosemirrorTransform.ReplaceStep) {
+            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
@@ -1265,11 +1561,17 @@ function trackTransaction(tr, oldState, newTr, userID) {
                 newTr.setSelection(near);
             }
         }
-        else if (step instanceof ReplaceAroundStep) {
-            trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
-            // } else if (step instanceof AddMarkStep) {
-            // } else if (step instanceof RemoveMarkStep) {
+        else if (step instanceof prosemirrorTransform.ReplaceAroundStep) {
+            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.
@@ -1281,24 +1583,24 @@ function trackTransaction(tr, oldState, newTr, userID) {
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     });
     // This is kinda hacky solution at the moment to maintain NodeSelections over transactions
-    // These are required by at least cross-references that need it to activate the selector pop-up
+    // These are required by at least cross-references and links to activate their selector pop-ups
     if (wasNodeSelection) {
-        const mappedPos = newTr.mapping.map(tr.selection.from);
-        const resPos = newTr.doc.resolve(mappedPos);
-        const nodePos = mappedPos - (((_a = resPos.nodeBefore) === null || _a === void 0 ? void 0 : _a.nodeSize) || 0);
+        // And -1 here is necessary to keep the selection pointing at the start of the node
+        // (or something, breaks with cross-references otherwise)
+        const mappedPos = newTr.mapping.map(tr.selection.from, -1);
         const sel = getSelectionStaticConstructor(tr.selection);
-        newTr.setSelection(sel.create(newTr.doc, nodePos));
+        newTr.setSelection(sel.create(newTr.doc, mappedPos));
     }
     log.info('NEW transaction', newTr);
     return newTr;
 }
 
-var TrackChangesStatus;
+exports.TrackChangesStatus = void 0;
 (function (TrackChangesStatus) {
     TrackChangesStatus["enabled"] = "enabled";
     TrackChangesStatus["viewSnapshots"] = "view-snapshots";
     TrackChangesStatus["disabled"] = "disabled";
-})(TrackChangesStatus || (TrackChangesStatus = {}));
+})(exports.TrackChangesStatus || (exports.TrackChangesStatus = {}));
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -1315,12 +1617,7 @@ var TrackChangesStatus;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const trackChangesPluginKey = new PluginKey('track-changes');
-// TODO remove
-const infiniteLoopCounter = {
-    start: 0,
-    iters: 0,
-};
+const trackChangesPluginKey = new prosemirrorState.PluginKey('track-changes');
 /**
  * The ProseMirror plugin needed to enable track-changes.
  *
@@ -1333,18 +1630,18 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
     if (debug) {
         enableDebug(true);
     }
-    return new Plugin({
+    return new prosemirrorState.Plugin({
         key: trackChangesPluginKey,
         props: {
             editable(state) {
                 var _a;
-                return ((_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status) !== TrackChangesStatus.viewSnapshots;
+                return ((_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status) !== exports.TrackChangesStatus.viewSnapshots;
             },
         },
         state: {
             init(_config, state) {
                 return {
-                    status: TrackChangesStatus.enabled,
+                    status: exports.TrackChangesStatus.enabled,
                     userID,
                     changeSet: findChanges(state),
                 };
@@ -1362,7 +1659,7 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                         changeSet: findChanges(newState),
                     };
                 }
-                else if (pluginState.status === TrackChangesStatus.disabled) {
+                else if (pluginState.status === exports.TrackChangesStatus.disabled) {
                     return { ...pluginState, changeSet: new ChangeSet() };
                 }
                 let { changeSet, ...rest } = pluginState;
@@ -1386,18 +1683,10 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
         appendTransaction(trs, oldState, newState) {
             const pluginState = trackChangesPluginKey.getState(newState);
             if (!pluginState ||
-                pluginState.status === TrackChangesStatus.disabled ||
+                pluginState.status === exports.TrackChangesStatus.disabled ||
                 !(editorView === null || editorView === void 0 ? void 0 : editorView.editable)) {
                 return null;
             }
-            if (infiniteLoopCounter.start < Date.now() - 10000) {
-                infiniteLoopCounter.start = Date.now();
-                infiniteLoopCounter.iters = 0;
-            }
-            if (infiniteLoopCounter.iters >= 100) {
-                console.error('Detected probable infinite loop in track changes!');
-                return null;
-            }
             const { userID, changeSet } = pluginState;
             let createdTr = newState.tr, docChanged = false;
             log.info('TRS', trs);
@@ -1408,7 +1697,6 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                     (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
                 if (tr.docChanged && !skipMetaUsed && !skipTrackUsed && !tr.getMeta('history$')) {
                     createdTr = trackTransaction(tr, oldState, createdTr, userID);
-                    infiniteLoopCounter.iters += 1;
                 }
                 docChanged = docChanged || tr.docChanged;
                 const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
@@ -1417,7 +1705,7 @@ 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 }, oldState.schema);
+                            createdTr = updateChangeAttrs(createdTr, change, { status, reviewedByID: userID }, oldState.schema);
                             setAction(createdTr, TrackChangesAction.updateChanges, [change.id]);
                         }
                     });
@@ -1442,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'.
@@ -1473,9 +1746,9 @@ const setTrackingStatus = (status) => (state, dispatch) => {
         let newStatus = status;
         if (newStatus === undefined) {
             newStatus =
-                currentStatus === TrackChangesStatus.enabled
-                    ? TrackChangesStatus.disabled
-                    : TrackChangesStatus.enabled;
+                currentStatus === exports.TrackChangesStatus.enabled
+                    ? exports.TrackChangesStatus.disabled
+                    : exports.TrackChangesStatus.enabled;
         }
         dispatch && dispatch(setAction(state.tr, TrackChangesAction.setPluginStatus, newStatus));
         return true;
@@ -1544,4 +1817,9 @@ var commands = /*#__PURE__*/Object.freeze({
   setParagraphTestAttribute: setParagraphTestAttribute
 });
 
-export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesAction, TrackChangesStatus, enableDebug, getAction, setAction, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };
+exports.ChangeSet = ChangeSet;
+exports.enableDebug = enableDebug;
+exports.skipTracking = skipTracking;
+exports.trackChangesPlugin = trackChangesPlugin;
+exports.trackChangesPluginKey = trackChangesPluginKey;
+exports.trackCommands = commands;