@manuscripts/track-changes-plugin 0.4.1 → 0.4.3

package/dist/index.js

@@ -9,7 +9,6 @@ var TrackChangesAction;
     TrackChangesAction["setUserID"] = "track-changes-set-user-id";
     TrackChangesAction["setPluginStatus"] = "track-changes-set-track-status";
     TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
-    TrackChangesAction["updateChanges"] = "track-changes-update-changes";
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
 })(TrackChangesAction || (TrackChangesAction = {}));
@@ -224,6 +223,9 @@ class ChangeSet {
     get nodeAttrChanges() {
         return this.changes.filter((c) => c.type === 'node-attr-change');
     }
+    get bothNodeChanges() {
+        return this.changes.filter((c) => c.type === 'node-change' || c.type === 'node-attr-change');
+    }
     get isEmpty() {
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
     }
@@ -362,7 +364,7 @@ function getTextNodeTrackedMarkData(node, schema) {
     return marksTrackedData[0] || undefined;
 }
 function getBlockInlineTrackedData(node) {
-    let { dataTracked } = node.attrs;
+    const { dataTracked } = node.attrs;
     if (dataTracked && !Array.isArray(dataTracked)) {
         return [dataTracked];
     }
@@ -537,11 +539,11 @@ function updateChangeAttrs(tr, change, trackedAttrs, schema) {
         // TODO add operation based on mark type if it's undefined?
         tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked: { ...oldTrackData, ...trackedAttrs } }));
     }
-    else if (change.type === 'node-change' && !operation) {
+    else if ((change.type === 'node-change' || change.type === 'node-attr-change') && !operation) {
         // Very weird edge-case if this happens
         tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked: null }, node.marks);
     }
-    else if (change.type === 'node-change') {
+    else if (change.type === 'node-change' || change.type === 'node-attr-change') {
         const newDataTracked = (getBlockInlineTrackedData(node) || []).map((oldTrack) => {
             if (oldTrack.operation === operation) {
                 return { ...oldTrack, ...trackedAttrs };
@@ -611,13 +613,11 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mappi
         }
         else if (ChangeSet.isNodeAttrChange(change) &&
             change.dataTracked.status === CHANGE_STATUS.accepted) {
-            const attrs = { ...node.attrs, dataTracked: null };
-            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            tr.setNodeMarkup(from, undefined, { ...node.attrs, dataTracked: null }, node.marks);
         }
         else if (ChangeSet.isNodeAttrChange(change) &&
             change.dataTracked.status === CHANGE_STATUS.rejected) {
-            const attrs = { ...change.oldAttrs, dataTracked: null };
-            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            tr.setNodeMarkup(from, undefined, { ...change.oldAttrs, dataTracked: null }, node.marks);
         }
     });
     return deleteMap;
@@ -626,9 +626,9 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mappi
 /**
  * Finds all changes (basically text marks or node attributes) from document
  *
- * This could be possibly made more efficient by only iterating the sections of doc
- * where changes have been applied. This could attempted with eg findDiffStart
- * but it might be less robust than just using doc.descendants
+ * This could be possibly made more efficient by only iterating the sections of doc where changes have
+ * been applied. This could attempted with eg findDiffStart but it might be less robust than just using
+ * doc.descendants
  * @param state
  * @returns
  */
@@ -937,10 +937,12 @@ function createNewDeleteAttrs(attrs) {
     };
 }
 function createNewUpdateAttrs(attrs, oldAttrs) {
+    // Omit dataTracked
+    const { dataTracked, ...restAttrs } = oldAttrs;
     return {
         ...attrs,
         operation: CHANGE_OPERATION.set_node_attributes,
-        oldAttrs,
+        oldAttrs: restAttrs,
     };
 }
 
@@ -1010,7 +1012,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         // @TODO ATM 20.7.2022 there doesn't seem to be tests that capture this.
         const wasWithinGap = gap &&
             ((!node.isText && pos >= gap.start) ||
-                (node.isText && pos <= gap.start && nodeEnd >= gap.start));
+                (node.isText && pos >= gap.start && nodeEnd <= gap.end));
         // nodeEnd > offsetFrom -> delete touches this node
         // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
         if (nodeEnd > from && !wasWithinGap) {
@@ -1111,41 +1113,6 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
     };
 }
 
