@manuscripts/track-changes-plugin 2.0.12 → 2.1.0

package/README.md

@@ -17,8 +17,8 @@ ProseMirror plugin designed to track changes within a document, similar to the t
   Transactions are intercepted and reverted using default plugins lifecycle, unless transaction has meta commanding to skip tracking.
 
 - Annotate changes with metadata using node attributes and marks.
-  Before transaction is reverted the changes in each step of transaction are processed and created metadata that described the changes are stored in the dataTracked attributes. For text changes, dataTracked attributes are added to marks,
-  with which the inline change is marked on the document. For node changes the dataTracked metadata are assigned to nodes.
+  Before transaction is reverted the changes in each step of transaction are processed and metadata are created that describe the changes stored in the dataTracked attributes. For text changes, dataTracked attributes are added to marks,
+  with which the inline change is marked on the document. For node changes the dataTracked metadata are assigned to nodes via attributes.
 
 - ChangeSet class handles changes interpretation to create a more meaningful representation:
   - Creates a list of top level changes out of a list of nested changed.
@@ -48,7 +48,7 @@ Nodes that change are extended with dataTracked attributes:
 
 ## Requirements
 
-Node schema needs to have { dataTracked: null } attribute declared. Otherwise the node will not be tracked.
+Node or mark schema needs to have { dataTracked: null } attribute declared. Otherwise the node will not be tracked. Plugin also expects schema to support marks for highlighting current changes.
 
 ## Best practices and caveats
 

package/dist/cjs/ChangeSet.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChangeSet = void 0;
 const change_1 = require("./types/change");
 const logger_1 = require("./utils/logger");
+const track_utils_1 = require("./utils/track-utils");
 class ChangeSet {
     constructor(changes = []) {
         _ChangeSet_instances.add(this);
@@ -150,19 +151,34 @@ class ChangeSet {
             }
         }
     }
+    areMatchingWrapOperations(c1, c2) {
+        const op1 = c1.dataTracked.operation;
+        const op2 = c2.dataTracked.operation;
+        return ((op1 === 'wrap_with_node' && (op2 === 'insert' || op2 === 'set_attrs')) ||
+            (op2 === 'wrap_with_node' && (op1 === 'insert' || op1 === 'set_attrs')));
+    }
+    areMatchingMarkOperations(c1, c2) {
+        if (ChangeSet.isMarkChange(c1) && ChangeSet.isMarkChange(c2)) {
+            const op1 = c1.dataTracked.operation;
+            const op2 = c2.dataTracked.operation;
+            if (op1 == op2 && c1.mark.type === c2.mark.type) {
+                return true;
+            }
+        }
+        return false;
+    }
     canJoinAdjacentInlineChanges(change, index) {
         const nextChange = this.changeTree.at(index + 1);
-        const isInline = (c) => c.type === 'text-change' || (c.type === 'node-change' && c.node.isInline);
-        const hasMatchingOperation = (c1, c2) => c1.dataTracked.operation === c2.dataTracked.operation ||
-            (c1.dataTracked.operation === 'wrap_with_node' &&
-                (c2.dataTracked.operation === 'insert' || c2.dataTracked.operation === 'set_attrs')) ||
-            (c2.dataTracked.operation === 'wrap_with_node' &&
-                (c1.dataTracked.operation === 'insert' || c1.dataTracked.operation === 'set_attrs'));
+        if (!nextChange) {
+            return false;
+        }
+        const isInline = (c) => c.type === 'text-change' || (c.type === 'node-change' && c.node.isInline) || (0, track_utils_1.isInlineMarkChange)(c);
         return (isInline(change) &&
-            nextChange &&
             isInline(nextChange) &&
             change.to === nextChange.from &&
-            hasMatchingOperation(change, nextChange));
+            (change.dataTracked.operation === nextChange.dataTracked.operation ||
+                this.areMatchingWrapOperations(change, nextChange) ||
+                this.areMatchingMarkOperations(change, nextChange)));
     }
     joinRelatedStructuralChanges(rootNodes, change) {
         if (change.dataTracked.operation !== change_1.CHANGE_OPERATION.structure) {
@@ -213,6 +229,9 @@ class ChangeSet {
     static isTextChange(change) {
         return change.type === 'text-change';
     }
+    static isMarkChange(change) {
+        return change.type === 'mark-change';
+    }
     static isNodeChange(change) {
         return change.type === 'node-change';
     }

package/dist/cjs/changes/applyChanges.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUpdatedDataTracked = getUpdatedDataTracked;
 exports.applyAcceptedRejectedChanges = applyAcceptedRejectedChanges;
 const prosemirror_transform_1 = require("prosemirror-transform");
 const ChangeSet_1 = require("../ChangeSet");
@@ -8,6 +7,7 @@ const deleteNode_1 = require("../mutate/deleteNode");
 const mergeNode_1 = require("../mutate/mergeNode");
 const change_1 = require("../types/change");
 const logger_1 = require("../utils/logger");
+const track_utils_1 = require("../utils/track-utils");
 const revertChange_1 = require("./revertChange");
 const updateChangeAttrs_1 = require("./updateChangeAttrs");
 function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
@@ -25,13 +25,6 @@ function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
     });
     return moveNodeIds;
 }
