@manuscripts/track-changes-plugin 2.0.13 → 2.1.0

package/dist/cjs/utils/track-utils.js

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateBlockNodesAttrs = exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = exports.isStructureSteps = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = void 0;
+exports.updateBlockNodesAttrs = exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = void 0;
 exports.createNewInsertAttrs = createNewInsertAttrs;
 exports.createNewWrapAttrs = createNewWrapAttrs;
 exports.createNewSplitAttrs = createNewSplitAttrs;
@@ -20,7 +20,9 @@ exports.createNewDeleteAttrs = createNewDeleteAttrs;
 exports.createNewMoveAttrs = createNewMoveAttrs;
 exports.createNewUpdateAttrs = createNewUpdateAttrs;
 exports.createNewStructureAttrs = createNewStructureAttrs;
-exports.stepIsLift = stepIsLift;
+exports.isValidTrackableMark = isValidTrackableMark;
+exports.excludeFromTracked = excludeFromTracked;
+exports.isInlineMarkChange = isInlineMarkChange;
 const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_transform_1 = require("prosemirror-transform");
 const actions_1 = require("../actions");
@@ -51,55 +53,6 @@ function createNewUpdateAttrs(attrs, oldAttrs) {
 function createNewStructureAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.structure });
 }
-const isSplitStep = (step, selection, uiEvent) => {
-    var _a, _b, _c, _d;
-    const { from, to, slice } = step;
-    if (from !== to ||
-        slice.content.childCount < 2 ||
-        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
-        return false;
-    }
-    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
-    const parentSize = $from.node().content.size;
-    if (uiEvent === 'paste') {
-        return !((startOffset === 0 && endOffset === 0) ||
-            (startOffset === parentSize && endOffset === parentSize));
-    }
-    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
-    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
-        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
-        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
-    }
-    return (openStart === openEnd &&
-        firstChild.type === lastChild.type &&
-        firstChild.inlineContent &&
-        lastChild.inlineContent &&
-        !(startOffset === parentSize && endOffset === parentSize));
-};
-exports.isSplitStep = isSplitStep;
-const isWrapStep = (step) => step.from === step.gapFrom &&
-    step.to === step.gapTo &&
-    step.slice.openStart === 0 &&
-    step.slice.openEnd === 0;
-exports.isWrapStep = isWrapStep;
-const isLiftStep = (step) => {
-    if (step.from < step.gapFrom &&
-        step.to > step.gapTo &&
-        step.slice.size === 0 &&
-        step.gapTo - step.gapFrom > 0) {
-        return true;
-    }
-    return false;
-};
-exports.isLiftStep = isLiftStep;
-function stepIsLift(gap, node, to) {
-    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
-}
-const isStructureSteps = (tr) => tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction) &&
-    tr.steps.length === 2 &&
-    tr.steps[0] instanceof prosemirror_transform_1.ReplaceStep &&
-    tr.steps[1] instanceof prosemirror_transform_1.ReplaceStep;
-exports.isStructureSteps = isStructureSteps;
 const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 exports.trFromHistory = trFromHistory;
 const HasMoveOperations = (tr) => {
@@ -260,3 +213,27 @@ const updateBlockNodesAttrs = (fragment, predicate) => {
     return prosemirror_model_1.Fragment.fromArray(updatedNodes);
 };
 exports.updateBlockNodesAttrs = updateBlockNodesAttrs;
+function isValidTrackableMark(mark) {
+    var _a, _b;
+    const spec = mark.type.spec;
+    const name = mark.type.name;
+    if (!name.startsWith('tracked_') &&
+        ((_a = spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) &&
+        typeof ((_b = spec.attrs) === null || _b === void 0 ? void 0 : _b.dataTracked) === 'object') {
+        return true;
+    }
+    return false;
+}
+function excludeFromTracked(dataTracked, changeIdToExclude) {
+    if (!dataTracked) {
+        return null;
+    }
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeIdToExclude);
+    return newDataTracked.length ? newDataTracked : null;
+}
+function isInlineMarkChange(change) {
+    if (change.type == 'mark-change') {
+        return change.nodeType.isInline || change.nodeType.isText;
+    }
+    return false;
+}

package/dist/cjs/utils/uuidv4.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuidv4 = uuidv4;
 function uuidv4() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
     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);