-/**
- * Merges tracked marks between text nodes at a position
- *
- * Will work for any nodes that use tracked_insert or tracked_delete marks which may not be preferrable
- * if used for block nodes (since we possibly want to show the individual changed nodes).
- * Merging is done based on the userID, operation type and status.
- * @param pos
- * @param doc
- * @param newTr
- * @param schema
- */
-function mergeTrackedMarks(pos, doc, newTr, schema) {
-    const resolved = doc.resolve(pos);
-    const { nodeAfter, nodeBefore } = resolved;
-    const leftMark = nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
-    const rightMark = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
-    if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
-        return;
-    }
-    const leftDataTracked = leftMark.attrs.dataTracked;
-    const rightDataTracked = rightMark.attrs.dataTracked;
-    if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
-        return;
-    }
-    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
-    const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
-    const dataTracked = {
-        ...ancestorAttrs,
-        updatedAt: Date.now(),
-    };
-    const fromStartOfMark = pos - nodeBefore.nodeSize;
-    const toEndOfMark = pos + nodeAfter.nodeSize;
-    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create({ ...leftMark.attrs, dataTracked }));
-}
-
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -1198,7 +1165,7 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
     // First apply the deleted range and update the insert slice to not include content that was deleted,
     // eg partial nodes in an open-ended slice
     const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
-    let steps = deleteSteps;
+    const steps = deleteSteps;
     log.info('TR: new steps after applying delete', [...newTr.steps]);
     log.info('DELETE STEPS: ', deleteSteps);
     // We only want to insert when there something inside the gap (actually would this be always true?)
@@ -1223,11 +1190,6 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
             sliceWasSplit,
         });
     }
-    else {
-        // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-        mergeTrackedMarks(gapFrom, newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(gapTo, newTr.doc, newTr, oldState.schema);
-    }
     return steps;
 }
 
@@ -1266,7 +1228,7 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
         changeSteps.push(...deleteSteps);
         log.info('TR: steps after applying delete', [...newTr.steps]);
         log.info('DELETE STEPS: ', changeSteps);
-        const adjustedInsertPos = toA; // deleteMap.map(toA)
+        const adjustedInsertPos = toA;
         if (newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
             // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
@@ -1283,7 +1245,7 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
         }
         else {
             // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
+            // mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema)
             selectionPos = fromA;
         }
     });
@@ -1317,6 +1279,7 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
  * @param deleteAttrs
  * @param from
  * @param to
+ * @returns position at the end of the possibly deleted text
  */
 function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
     const start = from ? Math.max(pos, from) : pos;
@@ -1350,6 +1313,41 @@ function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
     }
 }
 
