@manuscripts/track-changes-plugin 0.0.4 → 0.3.0

package/dist/index.js

@@ -1,17 +1,9 @@
-'use strict';
+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';
 
-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);
-
-exports.TrackChangesAction = void 0;
+var TrackChangesAction;
 (function (TrackChangesAction) {
     TrackChangesAction["skipTrack"] = "track-changes-skip-tracking";
     TrackChangesAction["setUserID"] = "track-changes-set-user-id";
@@ -20,7 +12,7 @@ exports.TrackChangesAction = void 0;
     TrackChangesAction["updateChanges"] = "track-changes-update-changes";
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
-})(exports.TrackChangesAction || (exports.TrackChangesAction = {}));
+})(TrackChangesAction || (TrackChangesAction = {}));
 /**
  * Gets the value of a meta field, action payload, of a defined track-changes action.
  * @param tr
@@ -38,7 +30,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.
@@ -83,7 +82,7 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-exports.CHANGE_OPERATION = void 0;
+var CHANGE_OPERATION;
 (function (CHANGE_OPERATION) {
     CHANGE_OPERATION["insert"] = "insert";
     CHANGE_OPERATION["delete"] = "delete";
@@ -92,13 +91,13 @@ exports.CHANGE_OPERATION = void 0;
     CHANGE_OPERATION["unwrap_from_node"] = "unwrap_from_node";
     CHANGE_OPERATION["add_mark"] = "add_mark";
     CHANGE_OPERATION["remove_mark"] = "remove_mark";
-})(exports.CHANGE_OPERATION || (exports.CHANGE_OPERATION = {}));
-exports.CHANGE_STATUS = void 0;
+})(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
+var CHANGE_STATUS;
 (function (CHANGE_STATUS) {
     CHANGE_STATUS["accepted"] = "accepted";
     CHANGE_STATUS["rejected"] = "rejected";
     CHANGE_STATUS["pending"] = "pending";
-})(exports.CHANGE_STATUS || (exports.CHANGE_STATUS = {}));
+})(CHANGE_STATUS || (CHANGE_STATUS = {}));
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -115,7 +114,7 @@ exports.CHANGE_STATUS = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const logger = debug__default["default"]('track');
+const logger = debug('track');
 const log = {
     info(str, obj) {
         if (obj) {
@@ -148,10 +147,10 @@ const log = {
  */
 const enableDebug = (enabled) => {
     if (enabled) {
-        debug__default["default"].enable('track');
+        debug.enable('track');
     }
     else {
-        debug__default["default"].disable();
+        debug.disable();
     }
 };
 
@@ -211,13 +210,13 @@ class ChangeSet {
         return rootNodes;
     }
     get pending() {
-        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.pending);
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
     }
     get accepted() {
-        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.accepted);
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
     }
     get rejected() {
-        return this.changeTree.filter((c) => c.attrs.status === exports.CHANGE_STATUS.rejected);
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
     }
     get textChanges() {
         return this.changes.filter((c) => c.type === 'text-change');
@@ -271,8 +270,8 @@ class ChangeSet {
      */
     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 ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.accepted) ||
+            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.rejected));
     }
     /**
      * Determines whether a change should be deleted when applying it to the document.
@@ -280,8 +279,8 @@ class ChangeSet {
      */
     static shouldDeleteChange(change) {
         const { status, operation } = change.attrs;
-        return ((operation === exports.CHANGE_OPERATION.insert && status === exports.CHANGE_STATUS.rejected) ||
-            (operation === exports.CHANGE_OPERATION.delete && status === exports.CHANGE_STATUS.accepted));
+        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
+            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
     }
     /**
      * Checks whether change attributes contain all TrackedAttrs keys with non-undefined values
@@ -291,10 +290,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 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
         );
     }
@@ -335,14 +346,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 ? Number(prosemirrorTransform.liftTarget(range)) : NaN;
-    if (range && !Number.isNaN(targetDepth)) {
+    const targetDepth = range && 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, prosemirrorModel.Fragment.empty);
+        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
     }
     else {
         // NOTE: there's an edge case where moving content is not possible but because the immediate
@@ -375,17 +389,18 @@ function deleteNode(node, pos, tr) {
  */
 function mergeNode(node, pos, tr) {
     var _a;
-    if (prosemirrorTransform.canJoin(tr.doc, pos)) {
+    if (canJoin(tr.doc, pos)) {
         return tr.join(pos);
     }
-    else if (prosemirrorTransform.canJoin(tr.doc, pos + node.nodeSize)) {
+    else if (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, prosemirrorModel.Fragment.empty);
+        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
     }
     return undefined;
 }
@@ -429,8 +444,8 @@ function getInlineNodeTrackedMarkData(node, schema) {
     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;
+                ? CHANGE_OPERATION.insert
+                : CHANGE_OPERATION.delete;
             marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
         }
     });
