@manuscripts/track-changes-plugin 2.1.1 → 2.2.1

package/dist/cjs/tracking/transactionProcessing.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trFromHistory = exports.filterMeaninglessMoveSteps = exports.changeMovedToInsertsOnSourceDeletion = exports.getMoveOperationsSteps = exports.excludeFromTracking = void 0;
+exports.getIndentationOperationSteps = getIndentationOperationSteps;
+exports.passThroughMeta = passThroughMeta;
+exports.iterationIsValid = iterationIsValid;
+const prosemirror_transform_1 = require("prosemirror-transform");
+const actions_1 = require("../actions");
+const ChangeSet_1 = require("../ChangeSet");
+const change_1 = require("../types/change");
+const uuidv4_1 = require("../utils/uuidv4");
+const qualifiers_1 = require("./steps-trackers/qualifiers");
+function getIndentationOperationSteps(tr, trContext) {
+    if ((0, actions_1.isIndentationAction)(trContext.action)) {
+        const moveId = (0, uuidv4_1.uuidv4)();
+        for (let i = 0; i < tr.steps.length; i++) {
+            const step = tr.steps[i];
+            if (step instanceof prosemirror_transform_1.ReplaceStep) {
+                trContext.stepsByGroupIDMap.set(step, moveId);
+            }
+        }
+    }
+}
+const excludeFromTracking = (node) => {
+    var _a;
+    if (node.isText) {
+        return false;
+    }
+    return node && !((_a = node.type.spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked);
+};
+exports.excludeFromTracking = excludeFromTracking;
+function passThroughMeta(oldTr, newTr) {
+    oldTr.getMeta('inputType') && newTr.setMeta('inputType', oldTr.getMeta('inputType'));
+    oldTr.getMeta('uiEvent') && newTr.setMeta('uiEvent', oldTr.getMeta('uiEvent'));
+    return newTr;
+}
+function iterationIsValid(iterations, oldTr, newTr, step) {
+    const uiEvent = oldTr.getMeta('uiEvent');
+    const isMassReplace = oldTr.getMeta('massSearchReplace');
+    if (iterations > 20 && uiEvent != 'cut' && !isMassReplace) {
+        console.error('@manuscripts/track-changes-plugin: Possible infinite loop in iterating tr.steps, tracking skipped!\n' +
+            'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
+        return false;
+    }
+    else if (!(step instanceof prosemirror_transform_1.ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+        console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
+            'or instanceof checks fail as well as creating new steps');
+        return false;
+    }
+    return true;
+}
+const getMoveOperationsSteps = (tr, context) => {
+    const movingAssoc = context.stepsByGroupIDMap;
+    if (tr.steps.length < 2) {
+        return movingAssoc;
+    }
+    if (tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction)) {
+        const commonID = (0, uuidv4_1.uuidv4)();
+        movingAssoc.set(tr.steps[0], commonID);
+        movingAssoc.set(tr.steps[1], commonID);
+        return movingAssoc;
+    }
+    const matched = [];
+    for (let i = 0; i < tr.steps.length; i++) {
+        if (matched.includes(i)) {
+            continue;
+        }
+        const step = tr.steps[i];
+        const doc = tr.docs[i];
+        if (!step.slice) {
+            continue;
+        }
+        const stepDeletesContent = step.from !== step.to && step.slice.size === 0;
+        const stepInsertsContent = step.slice.size && step.slice.content.firstChild ? true : false;
+        for (let g = 0; g < tr.steps.length; g++) {
+            if (g === i || matched.includes(g)) {
+                continue;
+            }
+            const peerStep = tr.steps[g];
+            if (!peerStep.slice) {
+                continue;
+            }
+            const peerStepInsertsContent = peerStep.slice.size && peerStep.slice.content.firstChild;
+            const peerStepDeletesContent = peerStep.from !== peerStep.to && peerStep.slice.size === 0;
+            if (stepDeletesContent) {
+                const deletedContent = doc.slice(step.from, step.to);
+                if (peerStepInsertsContent &&
+                    deletedContent.content.firstChild &&
+                    peerStep.slice.content.firstChild.toString() === deletedContent.content.firstChild.toString()) {
+                    const commonID = (0, uuidv4_1.uuidv4)();
+                    movingAssoc.set(peerStep, commonID);
+                    movingAssoc.set(step, commonID);
+                    matched.push(i, g);
+                }
+                continue;
+            }
+            if (stepInsertsContent && peerStepDeletesContent) {
+                const insertedContent = step.slice;
+                const deletedPeerContent = tr.docs[g].slice(peerStep.from, peerStep.to);
+                if (insertedContent.content.firstChild &&
+                    deletedPeerContent.content.firstChild &&
+                    insertedContent.content.firstChild.toString() === deletedPeerContent.content.firstChild.toString()) {
+                    const commonID = (0, uuidv4_1.uuidv4)();
+                    movingAssoc.set(peerStep, commonID);
+                    movingAssoc.set(step, commonID);
+                }
+                matched.push(i, g);
+            }
+        }
+    }
+};
+exports.getMoveOperationsSteps = getMoveOperationsSteps;
+const changeMovedToInsertsOnSourceDeletion = (tr, newTr, trContext) => {
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        if (step instanceof prosemirror_transform_1.ReplaceStep) {
+            const doc = tr.docs[tr.steps.indexOf(step)];
+            if ((0, qualifiers_1.isDirectPendingMoveDeletion)(step, doc, trContext.stepsByGroupIDMap)) {
+                const node = doc.nodeAt(step.from);
+                if (node === null || node === void 0 ? void 0 : node.attrs.dataTracked) {
+                    newTr.setNodeMarkup(step.from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: node.attrs.dataTracked.filter((t) => !(t.operation === change_1.CHANGE_OPERATION.move && t.status === change_1.CHANGE_STATUS.pending)) }));
+                }
+            }
+        }
+    }
+};
+exports.changeMovedToInsertsOnSourceDeletion = changeMovedToInsertsOnSourceDeletion;
+const filterMeaninglessMoveSteps = (tr, context) => {
+    var _a;
+    const cleanSteps = [];
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        const moveID = context.stepsByGroupIDMap.get(step);
+        if (moveID) {
+            const prevMoveID = (0, qualifiers_1.isDeletingPendingMovedNode)(step, tr.docs[i]);
+            if (prevMoveID) {
+                context.stepsByGroupIDMap.forEach((replaceStepMoveID, replaceStep) => {
+                    if (replaceStep !== step && moveID === replaceStepMoveID) {
+                        context.stepsByGroupIDMap.set(replaceStep, prevMoveID);
+                    }
+                });
+                cleanSteps.push(null);
+                continue;
+            }
+            if (step instanceof prosemirror_transform_1.ReplaceStep && !tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction)) {
+                const { slice } = step;
+                if ((_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.firstChild) {
+                    const insertedNode = slice.content.firstChild;
+                    if (insertedNode.attrs.dataTracked) {
+                        const isPendingInsert = ChangeSet_1.ChangeSet.isPendingChange(insertedNode.attrs.dataTracked, change_1.CHANGE_OPERATION.insert);
+                        if (isPendingInsert) {
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        cleanSteps.push(step);
+    }
+    return cleanSteps;
+};
+exports.filterMeaninglessMoveSteps = filterMeaninglessMoveSteps;
+const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
+exports.trFromHistory = trFromHistory;

package/dist/cjs/tracking/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/*!
+ * © 2025 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es/ChangeSet.js

@@ -12,7 +12,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
 import { CHANGE_OPERATION, CHANGE_STATUS, } from './types/change';
 import { log } from './utils/logger';
-import { isInlineMarkChange } from './utils/track-utils';
 export class ChangeSet {
     constructor(changes = []) {
         _ChangeSet_instances.add(this);
@@ -169,9 +168,8 @@ export class ChangeSet {
         if (!nextChange) {
             return false;
         }
-        const isInline = (c) => c.type === 'text-change' || (c.type === 'node-change' && c.node.isInline) || isInlineMarkChange(c);
-        return (isInline(change) &&
-            isInline(nextChange) &&
+        return (ChangeSet.isInline(change) &&
+            ChangeSet.isInline(nextChange) &&
             change.to === nextChange.from &&
             (change.dataTracked.operation === nextChange.dataTracked.operation ||
                 this.areMatchingWrapOperations(change, nextChange) ||
@@ -196,11 +194,13 @@ export class ChangeSet {
     }
     static shouldDeleteChange(change) {
         const { status, operation } = change.dataTracked;
-        return (((operation === CHANGE_OPERATION.insert ||
-            operation === CHANGE_OPERATION.node_split ||
-            operation === CHANGE_OPERATION.wrap_with_node ||
-            operation === CHANGE_OPERATION.move) &&
-            status === CHANGE_STATUS.rejected) ||
+        const allowedRejectedForDeletion = [
+            CHANGE_OPERATION.insert,
+            CHANGE_OPERATION.node_split,
+            CHANGE_OPERATION.wrap_with_node,
+            CHANGE_OPERATION.move,
+        ];
+        return ((allowedRejectedForDeletion.includes(operation) && status === CHANGE_STATUS.rejected) ||
             (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
     }
     static isValidDataTracked(dataTracked = {}) {
@@ -223,6 +223,17 @@ export class ChangeSet {
             optionalEntries.every(([key, val]) => optionalKeys.includes(key) && val !== undefined) &&
             (dataTracked.id || '').length > 0);
     }
+    static isInlineMarkChange(change) {
+        if (ChangeSet.isMarkChange(change)) {
+            return change.nodeType.isInline || change.nodeType.isText;
+        }
+        return false;
+    }
+    static isInline(c) {
+        return (c.type === 'text-change' ||
+            (c.type === 'node-change' && c.node.isInline) ||
+            ChangeSet.isInlineMarkChange(c));
+    }
     static isTextChange(change) {
         return change.type === 'text-change';
     }
@@ -238,6 +249,9 @@ export class ChangeSet {
     static isReferenceChange(change) {
         return change.type === 'reference-change';
     }
+    static isPendingChange(trackedAttrs, operation) {
+        return !!(trackedAttrs === null || trackedAttrs === void 0 ? void 0 : trackedAttrs.some((t) => t.operation === operation));
+    }
 }
 _ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
     return currentChange.from === nextChange.from && currentChange.to === nextChange.to;

package/dist/es/actions.js

@@ -19,3 +19,4 @@ export function setAction(tr, action, payload) {
     return tr.setMeta(action, payload);
 }
 export const skipTracking = (tr) => setAction(tr, TrackChangesAction.skipTrack, true);
+export const isIndentationAction = (action) => action === 'indent' || action === 'unindent';

package/dist/es/{changes/applyChanges.js → applyChanges.js}

@@ -1,12 +1,12 @@
 import { Mapping } from 'prosemirror-transform';
-import { ChangeSet } from '../ChangeSet';
-import { deleteNode, keepPairedChanges } from '../mutate/deleteNode';
-import { mergeNode } from '../mutate/mergeNode';
-import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
-import { log } from '../utils/logger';
-import { excludeFromTracked, isInlineMarkChange } from '../utils/track-utils';
-import { revertSplitNodeChange, revertWrapNodeChange } from './revertChange';
-import { restoreNode, updateChangeChildrenAttributes } from './updateChangeAttrs';
+import { revertSplitNodeChange, revertWrapNodeChange } from './changeHelpers/revertChange';
+import { restoreNode, updateChangeChildrenAttributes } from './changeHelpers/updateChangeAttrs';
+import { ChangeSet } from './ChangeSet';
+import { excludeFromTracked } from './helpers/attributes';
+import { deleteNode, keepPairedChanges } from './tracking/lib/deleteNode';
+import { mergeNode } from './tracking/lib/mergeNode';
+import { CHANGE_OPERATION, CHANGE_STATUS } from './types/change';
+import { log } from './utils/logger';
 function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
     const moveNodeIds = new Set();
     moveNodeIds.add(primaryMoveNodeId);
@@ -22,7 +22,7 @@ function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
     });
     return moveNodeIds;
 }
-export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap = new Mapping()) {
+export function applyChanges(tr, schema, changes, changeSet, deleteMap = new Mapping()) {
     changes.sort((c1, c2) => {
         if ((c1.type === 'node-change' && c1.node.type === schema.nodes.list) ||
             (c2.type === 'node-change' && c2.node.type === schema.nodes.list)) {
@@ -97,7 +97,7 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             const isDelete = change.dataTracked.operation === CHANGE_OPERATION.delete;
             const toBeRestored = (change.dataTracked.status === CHANGE_STATUS.accepted && isInsert) ||
                 (change.dataTracked.status === CHANGE_STATUS.rejected && isDelete);
-            if (isInlineMarkChange(change)) {
+            if (ChangeSet.isInlineMarkChange(change)) {
                 tr.removeMark(change.from, change.to, change.mark);
                 if (toBeRestored) {
                     tr.addMark(change.from, change.to, newMark);

package/dist/es/{changes → changeHelpers}/revertChange.js

@@ -1,7 +1,6 @@
 import { Slice } from 'prosemirror-model';
 import { liftTarget, ReplaceAroundStep } from 'prosemirror-transform';
-import { getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { excludeFromTracked } from '../utils/track-utils';
+import { excludeFromTracked, getBlockInlineTrackedData } from '../helpers/attributes';
 export function revertSplitNodeChange(tr, change, changeSet) {
     const sourceChange = changeSet.changes.find((c) => c.dataTracked.operation === 'reference' && c.dataTracked.referenceId === change.id);
     const node = tr.doc.nodeAt(tr.mapping.map(change.from));

package/dist/es/{mutate/dropStructureChange.js → changeHelpers/structureChange.js}

@@ -11,12 +11,13 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { Fragment } from 'prosemirror-model';
 import { EditorState } from 'prosemirror-state';
-import { findChanges } from '../changes/findChanges';
-import { updateChangeAttrs } from '../changes/updateChangeAttrs';
-import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { setFragmentAsInserted } from '../compute/setFragmentAsInserted';
+import { ReplaceStep } from 'prosemirror-transform';
+import { TrackChangesAction } from '../actions';
+import { findChanges } from '../findChanges';
+import { addTrackIdIfDoesntExist, createNewInsertAttrs, createNewStructureAttrs, getBlockInlineTrackedData, updateBlockNodesAttrs, } from '../helpers/attributes';
+import { setFragmentAsInserted } from '../helpers/fragment';
 import { CHANGE_OPERATION } from '../types/change';
-import { createNewInsertAttrs, createNewStructureAttrs, updateBlockNodesAttrs } from '../utils/track-utils';
+import { updateChangeAttrs } from './updateChangeAttrs';
 export const dropStructuralChangeShadow = (moveNodeId, tr) => {
     const changeSet = findChanges(EditorState.create({ doc: tr.doc }));
     const changes = changeSet.changes.filter((c) => c.type === 'node-change' && c.dataTracked.moveNodeId === moveNodeId);
@@ -123,3 +124,7 @@ export const joinStructureChanges = (attrs, sliceContent, content, tr, newTr) =>
         return Object.assign(Object.assign({}, _), { dataTracked: [addTrackIdIfDoesntExist(createNewStructureAttrs(Object.assign(Object.assign({}, attrs), { moveNodeId })))] });
     });
 };
+export const isStructuralChange = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof ReplaceStep &&
+    tr.steps[1] instanceof ReplaceStep;

package/dist/es/{changes → changeHelpers}/updateChangeAttrs.js

@@ -1,8 +1,7 @@
 import { ChangeSet } from '../ChangeSet';
-import { getBlockInlineTrackedData, getTextNodeTrackedMarkData } from '../compute/nodeHelpers';
+import { getBlockInlineTrackedData, getTextNodeTrackedMarkData } from '../helpers/attributes';
 import { CHANGE_OPERATION, CHANGE_STATUS, } from '../types/change';
 import { log } from '../utils/logger';
-import { isInlineMarkChange } from '../utils/track-utils';
 export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
@@ -78,7 +77,7 @@ export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
                 return dt;
             });
             const newMark = markChange.mark.type.create(Object.assign(Object.assign({}, markChange.mark.attrs), { dataTracked: newDT }));
-            if (isInlineMarkChange(markChange)) {
+            if (ChangeSet.isInlineMarkChange(markChange)) {
                 tr.removeMark(markChange.from, markChange.to, markChange.mark);
                 tr.addMark(markChange.from, markChange.to, newMark);
             }

package/dist/es/{changes → changeHelpers}/updateChangesStatus.js

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 import { closeHistory } from 'prosemirror-history';
+import { applyChanges } from '../applyChanges';
 import { ChangeSet } from '../ChangeSet';
-import { dropOrphanChanges } from '../mutate/dropStructureChange';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
-import { applyAcceptedRejectedChanges } from './applyChanges';
+import { dropOrphanChanges } from './structureChange';
 import { updateChangeAttrs } from './updateChangeAttrs';
 export function updateChangesStatus(createdTr, changeSet, ids, status, userID, oldState) {
     const change = changeSet.get(ids[0]);
@@ -58,8 +58,8 @@ export function updateChangesStatus(createdTr, changeSet, ids, status, userID, o
                 }
             }
         });
-        const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, nonTextChanges, changeSet);
-        applyAcceptedRejectedChanges(createdTr, oldState.schema, textChanges, changeSet, mapping);
+        const mapping = applyChanges(createdTr, oldState.schema, nonTextChanges, changeSet);
+        applyChanges(createdTr, oldState.schema, textChanges, changeSet, mapping);
         dropOrphanChanges(createdTr);
     }
     else {

package/dist/es/{changes/findChanges.js → findChanges.js}

@@ -1,6 +1,6 @@
-import { ChangeSet } from '../ChangeSet';
-import { getMarkTrackedData, getNodeTrackedData } from '../compute/nodeHelpers';
-import { CHANGE_OPERATION, } from '../types/change';
+import { ChangeSet } from './ChangeSet';
+import { getMarkTrackedData, getNodeTrackedData } from './helpers/attributes';
+import { CHANGE_OPERATION, } from './types/change';
 export function findChanges(state) {
     const changes = [];
     let current;

package/dist/es/helpers/attributes.js

@@ -0,0 +1,136 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { Fragment } from 'prosemirror-model';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
+import { log } from '../utils/logger';
+import { uuidv4 } from '../utils/uuidv4';
+import { isValidTrackableMark } from './mark';
+export function createNewInsertAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.insert });
+}
+export function createNewWrapAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.wrap_with_node });
+}
+export function createNewSplitAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.node_split });
+}
+export function createNewReferenceAttrs(attrs, id) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.reference, referenceId: id });
+}
+export function createNewDeleteAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.delete });
+}
+export function createNewMoveAttrs(attrs, indentationType) {
+    return Object.assign(Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.move }), (indentationType && { indentationType }));
+}
+export function createNewUpdateAttrs(attrs, oldAttrs) {
+    const { dataTracked } = oldAttrs, restAttrs = __rest(oldAttrs, ["dataTracked"]);
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.set_node_attributes, oldAttrs: JSON.parse(JSON.stringify(restAttrs)) });
+}
+export function createNewStructureAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.structure });
+}
+export function createNewPendingAttrs(time, authorID) {
+    return {
+        authorID,
+        reviewedByID: null,
+        createdAt: time,
+        updatedAt: time,
+        statusUpdateAt: 0,
+        status: CHANGE_STATUS.pending,
+    };
+}
+export function addTrackIdIfDoesntExist(attrs) {
+    if (!attrs.id) {
+        return Object.assign({ id: uuidv4() }, attrs);
+    }
+    return attrs;
+}
+export function getTextNodeTrackedMarkData(node, schema) {
+    if (!node || !node.isText) {
+        return undefined;
+    }
+    const marksTrackedData = [];
+    node.marks.forEach((mark) => {
+        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
+            const operation = mark.type === schema.marks.tracked_insert ? CHANGE_OPERATION.insert : CHANGE_OPERATION.delete;
+            marksTrackedData.push(Object.assign(Object.assign({}, mark.attrs.dataTracked), { operation }));
+        }
+    });
+    if (marksTrackedData.length > 1) {
+        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
+    }
+    return marksTrackedData[0] || undefined;
+}
+export function getBlockInlineTrackedData(node) {
+    const { dataTracked } = node.attrs;
+    if (dataTracked && !Array.isArray(dataTracked)) {
+        return [dataTracked];
+    }
+    return dataTracked || [];
+}
+export function getMarkTrackedData(node) {
+    const tracked = node === null || node === void 0 ? void 0 : node.marks.reduce((acc, current) => {
+        if (isValidTrackableMark(current) && current.attrs.dataTracked) {
+            acc.set(current, current.attrs.dataTracked);
+        }
+        return acc;
+    }, new Map());
+    return tracked || new Map();
+}
+export function getNodeTrackedData(node, schema) {
+    let tracked;
+    if (node && !node.isText) {
+        tracked = getBlockInlineTrackedData(node);
+    }
+    else if (node === null || node === void 0 ? void 0 : node.isText) {
+        tracked = getTextNodeTrackedMarkData(node, schema);
+    }
+    if (tracked && !Array.isArray(tracked)) {
+        tracked = [tracked];
+    }
+    return tracked;
+}
+export function shouldMergeTrackedAttributes(left, right) {
+    if (!left || !right) {
+        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
+            left,
+            right,
+        });
+        return false;
+    }
+    return (left.status === right.status && left.operation === right.operation && left.authorID === right.authorID);
+}
+export function getMergeableMarkTrackedAttrs(node, attrs, schema) {
+    const nodeAttrs = getTextNodeTrackedMarkData(node, schema);
+    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
+}
+export const updateBlockNodesAttrs = (fragment, predicate) => {
+    const updatedNodes = [];
+    fragment.forEach((child) => {
+        if (!child.isBlock) {
+            updatedNodes.push(child);
+            return;
+        }
+        const newContent = child.content.size ? updateBlockNodesAttrs(child.content, predicate) : child.content;
+        const newAttrs = predicate(child.attrs, child);
+        updatedNodes.push(child.type.create(newAttrs, newContent, child.marks));
+    });
+    return Fragment.fromArray(updatedNodes);
+};
+export function excludeFromTracked(dataTracked, changeIdToExclude) {
+    if (!dataTracked) {
+        return null;
+    }
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeIdToExclude);
+    return newDataTracked.length ? newDataTracked : null;
+}

package/dist/es/{compute/setFragmentAsInserted.js → helpers/fragment.js}

@@ -1,9 +1,73 @@
 import { Fragment } from 'prosemirror-model';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
-import * as trackUtils from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
-import { addTrackIdIfDoesntExist, equalMarks, getBlockInlineTrackedData, getTextNodeTrackedMarkData, } from './nodeHelpers';
+import { addTrackIdIfDoesntExist, createNewInsertAttrs, createNewReferenceAttrs, createNewSplitAttrs, createNewWrapAttrs, getBlockInlineTrackedData, getTextNodeTrackedMarkData, } from './attributes';
+import { equalMarks } from './mark';
+export function setFragmentAsInserted(inserted, insertAttrs, schema) {
+    const updatedInserted = loopContentAndMergeText(inserted, insertAttrs, schema);
+    return updatedInserted.length === 0 ? Fragment.empty : Fragment.fromArray(updatedInserted);
+}
+export function setFragmentAsWrapChange(inserted, attrs, schema) {
+    const content = [];
+    inserted.forEach((node) => {
+        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(createNewWrapAttrs(attrs))] }), setFragmentAsInserted(node.content, createNewInsertAttrs(attrs), schema), node.marks));
+    });
+    return Fragment.from(content);
+}
+export function setFragmentAsMoveChange(fragment, moveAttrs) {
+    const content = [];
+    fragment.forEach((node) => {
+        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(moveAttrs)] }), node.content, node.marks));
+    });
+    return Fragment.from(content);
+}
+export function setFragmentAsNodeSplit($pos, newTr, inserted, attrs) {
+    const lastChild = inserted.lastChild;
+    const referenceId = uuidv4();
+    const parentPos = $pos.before($pos.depth);
+    const parent = $pos.node($pos.depth);
+    const oldDataTracked = getBlockInlineTrackedData(parent) || [];
+    newTr.setNodeMarkup(parentPos, undefined, Object.assign(Object.assign({}, parent.attrs), { dataTracked: [
+            ...oldDataTracked.filter((c) => c.operation !== 'reference'),
+            Object.assign({}, addTrackIdIfDoesntExist(createNewReferenceAttrs(Object.assign(Object.assign({}, attrs), { status: CHANGE_STATUS.pending }), referenceId))),
+        ] }));
+    const splitSource = oldDataTracked.find((c) => c.operation === 'reference');
+    const dataTracked = Object.assign(Object.assign({}, createNewSplitAttrs(Object.assign({}, attrs))), { id: referenceId });
+    if (lastChild.type.name === 'list_item') {
+        let firstChild = lastChild.content.firstChild;
+        firstChild = firstChild.type.create(Object.assign(Object.assign({}, lastChild.attrs), { dataTracked: splitSource ? [dataTracked, splitSource] : [dataTracked] }), firstChild.content);
+        inserted = inserted.replaceChild(inserted.childCount - 1, lastChild.type.create(lastChild.attrs, lastChild.content.cut(firstChild.nodeSize).addToStart(firstChild)));
+    }
+    else {
+        inserted = inserted.replaceChild(inserted.childCount - 1, lastChild.type.create(Object.assign(Object.assign({}, lastChild.attrs), { dataTracked: splitSource ? [dataTracked, splitSource] : [dataTracked] }), lastChild.content));
+    }
+    return inserted;
+}
+export function cutFragment(matched, deleted, content) {
+    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) {
+            const cut = cutFragment(matched + 1, deleted, child.content);
+            matched = cut[0];
+            newContent.push(...cut[1].content);
+        }
+        else if (child.isText && matched + child.nodeSize > deleted) {
+            if (deleted - matched > 0) {
+                newContent.push(child.cut(deleted - matched));
+            }
+            else {
+                newContent.push(child);
+            }
+            matched = deleted + 1;
+        }
+        else {
+            matched += child.nodeSize;
+        }
+    }
+    return [matched, Fragment.fromArray(newContent)];
+}
 function markInlineNodeChange(node, newTrackAttrs, schema) {
     const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
     const mark = newTrackAttrs.operation === CHANGE_OPERATION.insert
@@ -45,43 +109,3 @@ function recurseNodeContent(node, newTrackAttrs, schema) {
         return node;
     }
 }
-export function setFragmentAsInserted(inserted, insertAttrs, schema) {
-    const updatedInserted = loopContentAndMergeText(inserted, insertAttrs, schema);
-    return updatedInserted.length === 0 ? Fragment.empty : Fragment.fromArray(updatedInserted);
-}
-export function setFragmentAsWrapChange(inserted, attrs, schema) {
-    const content = [];
-    inserted.forEach((node) => {
-        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(trackUtils.createNewWrapAttrs(attrs))] }), setFragmentAsInserted(node.content, trackUtils.createNewInsertAttrs(attrs), schema), node.marks));
-    });
-    return Fragment.from(content);
-}
-export function setFragmentAsMoveChange(fragment, moveAttrs) {
-    const content = [];
-    fragment.forEach((node) => {
-        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(moveAttrs)] }), node.content, node.marks));
-    });
-    return Fragment.from(content);
-}
-export function setFragmentAsNodeSplit($pos, newTr, inserted, attrs) {
-    const lastChild = inserted.lastChild;
-    const referenceId = uuidv4();
-    const parentPos = $pos.before($pos.depth);
-    const parent = $pos.node($pos.depth);
-    const oldDataTracked = getBlockInlineTrackedData(parent) || [];
-    newTr.setNodeMarkup(parentPos, undefined, Object.assign(Object.assign({}, parent.attrs), { dataTracked: [
-            ...oldDataTracked.filter((c) => c.operation !== 'reference'),
-            Object.assign({}, addTrackIdIfDoesntExist(trackUtils.createNewReferenceAttrs(Object.assign(Object.assign({}, attrs), { status: CHANGE_STATUS.pending }), referenceId))),
-        ] }));
-    const splitSource = oldDataTracked.find((c) => c.operation === 'reference');
-    const dataTracked = Object.assign(Object.assign({}, trackUtils.createNewSplitAttrs(Object.assign({}, attrs))), { id: referenceId });
-    if (lastChild.type.name === 'list_item') {
-        let firstChild = lastChild.content.firstChild;
-        firstChild = firstChild.type.create(Object.assign(Object.assign({}, lastChild.attrs), { dataTracked: splitSource ? [dataTracked, splitSource] : [dataTracked] }), firstChild.content);
-        inserted = inserted.replaceChild(inserted.childCount - 1, lastChild.type.create(lastChild.attrs, lastChild.content.cut(firstChild.nodeSize).addToStart(firstChild)));
-    }
-    else {
-        inserted = inserted.replaceChild(inserted.childCount - 1, lastChild.type.create(Object.assign(Object.assign({}, lastChild.attrs), { dataTracked: splitSource ? [dataTracked, splitSource] : [dataTracked] }), lastChild.content));
-    }
-    return inserted;
-}