+/**
+ * Merges tracked marks between text nodes at a position
+ *
+ * Will work for any nodes that use tracked_insert or tracked_delete marks which may not be preferrable
+ * if used for block nodes (since we possibly want to show the individual changed nodes).
+ * Merging is done based on the userID, operation type and status.
+ * @param pos
+ * @param doc
+ * @param newTr
+ * @param schema
+ */
+function mergeTrackedMarks(pos, doc, newTr, schema) {
+    const resolved = doc.resolve(pos);
+    const { nodeAfter, nodeBefore } = resolved;
+    const leftMark = nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    const rightMark = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
+        return;
+    }
+    const leftDataTracked = leftMark.attrs.dataTracked;
+    const rightDataTracked = rightMark.attrs.dataTracked;
+    if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
+        return;
+    }
+    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
+    const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
+    const dataTracked = {
+        ...ancestorAttrs,
+        updatedAt: Date.now(),
+    };
+    const fromStartOfMark = pos - nodeBefore.nodeSize;
+    const toEndOfMark = pos + nodeAfter.nodeSize;
+    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create({ ...leftMark.attrs, dataTracked }));
+}
+
 function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const mapping = new Mapping();
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
@@ -1411,22 +1409,18 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
         else if (c.type === 'update-node-attrs') {
             const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
             const oldUpdate = oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
-            let newDataTracked = oldDataTracked;
-            if (oldUpdate) {
-                newDataTracked = [
-                    ...oldDataTracked.filter((d) => d === oldUpdate),
-                    {
-                        ...oldUpdate,
-                        updatedAt: emptyAttrs.updatedAt,
-                    },
-                ];
-            }
-            else if (oldDataTracked.length === 0 ||
-                oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.delete)) {
-                newDataTracked = [
-                    ...oldDataTracked,
-                    addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, c.node.attrs)),
-                ];
+            const { dataTracked, ...oldAttrs } = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+            const newDataTracked = [...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id)];
+            const newUpdate = oldUpdate
+                ? {
+                    ...oldUpdate,
+                    updatedAt: emptyAttrs.updatedAt,
+                }
+                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, 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,
@@ -1441,61 +1435,77 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     return [mapping, selectionPos];
 }
 
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+/**
+ * Matches deleted-text recursively to inserted text
  *
- *    http://www.apache.org/licenses/LICENSE-2.0
+ * This is needed as text containing various marks is split into multiple parts even though it's
+ * continously deleted. Therefore, we need to find the next part if there is any and keep going until
+ * we've reached the end of the deleted text or inserted content.
+ * @param adjDeleted
+ * @param insNode
+ * @param offset
+ * @param matchedDeleted
+ * @param deleted
+ * @returns
+ */
+function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
+    const { pos, from, to, node: delNode } = adjDeleted;
+    let j = offset, d = from - pos, maxSteps = to - Math.max(pos, from);
+    // Match text inside the inserted text node to the deleted text node
+    for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
+        matchedDeleted += 1;
+    }
+    // this is needed incase diffing tr.doc
+    // deleted.push({
+    //   pos: pos,
+    //   type: 'update-node-attrs',
+    //   // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
+    //   oldAttrs: adjDeleted.node.attrs || {},
+    //   newAttrs: child.attrs || {},
+    // })
+    deleted = deleted.filter((d) => d !== adjDeleted);
+    if (maxSteps !== j) {
+        deleted.push({
+            pos,
+            from: from + j - offset,
+            to,
+            type: 'delete-text',
+            node: delNode,
+        });
+        return [matchedDeleted, deleted];
+    }
+    const nextTextDelete = deleted.find((d) => d.type === 'delete-text' && d.pos === to);
+    if (nextTextDelete) {
+        return matchText(nextTextDelete, insNode, j, matchedDeleted, deleted);
+    }
+    return [matchedDeleted, deleted];
+}
+/**
+ * Matches deleted to inserted content and returns the first pos they differ and the updated
+ * ChangeStep list.
  *
- * 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.
+ * Based on https://github.com/ProseMirror/prosemirror-model/blob/master/src/diff.ts
+ * @param matchedDeleted
+ * @param deleted
+ * @param inserted
+ * @returns
  */