-function getUpdatedDataTracked(dataTracked, changeId) {
-    if (!dataTracked) {
-        return null;
-    }
-    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
-    return newDataTracked.length ? newDataTracked : null;
-}
 function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap = new prosemirror_transform_1.Mapping()) {
     changes.sort((c1, c2) => {
         if ((c1.type === 'node-change' && c1.node.type === schema.nodes.list) ||
@@ -75,7 +68,7 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet_1.ChangeSet.isNodeChange(change) && noChangeNeeded) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: (0, deleteNode_1.keepDeleteWithMoveNodeId)(node) });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: (0, deleteNode_1.keepPairedChanges)(node) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             if (node.isAtom) {
                 tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
@@ -91,13 +84,34 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet_1.ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === change_1.CHANGE_STATUS.accepted) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.newAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.newAttrs), { dataTracked: (0, track_utils_1.excludeFromTracked)(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (ChangeSet_1.ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === change_1.CHANGE_STATUS.rejected) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.oldAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.oldAttrs), { dataTracked: (0, track_utils_1.excludeFromTracked)(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (ChangeSet_1.ChangeSet.isReferenceChange(change)) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: (0, track_utils_1.excludeFromTracked)(node.attrs.dataTracked, change.id) }), node.marks);
+        }
+        else if (ChangeSet_1.ChangeSet.isMarkChange(change)) {
+            const newMark = change.mark.type.create({
+                dataTracked: (0, track_utils_1.excludeFromTracked)(change.mark.attrs.dataTracked, change.id),
+            });
+            const isInsert = change.dataTracked.operation === change_1.CHANGE_OPERATION.insert;
+            const isDelete = change.dataTracked.operation === change_1.CHANGE_OPERATION.delete;
+            const toBeRestored = (change.dataTracked.status === change_1.CHANGE_STATUS.accepted && isInsert) ||
+                (change.dataTracked.status === change_1.CHANGE_STATUS.rejected && isDelete);
+            if ((0, track_utils_1.isInlineMarkChange)(change)) {
+                tr.removeMark(change.from, change.to, change.mark);
+                if (toBeRestored) {
+                    tr.addMark(change.from, change.to, newMark);
+                }
+            }
+            else {
+                tr.removeNodeMark(change.from, change.mark);
+                if (toBeRestored) {
+                    tr.addNodeMark(change.from, newMark);
+                }
+            }
         }
     });
     changes.forEach((change) => {
@@ -114,7 +128,7 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
             return;
         }
         if (change.dataTracked.status === change_1.CHANGE_STATUS.accepted) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: (0, track_utils_1.excludeFromTracked)(node.attrs.dataTracked, change.id) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             const originalChanges = changeSet.changes.filter((c) => c.dataTracked.moveNodeId === change.dataTracked.moveNodeId &&
                 c.dataTracked.operation === change_1.CHANGE_OPERATION.delete);

package/dist/cjs/changes/findChanges.js

@@ -9,6 +9,22 @@ function findChanges(state) {
     let current;
     state.doc.descendants((node, pos) => {
         const tracked = (0, nodeHelpers_1.getNodeTrackedData)(node, state.schema) || [];
+        const marksWithTrackChanges = (0, nodeHelpers_1.getMarkTrackedData)(node);
+        marksWithTrackChanges === null || marksWithTrackChanges === void 0 ? void 0 : marksWithTrackChanges.forEach((trackAttrs, mark) => {
+            trackAttrs.forEach((c) => {
+                const ch = {
+                    id: c.id,
+                    type: 'mark-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked: Object.assign({}, c),
+                    nodeType: node.type,
+                    node: node,
+                    mark: mark,
+                };
+                changes.push(ch);
+            });
+        });
         for (let i = 0; i < tracked.length; i += 1) {
             const dataTracked = tracked[i];
             const id = dataTracked.id || '';

package/dist/cjs/changes/revertChange.js

@@ -5,7 +5,7 @@ exports.revertWrapNodeChange = revertWrapNodeChange;
 const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_transform_1 = require("prosemirror-transform");
 const nodeHelpers_1 = require("../compute/nodeHelpers");
-const applyChanges_1 = require("./applyChanges");
+const track_utils_1 = require("../utils/track-utils");
 function revertSplitNodeChange(tr, change, changeSet) {
     const sourceChange = changeSet.changes.find((c) => c.dataTracked.operation === 'reference' && c.dataTracked.referenceId === change.id);
     const node = tr.doc.nodeAt(tr.mapping.map(change.from));
@@ -24,7 +24,7 @@ function revertSplitNodeChange(tr, change, changeSet) {
     const deleteChange = changeSet.changes.find((c) => c.dataTracked.operation == 'delete' && c.from === sourceChange.from);
     if (deleteChange) {
         const node = tr.doc.nodeAt(tr.mapping.map(deleteChange.from));
-        tr.setNodeMarkup(tr.mapping.map(deleteChange.from), undefined, (0, applyChanges_1.getUpdatedDataTracked)(node.attrs.dataTracked, deleteChange.id));
+        tr.setNodeMarkup(tr.mapping.map(deleteChange.from), undefined, (0, track_utils_1.excludeFromTracked)(node.attrs.dataTracked, deleteChange.id));
     }
 }
 function revertWrapNodeChange(tr, change, deleteMap) {

package/dist/cjs/changes/updateChangeAttrs.js

@@ -7,6 +7,7 @@ const ChangeSet_1 = require("../ChangeSet");
 const nodeHelpers_1 = require("../compute/nodeHelpers");
 const change_1 = require("../types/change");
 const logger_1 = require("../utils/logger");
+const track_utils_1 = require("../utils/track-utils");
 function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
@@ -69,6 +70,32 @@ function updateChangeAttrs(tr, change, trackedAttrs, schema) {
             .filter(Boolean);
         tr.setNodeMarkup(change.from, undefined, Object.assign(Object.assign({}, (restoredAttrs || node.attrs)), { dataTracked: newDataTracked.length === 0 ? null : newDataTracked }), node.marks);
     }
+    else if (change.type === 'mark-change') {
+        const markChange = change;
+        if (markChange.mark && markChange.from && markChange.to) {
+            const markDataTracked = Array.isArray(markChange.mark.attrs.dataTracked)
+                ? markChange.mark.attrs.dataTracked
+                : [];
+            const newDT = markDataTracked === null || markDataTracked === void 0 ? void 0 : markDataTracked.map((dt) => {
+                if (dt.createdAt === change.dataTracked.createdAt && dt.operation === change.dataTracked.operation) {
+                    return Object.assign(Object.assign({}, dt), trackedAttrs);
+                }
+                return dt;
+            });
+            const newMark = markChange.mark.type.create(Object.assign(Object.assign({}, markChange.mark.attrs), { dataTracked: newDT }));
+            if ((0, track_utils_1.isInlineMarkChange)(markChange)) {
+                tr.removeMark(markChange.from, markChange.to, markChange.mark);
+                tr.addMark(markChange.from, markChange.to, newMark);
+            }
+            else {
+                tr.removeNodeMark(markChange.from, markChange.mark);
+                tr.addNodeMark(markChange.from, newMark);
+            }
+        }
+        else {
+            console.warn('Unable to update a mark change because the mark change data are incomplete');
+        }
+    }
     return tr;
 }
 function updateChangeChildrenAttributes(changes, tr, mapping) {

package/dist/cjs/compute/nodeHelpers.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addTrackIdIfDoesntExist = addTrackIdIfDoesntExist;
 exports.getTextNodeTrackedMarkData = getTextNodeTrackedMarkData;
 exports.getBlockInlineTrackedData = getBlockInlineTrackedData;
+exports.getMarkTrackedData = getMarkTrackedData;
 exports.getNodeTrackedData = getNodeTrackedData;
 exports.equalMarks = equalMarks;
 exports.shouldMergeTrackedAttributes = shouldMergeTrackedAttributes;
 exports.getMergeableMarkTrackedAttrs = getMergeableMarkTrackedAttrs;
 const change_1 = require("../types/change");
 const logger_1 = require("../utils/logger");
+const track_utils_1 = require("../utils/track-utils");
 const uuidv4_1 = require("../utils/uuidv4");
 function addTrackIdIfDoesntExist(attrs) {
     if (!attrs.id) {
@@ -39,6 +41,15 @@ function getBlockInlineTrackedData(node) {
     }
     return dataTracked || [];
 }
+function getMarkTrackedData(node) {
+    const tracked = node === null || node === void 0 ? void 0 : node.marks.reduce((acc, current) => {
+        if ((0, track_utils_1.isValidTrackableMark)(current) && current.attrs.dataTracked) {
+            acc.set(current, current.attrs.dataTracked);
+        }
+        return acc;
+    }, new Map());
+    return tracked || new Map();
+}
 function getNodeTrackedData(node, schema) {
     let tracked;
     if (node && !node.isText) {

package/dist/cjs/mutate/deleteAndMergeSplitNodes.js

@@ -37,6 +37,7 @@ exports.deleteAndMergeSplitNodes = deleteAndMergeSplitNodes;
 const prosemirror_model_1 = require("prosemirror-model");
 const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
 const splitSliceIntoMergedParts_1 = require("../compute/splitSliceIntoMergedParts");
+const utils_1 = require("../steps/utils");
 const trackUtils = __importStar(require("../utils/track-utils"));
 function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
     const steps = [];
@@ -69,7 +70,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent;
                 const mergeEndNodeNotEmpty = mergeEndNode && mergeContent.size;
                 if (mergeEndNode && !mergeEndNodeNotEmpty && gap) {
-                    if (trackUtils.stepIsLift(gap, node, to)) {
+                    if ((0, utils_1.stepIsLift)(gap, node, to)) {
                         gap.slice.content.forEach((node, offset) => {
                             steps.push({
                                 type: 'delete-node',

package/dist/cjs/mutate/deleteNode.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keepDeleteWithMoveNodeId = void 0;
+exports.keepPairedChanges = void 0;
 exports.deleteNode = deleteNode;
 exports.deleteOrSetNodeDeleted = deleteOrSetNodeDeleted;
 const prosemirror_model_1 = require("prosemirror-model");
@@ -49,9 +49,9 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
         (0, dropStructureChange_1.dropStructuralChangeShadow)(structure.moveNodeId, newTr);
     }
 }
-const keepDeleteWithMoveNodeId = (node) => {
+const keepPairedChanges = (node) => {
     var _a;
-    const dataTracked = (_a = (0, nodeHelpers_1.getBlockInlineTrackedData)(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => c.operation === change_1.CHANGE_OPERATION.delete && c.moveNodeId);
+    const dataTracked = (_a = (0, nodeHelpers_1.getBlockInlineTrackedData)(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => (c.operation === change_1.CHANGE_OPERATION.delete && c.moveNodeId) || c.operation === change_1.CHANGE_OPERATION.reference);
     return (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.length) ? dataTracked : null;
 };
-exports.keepDeleteWithMoveNodeId = keepDeleteWithMoveNodeId;
+exports.keepPairedChanges = keepPairedChanges;

package/dist/cjs/mutate/dropStructureChange.js

@@ -34,9 +34,10 @@ const dropStructuralChangeShadow = (moveNodeId, tr) => {
     return tr;
 };
 exports.dropStructuralChangeShadow = dropStructuralChangeShadow;
-const dropOrphanChanges = (newTr, dropDataTracked) => {
+const dropOrphanChanges = (newTr) => {
     const changeSet = (0, findChanges_1.findChanges)(prosemirror_state_1.EditorState.create({ doc: newTr.doc }));
     const shadowIds = new Set();
+    const referenceIds = new Set();
     const changesIds = new Set();
     changeSet.changes.forEach((c) => {
         if (c.dataTracked.moveNodeId && c.dataTracked.operation === change_1.CHANGE_OPERATION.delete) {
@@ -46,14 +47,38 @@ const dropOrphanChanges = (newTr, dropDataTracked) => {
             c.dataTracked.operation === change_1.CHANGE_OPERATION.move) {
             changesIds.add(c.dataTracked.moveNodeId);
         }
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.node_split) {
+            changesIds.add(c.dataTracked.id);
+        }
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.reference) {
+            referenceIds.add(c.dataTracked.referenceId);
+        }
     });
-    if (!shadowIds.size && !changesIds.size) {
+    if (!shadowIds.size && !referenceIds.size && !changesIds.size) {
         return;
     }
     changeSet.changes.forEach((c) => {
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.reference &&
+            !changesIds.has(c.dataTracked.referenceId)) {
+            const node = newTr.doc.nodeAt(c.from);
+            const dataTracked = node && ((0, nodeHelpers_1.getBlockInlineTrackedData)(node) || []).filter((d) => d.id !== c.id);
+            newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked }));
+        }
+        if (c.type === 'node-change' &&
+            c.dataTracked.operation === change_1.CHANGE_OPERATION.node_split &&
+            !referenceIds.has(c.id)) {
+            const _a = c.dataTracked, { id } = _a, attrs = __rest(_a, ["id"]);
+            newTr.replaceWith(c.from, c.to, (0, setFragmentAsInserted_1.setFragmentAsInserted)(prosemirror_model_1.Fragment.from(c.node), (0, track_utils_1.createNewInsertAttrs)(attrs), newTr.doc.type.schema));
+            const referenceChanges = ((0, nodeHelpers_1.getBlockInlineTrackedData)(c.node) || []).filter((d) => d.operation === change_1.CHANGE_OPERATION.reference);
+            if (referenceChanges.length) {
+                const node = newTr.doc.nodeAt(c.from);
+                const dataTracked = (node && (0, nodeHelpers_1.getBlockInlineTrackedData)(node)) || [];
+                newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked: [...dataTracked, ...referenceChanges] }));
+            }
+        }
         if (c.dataTracked.moveNodeId &&
             !(shadowIds.has(c.dataTracked.moveNodeId) && changesIds.has(c.dataTracked.moveNodeId))) {
-            if (c.dataTracked.operation === change_1.CHANGE_OPERATION.delete || dropDataTracked) {
+            if (c.dataTracked.operation === change_1.CHANGE_OPERATION.delete) {
                 if (c.type === 'text-change') {
                     newTr.removeMark(c.from, c.to, newTr.doc.type.schema.marks.tracked_delete);
                 }
@@ -62,7 +87,7 @@ const dropOrphanChanges = (newTr, dropDataTracked) => {
                 }
             }
             else if (c.type === 'node-change') {
-                const _a = c.dataTracked, { id, moveNodeId } = _a, attrs = __rest(_a, ["id", "moveNodeId"]);
+                const _b = c.dataTracked, { id, moveNodeId } = _b, attrs = __rest(_b, ["id", "moveNodeId"]);
                 newTr.replaceWith(c.from, c.to, (0, setFragmentAsInserted_1.setFragmentAsInserted)(prosemirror_model_1.Fragment.from(c.node), (0, track_utils_1.createNewInsertAttrs)(attrs), newTr.doc.type.schema));
             }
         }

package/dist/cjs/steps/trackMarkSteps.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackRemoveMarkStep = trackRemoveMarkStep;
+exports.trackRemoveNodeMarkStep = trackRemoveNodeMarkStep;
+exports.trackAddMarkStep = trackAddMarkStep;
+exports.trackAddNodeMarkStep = trackAddNodeMarkStep;
+const prosemirror_transform_1 = require("prosemirror-transform");
+const change_1 = require("../types/change");
+const track_utils_1 = require("../utils/track-utils");
+const uuidv4_1 = require("../utils/uuidv4");
+function markHasOp(mark, operation) {
+    if (mark.attrs.dataTracked && Array.isArray(mark.attrs.dataTracked)) {
+        const dtAttrs = mark.attrs.dataTracked;
+        return dtAttrs.some((at) => at.operation === operation);
+    }
+}
+function trackRemoveMarkStep(step, emptyAttrs, newTr, doc) {
+    if ((0, track_utils_1.isValidTrackableMark)(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[step.mark.type.name];
+        let sameMark = null;
+        const targetNode = doc.nodeAt(step.from);
+        if (targetNode) {
+            let targetNodePos = -1;
+            doc.descendants((node, pos) => {
+                if (node === targetNode) {
+                    targetNodePos = pos;
+                }
+                if (targetNodePos >= 0) {
+                    return false;
+                }
+            });
+            const parentsSameMark = targetNode.marks.find((mark) => {
+                var _a;
+                if (mark.type.name === markName && ((_a = mark.attrs.dataTracked) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return mark;
+                }
+            });
+            const nodeEnd = targetNodePos + targetNode.nodeSize;
+            if (parentsSameMark && step.from <= nodeEnd && step.to <= nodeEnd) {
+                sameMark = parentsSameMark;
+            }
+        }
+        const newDataTracked = (0, track_utils_1.createNewDeleteAttrs)(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: (0, uuidv4_1.uuidv4)() })],
+        });
+        let newStep = new prosemirror_transform_1.AddMarkStep(step.from, step.to, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, change_1.CHANGE_OPERATION.delete)) {
+                newStep = new prosemirror_transform_1.AddMarkStep(step.from, step.to, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, change_1.CHANGE_OPERATION.insert)) {
+                newStep = new prosemirror_transform_1.RemoveMarkStep(step.from, step.to, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveMarkStep with error: ' + e);
+        }
+    }
+}
+function trackRemoveNodeMarkStep(step, emptyAttrs, newTr, doc) {
+    if ((0, track_utils_1.isValidTrackableMark)(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[markName];
+        let sameMark = null;
+        const targetNode = doc.nodeAt(step.pos);
+        if (targetNode) {
+            targetNode.marks.find((mark) => {
+                var _a;
+                if (mark.type.name === markName && ((_a = mark.attrs.dataTracked) === null || _a === void 0 ? void 0 : _a.length)) {
+                    sameMark = mark;
+                }
+            });
+        }
+        const newDataTracked = (0, track_utils_1.createNewDeleteAttrs)(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: (0, uuidv4_1.uuidv4)() })],
+        });
+        let newStep = new prosemirror_transform_1.AddNodeMarkStep(step.pos, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, change_1.CHANGE_OPERATION.delete)) {
+                newStep = new prosemirror_transform_1.AddNodeMarkStep(step.pos, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, change_1.CHANGE_OPERATION.insert)) {
+                newStep = new prosemirror_transform_1.AddNodeMarkStep(step.pos, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveNodeMarkStep with error: ' + e);
+        }
+    }
+}
+function trackAddMarkStep(step, emptyAttrs, newTr, doc) {
+    if ((0, track_utils_1.isValidTrackableMark)(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[markName];
+        const newDataTracked = (0, track_utils_1.createNewInsertAttrs)(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: (0, uuidv4_1.uuidv4)() })],
+        });
+        const newStep = new prosemirror_transform_1.AddMarkStep(step.from, step.to, newMark);
+        try {
+            const inverted = step.invert();
+            newTr.step(inverted);
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a remove node mark step: ' + e);
+        }
+    }
+}
+function trackAddNodeMarkStep(step, emptyAttrs, newTr, stepDoc) {
+    if ((0, track_utils_1.isValidTrackableMark)(step.mark)) {
+        const newDataTracked = (0, track_utils_1.createNewInsertAttrs)(emptyAttrs);
+        const markSource = step.mark.type.schema.marks[step.mark.type.name];
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: (0, uuidv4_1.uuidv4)() })],
+        });
+        const newStep = new prosemirror_transform_1.AddNodeMarkStep(step.pos, newMark);
+        try {
+            const inverted = step.invert(stepDoc);
+            newTr.step(inverted);
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record an AddNodeMarkStep with error: ' + e);
+        }
+    }
+}

package/dist/cjs/steps/trackReplaceAroundStep.js

@@ -40,7 +40,7 @@ const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
 const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes");
 const logger_1 = require("../utils/logger");
 const trackUtils = __importStar(require("../utils/track-utils"));
-const track_utils_1 = require("../utils/track-utils");
+const utils_1 = require("./utils");
 function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
     const prevDoc = newTr.docs[newTr.docs.length - 2];
     if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {
@@ -68,7 +68,7 @@ function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc
     logger_1.log.info('RETAINED GAP CONTENT', gap);
     let { sliceWasSplit, newSliceContent, steps: deleteSteps, } = (0, deleteAndMergeSplitNodes_1.deleteAndMergeSplitNodes)(from, to, { start: gapFrom, end: gapTo, slice: gap, insert }, newTr.doc, newTr, oldState.schema, attrs, slice);
     let fragment;
-    if ((0, track_utils_1.isWrapStep)(step)) {
+    if ((0, utils_1.isWrapStep)(step)) {
         fragment = (0, setFragmentAsInserted_1.setFragmentAsWrapChange)(newSliceContent, attrs, oldState.schema);
     }
     else {
@@ -77,7 +77,7 @@ function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc
     let steps = deleteSteps;
     logger_1.log.info('TR: new steps after applying delete', [...newTr.steps]);
     logger_1.log.info('DELETE STEPS: ', deleteSteps);
-    let liftStep = (0, track_utils_1.isLiftStep)(step);
+    let liftStep = (0, utils_1.isLiftStep)(step);
     if (liftStep) {
         logger_1.log.info('DETECTING INIT LIFT STEP: ', step);
         trContext.prevLiftStep = step;

package/dist/cjs/steps/trackReplaceStep.js

@@ -41,7 +41,7 @@ const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes")
 const dropStructureChange_1 = require("../mutate/dropStructureChange");
 const logger_1 = require("../utils/logger");
 const trackUtils = __importStar(require("../utils/track-utils"));
-const track_utils_1 = require("../utils/track-utils");
+const utils_1 = require("./utils");
 function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, currentStepDoc, tr, moveID) {
     logger_1.log.info('###### ReplaceStep ######');
     let selectionPos = 0;
@@ -78,10 +78,10 @@ function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, curr
         if (!backSpacedText && newSliceContent.size > 0) {
             logger_1.log.info('newSliceContent', newSliceContent);
             let fragment = (0, setFragmentAsInserted_1.setFragmentAsInserted)(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
-            if ((0, track_utils_1.isStructureSteps)(tr)) {
+            if ((0, utils_1.isStructureSteps)(tr)) {
                 fragment = (0, dropStructureChange_1.joinStructureChanges)(attrs, newSliceContent, fragment, tr, newTr);
             }
-            else if ((0, track_utils_1.isSplitStep)(step, oldState.selection, tr.getMeta('uiEvent'))) {
+            else if ((0, utils_1.isSplitStep)(step, oldState.selection, tr.getMeta('uiEvent'))) {
                 fragment = (0, setFragmentAsInserted_1.setFragmentAsNodeSplit)(newTr.doc.resolve(step.from), newTr, fragment, attrs);
             }
             else if (moveID) {

package/dist/cjs/steps/trackTransaction.js

@@ -17,8 +17,10 @@ const mapChangeStep_1 = require("../utils/mapChangeStep");
 const track_utils_1 = require("../utils/track-utils");
 const uuidv4_1 = require("../utils/uuidv4");
 const trackAttrsChange_1 = __importDefault(require("./trackAttrsChange"));
+const trackMarkSteps_1 = require("./trackMarkSteps");
 const trackReplaceAroundStep_1 = require("./trackReplaceAroundStep");
 const trackReplaceStep_1 = require("./trackReplaceStep");
+const utils_1 = require("./utils");
 const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
 const isHighlightMarkerNode = (node) => node && node.type === node.type.schema.nodes.highlight_marker;
 function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
@@ -74,7 +76,7 @@ function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const invertedStep = step.invert(tr.docs[i]);
             const isDelete = step.from !== step.to && step.slice.content.size < invertedStep.slice.content.size;
             let thisStepMapping = tr.mapping.slice(i + 1, i + 1);
-            if (isDelete || (0, track_utils_1.isStructureSteps)(tr)) {
+            if (isDelete || (0, utils_1.isStructureSteps)(tr)) {
                 thisStepMapping = deletedNodeMapping;
             }
             const newStep = new prosemirror_transform_1.ReplaceStep(thisStepMapping.map(invertedStep.from), thisStepMapping.map(invertedStep.to), invertedStep.slice);
@@ -115,17 +117,27 @@ function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(changeSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema, deletedNodeMapping);
         }
         else if (step instanceof prosemirror_transform_1.AddMarkStep) {
+            (0, trackMarkSteps_1.trackAddMarkStep)(step, emptyAttrs, newTr, tr.docs[i]);
             const dataTracked = (_f = (0, nodeHelpers_1.getNodeTrackedData)(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _f === void 0 ? void 0 : _f.pop();
             if (dataTracked) {
                 (0, updateChangeAttrs_1.updateChangeAttrs)(newTr, { id: dataTracked.id, from: step.from, to: step.to, type: 'text-change', dataTracked }, Object.assign(Object.assign({}, dataTracked), { id: (0, uuidv4_1.uuidv4)() }), oldState.schema);
             }
         }
+        else if (step instanceof prosemirror_transform_1.RemoveMarkStep) {
+            (0, trackMarkSteps_1.trackRemoveMarkStep)(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof prosemirror_transform_1.RemoveNodeMarkStep) {
+            (0, trackMarkSteps_1.trackRemoveNodeMarkStep)(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof prosemirror_transform_1.AddNodeMarkStep) {
+            (0, trackMarkSteps_1.trackAddNodeMarkStep)(step, emptyAttrs, newTr, tr.docs[i]);
+        }
         tr.getMeta('inputType') && newTr.setMeta('inputType', tr.getMeta('inputType'));
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     }
     if (setsNewSelection && tr.selection instanceof prosemirror_state_1.TextSelection) {
         let from = tr.selection.from;
-        if ((0, track_utils_1.isStructureSteps)(tr)) {
+        if ((0, utils_1.isStructureSteps)(tr)) {
             const selectionMapping = new prosemirror_transform_1.Mapping();
             tr.steps.map((step) => {
                 const isDeleteStep = step instanceof prosemirror_transform_1.ReplaceStep && step.from !== step.to && step.slice.size === 0;