@@ -460,7 +475,7 @@ function shouldMergeTrackedAttributes(left, right) {
     }
     return (left.status === right.status &&
         left.operation === right.operation &&
-        left.userID === right.userID);
+        left.authorID === right.authorID);
 }
 function getMergeableMarkTrackedAttrs(node, attrs, schema) {
     const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
@@ -504,16 +519,16 @@ function updateChangeChildrenAttributes(changes, tr, mapping) {
  * @param changes
  * @param deleteMap
  */
-function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prosemirrorTransform.Mapping()) {
+function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
     changes.forEach((change) => {
-        if (change.attrs.status === exports.CHANGE_STATUS.pending) {
+        if (change.attrs.status === CHANGE_STATUS.pending) {
             return;
         }
         // Map change.from and skip those which dont need to be applied
         // or were already deleted by an applied block delete
         const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || ChangeSet.shouldNotDelete(change);
         if (!node) {
-            log.warn('no node found to update for change', change);
+            !deleted && log.warn('no node found to update for change', change);
             return;
         }
         if (ChangeSet.isTextChange(change) && noChangeNeeded) {
@@ -580,6 +595,7 @@ function findChanges(state) {
                         type: 'text-change',
                         from: pos,
                         to: pos + node.nodeSize,
+                        text: node.text,
                         attrs,
                     },
                     node,
@@ -624,13 +640,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: exports.CHANGE_OPERATION.insert }),
-            ...(!status && { status: exports.CHANGE_STATUS.pending }),
+            ...(!authorID && { authorID: trackUserID }),
+            ...(!operation && { operation: CHANGE_OPERATION.insert }),
+            ...(!reviewedByID && { reviewedByID: null }),
+            ...(!status && { status: CHANGE_STATUS.pending }),
             ...(!createdAt && { createdAt: Date.now() }),
+            ...(!updatedAt && { updatedAt: Date.now() }),
         };
         if (Object.keys(newAttrs).length > 0) {
             updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
@@ -658,7 +676,7 @@ function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
  */
 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
+    const mark = newTrackAttrs.operation === CHANGE_OPERATION.insert
         ? schema.marks.tracked_insert
         : schema.marks.tracked_delete;
     const createdMark = mark.create({
@@ -678,7 +696,7 @@ function recurseNodeContent(node, newTrackAttrs, schema) {
         return node.type.create({
             ...node.attrs,
             dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-        }, prosemirrorModel.Fragment.fromArray(updatedChildren), node.marks);
+        }, Fragment.fromArray(updatedChildren), node.marks);
     }
     else {
         log.error(`unhandled node type: "${node.type.name}"`, node);
@@ -691,7 +709,7 @@ function setFragmentAsInserted(inserted, insertAttrs, schema) {
     inserted.forEach((n) => {
         updatedInserted.push(recurseNodeContent(n, insertAttrs, schema));
     });
-    return updatedInserted.length === 0 ? inserted : prosemirrorModel.Fragment.fromArray(updatedInserted);
+    return updatedInserted.length === 0 ? inserted : Fragment.fromArray(updatedInserted);
 }
 
 /*!
@@ -712,13 +730,13 @@ function setFragmentAsInserted(inserted, insertAttrs, schema) {
 function createNewInsertAttrs(attrs) {
     return {
         ...attrs,
-        operation: exports.CHANGE_OPERATION.insert,
+        operation: CHANGE_OPERATION.insert,
     };
 }
 function createNewDeleteAttrs(attrs) {
     return {
         ...attrs,
-        operation: exports.CHANGE_OPERATION.delete,
+        operation: CHANGE_OPERATION.delete,
     };
 }
 
@@ -761,7 +779,7 @@ function getMergedNode(node, currentDepth, depth, first) {
         };
     }
     const result = [];
-    let merged = prosemirrorModel.Fragment.empty;
+    let merged = 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);
@@ -776,7 +794,7 @@ function getMergedNode(node, currentDepth, depth, first) {
     });
     return {
         mergedNodeContent: merged,
-        unmergedContent: result.length > 0 ? prosemirrorModel.Fragment.fromArray(result) : undefined,
+        unmergedContent: result.length > 0 ? Fragment.fromArray(result) : undefined,
     };
 }
 /**
@@ -839,7 +857,7 @@ function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
         // 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);
+        newTr.replaceWith(start, end, Fragment.empty);
         return start;
     }
     else {
@@ -849,10 +867,12 @@ function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
         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,
@@ -869,7 +889,8 @@ function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
  */
 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.userID === deleteAttrs.userID;
+    const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === CHANGE_OPERATION.insert &&
+        dataTracked.authorID === deleteAttrs.authorID;
     if (wasInsertedBySameUser) {
         deleteNode(node, pos, newTr);
     }
@@ -907,7 +928,7 @@ 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 prosemirrorTransform.Mapping();
+    const deleteMap = new Mapping();
     const mergedInsertPos = undefined;
     // No deletion applied, return default values
     if (from === to) {
@@ -925,10 +946,22 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         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
         //
@@ -937,6 +970,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         // But from what I remember what it safeguards against is, when you've already deleted a node
         // say an inserted blockquote that had all its children deleted, nodesBetween still iterates over those
         // nodes and therefore we have to make this check to ensure they still exist in the doc.
+        //
         if (nodeEnd > offsetFrom && !nodeWasDeleted && !wasWithinGap) {
             // |<p>asdf</p>| -> node deleted completely
             const nodeCompletelyDeleted = offsetPos >= offsetFrom && nodeEnd <= offsetTo;
@@ -1029,7 +1063,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         deleteMap,
         mergedInsertPos,
         newSliceContent: updatedSliceNodes
-            ? prosemirrorModel.Fragment.fromArray(updatedSliceNodes)
+            ? Fragment.fromArray(updatedSliceNodes)
             : insertSlice.content,
     };
 }
@@ -1053,18 +1087,21 @@ 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 || Number.MAX_VALUE) <
+        (rightDataTracked.createdAt || Number.MAX_VALUE);
+    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 }));
 }
 
 /*!
@@ -1128,13 +1165,13 @@ 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 prosemirrorModel.Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
+        let insertedSlice = new 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 prosemirrorTransform.ReplaceStep(deleteMap.map(gapFrom), deleteMap.map(gapTo), insertedSlice, false);
+        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);
@@ -1179,10 +1216,11 @@ 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]);
+        log.info('TR: steps after applying delete', [...newTr.steps]);
         const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : deleteMap.map(toA);
         if (newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
@@ -1190,8 +1228,8 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
             // 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);
+            const insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
+            const newStep = new ReplaceStep(adjustedInsertPos, adjustedInsertPos, insertedSlice);
             const stepResult = newTr.maybeStep(newStep);
             if (stepResult.failed) {
                 log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
@@ -1217,11 +1255,9 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
  * This skips the direct dependency to prosemirror-state where multiple versions might cause conflicts
  * as the created instances might belong to different prosemirror-state import than one used in the editor.
  * @param sel
- * @param doc
- * @param from
  * @returns
  */