-function matchInserted(matchedDeleted, deleted, inserted, newTr, schema) {
+function matchInserted(matchedDeleted, deleted, inserted) {
     var _a;
     let matched = [matchedDeleted, deleted];
     for (let i = 0;; i += 1) {
-        if (inserted.childCount === i)
+        if (inserted.childCount === i) {
             return matched;
+        }
         const insNode = inserted.child(i);
         // @ts-ignore
-        let adjDeleted = matched[1].find((d) => (d.type === 'delete-text' && Math.max(d.pos, d.from) === matched[0]) ||
+        const adjDeleted = matched[1].find((d) => (d.type === 'delete-text' && Math.max(d.pos, d.from) === matched[0]) ||
             (d.type === 'delete-node' && d.pos === matched[0]));
         if (insNode.type !== ((_a = adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node) === null || _a === void 0 ? void 0 : _a.type)) {
             return matched;
         }
         else if (insNode.isText && (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node)) {
-            adjDeleted = adjDeleted;
-            const { pos, from, to, node: delNode } = adjDeleted;
-            let j = 0, d = from - pos, maxSteps = to - Math.max(pos, from);
-            // Match text inside the inserted text node to the deleted text node
-            for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
-                matched[0] += 1;
-            }
-            // this is needed incase diffing tr.doc
-            // deleted.push({
-            //   pos: pos,
-            //   type: 'update-node-attrs',
-            //   // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
-            //   oldAttrs: adjDeleted.node.attrs || {},
-            //   newAttrs: child.attrs || {},
-            // })
-            matched = [matched[0], matched[1].filter((d) => d !== adjDeleted)];
-            if (maxSteps !== j) {
-                matched[1].push({
-                    pos,
-                    from: Math.max(pos, from) + j,
-                    to,
-                    type: 'delete-text',
-                    node: delNode,
-                });
-                return matched;
-            }
+            matched = matchText(adjDeleted, insNode, 0, matched[0], matched[1]);
             continue;
         }
         else if (insNode.content.size > 0 || (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node.content.size) > 0) {
@@ -1505,28 +1515,42 @@ function matchInserted(matchedDeleted, deleted, inserted, newTr, schema) {
         else {
             matched = [matched[0] + insNode.nodeSize, matched[1].filter((d) => d !== adjDeleted)];
         }
+        // Omit dataTracked
+        const { dataTracked, ...newAttrs } = insNode.attrs || {};
         matched[1].push({
             pos: adjDeleted.pos,
             type: 'update-node-attrs',
             node: adjDeleted.node,
-            // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
-            newAttrs: insNode.attrs || {},
+            newAttrs,
         });
     }
-}
+}
+
+/*!
+ * © 2021 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 /**
  * Cuts a fragment similar to Fragment.cut but also removes the parent node.
  *
- * @TODO there is however, some silly calculation mistake so that I need to use matched - deleted + 1 > 0
- * inside it to check whether to actually cut a text node. The offset might be cascading, therefore it should
- * be fixed at some point.
  * @param matched
  * @param deleted
  * @param content
  * @returns
  */
 function cutFragment(matched, deleted, content) {
-    let newContent = [];
+    const newContent = [];
     for (let i = 0; matched <= deleted && i < content.childCount; i += 1) {
         const child = content.child(i);
         if (!child.isText && child.content.size > 0) {
@@ -1535,8 +1559,8 @@ function cutFragment(matched, deleted, content) {
             newContent.push(...cut[1].content);
         }
         else if (child.isText && matched + child.nodeSize > deleted) {
-            if (matched - deleted + 1 > 0) {
-                newContent.push(child.cut(0, matched - deleted + 1));
+            if (deleted - matched > 0) {
+                newContent.push(child.cut(deleted - matched));
             }
             else {
                 newContent.push(child);
@@ -1549,7 +1573,7 @@ function cutFragment(matched, deleted, content) {
     }
     return [matched, Fragment.fromArray(newContent)];
 }
-function diffChangeSteps(deleted, inserted, newTr, schema) {
+function diffChangeSteps(deleted, inserted) {
     const updated = [];
     let updatedDeleted = [...deleted];
     inserted.forEach((ins) => {
@@ -1571,7 +1595,7 @@ function diffChangeSteps(deleted, inserted, newTr, schema) {
             return;
         }
         // Start diffing from the start of the deleted range
-        const deleteStart = deleted.reduce((acc, cur) => {
+        const deleteStart = updatedDeleted.reduce((acc, cur) => {
             if (cur.type === 'delete-node') {
                 return Math.min(acc, cur.pos);
             }
@@ -1580,13 +1604,13 @@ function diffChangeSteps(deleted, inserted, newTr, schema) {
             }
             return acc;
         }, Number.MAX_SAFE_INTEGER);
-        const [inDeleted, updatedDel] = matchInserted(deleteStart, updatedDeleted, ins.slice.content);
-        if (inDeleted === deleteStart) {
+        const [matchedDeleted, updatedDel] = matchInserted(deleteStart, updatedDeleted, ins.slice.content);
+        if (matchedDeleted === deleteStart) {
             updated.push(ins);
             return;
         }
         updatedDeleted = updatedDel;
-        const newInserted = cutFragment(0, inDeleted, ins.slice.content)[1];
+        const [_, newInserted] = cutFragment(0, matchedDeleted - deleteStart, ins.slice.content);
         if (newInserted.size > 0) {
             updated.push({
                 ...ins,
@@ -1654,9 +1678,10 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             // deleted and merged really...
             const deleted = steps.filter((s) => s.type !== 'insert-slice');
             const inserted = steps.filter((s) => s.type === 'insert-slice');
-            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            steps = diffChangeSteps(deleted, inserted);
             log.info('DIFFED STEPS: ', steps);
-            const [mapping, selectionPos] = processChangeSteps(steps, startPos, newTr, emptyAttrs, oldState.schema);
+            const [mapping, selectionPos] = processChangeSteps(steps, startPos || tr.selection.head, // Incase startPos is it's default value 0, use the old selection head
+            newTr, emptyAttrs, oldState.schema);
             if (!wasNodeSelection) {
                 const sel = getSelectionStaticConstructor(tr.selection);
                 // Use Selection.near to fix selections that point to a block node instead of inline content
@@ -1671,7 +1696,7 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             const deleted = steps.filter((s) => s.type !== 'insert-slice');
             const inserted = steps.filter((s) => s.type === 'insert-slice');
             log.info('INSERT STEPS: ', inserted);
-            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            steps = diffChangeSteps(deleted, inserted);
             log.info('DIFFED STEPS: ', steps);
             processChangeSteps(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
@@ -1761,15 +1786,14 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                     return {
                         ...pluginState,
                         status: setStatus,
-                        changeSet: findChanges(newState),
+                        changeSet: setStatus === TrackChangesStatus.disabled ? new ChangeSet() : findChanges(newState),
                     };
                 }
                 else if (pluginState.status === TrackChangesStatus.disabled) {
                     return { ...pluginState, changeSet: new ChangeSet() };
                 }
                 let { changeSet, ...rest } = pluginState;
-                const updatedChangeIds = getAction(tr, TrackChangesAction.updateChanges);
-                if (updatedChangeIds || getAction(tr, TrackChangesAction.refreshChanges)) {
+                if (getAction(tr, TrackChangesAction.refreshChanges)) {
                     changeSet = findChanges(newState);
                 }
                 return {
@@ -1813,10 +1837,9 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                             createdTr = updateChangeAttrs(createdTr, change, { ...change.dataTracked, status, reviewedByID: userID }, oldState.schema);
                         }
                     });
-                    setAction(createdTr, TrackChangesAction.updateChanges, ids);
                 }
                 else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
-                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);
+                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.bothNodeChanges);
                     applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.textChanges, mapping);
                     setAction(createdTr, TrackChangesAction.refreshChanges, true);
                 }
@@ -1892,24 +1915,8 @@ const applyAndRemoveChanges = () => (state, dispatch) => {
  * Runs `findChanges` to iterate over the document to collect changes into a new ChangeSet.
  */
 const refreshChanges = () => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, TrackChangesAction.updateChanges, []));
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.refreshChanges, true));
     return true;
-};
-/**
- * Adds track attributes for a block node. For testing puroses
- */
-const setParagraphTestAttribute = (val = 'changed') => (state, dispatch) => {
-    var _a;
-    const cursor = state.selection.head;
-    const blockNodePos = state.doc.resolve(cursor).start(1) - 1;
-    if (((_a = state.doc.resolve(blockNodePos).nodeAfter) === null || _a === void 0 ? void 0 : _a.type) === state.schema.nodes.paragraph &&
-        dispatch) {
-        dispatch(state.tr.setNodeMarkup(blockNodePos, undefined, {
-            testAttribute: val,
-        }));
-        return true;
-    }
-    return false;
 };
 
 var commands = /*#__PURE__*/Object.freeze({
@@ -1918,8 +1925,7 @@ var commands = /*#__PURE__*/Object.freeze({
   setChangeStatuses: setChangeStatuses,
   setUserID: setUserID,
   applyAndRemoveChanges: applyAndRemoveChanges,
-  refreshChanges: refreshChanges,
-  setParagraphTestAttribute: setParagraphTestAttribute
+  refreshChanges: refreshChanges
 });
 
 export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesStatus, enableDebug, skipTracking, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };

package/dist/mutate/deleteText.d.ts

@@ -28,5 +28,6 @@ import { NewDeleteAttrs } from '../types/track';
  * @param deleteAttrs
  * @param from
  * @param to
+ * @returns position at the end of the possibly deleted text
  */
 export declare function deleteTextIfInserted(node: PMNode, pos: number, newTr: Transaction, schema: Schema, deleteAttrs: NewDeleteAttrs, from?: number, to?: number): number;

package/dist/types/change.d.ts

@@ -32,7 +32,7 @@ declare type InsertDeleteAttrs = {
     createdAt: number;
     updatedAt: number;
 };
-declare type UpdateAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
+export declare type UpdateAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
     operation: CHANGE_OPERATION.set_node_attributes;
     oldAttrs: Record<string, any>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-quarterback/tree/main/quarterback-packages/track-changes-plugin",
@@ -21,28 +21,28 @@
     "access": "public"
   },
   "devDependencies": {
-    "@manuscripts/manuscript-transform": "^0.49.4",
-    "@rollup/plugin-commonjs": "^22.0.0",
+    "@manuscripts/manuscript-transform": "^0.54.0",
+    "@rollup/plugin-commonjs": "^22.0.2",
     "@types/debug": "^4.1.7",
     "@types/jest": "27.5.1",
-    "@types/node": "^17.0.35",
+    "@types/node": "^18.7.18",
     "jest": "27.5.1",
     "jest-environment-jsdom": "27.5.1",
-    "jsdom": "^19.0.0",
-    "prosemirror-commands": "^1.3.0",
+    "jsdom": "^20.0.0",
+    "prosemirror-commands": "^1.3.1",
     "prosemirror-example-setup": "^1.2.1",
     "prosemirror-history": "^1.3.0",
     "prosemirror-keymap": "^1.2.0",
     "prosemirror-model": "^1.18.1",
-    "prosemirror-schema-list": "^1.2.0",
+    "prosemirror-schema-list": "^1.2.2",
     "prosemirror-state": "^1.4.1",
-    "prosemirror-transform": "^1.6.0",
-    "prosemirror-view": "^1.27.0",
-    "rollup": "^2.74.0",
-    "rollup-plugin-typescript2": "^0.31.2",
+    "prosemirror-transform": "^1.7.0",
+    "prosemirror-view": "^1.28.1",
+    "rollup": "^2.79.0",
+    "rollup-plugin-typescript2": "^0.34.0",
     "ts-jest": "27.1.4",
     "tslib": "^2.4.0",
-    "typescript": "^4.6.4"
+    "typescript": "^4.8.3"
   },
   "peerDependencies": {
     "prosemirror-model": ">=1.14.0",