@manuscripts/track-changes-plugin 0.4.1 → 0.4.3

package/dist/ChangeSet.d.ts

@@ -38,6 +38,7 @@ export declare class ChangeSet {
     get textChanges(): TrackedChange[];
     get nodeChanges(): TrackedChange[];
     get nodeAttrChanges(): TrackedChange[];
+    get bothNodeChanges(): TrackedChange[];
     get isEmpty(): boolean;
     /**
      * Used to determine whether `fixInconsistentChanges` has to be executed to replace eg duplicate ids or

package/dist/actions.d.ts

@@ -21,7 +21,6 @@ export declare enum TrackChangesAction {
     setUserID = "track-changes-set-user-id",
     setPluginStatus = "track-changes-set-track-status",
     setChangeStatuses = "track-changes-set-change-statuses",
-    updateChanges = "track-changes-update-changes",
     refreshChanges = "track-changes-refresh-changes",
     applyAndRemoveChanges = "track-changes-apply-remove-changes"
 }
@@ -33,7 +32,6 @@ export declare type TrackChangesActionParams = {
         status: CHANGE_STATUS;
         ids: string[];
     };
-    [TrackChangesAction.updateChanges]: string[];
     [TrackChangesAction.refreshChanges]: boolean;
     [TrackChangesAction.applyAndRemoveChanges]: boolean;
 };

package/dist/change-steps/diffChangeSteps.d.ts

@@ -1,21 +1,2 @@
-/*!
- * © 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.
- */
-import { Schema } from 'prosemirror-model';
-import type { Transaction } from 'prosemirror-state';
-import { ExposedFragment } from '../types/pm';
 import { ChangeStep, InsertSliceStep } from '../types/step';
-export declare function matchInserted(matchedDeleted: number, deleted: ChangeStep[], inserted: ExposedFragment, newTr: Transaction, schema: Schema): [number, ChangeStep[]];
-export declare function diffChangeSteps(deleted: ChangeStep[], inserted: InsertSliceStep[], newTr: Transaction, schema: Schema): ChangeStep[];
+export declare function diffChangeSteps(deleted: ChangeStep[], inserted: InsertSliceStep[]): ChangeStep[];

package/dist/change-steps/matchInserted.d.ts

@@ -0,0 +1,13 @@
+import { ExposedFragment } from '../types/pm';
+import { ChangeStep } from '../types/step';
+/**
+ * Matches deleted to inserted content and returns the first pos they differ and the updated
+ * ChangeStep list.
+ *
+ * Based on https://github.com/ProseMirror/prosemirror-model/blob/master/src/diff.ts
+ * @param matchedDeleted
+ * @param deleted
+ * @param inserted
+ * @returns
+ */
+export declare function matchInserted(matchedDeleted: number, deleted: ChangeStep[], inserted: ExposedFragment): [number, ChangeStep[]];

package/dist/changes/findChanges.d.ts

@@ -18,9 +18,9 @@ import { ChangeSet } from '../ChangeSet';
 /**
  * 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
  */

package/dist/commands.d.ts

@@ -25,7 +25,7 @@ import { TrackChangesStatus } from './types/track';
  * to the document.
  * @param status
  */
-export declare const setTrackingStatus: (status?: TrackChangesStatus | undefined) => Command;
+export declare const setTrackingStatus: (status?: TrackChangesStatus) => Command;
 /**
  * Appends a transaction to set change attributes/marks' statuses to any of: 'pending' 'accepted' 'rejected'.
  * @param status
@@ -45,7 +45,3 @@ export declare const applyAndRemoveChanges: () => Command;
  * Runs `findChanges` to iterate over the document to collect changes into a new ChangeSet.
  */
 export declare const refreshChanges: () => Command;
-/**
- * Adds track attributes for a block node. For testing puroses
- */
-export declare const setParagraphTestAttribute: (val?: string) => Command;

package/dist/index.cjs

@@ -17,7 +17,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 = {}));
@@ -232,6 +231,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;
     }
@@ -370,7 +372,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];
     }
@@ -545,11 +547,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 };
@@ -619,13 +621,11 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prose
         }
         else if (ChangeSet.isNodeAttrChange(change) &&
             change.dataTracked.status === exports.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 === exports.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;
@@ -634,9 +634,9 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prose
 /**
  * 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
  */
@@ -945,10 +945,12 @@ function createNewDeleteAttrs(attrs) {
     };
 }
 function createNewUpdateAttrs(attrs, oldAttrs) {
+    // Omit dataTracked
+    const { dataTracked, ...restAttrs } = oldAttrs;
     return {
         ...attrs,
         operation: exports.CHANGE_OPERATION.set_node_attributes,
-        oldAttrs,
+        oldAttrs: restAttrs,
     };
 }
 
@@ -1018,7 +1020,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) {
@@ -1119,41 +1121,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
  *
@@ -1206,7 +1173,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?)
@@ -1231,11 +1198,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;
 }
 
@@ -1274,7 +1236,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,
@@ -1291,7 +1253,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;
         }
     });
@@ -1325,6 +1287,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;
@@ -1358,6 +1321,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 prosemirrorTransform.Mapping();
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
@@ -1419,22 +1417,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 === exports.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 === exports.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 === exports.CHANGE_OPERATION.insert)) {
+                newDataTracked.push(newUpdate);
             }
             newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
                 ...c.newAttrs,
@@ -1449,61 +1443,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) {
@@ -1513,28 +1523,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) {
@@ -1543,8 +1567,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);
@@ -1557,7 +1581,7 @@ function cutFragment(matched, deleted, content) {
     }
     return [matched, prosemirrorModel.Fragment.fromArray(newContent)];
 }
-function diffChangeSteps(deleted, inserted, newTr, schema) {
+function diffChangeSteps(deleted, inserted) {
     const updated = [];
     let updatedDeleted = [...deleted];
     inserted.forEach((ins) => {
@@ -1579,7 +1603,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);
             }
@@ -1588,13 +1612,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,
@@ -1662,9 +1686,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
@@ -1679,7 +1704,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);
         }
@@ -1769,15 +1794,14 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                     return {
                         ...pluginState,
                         status: setStatus,
-                        changeSet: findChanges(newState),
+                        changeSet: setStatus === exports.TrackChangesStatus.disabled ? new ChangeSet() : findChanges(newState),
                     };
                 }
                 else if (pluginState.status === exports.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 {
@@ -1821,10 +1845,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);
                 }
@@ -1900,24 +1923,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({
@@ -1926,8 +1933,7 @@ var commands = /*#__PURE__*/Object.freeze({
   setChangeStatuses: setChangeStatuses,
   setUserID: setUserID,
   applyAndRemoveChanges: applyAndRemoveChanges,
-  refreshChanges: refreshChanges,
-  setParagraphTestAttribute: setParagraphTestAttribute
+  refreshChanges: refreshChanges
 });
 
 exports.ChangeSet = ChangeSet;