-const getSelectionStaticCreate = (sel, doc, from) => Object.getPrototypeOf(sel).constructor.create(doc, from);
+const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
 /**
  * Inverts transactions to wrap their contents/operations with track data instead
  *
@@ -1234,15 +1270,16 @@ const getSelectionStaticCreate = (sel, doc, from) => Object.getPrototypeOf(sel).
  * @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: exports.CHANGE_STATUS.pending,
+        updatedAt: tr.time,
+        status: CHANGE_STATUS.pending,
     };
     // Must use constructor.name instead of instanceof as aliasing prosemirror-state is a lot more
     // difficult than prosemirror-transform
@@ -1257,45 +1294,56 @@ 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 prosemirrorTransform.ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+        else if (!(step instanceof 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 prosemirrorTransform.ReplaceStep) {
+        else if (step instanceof ReplaceStep) {
             const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
             if (!wasNodeSelection) {
-                newTr.setSelection(getSelectionStaticCreate(tr.selection, newTr.doc, selectionPos));
+                const sel = getSelectionStaticConstructor(tr.selection);
+                // Use Selection.near to fix selections that point to a block node instead of inline content
+                // eg when inserting a complete new paragraph. -1 finds the first valid position moving backwards
+                // inside the content
+                const near = sel.near(newTr.doc.resolve(selectionPos), -1);
+                newTr.setSelection(near);
             }
         }
-        else if (step instanceof prosemirrorTransform.ReplaceAroundStep) {
+        else if (step instanceof ReplaceAroundStep) {
             trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
             // } 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.
         // The old meta keys are not copied to the new transaction since this will cause race-conditions
-        // when a single meta-field is thought to be processed. MAYBE only the generic meta keys, such as
-        // inputType or uiEvent, could be copied over but it remains to be seen if it's necessary.
-        // Object.keys(meta).forEach((key) => newTr.setMeta(key, tr.getMeta(key)))
+        // when a single meta-field is expected to having been processed / removed. Generic input meta keys,
+        // inputType and uiEvent, are re-added since some plugins might depend on them and process the transaction
+        // after track-changes plugin.
+        tr.getMeta('inputType') && newTr.setMeta('inputType', tr.getMeta('inputType'));
+        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);
-        newTr.setSelection(getSelectionStaticCreate(tr.selection, newTr.doc, nodePos));
+        // 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, mappedPos));
     }
     log.info('NEW transaction', newTr);
     return newTr;
 }
 
-exports.TrackChangesStatus = void 0;
+var TrackChangesStatus;
 (function (TrackChangesStatus) {
     TrackChangesStatus["enabled"] = "enabled";
     TrackChangesStatus["viewSnapshots"] = "view-snapshots";
     TrackChangesStatus["disabled"] = "disabled";
-})(exports.TrackChangesStatus || (exports.TrackChangesStatus = {}));
+})(TrackChangesStatus || (TrackChangesStatus = {}));
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -1312,12 +1360,7 @@ exports.TrackChangesStatus = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const trackChangesPluginKey = new prosemirrorState.PluginKey('track-changes');
-// TODO remove
-const infiniteLoopCounter = {
-    start: 0,
-    iters: 0,
-};
+const trackChangesPluginKey = new PluginKey('track-changes');
 /**
  * The ProseMirror plugin needed to enable track-changes.
  *
@@ -1330,24 +1373,25 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
     if (debug) {
         enableDebug(true);
     }
-    return new prosemirrorState.Plugin({
+    return new Plugin({
         key: trackChangesPluginKey,
         props: {
             editable(state) {
-                return this.getState(state).status !== exports.TrackChangesStatus.viewSnapshots;
+                var _a;
+                return ((_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status) !== TrackChangesStatus.viewSnapshots;
             },
         },
         state: {
             init(_config, state) {
                 return {
-                    status: exports.TrackChangesStatus.enabled,
+                    status: TrackChangesStatus.enabled,
                     userID,
                     changeSet: findChanges(state),
                 };
             },
             apply(tr, pluginState, _oldState, newState) {
-                const setUserID = getAction(tr, exports.TrackChangesAction.setUserID);
-                const setStatus = getAction(tr, exports.TrackChangesAction.setPluginStatus);
+                const setUserID = getAction(tr, TrackChangesAction.setUserID);
+                const setStatus = getAction(tr, TrackChangesAction.setPluginStatus);
                 if (setUserID) {
                     return { ...pluginState, userID: setUserID };
                 }
@@ -1358,12 +1402,12 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                         changeSet: findChanges(newState),
                     };
                 }
-                else if (pluginState.status === exports.TrackChangesStatus.disabled) {
+                else if (pluginState.status === TrackChangesStatus.disabled) {
                     return { ...pluginState, changeSet: new ChangeSet() };
                 }
                 let { changeSet, ...rest } = pluginState;
-                const updatedChangeIds = getAction(tr, exports.TrackChangesAction.updateChanges);
-                if (updatedChangeIds || getAction(tr, exports.TrackChangesAction.refreshChanges)) {
+                const updatedChangeIds = getAction(tr, TrackChangesAction.updateChanges);
+                if (updatedChangeIds || getAction(tr, TrackChangesAction.refreshChanges)) {
                     changeSet = findChanges(newState);
                 }
                 return {
@@ -1382,47 +1426,37 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
         appendTransaction(trs, oldState, newState) {
             const pluginState = trackChangesPluginKey.getState(newState);
             if (!pluginState ||
-                pluginState.status === exports.TrackChangesStatus.disabled ||
+                pluginState.status === 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);
             trs.forEach((tr) => {
                 const wasAppended = tr.getMeta('appendedTransaction');
                 const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
-                const skipTrackUsed = getAction(tr, exports.TrackChangesAction.skipTrack) ||
-                    (wasAppended && getAction(wasAppended, exports.TrackChangesAction.skipTrack));
+                const skipTrackUsed = getAction(tr, TrackChangesAction.skipTrack) ||
+                    (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
                 if (tr.docChanged && !skipMetaUsed && !skipTrackUsed && !tr.getMeta('history$')) {
                     createdTr = trackTransaction(tr, oldState, createdTr, userID);
-                    createdTr.setMeta('origin', trackChangesPluginKey);
-                    infiniteLoopCounter.iters += 1;
                 }
                 docChanged = docChanged || tr.docChanged;
-                const setChangeStatuses = getAction(tr, exports.TrackChangesAction.setChangeStatuses);
+                const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
                 if (setChangeStatuses) {
                     const { status, ids } = setChangeStatuses;
                     ids.forEach((changeId) => {
                         const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
                         if (change) {
-                            createdTr = updateChangeAttrs(createdTr, change, { status }, oldState.schema);
-                            setAction(createdTr, exports.TrackChangesAction.updateChanges, [change.id]);
+                            createdTr = updateChangeAttrs(createdTr, change, { status, reviewedByID: userID }, oldState.schema);
+                            setAction(createdTr, TrackChangesAction.updateChanges, [change.id]);
                         }
                     });
                 }
-                else if (getAction(tr, exports.TrackChangesAction.applyAndRemoveChanges)) {
+                else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
                     const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);
                     applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.textChanges, mapping);
-                    setAction(createdTr, exports.TrackChangesAction.refreshChanges, true);
+                    setAction(createdTr, TrackChangesAction.refreshChanges, true);
                 }
             });
             const changed = pluginState.changeSet.hasInconsistentData &&
@@ -1431,7 +1465,8 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                 log.warn('had to fix inconsistent changes in', createdTr);
             }
             if (docChanged || createdTr.docChanged || changed) {
-                return setAction(createdTr, exports.TrackChangesAction.refreshChanges, true);
+                createdTr.setMeta('origin', trackChangesPluginKey);
+                return setAction(createdTr, TrackChangesAction.refreshChanges, true);
             }
             return null;
         },
@@ -1469,11 +1504,11 @@ const setTrackingStatus = (status) => (state, dispatch) => {
         let newStatus = status;
         if (newStatus === undefined) {
             newStatus =
-                currentStatus === exports.TrackChangesStatus.enabled
-                    ? exports.TrackChangesStatus.disabled
-                    : exports.TrackChangesStatus.enabled;
+                currentStatus === TrackChangesStatus.enabled
+                    ? TrackChangesStatus.disabled
+                    : TrackChangesStatus.enabled;
         }
-        dispatch && dispatch(setAction(state.tr, exports.TrackChangesAction.setPluginStatus, newStatus));
+        dispatch && dispatch(setAction(state.tr, TrackChangesAction.setPluginStatus, newStatus));
         return true;
     }
     return false;
@@ -1485,7 +1520,7 @@ const setTrackingStatus = (status) => (state, dispatch) => {
  */
 const setChangeStatuses = (status, ids) => (state, dispatch) => {
     dispatch &&
-        dispatch(setAction(state.tr, exports.TrackChangesAction.setChangeStatuses, {
+        dispatch(setAction(state.tr, TrackChangesAction.setChangeStatuses, {
             status,
             ids,
         }));
@@ -1496,21 +1531,21 @@ const setChangeStatuses = (status, ids) => (state, dispatch) => {
  * @param userID
  */
 const setUserID = (userID) => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, exports.TrackChangesAction.setUserID, userID));
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.setUserID, userID));
     return true;
 };
 /**
  * Appends a transaction that applies all 'accepted' and 'rejected' changes to the document.
  */
 const applyAndRemoveChanges = () => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, exports.TrackChangesAction.applyAndRemoveChanges, true));
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.applyAndRemoveChanges, true));
     return true;
 };
 /**
  * Runs `findChanges` to iterate over the document to collect changes into a new ChangeSet.
  */
 const refreshChanges = () => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, exports.TrackChangesAction.updateChanges, []));
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.updateChanges, []));
     return true;
 };
 /**
@@ -1540,10 +1575,4 @@ var commands = /*#__PURE__*/Object.freeze({
   setParagraphTestAttribute: setParagraphTestAttribute
 });
 
-exports.ChangeSet = ChangeSet;
-exports.enableDebug = enableDebug;
-exports.getAction = getAction;
-exports.setAction = setAction;
-exports.trackChangesPlugin = trackChangesPlugin;
-exports.trackChangesPluginKey = trackChangesPluginKey;
-exports.trackCommands = commands;
+export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesStatus, enableDebug, skipTracking, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };