@manuscripts/track-changes-plugin 1.7.1 → 1.7.2-LEAN-3046

package/dist/index.cjs

@@ -162,13 +162,14 @@ const enableDebug = (enabled) => {
     }
 };
 
-var _ChangeSet_changes;
+var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
 /**
  * ChangeSet is a data structure to contain the tracked changes with some utility methods and computed
  * values to allow easier operability.
  */
 class ChangeSet {
     constructor(changes = []) {
+        _ChangeSet_instances.add(this);
         _ChangeSet_changes.set(this, void 0);
         __classPrivateFieldSet(this, _ChangeSet_changes, changes, "f");
     }
@@ -199,7 +200,10 @@ class ChangeSet {
                 rootNodes.push(currentNodeChange);
                 currentNodeChange = undefined;
             }
-            if (currentNodeChange && c.from < currentNodeChange.to) {
+            if (currentNodeChange &&
+                c.from < currentNodeChange.to &&
+                !(__classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isSameNodeChange).call(this, currentNodeChange, c) &&
+                    __classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isNotPendingOrDeleted).call(this, currentNodeChange))) {
                 currentNodeChange.children.push(c);
             }
             else if (c.type === 'node-change') {
@@ -321,7 +325,12 @@ class ChangeSet {
         return change.type === 'node-attr-change';
     }
 }
-_ChangeSet_changes = new WeakMap();
+_ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
+    return currentChange.from === nextChange.from && currentChange.to === nextChange.to;
+}, _ChangeSet_isNotPendingOrDeleted = function _ChangeSet_isNotPendingOrDeleted(change) {
+    return (change.dataTracked.operation !== exports.CHANGE_OPERATION.delete &&
+        change.dataTracked.status !== exports.CHANGE_STATUS.pending);
+};
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -1403,94 +1412,105 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
     let selectionPos = startPos;
     // @TODO add custom handler / condition?
+    let deletesCounter = 0; // counter for deletion
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
-        log.info('process change: ', c);
-        // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
-        if (c.type === 'delete-node') {
-            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-            const newestStep = newTr.steps[newTr.steps.length - 1];
-            if (step !== newestStep) {
-                mapping.appendMap(newestStep.getMap());
-                step = newestStep;
-            }
-            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'delete-text') {
-            const node = newTr.doc.nodeAt(mapping.map(c.pos));
-            if (!node) {
-                log.error(`processChangeSteps: no text node found for text-change`, c);
-                return;
-            }
-            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
-            mergeTrackedMarks(where, newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'merge-fragment') {
-            let insertPos = mapping.map(c.mergePos);
-            // The default insert position for block nodes is either the start of the merged content or the end.
-            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-            // actual position of the merge. Currently the inserted content is inserted at the start or end
-            // of the merged content, TODO reverse the start/end when end/start token?
-            if (c.node.isText) {
-                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                // the text node.
-                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+        switch (c.type) {
+            case "delete-node":
+                deletesCounter++; // increase the counter for deleted nodes
+                let trackedData = getBlockInlineTrackedData(c.node);
+                const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === exports.CHANGE_OPERATION.insert);
+                // For inserted node: the top node and its content (children nodes) is deleted in the first step
+                if (inserted && deletesCounter > 1)
+                    return false;
+                deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
                 if (step !== newestStep) {
                     mapping.appendMap(newestStep.getMap());
                     step = newestStep;
                 }
-            }
-            if (c.fragment.size > 0) {
-                newTr.insert(insertPos, c.fragment);
-            }
-        }
-        else if (c.type === 'insert-slice') {
-            const newStep = new prosemirrorTransform.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
-            const stepResult = newTr.maybeStep(newStep);
-            if (stepResult.failed) {
-                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
-                return;
-            }
-            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
-            const to = mapping.map(c.to) + c.slice.size;
-            mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
-            selectionPos = mapping.map(c.to) + c.slice.size;
-        }
-        else if (c.type === 'update-node-attrs') {
-            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
-            const oldUpdate = oldDataTracked.reverse().find((d) => {
-                // reversing to start from the most recent change
-                if (d.operation === exports.CHANGE_OPERATION.set_node_attributes &&
-                    (d.status === exports.CHANGE_STATUS.pending || d.status === exports.CHANGE_STATUS.rejected)) {
-                    return true;
+                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case "delete-text":
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
                 }
-                return false;
-            });
-            // if the selected last change is with status "rejected" we need to use oldAttrs from it because
-            // node's actual attributes represent the "rejected" values
-            const lastChangeRejected = oldUpdate && oldUpdate.status === exports.CHANGE_STATUS.rejected;
-            const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
-            const { dataTracked, ...restAttrs } = sourceAttrs;
-            const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
-            const newDataTracked = [
-                ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
-            ];
-            const newUpdate = oldUpdate && oldUpdate.status !== exports.CHANGE_STATUS.rejected
-                ? {
-                    ...oldUpdate,
-                    updatedAt: emptyAttrs.updatedAt,
+                const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                mergeTrackedMarks(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                // The default insert position for block nodes is either the start of the merged content or the end.
+                // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+                // actual position of the merge. Currently the inserted content is inserted at the start or end
+                // of the merged content, TODO reverse the start/end when end/start token?
+                if (c.node.isText) {
+                    // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                    // the text node.
+                    insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                    const newestStep = newTr.steps[newTr.steps.length - 1];
+                    if (step !== newestStep) {
+                        mapping.appendMap(newestStep.getMap());
+                        step = newestStep;
+                    }
                 }
-                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
-            // Dont add update changes if there exists already an insert change for this node
-            if (JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) &&
-                !oldDataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert)) {
-                newDataTracked.push(newUpdate);
-            }
-            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
-                ...c.newAttrs,
-                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
-            }, c.node.marks);
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new prosemirrorTransform.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
+                selectionPos = mapping.map(c.to) + c.slice.size;
+                break;
+            case 'update-node-attrs':
+                const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    // reversing to start from the most recent change
+                    if (d.operation === exports.CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === exports.CHANGE_STATUS.pending || d.status === exports.CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                // if the selected last change is with status "rejected" we need to use oldAttrs from it because
+                // node's actual attributes represent the "rejected" values
+                const lastChangeRejected = oldUpdate && oldUpdate.status === exports.CHANGE_STATUS.rejected;
+                const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+                const { dataTracked, ...restAttrs } = sourceAttrs;
+                const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
+                const newDataTracked = [
+                    ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
+                ];
+                const newUpdate = oldUpdate && oldUpdate.status !== exports.CHANGE_STATUS.rejected
+                    ? {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    }
+                    : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
+                // Dont add update changes if there exists already an insert change for this node
+                if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
+                    c.node.type === c.node.type.schema.nodes.citation) &&
+                    !oldDataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert && d.status === exports.CHANGE_STATUS.pending)) {
+                    newDataTracked.push(newUpdate);
+                }
+                newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                    ...c.newAttrs,
+                    dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+                }, c.node.marks);
+                break;
+            default:
+                log.error(`processChangeSteps: unknown change type`, c);
+                return;
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
         if (step !== newestStep) {

package/dist/index.js

@@ -154,13 +154,14 @@ const enableDebug = (enabled) => {
     }
 };
 