package/dist/es/ChangeSet.js

@@ -12,6 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
 import { CHANGE_OPERATION, CHANGE_STATUS, } from './types/change';
 import { log } from './utils/logger';
+import { isInlineMarkChange } from './utils/track-utils';
 export class ChangeSet {
     constructor(changes = []) {
         _ChangeSet_instances.add(this);
@@ -147,19 +148,34 @@ export 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) || 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_OPERATION.structure) {
@@ -210,6 +226,9 @@ export 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/es/changes/applyChanges.js

@@ -4,6 +4,7 @@ import { deleteNode, keepPairedChanges } from '../mutate/deleteNode';
 import { mergeNode } from '../mutate/mergeNode';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
+import { excludeFromTracked, isInlineMarkChange } from '../utils/track-utils';
 import { revertSplitNodeChange, revertWrapNodeChange } from './revertChange';
 import { restoreNode, updateChangeChildrenAttributes } from './updateChangeAttrs';
 function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
@@ -21,13 +22,6 @@ function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
     });
     return moveNodeIds;
 }
-export function getUpdatedDataTracked(dataTracked, changeId) {
-    if (!dataTracked) {
-        return null;
-    }
-    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
-    return newDataTracked.length ? newDataTracked : null;
-}
 export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap = new Mapping()) {
     changes.sort((c1, c2) => {
         if ((c1.type === 'node-change' && c1.node.type === schema.nodes.list) ||
@@ -87,13 +81,34 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === 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: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === 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: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (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: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
+        }
+        else if (ChangeSet.isMarkChange(change)) {
+            const newMark = change.mark.type.create({
+                dataTracked: excludeFromTracked(change.mark.attrs.dataTracked, change.id),
+            });
+            const isInsert = change.dataTracked.operation === CHANGE_OPERATION.insert;
+            const isDelete = change.dataTracked.operation === CHANGE_OPERATION.delete;
+            const toBeRestored = (change.dataTracked.status === CHANGE_STATUS.accepted && isInsert) ||
+                (change.dataTracked.status === CHANGE_STATUS.rejected && isDelete);
+            if (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) => {
@@ -110,7 +125,7 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             return;
         }
         if (change.dataTracked.status === 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: 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_OPERATION.delete);

package/dist/es/changes/findChanges.js

@@ -1,11 +1,27 @@
 import { ChangeSet } from '../ChangeSet';
-import { getNodeTrackedData } from '../compute/nodeHelpers';
+import { getMarkTrackedData, getNodeTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_OPERATION, } from '../types/change';
 export function findChanges(state) {
     const changes = [];
     let current;
     state.doc.descendants((node, pos) => {
         const tracked = getNodeTrackedData(node, state.schema) || [];
+        const marksWithTrackChanges = 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/es/changes/revertChange.js

@@ -1,7 +1,7 @@
 import { Slice } from 'prosemirror-model';
 import { liftTarget, ReplaceAroundStep } from 'prosemirror-transform';
 import { getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { getUpdatedDataTracked } from './applyChanges';
+import { excludeFromTracked } from '../utils/track-utils';
 export 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));
@@ -20,7 +20,7 @@ export 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, getUpdatedDataTracked(node.attrs.dataTracked, deleteChange.id));
+        tr.setNodeMarkup(tr.mapping.map(deleteChange.from), undefined, excludeFromTracked(node.attrs.dataTracked, deleteChange.id));
     }
 }
 export function revertWrapNodeChange(tr, change, deleteMap) {

package/dist/es/changes/updateChangeAttrs.js

@@ -2,6 +2,7 @@ import { ChangeSet } from '../ChangeSet';
 import { getBlockInlineTrackedData, getTextNodeTrackedMarkData } from '../compute/nodeHelpers';
 import { CHANGE_OPERATION, CHANGE_STATUS, } from '../types/change';
 import { log } from '../utils/logger';
+import { isInlineMarkChange } from '../utils/track-utils';
 export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
@@ -64,6 +65,32 @@ export 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 (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;
 }
 export function updateChangeChildrenAttributes(changes, tr, mapping) {

package/dist/es/compute/nodeHelpers.js

@@ -1,5 +1,6 @@
 import { CHANGE_OPERATION } from '../types/change';
 import { log } from '../utils/logger';
+import { isValidTrackableMark } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 export function addTrackIdIfDoesntExist(attrs) {
     if (!attrs.id) {
@@ -30,6 +31,15 @@ export function getBlockInlineTrackedData(node) {
     }
     return dataTracked || [];
 }
+export function getMarkTrackedData(node) {
+    const tracked = node === null || node === void 0 ? void 0 : node.marks.reduce((acc, current) => {
+        if (isValidTrackableMark(current) && current.attrs.dataTracked) {
+            acc.set(current, current.attrs.dataTracked);
+        }
+        return acc;
+    }, new Map());
+    return tracked || new Map();
+}
 export function getNodeTrackedData(node, schema) {
     let tracked;
     if (node && !node.isText) {

package/dist/es/mutate/deleteAndMergeSplitNodes.js

@@ -1,6 +1,7 @@
 import { Fragment } from 'prosemirror-model';
 import { setFragmentAsInserted } from '../compute/setFragmentAsInserted';
 import { splitSliceIntoMergedParts } from '../compute/splitSliceIntoMergedParts';
+import { stepIsLift } from '../steps/utils';
 import * as trackUtils from '../utils/track-utils';
 export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
     const steps = [];
@@ -33,7 +34,7 @@ export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema,
                 const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent;
                 const mergeEndNodeNotEmpty = mergeEndNode && mergeContent.size;
                 if (mergeEndNode && !mergeEndNodeNotEmpty && gap) {
-                    if (trackUtils.stepIsLift(gap, node, to)) {
+                    if (stepIsLift(gap, node, to)) {
                         gap.slice.content.forEach((node, offset) => {
                             steps.push({
                                 type: 'delete-node',

package/dist/es/steps/trackMarkSteps.js

@@ -0,0 +1,134 @@
+import { AddMarkStep, AddNodeMarkStep, RemoveMarkStep } from 'prosemirror-transform';
+import { CHANGE_OPERATION } from '../types/change';
+import { createNewDeleteAttrs, createNewInsertAttrs, isValidTrackableMark } from '../utils/track-utils';
+import { uuidv4 } from '../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);
+    }
+}
+export function trackRemoveMarkStep(step, emptyAttrs, newTr, doc) {
+    if (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 = createNewDeleteAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        let newStep = new AddMarkStep(step.from, step.to, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, CHANGE_OPERATION.delete)) {
+                newStep = new AddMarkStep(step.from, step.to, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, CHANGE_OPERATION.insert)) {
+                newStep = new RemoveMarkStep(step.from, step.to, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveMarkStep with error: ' + e);
+        }
+    }
+}
+export function trackRemoveNodeMarkStep(step, emptyAttrs, newTr, doc) {
+    if (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 = createNewDeleteAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        let newStep = new AddNodeMarkStep(step.pos, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, CHANGE_OPERATION.delete)) {
+                newStep = new AddNodeMarkStep(step.pos, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, CHANGE_OPERATION.insert)) {
+                newStep = new AddNodeMarkStep(step.pos, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveNodeMarkStep with error: ' + e);
+        }
+    }
+}
+export function trackAddMarkStep(step, emptyAttrs, newTr, doc) {
+    if (isValidTrackableMark(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[markName];
+        const newDataTracked = createNewInsertAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        const newStep = new 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);
+        }
+    }
+}
+export function trackAddNodeMarkStep(step, emptyAttrs, newTr, stepDoc) {
+    if (isValidTrackableMark(step.mark)) {
+        const newDataTracked = createNewInsertAttrs(emptyAttrs);
+        const markSource = step.mark.type.schema.marks[step.mark.type.name];
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        const newStep = new 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/es/steps/trackReplaceAroundStep.js

@@ -4,7 +4,7 @@ import { setFragmentAsInserted, setFragmentAsWrapChange } from '../compute/setFr
 import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isLiftStep, isWrapStep } from '../utils/track-utils';
+import { isLiftStep, isWrapStep } from './utils';
 function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
     const prevDoc = newTr.docs[newTr.docs.length - 2];
     if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {

package/dist/es/steps/trackReplaceStep.js

@@ -5,7 +5,7 @@ import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
 import { joinStructureChanges } from '../mutate/dropStructureChange';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isSplitStep, isStructureSteps } from '../utils/track-utils';
+import { isSplitStep, isStructureSteps } from './utils';
 export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, currentStepDoc, tr, moveID) {
     log.info('###### ReplaceStep ######');
     let selectionPos = 0;

package/dist/es/steps/trackTransaction.js

@@ -1,5 +1,5 @@
 import { NodeSelection as NodeSelectionClass, TextSelection, } from 'prosemirror-state';
-import { AddMarkStep, AttrStep, Mapping, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
+import { AddMarkStep, AddNodeMarkStep, AttrStep, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
 import { getAction, TrackChangesAction } from '../actions';
 import { diffChangeSteps } from '../change-steps/diffChangeSteps';
 import { processChangeSteps } from '../change-steps/processChangeSteps';
@@ -8,11 +8,13 @@ import { getNodeTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
 import { mapChangeSteps } from '../utils/mapChangeStep';
-import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, isStructureSteps, } from '../utils/track-utils';
+import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 import trackAttrsChange from './trackAttrsChange';
+import { trackAddMarkStep, trackAddNodeMarkStep, trackRemoveMarkStep, trackRemoveNodeMarkStep, } from './trackMarkSteps';
 import { trackReplaceAroundStep } from './trackReplaceAroundStep';
 import { trackReplaceStep } from './trackReplaceStep';
+import { isStructureSteps } from './utils';
 const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
 const isHighlightMarkerNode = (node) => node && node.type === node.type.schema.nodes.highlight_marker;
 export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
@@ -109,11 +111,21 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const [mapping, selectionPos] = processChangeSteps(changeSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema, deletedNodeMapping);
         }
         else if (step instanceof AddMarkStep) {
+            trackAddMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
             const dataTracked = (_f = getNodeTrackedData(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _f === void 0 ? void 0 : _f.pop();
             if (dataTracked) {
                 updateChangeAttrs(newTr, { id: dataTracked.id, from: step.from, to: step.to, type: 'text-change', dataTracked }, Object.assign(Object.assign({}, dataTracked), { id: uuidv4() }), oldState.schema);
             }
         }
+        else if (step instanceof RemoveMarkStep) {
+            trackRemoveMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof RemoveNodeMarkStep) {
+            trackRemoveNodeMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof AddNodeMarkStep) {
+            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'));
     }

package/dist/es/steps/utils.js

@@ -0,0 +1,62 @@
+/*!
+ * © 2023 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.
+ */
+import { ReplaceStep } from 'prosemirror-transform';
+import { TrackChangesAction } from '../actions';
+export const isSplitStep = (step, selection, uiEvent) => {
+    var _a, _b, _c, _d;
+    const { from, to, slice } = step;
+    if (from !== to ||
+        slice.content.childCount < 2 ||
+        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
+        return false;
+    }
+    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
+    const parentSize = $from.node().content.size;
+    if (uiEvent === 'paste') {
+        return !((startOffset === 0 && endOffset === 0) ||
+            (startOffset === parentSize && endOffset === parentSize));
+    }
+    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
+    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
+        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
+        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
+    }
+    return (openStart === openEnd &&
+        firstChild.type === lastChild.type &&
+        firstChild.inlineContent &&
+        lastChild.inlineContent &&
+        !(startOffset === parentSize && endOffset === parentSize));
+};
+export const isWrapStep = (step) => step.from === step.gapFrom &&
+    step.to === step.gapTo &&
+    step.slice.openStart === 0 &&
+    step.slice.openEnd === 0;
+export const isLiftStep = (step) => {
+    if (step.from < step.gapFrom &&
+        step.to > step.gapTo &&
+        step.slice.size === 0 &&
+        step.gapTo - step.gapFrom > 0) {
+        return true;
+    }
+    return false;
+};
+export function stepIsLift(gap, node, to) {
+    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
+}
+export const isStructureSteps = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof ReplaceStep &&
+    tr.steps[1] instanceof ReplaceStep;