@manuscripts/track-changes-plugin 0.4.2 → 0.4.3

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,19 +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 { ChangeStep, InsertSliceStep } from '../types/step';
-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

@@ -1,3 +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 = {}));
@@ -373,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];
     }
@@ -635,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
  */
@@ -1021,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) {
@@ -1122,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
  *
@@ -1209,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?)
@@ -1234,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;
 }
 
@@ -1277,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,
@@ -1294,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;
         }
     });
@@ -1328,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;
@@ -1361,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);
@@ -1448,6 +1443,19 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     return [mapping, selectionPos];
 }
 
+/**
+ * Matches deleted-text recursively to inserted text
+ *
+ * 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);
@@ -1480,15 +1488,26 @@ function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
     }
     return [matchedDeleted, deleted];
 }
+/**
+ * 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
+ */
 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;
@@ -1533,16 +1552,13 @@ function matchInserted(matchedDeleted, deleted, inserted) {
 /**
  * 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) {
@@ -1565,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) => {
@@ -1670,7 +1686,7 @@ 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 || tr.selection.head, // Incase startPos is it's default value 0, use the old selection head
             newTr, emptyAttrs, oldState.schema);
@@ -1688,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);
         }
@@ -1778,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 {
@@ -1830,7 +1845,6 @@ 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.bothNodeChanges);
@@ -1909,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({
@@ -1935,8 +1933,7 @@ var commands = /*#__PURE__*/Object.freeze({
   setChangeStatuses: setChangeStatuses,
   setUserID: setUserID,
   applyAndRemoveChanges: applyAndRemoveChanges,
-  refreshChanges: refreshChanges,
-  setParagraphTestAttribute: setParagraphTestAttribute
+  refreshChanges: refreshChanges
 });
 
 exports.ChangeSet = ChangeSet;

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 = {}));
@@ -365,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];
     }
@@ -627,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
  */
@@ -1013,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) {
@@ -1114,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
  *
@@ -1201,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?)
@@ -1226,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;
 }
 
@@ -1269,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,
@@ -1286,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;
         }
     });
@@ -1320,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;
@@ -1353,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);
@@ -1440,6 +1435,19 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     return [mapping, selectionPos];
 }
 
+/**
+ * Matches deleted-text recursively to inserted text
+ *
+ * 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);
@@ -1472,15 +1480,26 @@ function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
     }
     return [matchedDeleted, deleted];
 }
+/**
+ * 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
+ */
 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;
@@ -1525,16 +1544,13 @@ function matchInserted(matchedDeleted, deleted, inserted) {
 /**
  * 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) {
@@ -1557,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) => {
@@ -1662,7 +1678,7 @@ 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 || tr.selection.head, // Incase startPos is it's default value 0, use the old selection head
             newTr, emptyAttrs, oldState.schema);
@@ -1680,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);
         }
@@ -1770,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 {
@@ -1822,7 +1837,6 @@ 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.bothNodeChanges);
@@ -1901,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({
@@ -1927,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "0.4.2",
+  "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",