-var _ChangeSet_changes;
+var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
 /**
  * ChangeSet is a data structure to contain the tracked changes with some utility methods and computed
  * values to allow easier operability.
  */
 class ChangeSet {
     constructor(changes = []) {
+        _ChangeSet_instances.add(this);
         _ChangeSet_changes.set(this, void 0);
         __classPrivateFieldSet(this, _ChangeSet_changes, changes, "f");
     }
@@ -191,7 +192,10 @@ class ChangeSet {
                 rootNodes.push(currentNodeChange);
                 currentNodeChange = undefined;
             }
-            if (currentNodeChange && c.from < currentNodeChange.to) {
+            if (currentNodeChange &&
+                c.from < currentNodeChange.to &&
+                !(__classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isSameNodeChange).call(this, currentNodeChange, c) &&
+                    __classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isNotPendingOrDeleted).call(this, currentNodeChange))) {
                 currentNodeChange.children.push(c);
             }
             else if (c.type === 'node-change') {
@@ -313,7 +317,12 @@ class ChangeSet {
         return change.type === 'node-attr-change';
     }
 }
-_ChangeSet_changes = new WeakMap();
+_ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
+    return currentChange.from === nextChange.from && currentChange.to === nextChange.to;
+}, _ChangeSet_isNotPendingOrDeleted = function _ChangeSet_isNotPendingOrDeleted(change) {
+    return (change.dataTracked.operation !== CHANGE_OPERATION.delete &&
+        change.dataTracked.status !== CHANGE_STATUS.pending);
+};
 
 /*!
  * © 2021 Atypon Systems LLC
@@ -1395,94 +1404,105 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
     let selectionPos = startPos;
     // @TODO add custom handler / condition?
+    let deletesCounter = 0; // counter for deletion
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
-        log.info('process change: ', c);
-        // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
-        if (c.type === 'delete-node') {
-            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-            const newestStep = newTr.steps[newTr.steps.length - 1];
-            if (step !== newestStep) {
-                mapping.appendMap(newestStep.getMap());
-                step = newestStep;
-            }
-            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'delete-text') {
-            const node = newTr.doc.nodeAt(mapping.map(c.pos));
-            if (!node) {
-                log.error(`processChangeSteps: no text node found for text-change`, c);
-                return;
-            }
-            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
-            mergeTrackedMarks(where, newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'merge-fragment') {
-            let insertPos = mapping.map(c.mergePos);
-            // The default insert position for block nodes is either the start of the merged content or the end.
-            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-            // actual position of the merge. Currently the inserted content is inserted at the start or end
-            // of the merged content, TODO reverse the start/end when end/start token?
-            if (c.node.isText) {
-                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                // the text node.
-                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+        switch (c.type) {
+            case "delete-node":
+                deletesCounter++; // increase the counter for deleted nodes
+                let trackedData = getBlockInlineTrackedData(c.node);
+                const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === CHANGE_OPERATION.insert);
+                // For inserted node: the top node and its content (children nodes) is deleted in the first step
+                if (inserted && deletesCounter > 1)
+                    return false;
+                deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
                 if (step !== newestStep) {
                     mapping.appendMap(newestStep.getMap());
                     step = newestStep;
                 }
-            }
-            if (c.fragment.size > 0) {
-                newTr.insert(insertPos, c.fragment);
-            }
-        }
-        else if (c.type === 'insert-slice') {
-            const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
-            const stepResult = newTr.maybeStep(newStep);
-            if (stepResult.failed) {
-                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
-                return;
-            }
-            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
-            const to = mapping.map(c.to) + c.slice.size;
-            mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
-            selectionPos = mapping.map(c.to) + c.slice.size;
-        }
-        else if (c.type === 'update-node-attrs') {
-            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
-            const oldUpdate = oldDataTracked.reverse().find((d) => {
-                // reversing to start from the most recent change
-                if (d.operation === CHANGE_OPERATION.set_node_attributes &&
-                    (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
-                    return true;
+                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case "delete-text":
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
                 }
-                return false;
-            });
-            // if the selected last change is with status "rejected" we need to use oldAttrs from it because
-            // node's actual attributes represent the "rejected" values
-            const lastChangeRejected = oldUpdate && oldUpdate.status === CHANGE_STATUS.rejected;
-            const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
-            const { dataTracked, ...restAttrs } = sourceAttrs;
-            const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
-            const newDataTracked = [
-                ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
-            ];
-            const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
-                ? {
-                    ...oldUpdate,
-                    updatedAt: emptyAttrs.updatedAt,
+                const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                mergeTrackedMarks(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                // The default insert position for block nodes is either the start of the merged content or the end.
+                // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+                // actual position of the merge. Currently the inserted content is inserted at the start or end
+                // of the merged content, TODO reverse the start/end when end/start token?
+                if (c.node.isText) {
+                    // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                    // the text node.
+                    insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                    const newestStep = newTr.steps[newTr.steps.length - 1];
+                    if (step !== newestStep) {
+                        mapping.appendMap(newestStep.getMap());
+                        step = newestStep;
+                    }
                 }
-                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
-            // Dont add update changes if there exists already an insert change for this node
-            if (JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) &&
-                !oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.insert)) {
-                newDataTracked.push(newUpdate);
-            }
-            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
-                ...c.newAttrs,
-                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
-            }, c.node.marks);
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
+                selectionPos = mapping.map(c.to) + c.slice.size;
+                break;
+            case 'update-node-attrs':
+                const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    // reversing to start from the most recent change
+                    if (d.operation === CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                // if the selected last change is with status "rejected" we need to use oldAttrs from it because
+                // node's actual attributes represent the "rejected" values
+                const lastChangeRejected = oldUpdate && oldUpdate.status === CHANGE_STATUS.rejected;
+                const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+                const { dataTracked, ...restAttrs } = sourceAttrs;
+                const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
+                const newDataTracked = [
+                    ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
+                ];
+                const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
+                    ? {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    }
+                    : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
+                // Dont add update changes if there exists already an insert change for this node
+                if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
+                    c.node.type === c.node.type.schema.nodes.citation) &&
+                    !oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.insert && d.status === CHANGE_STATUS.pending)) {
+                    newDataTracked.push(newUpdate);
+                }
+                newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                    ...c.newAttrs,
+                    dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+                }, c.node.marks);
+                break;
+            default:
+                log.error(`processChangeSteps: unknown change type`, c);
+                return;
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
         if (step !== newestStep) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "1.7.1",
+  "version": "1.7.2-LEAN-3046",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-quarterback/tree/main/quarterback-packages/track-changes-plugin",