@manuscripts/track-changes-plugin 2.0.11 → 2.0.13

package/dist/cjs/ChangeSet.js

@@ -89,6 +89,9 @@ class ChangeSet {
                 currentInlineChange = undefined;
                 return;
             }
+            if (this.joinRelatedStructuralChanges(rootNodes, change)) {
+                return;
+            }
             rootNodes.push([change]);
         });
         return rootNodes.filter((changes) => changes.filter((c) => c.dataTracked.operation !== change_1.CHANGE_OPERATION.reference &&
@@ -161,6 +164,20 @@ class ChangeSet {
             change.to === nextChange.from &&
             hasMatchingOperation(change, nextChange));
     }
+    joinRelatedStructuralChanges(rootNodes, change) {
+        if (change.dataTracked.operation !== change_1.CHANGE_OPERATION.structure) {
+            return;
+        }
+        const index = rootNodes.findIndex((c) => c[0].dataTracked.operation === change_1.CHANGE_OPERATION.structure &&
+            c[0].dataTracked.moveNodeId === change.dataTracked.moveNodeId);
+        if (index !== -1) {
+            rootNodes[index] = [...rootNodes[index], change];
+        }
+        else {
+            rootNodes.push([change]);
+        }
+        return true;
+    }
     static flattenTreeToIds(changes) {
         return changes.flatMap((c) => (this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id));
     }

package/dist/cjs/actions.js

@@ -12,6 +12,7 @@ var TrackChangesAction;
     TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
+    TrackChangesAction["structuralChangeAction"] = "track-changes-structural-change-action";
     TrackChangesAction["indentationAction"] = "track-changes-indentation-action";
 })(TrackChangesAction || (exports.TrackChangesAction = TrackChangesAction = {}));
 function hasAction(tr) {

package/dist/cjs/change-steps/processChangeSteps.js

@@ -59,7 +59,7 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema, delete
     let selectionPos = startPos;
     let deletesCounter = 0;
     let isInserted = false;
-    let prevDeletedNode;
+    let prevDelete;
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
         switch (c.type) {
@@ -68,10 +68,12 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema, delete
                 const prevDeletedNodeInserted = isInserted;
                 const trackedData = (0, nodeHelpers_1.getBlockInlineTrackedData)(c.node);
                 const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === change_1.CHANGE_OPERATION.insert);
-                isInserted = !!inserted || (!trackedData && isInserted);
+                const structure = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((c) => c.operation === change_1.CHANGE_OPERATION.structure &&
+                    deleteAttrs.moveNodeId &&
+                    c.moveNodeId !== deleteAttrs.moveNodeId);
                 let childOfDeleted = false;
-                if (prevDeletedNode) {
-                    prevDeletedNode.descendants((node) => {
+                if (prevDelete) {
+                    prevDelete.node.descendants((node) => {
                         if (childOfDeleted) {
                             return false;
                         }
@@ -80,18 +82,20 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema, delete
                         }
                     });
                 }
-                const nodeAtMappedPos = newTr.doc.nodeAt(mapping.map(c.pos));
-                const nodeWasAlreadyDeleted = !nodeAtMappedPos || nodeAtMappedPos !== c.node;
                 const isMoveOperation = !!emptyAttrs.moveNodeId;
-                if ((isInserted && deletesCounter > 1 && !isMoveOperation) ||
-                    (childOfDeleted && prevDeletedNodeInserted) ||
-                    nodeWasAlreadyDeleted) {
+                if ((prevDelete &&
+                    c.pos < prevDelete.nodeEnd &&
+                    isInserted &&
+                    deletesCounter > 1 &&
+                    !isMoveOperation) ||
+                    (childOfDeleted && prevDeletedNodeInserted)) {
                     return false;
                 }
                 (0, deleteNode_1.deleteOrSetNodeDeleted)(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-                prevDeletedNode = c.node;
+                prevDelete = c;
+                isInserted = !!inserted || !!structure || (!trackedData && isInserted);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
-                if (isInserted) {
+                if (isInserted || structure) {
                     deletedNodeMapping.appendMap(newestStep.getMap());
                 }
                 if (step !== newestStep) {

package/dist/cjs/changes/applyChanges.js

@@ -41,7 +41,8 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
         return c1.dataTracked.updatedAt - c2.dataTracked.updatedAt;
     });
     changes.forEach((change) => {
-        if (change.dataTracked.operation === change_1.CHANGE_OPERATION.move) {
+        if (change.dataTracked.operation === change_1.CHANGE_OPERATION.move ||
+            change.dataTracked.operation === change_1.CHANGE_OPERATION.structure) {
             return;
         }
         if (change.dataTracked.operation === change_1.CHANGE_OPERATION.delete && change.dataTracked.moveNodeId) {
@@ -74,7 +75,7 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet_1.ChangeSet.isNodeChange(change) && noChangeNeeded) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: (0, deleteNode_1.keepPairedChanges)(node) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             if (node.isAtom) {
                 tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
@@ -100,7 +101,8 @@ function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap
         }
     });
     changes.forEach((change) => {
-        if (change.dataTracked.operation !== change_1.CHANGE_OPERATION.move) {
+        if (change.dataTracked.operation !== change_1.CHANGE_OPERATION.move &&
+            change.dataTracked.operation !== change_1.CHANGE_OPERATION.structure) {
             return;
         }
         const { pos: from, deleted } = deleteMap.mapResult(change.from);

package/dist/cjs/changes/updateChangesStatus.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateChangesStatus = updateChangesStatus;
 const prosemirror_history_1 = require("prosemirror-history");
 const ChangeSet_1 = require("../ChangeSet");
+const dropStructureChange_1 = require("../mutate/dropStructureChange");
 const change_1 = require("../types/change");
 const applyChanges_1 = require("./applyChanges");
 const updateChangeAttrs_1 = require("./updateChangeAttrs");
@@ -46,9 +47,7 @@ function updateChangesStatus(createdTr, changeSet, ids, status, userID, oldState
                             c.dataTracked.operation === 'delete' &&
                             c.dataTracked.moveNodeId === change.dataTracked.moveNodeId);
                         if (oldChange && ChangeSet_1.ChangeSet.isNodeChange(oldChange)) {
-                            createdTr = (0, updateChangeAttrs_1.updateChangeAttrs)(createdTr, oldChange, Object.assign(Object.assign({}, oldChange.dataTracked), { status, statusUpdateAt: changeTime, reviewedByID: userID }), oldState.schema);
                             oldChange.children.forEach((child) => {
-                                createdTr = (0, updateChangeAttrs_1.updateChangeAttrs)(createdTr, child, Object.assign(Object.assign({}, child.dataTracked), { status, statusUpdateAt: changeTime, reviewedByID: userID }), oldState.schema);
                                 if (ChangeSet_1.ChangeSet.isTextChange(child)) {
                                     textChanges.push(child);
                                 }
@@ -64,6 +63,7 @@ function updateChangesStatus(createdTr, changeSet, ids, status, userID, oldState
         });
         const mapping = (0, applyChanges_1.applyAcceptedRejectedChanges)(createdTr, oldState.schema, nonTextChanges, changeSet);
         (0, applyChanges_1.applyAcceptedRejectedChanges)(createdTr, oldState.schema, textChanges, changeSet, mapping);
+        (0, dropStructureChange_1.dropOrphanChanges)(createdTr);
     }
     else {
         ids.forEach((changeId) => {

package/dist/cjs/mutate/deleteNode.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.keepPairedChanges = void 0;
 exports.deleteNode = deleteNode;
 exports.deleteOrSetNodeDeleted = deleteOrSetNodeDeleted;
 const prosemirror_model_1 = require("prosemirror-model");
 const nodeHelpers_1 = require("../compute/nodeHelpers");
 const change_1 = require("../types/change");
 const logger_1 = require("../utils/logger");
+const dropStructureChange_1 = require("./dropStructureChange");
 function deleteNode(node, pos, tr) {
     var _a;
     const startPos = tr.doc.resolve(pos + 1);
@@ -22,7 +24,13 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
     const dataTracked = (0, nodeHelpers_1.getBlockInlineTrackedData)(node);
     const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => (d.operation === change_1.CHANGE_OPERATION.insert || d.operation === change_1.CHANGE_OPERATION.wrap_with_node) &&
         (d.status === change_1.CHANGE_STATUS.pending || d.status === change_1.CHANGE_STATUS.accepted));
-    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.set_node_attributes || d.operation === change_1.CHANGE_OPERATION.reference);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.set_node_attributes ||
+        d.operation === change_1.CHANGE_OPERATION.reference ||
+        (d.operation === change_1.CHANGE_OPERATION.delete && d.moveNodeId));
+    const structure = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((c) => c.operation === change_1.CHANGE_OPERATION.structure);
+    if (deleteAttrs.moveNodeId && structure && structure.moveNodeId !== deleteAttrs.moveNodeId) {
+        return newTr.delete(pos, pos + node.nodeSize);
+    }
     const moved = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.move && d.status === change_1.CHANGE_STATUS.pending);
     if (inserted) {
         return deleteNode(node, pos, newTr);
@@ -37,4 +45,13 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
     }
     const newDeleted = (0, nodeHelpers_1.addTrackIdIfDoesntExist)(deleteAttrs);
     newTr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: updated ? [newDeleted, updated] : moved ? [newDeleted, moved] : [newDeleted] }), node.marks);
+    if (!deleteAttrs.moveNodeId && (structure === null || structure === void 0 ? void 0 : structure.moveNodeId)) {
+        (0, dropStructureChange_1.dropStructuralChangeShadow)(structure.moveNodeId, newTr);
+    }
 }
+const keepPairedChanges = (node) => {
+    var _a;
+    const dataTracked = (_a = (0, nodeHelpers_1.getBlockInlineTrackedData)(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => (c.operation === change_1.CHANGE_OPERATION.delete && c.moveNodeId) || c.operation === change_1.CHANGE_OPERATION.reference);
+    return (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.length) ? dataTracked : null;
+};
+exports.keepPairedChanges = keepPairedChanges;

package/dist/cjs/mutate/dropStructureChange.js

@@ -0,0 +1,131 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinStructureChanges = exports.dropOrphanChanges = exports.dropStructuralChangeShadow = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_state_1 = require("prosemirror-state");
+const findChanges_1 = require("../changes/findChanges");
+const updateChangeAttrs_1 = require("../changes/updateChangeAttrs");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
+const change_1 = require("../types/change");
+const track_utils_1 = require("../utils/track-utils");
+const dropStructuralChangeShadow = (moveNodeId, tr) => {
+    const changeSet = (0, findChanges_1.findChanges)(prosemirror_state_1.EditorState.create({ doc: tr.doc }));
+    const changes = changeSet.changes.filter((c) => c.type === 'node-change' && c.dataTracked.moveNodeId === moveNodeId);
+    const shadow = changes.filter((c) => c.dataTracked.operation === change_1.CHANGE_OPERATION.delete);
+    const structures = changes.filter((c) => c.dataTracked.operation === change_1.CHANGE_OPERATION.structure);
+    structures.map((c) => {
+        tr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, c.node.attrs), { dataTracked: null }));
+    });
+    if (shadow.length > 0) {
+        tr.delete(shadow[0].from, shadow[shadow.length - 1].to);
+    }
+    return tr;
+};
+exports.dropStructuralChangeShadow = dropStructuralChangeShadow;
+const dropOrphanChanges = (newTr) => {
+    const changeSet = (0, findChanges_1.findChanges)(prosemirror_state_1.EditorState.create({ doc: newTr.doc }));
+    const shadowIds = new Set();
+    const referenceIds = new Set();
+    const changesIds = new Set();
+    changeSet.changes.forEach((c) => {
+        if (c.dataTracked.moveNodeId && c.dataTracked.operation === change_1.CHANGE_OPERATION.delete) {
+            shadowIds.add(c.dataTracked.moveNodeId);
+        }
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.structure ||
+            c.dataTracked.operation === change_1.CHANGE_OPERATION.move) {
+            changesIds.add(c.dataTracked.moveNodeId);
+        }
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.node_split) {
+            changesIds.add(c.dataTracked.id);
+        }
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.reference) {
+            referenceIds.add(c.dataTracked.referenceId);
+        }
+    });
+    if (!shadowIds.size && !referenceIds.size && !changesIds.size) {
+        return;
+    }
+    changeSet.changes.forEach((c) => {
+        if (c.dataTracked.operation === change_1.CHANGE_OPERATION.reference &&
+            !changesIds.has(c.dataTracked.referenceId)) {
+            const node = newTr.doc.nodeAt(c.from);
+            const dataTracked = node && ((0, nodeHelpers_1.getBlockInlineTrackedData)(node) || []).filter((d) => d.id !== c.id);
+            newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked }));
+        }
+        if (c.type === 'node-change' &&
+            c.dataTracked.operation === change_1.CHANGE_OPERATION.node_split &&
+            !referenceIds.has(c.id)) {
+            const _a = c.dataTracked, { id } = _a, attrs = __rest(_a, ["id"]);
+            newTr.replaceWith(c.from, c.to, (0, setFragmentAsInserted_1.setFragmentAsInserted)(prosemirror_model_1.Fragment.from(c.node), (0, track_utils_1.createNewInsertAttrs)(attrs), newTr.doc.type.schema));
+            const referenceChanges = ((0, nodeHelpers_1.getBlockInlineTrackedData)(c.node) || []).filter((d) => d.operation === change_1.CHANGE_OPERATION.reference);
+            if (referenceChanges.length) {
+                const node = newTr.doc.nodeAt(c.from);
+                const dataTracked = (node && (0, nodeHelpers_1.getBlockInlineTrackedData)(node)) || [];
+                newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked: [...dataTracked, ...referenceChanges] }));
+            }
+        }
+        if (c.dataTracked.moveNodeId &&
+            !(shadowIds.has(c.dataTracked.moveNodeId) && changesIds.has(c.dataTracked.moveNodeId))) {
+            if (c.dataTracked.operation === change_1.CHANGE_OPERATION.delete) {
+                if (c.type === 'text-change') {
+                    newTr.removeMark(c.from, c.to, newTr.doc.type.schema.marks.tracked_delete);
+                }
+                else if (c.type === 'node-change') {
+                    newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, c.node.attrs), { dataTracked: null }));
+                }
+            }
+            else if (c.type === 'node-change') {
+                const _b = c.dataTracked, { id, moveNodeId } = _b, attrs = __rest(_b, ["id", "moveNodeId"]);
+                newTr.replaceWith(c.from, c.to, (0, setFragmentAsInserted_1.setFragmentAsInserted)(prosemirror_model_1.Fragment.from(c.node), (0, track_utils_1.createNewInsertAttrs)(attrs), newTr.doc.type.schema));
+            }
+        }
+    });
+};
+exports.dropOrphanChanges = dropOrphanChanges;
+const groupStructureChanges = (tr, toNode) => {
+    const moveNodeIds = new Set();
+    const [insertStep, deleteStep] = tr.steps;
+    const fromNodes = tr.docs[1].slice(deleteStep.from, deleteStep.to).content;
+    const ignoredNode = tr.docs[1].nodeAt(deleteStep.from);
+    prosemirror_model_1.Fragment.from(toNode)
+        .append(insertStep.slice.content)
+        .append(fromNodes)
+        .descendants((node) => {
+        var _a;
+        const moveNodeId = (_a = ((0, nodeHelpers_1.getBlockInlineTrackedData)(node) || []).find((c) => c.operation === change_1.CHANGE_OPERATION.structure)) === null || _a === void 0 ? void 0 : _a.moveNodeId;
+        moveNodeId && moveNodeIds.add(moveNodeId);
+    });
+    return moveNodeIds;
+};
+const joinStructureChanges = (attrs, sliceContent, content, tr, newTr) => {
+    var _a, _b, _c;
+    const moveNodeId = attrs.moveNodeId;
+    let toNode = tr.docs[0].resolve(tr.steps[0].from).node();
+    toNode = ((_a = toNode === null || toNode === void 0 ? void 0 : toNode.type.spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) ? toNode : null;
+    const idsSet = groupStructureChanges(tr, toNode);
+    const changeSet = (0, findChanges_1.findChanges)(prosemirror_state_1.EditorState.create({ doc: newTr.doc }));
+    const relatedChanges = changeSet.changes.filter((c) => c.dataTracked.moveNodeId && idsSet.has(c.dataTracked.moveNodeId));
+    relatedChanges.map((c) => (0, updateChangeAttrs_1.updateChangeAttrs)(newTr, c, Object.assign(Object.assign({}, c.dataTracked), { moveNodeId }), newTr.doc.type.schema));
+    const toInsertChange = toNode && ((_b = (0, nodeHelpers_1.getBlockInlineTrackedData)(toNode)) === null || _b === void 0 ? void 0 : _b.find((c) => c.operation === change_1.CHANGE_OPERATION.insert));
+    const fromInsertChange = sliceContent.firstChild &&
+        ((_c = (0, nodeHelpers_1.getBlockInlineTrackedData)(sliceContent.firstChild)) === null || _c === void 0 ? void 0 : _c.find((c) => c.operation === change_1.CHANGE_OPERATION.insert));
+    if (toInsertChange || fromInsertChange) {
+        return (0, setFragmentAsInserted_1.setFragmentAsInserted)(content, (0, track_utils_1.createNewInsertAttrs)(attrs), newTr.doc.type.schema);
+    }
+    return (0, track_utils_1.updateBlockNodesAttrs)(sliceContent, (_, node) => {
+        return Object.assign(Object.assign({}, _), { dataTracked: [(0, nodeHelpers_1.addTrackIdIfDoesntExist)((0, track_utils_1.createNewStructureAttrs)(Object.assign(Object.assign({}, attrs), { moveNodeId })))] });
+    });
+};
+exports.joinStructureChanges = joinStructureChanges;

package/dist/cjs/steps/trackReplaceStep.js

@@ -38,6 +38,7 @@ const prosemirror_model_1 = require("prosemirror-model");
 const actions_1 = require("../actions");
 const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
 const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes");
+const dropStructureChange_1 = require("../mutate/dropStructureChange");
 const logger_1 = require("../utils/logger");
 const trackUtils = __importStar(require("../utils/track-utils"));
 const track_utils_1 = require("../utils/track-utils");
@@ -47,7 +48,6 @@ function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, curr
     const changeSteps = [];
     const attrs = Object.assign({}, attrsTemplate);
     if (moveID) {
-        console.log('Detected Node Moving ReplaceStep and assigning the following movenodeID: ' + moveID);
         attrs.moveNodeId = moveID;
     }
     step.getMap().forEach((fromA, toA, fromB, toB) => {
@@ -78,10 +78,13 @@ function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, curr
         if (!backSpacedText && newSliceContent.size > 0) {
             logger_1.log.info('newSliceContent', newSliceContent);
             let fragment = (0, setFragmentAsInserted_1.setFragmentAsInserted)(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
-            if ((0, track_utils_1.isSplitStep)(step, oldState.selection, tr.getMeta('uiEvent'))) {
+            if ((0, track_utils_1.isStructureSteps)(tr)) {
+                fragment = (0, dropStructureChange_1.joinStructureChanges)(attrs, newSliceContent, fragment, tr, newTr);
+            }
+            else if ((0, track_utils_1.isSplitStep)(step, oldState.selection, tr.getMeta('uiEvent'))) {
                 fragment = (0, setFragmentAsInserted_1.setFragmentAsNodeSplit)(newTr.doc.resolve(step.from), newTr, fragment, attrs);
             }
-            if (moveID) {
+            else if (moveID) {
                 const indentationType = (_a = (0, actions_1.getAction)(tr, actions_1.TrackChangesAction.indentationAction)) === null || _a === void 0 ? void 0 : _a.action;
                 fragment = (0, setFragmentAsInserted_1.setFragmentAsMoveChange)(newSliceContent, trackUtils.createNewMoveAttrs(attrs, indentationType));
             }

package/dist/cjs/steps/trackTransaction.js

@@ -74,7 +74,7 @@ function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const invertedStep = step.invert(tr.docs[i]);
             const isDelete = step.from !== step.to && step.slice.content.size < invertedStep.slice.content.size;
             let thisStepMapping = tr.mapping.slice(i + 1, i + 1);
-            if (isDelete) {
+            if (isDelete || (0, track_utils_1.isStructureSteps)(tr)) {
                 thisStepMapping = deletedNodeMapping;
             }
             const newStep = new prosemirror_transform_1.ReplaceStep(thisStepMapping.map(invertedStep.from), thisStepMapping.map(invertedStep.to), invertedStep.slice);
@@ -124,7 +124,19 @@ function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     }
     if (setsNewSelection && tr.selection instanceof prosemirror_state_1.TextSelection) {
-        const newPos = newTr.doc.resolve(tr.selection.from);
+        let from = tr.selection.from;
+        if ((0, track_utils_1.isStructureSteps)(tr)) {
+            const selectionMapping = new prosemirror_transform_1.Mapping();
+            tr.steps.map((step) => {
+                const isDeleteStep = step instanceof prosemirror_transform_1.ReplaceStep && step.from !== step.to && step.slice.size === 0;
+                if (isDeleteStep) {
+                    selectionMapping.appendMap(step.getMap().invert());
+                }
+            });
+            selectionMapping.appendMapping(deletedNodeMapping);
+            from = selectionMapping.map(tr.selection.from);
+        }
+        const newPos = newTr.doc.resolve(from);
         newTr.setSelection(new prosemirror_state_1.TextSelection(newPos));
     }
     if (wasNodeSelection) {

package/dist/cjs/types/change.js

@@ -25,6 +25,7 @@ var CHANGE_OPERATION;
     CHANGE_OPERATION["node_split"] = "node_split";
     CHANGE_OPERATION["reference"] = "reference";
     CHANGE_OPERATION["move"] = "move";
+    CHANGE_OPERATION["structure"] = "structure";
 })(CHANGE_OPERATION || (exports.CHANGE_OPERATION = CHANGE_OPERATION = {}));
 var CHANGE_STATUS;
 (function (CHANGE_STATUS) {

package/dist/cjs/utils/track-utils.js

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = void 0;
+exports.updateBlockNodesAttrs = exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = exports.isStructureSteps = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = void 0;
 exports.createNewInsertAttrs = createNewInsertAttrs;
 exports.createNewWrapAttrs = createNewWrapAttrs;
 exports.createNewSplitAttrs = createNewSplitAttrs;
@@ -19,8 +19,11 @@ exports.createNewReferenceAttrs = createNewReferenceAttrs;
 exports.createNewDeleteAttrs = createNewDeleteAttrs;
 exports.createNewMoveAttrs = createNewMoveAttrs;
 exports.createNewUpdateAttrs = createNewUpdateAttrs;
+exports.createNewStructureAttrs = createNewStructureAttrs;
 exports.stepIsLift = stepIsLift;
+const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_transform_1 = require("prosemirror-transform");
+const actions_1 = require("../actions");
 const change_1 = require("../types/change");
 const uuidv4_1 = require("./uuidv4");
 function createNewInsertAttrs(attrs) {
@@ -45,6 +48,9 @@ function createNewUpdateAttrs(attrs, oldAttrs) {
     const { dataTracked } = oldAttrs, restAttrs = __rest(oldAttrs, ["dataTracked"]);
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.set_node_attributes, oldAttrs: JSON.parse(JSON.stringify(restAttrs)) });
 }
+function createNewStructureAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.structure });
+}
 const isSplitStep = (step, selection, uiEvent) => {
     var _a, _b, _c, _d;
     const { from, to, slice } = step;
@@ -89,6 +95,11 @@ exports.isLiftStep = isLiftStep;
 function stepIsLift(gap, node, to) {
     return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
 }
+const isStructureSteps = (tr) => tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof prosemirror_transform_1.ReplaceStep &&
+    tr.steps[1] instanceof prosemirror_transform_1.ReplaceStep;
+exports.isStructureSteps = isStructureSteps;
 const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 exports.trFromHistory = trFromHistory;
 const HasMoveOperations = (tr) => {
@@ -96,6 +107,12 @@ const HasMoveOperations = (tr) => {
     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)) {
@@ -211,7 +228,7 @@ const filterMeaninglessMoveSteps = (tr, movingSteps) => {
                 });
                 continue;
             }
-            if (step instanceof prosemirror_transform_1.ReplaceStep) {
+            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;
@@ -229,3 +246,17 @@ const filterMeaninglessMoveSteps = (tr, movingSteps) => {
     return cleanSteps;
 };
 exports.filterMeaninglessMoveSteps = filterMeaninglessMoveSteps;
+const updateBlockNodesAttrs = (fragment, predicate) => {
+    const updatedNodes = [];
+    fragment.forEach((child) => {
+        if (!child.isBlock) {
+            updatedNodes.push(child);
+            return;
+        }
+        const newContent = child.content.size ? (0, exports.updateBlockNodesAttrs)(child.content, predicate) : child.content;
+        const newAttrs = predicate(child.attrs, child);
+        updatedNodes.push(child.type.create(newAttrs, newContent, child.marks));
+    });
+    return prosemirror_model_1.Fragment.fromArray(updatedNodes);
+};
+exports.updateBlockNodesAttrs = updateBlockNodesAttrs;

package/dist/es/ChangeSet.js

@@ -86,6 +86,9 @@ export class ChangeSet {
                 currentInlineChange = undefined;
                 return;
             }
+            if (this.joinRelatedStructuralChanges(rootNodes, change)) {
+                return;
+            }
             rootNodes.push([change]);
         });
         return rootNodes.filter((changes) => changes.filter((c) => c.dataTracked.operation !== CHANGE_OPERATION.reference &&
@@ -158,6 +161,20 @@ export class ChangeSet {
             change.to === nextChange.from &&
             hasMatchingOperation(change, nextChange));
     }
+    joinRelatedStructuralChanges(rootNodes, change) {
+        if (change.dataTracked.operation !== CHANGE_OPERATION.structure) {
+            return;
+        }
+        const index = rootNodes.findIndex((c) => c[0].dataTracked.operation === CHANGE_OPERATION.structure &&
+            c[0].dataTracked.moveNodeId === change.dataTracked.moveNodeId);
+        if (index !== -1) {
+            rootNodes[index] = [...rootNodes[index], change];
+        }
+        else {
+            rootNodes.push([change]);
+        }
+        return true;
+    }
     static flattenTreeToIds(changes) {
         return changes.flatMap((c) => (this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id));
     }

package/dist/es/actions.js

@@ -6,6 +6,7 @@ export var TrackChangesAction;
     TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
+    TrackChangesAction["structuralChangeAction"] = "track-changes-structural-change-action";
     TrackChangesAction["indentationAction"] = "track-changes-indentation-action";
 })(TrackChangesAction || (TrackChangesAction = {}));
 export function hasAction(tr) {

package/dist/es/change-steps/processChangeSteps.js

@@ -23,7 +23,7 @@ export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema,
     let selectionPos = startPos;
     let deletesCounter = 0;
     let isInserted = false;
-    let prevDeletedNode;
+    let prevDelete;
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
         switch (c.type) {
@@ -32,10 +32,12 @@ export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema,
                 const prevDeletedNodeInserted = isInserted;
                 const trackedData = getBlockInlineTrackedData(c.node);
                 const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === CHANGE_OPERATION.insert);
-                isInserted = !!inserted || (!trackedData && isInserted);
+                const structure = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((c) => c.operation === CHANGE_OPERATION.structure &&
+                    deleteAttrs.moveNodeId &&
+                    c.moveNodeId !== deleteAttrs.moveNodeId);
                 let childOfDeleted = false;
-                if (prevDeletedNode) {
-                    prevDeletedNode.descendants((node) => {
+                if (prevDelete) {
+                    prevDelete.node.descendants((node) => {
                         if (childOfDeleted) {
                             return false;
                         }
@@ -44,18 +46,20 @@ export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema,
                         }
                     });
                 }
-                const nodeAtMappedPos = newTr.doc.nodeAt(mapping.map(c.pos));
-                const nodeWasAlreadyDeleted = !nodeAtMappedPos || nodeAtMappedPos !== c.node;
                 const isMoveOperation = !!emptyAttrs.moveNodeId;
-                if ((isInserted && deletesCounter > 1 && !isMoveOperation) ||
-                    (childOfDeleted && prevDeletedNodeInserted) ||
-                    nodeWasAlreadyDeleted) {
+                if ((prevDelete &&
+                    c.pos < prevDelete.nodeEnd &&
+                    isInserted &&
+                    deletesCounter > 1 &&
+                    !isMoveOperation) ||
+                    (childOfDeleted && prevDeletedNodeInserted)) {
                     return false;
                 }
                 deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-                prevDeletedNode = c.node;
+                prevDelete = c;
+                isInserted = !!inserted || !!structure || (!trackedData && isInserted);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
-                if (isInserted) {
+                if (isInserted || structure) {
                     deletedNodeMapping.appendMap(newestStep.getMap());
                 }
                 if (step !== newestStep) {

package/dist/es/changes/applyChanges.js

@@ -1,6 +1,6 @@
 import { Mapping } from 'prosemirror-transform';
 import { ChangeSet } from '../ChangeSet';
-import { deleteNode } from '../mutate/deleteNode';
+import { deleteNode, keepPairedChanges } from '../mutate/deleteNode';
 import { mergeNode } from '../mutate/mergeNode';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
@@ -37,7 +37,8 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
         return c1.dataTracked.updatedAt - c2.dataTracked.updatedAt;
     });
     changes.forEach((change) => {
-        if (change.dataTracked.operation === CHANGE_OPERATION.move) {
+        if (change.dataTracked.operation === CHANGE_OPERATION.move ||
+            change.dataTracked.operation === CHANGE_OPERATION.structure) {
             return;
         }
         if (change.dataTracked.operation === CHANGE_OPERATION.delete && change.dataTracked.moveNodeId) {
@@ -70,7 +71,7 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet.isNodeChange(change) && noChangeNeeded) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: keepPairedChanges(node) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             if (node.isAtom) {
                 tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
@@ -96,7 +97,8 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
         }
     });
     changes.forEach((change) => {
-        if (change.dataTracked.operation !== CHANGE_OPERATION.move) {
+        if (change.dataTracked.operation !== CHANGE_OPERATION.move &&
+            change.dataTracked.operation !== CHANGE_OPERATION.structure) {
             return;
         }
         const { pos: from, deleted } = deleteMap.mapResult(change.from);

package/dist/es/changes/updateChangesStatus.js

@@ -15,6 +15,7 @@
  */
 import { closeHistory } from 'prosemirror-history';
 import { ChangeSet } from '../ChangeSet';
+import { dropOrphanChanges } from '../mutate/dropStructureChange';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { applyAcceptedRejectedChanges } from './applyChanges';
 import { updateChangeAttrs } from './updateChangeAttrs';
@@ -43,9 +44,7 @@ export function updateChangesStatus(createdTr, changeSet, ids, status, userID, o
                             c.dataTracked.operation === 'delete' &&
                             c.dataTracked.moveNodeId === change.dataTracked.moveNodeId);
                         if (oldChange && ChangeSet.isNodeChange(oldChange)) {
-                            createdTr = updateChangeAttrs(createdTr, oldChange, Object.assign(Object.assign({}, oldChange.dataTracked), { status, statusUpdateAt: changeTime, reviewedByID: userID }), oldState.schema);
                             oldChange.children.forEach((child) => {
-                                createdTr = updateChangeAttrs(createdTr, child, Object.assign(Object.assign({}, child.dataTracked), { status, statusUpdateAt: changeTime, reviewedByID: userID }), oldState.schema);
                                 if (ChangeSet.isTextChange(child)) {
                                     textChanges.push(child);
                                 }
@@ -61,6 +60,7 @@ export function updateChangesStatus(createdTr, changeSet, ids, status, userID, o
         });
         const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, nonTextChanges, changeSet);
         applyAcceptedRejectedChanges(createdTr, oldState.schema, textChanges, changeSet, mapping);
+        dropOrphanChanges(createdTr);
     }
     else {
         ids.forEach((changeId) => {

package/dist/es/mutate/deleteNode.js

@@ -2,6 +2,7 @@ import { Fragment } from 'prosemirror-model';
 import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
+import { dropStructuralChangeShadow } from './dropStructureChange';
 export function deleteNode(node, pos, tr) {
     var _a;
     const startPos = tr.doc.resolve(pos + 1);
@@ -18,7 +19,13 @@ export function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
     const dataTracked = getBlockInlineTrackedData(node);
     const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => (d.operation === CHANGE_OPERATION.insert || d.operation === CHANGE_OPERATION.wrap_with_node) &&
         (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.accepted));
-    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes || d.operation === CHANGE_OPERATION.reference);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes ||
+        d.operation === CHANGE_OPERATION.reference ||
+        (d.operation === CHANGE_OPERATION.delete && d.moveNodeId));
+    const structure = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((c) => c.operation === CHANGE_OPERATION.structure);
+    if (deleteAttrs.moveNodeId && structure && structure.moveNodeId !== deleteAttrs.moveNodeId) {
+        return newTr.delete(pos, pos + node.nodeSize);
+    }
     const moved = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.move && d.status === CHANGE_STATUS.pending);
     if (inserted) {
         return deleteNode(node, pos, newTr);
@@ -33,4 +40,12 @@ export function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
     }
     const newDeleted = addTrackIdIfDoesntExist(deleteAttrs);
     newTr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: updated ? [newDeleted, updated] : moved ? [newDeleted, moved] : [newDeleted] }), node.marks);
+    if (!deleteAttrs.moveNodeId && (structure === null || structure === void 0 ? void 0 : structure.moveNodeId)) {
+        dropStructuralChangeShadow(structure.moveNodeId, newTr);
+    }
 }
+export const keepPairedChanges = (node) => {
+    var _a;
+    const dataTracked = (_a = getBlockInlineTrackedData(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => (c.operation === CHANGE_OPERATION.delete && c.moveNodeId) || c.operation === CHANGE_OPERATION.reference);
+    return (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.length) ? dataTracked : null;
+};

package/dist/es/mutate/dropStructureChange.js

@@ -0,0 +1,125 @@
+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 { 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 { CHANGE_OPERATION } from '../types/change';
+import { createNewInsertAttrs, createNewStructureAttrs, updateBlockNodesAttrs } from '../utils/track-utils';
+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);
+    const shadow = changes.filter((c) => c.dataTracked.operation === CHANGE_OPERATION.delete);
+    const structures = changes.filter((c) => c.dataTracked.operation === CHANGE_OPERATION.structure);
+    structures.map((c) => {
+        tr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, c.node.attrs), { dataTracked: null }));
+    });
+    if (shadow.length > 0) {
+        tr.delete(shadow[0].from, shadow[shadow.length - 1].to);
+    }
+    return tr;
+};
+export const dropOrphanChanges = (newTr) => {
+    const changeSet = findChanges(EditorState.create({ doc: newTr.doc }));
+    const shadowIds = new Set();
+    const referenceIds = new Set();
+    const changesIds = new Set();
+    changeSet.changes.forEach((c) => {
+        if (c.dataTracked.moveNodeId && c.dataTracked.operation === CHANGE_OPERATION.delete) {
+            shadowIds.add(c.dataTracked.moveNodeId);
+        }
+        if (c.dataTracked.operation === CHANGE_OPERATION.structure ||
+            c.dataTracked.operation === CHANGE_OPERATION.move) {
+            changesIds.add(c.dataTracked.moveNodeId);
+        }
+        if (c.dataTracked.operation === CHANGE_OPERATION.node_split) {
+            changesIds.add(c.dataTracked.id);
+        }
+        if (c.dataTracked.operation === CHANGE_OPERATION.reference) {
+            referenceIds.add(c.dataTracked.referenceId);
+        }
+    });
+    if (!shadowIds.size && !referenceIds.size && !changesIds.size) {
+        return;
+    }
+    changeSet.changes.forEach((c) => {
+        if (c.dataTracked.operation === CHANGE_OPERATION.reference &&
+            !changesIds.has(c.dataTracked.referenceId)) {
+            const node = newTr.doc.nodeAt(c.from);
+            const dataTracked = node && (getBlockInlineTrackedData(node) || []).filter((d) => d.id !== c.id);
+            newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked }));
+        }
+        if (c.type === 'node-change' &&
+            c.dataTracked.operation === CHANGE_OPERATION.node_split &&
+            !referenceIds.has(c.id)) {
+            const _a = c.dataTracked, { id } = _a, attrs = __rest(_a, ["id"]);
+            newTr.replaceWith(c.from, c.to, setFragmentAsInserted(Fragment.from(c.node), createNewInsertAttrs(attrs), newTr.doc.type.schema));
+            const referenceChanges = (getBlockInlineTrackedData(c.node) || []).filter((d) => d.operation === CHANGE_OPERATION.reference);
+            if (referenceChanges.length) {
+                const node = newTr.doc.nodeAt(c.from);
+                const dataTracked = (node && getBlockInlineTrackedData(node)) || [];
+                newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked: [...dataTracked, ...referenceChanges] }));
+            }
+        }
+        if (c.dataTracked.moveNodeId &&
+            !(shadowIds.has(c.dataTracked.moveNodeId) && changesIds.has(c.dataTracked.moveNodeId))) {
+            if (c.dataTracked.operation === CHANGE_OPERATION.delete) {
+                if (c.type === 'text-change') {
+                    newTr.removeMark(c.from, c.to, newTr.doc.type.schema.marks.tracked_delete);
+                }
+                else if (c.type === 'node-change') {
+                    newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, c.node.attrs), { dataTracked: null }));
+                }
+            }
+            else if (c.type === 'node-change') {
+                const _b = c.dataTracked, { id, moveNodeId } = _b, attrs = __rest(_b, ["id", "moveNodeId"]);
+                newTr.replaceWith(c.from, c.to, setFragmentAsInserted(Fragment.from(c.node), createNewInsertAttrs(attrs), newTr.doc.type.schema));
+            }
+        }
+    });
+};
+const groupStructureChanges = (tr, toNode) => {
+    const moveNodeIds = new Set();
+    const [insertStep, deleteStep] = tr.steps;
+    const fromNodes = tr.docs[1].slice(deleteStep.from, deleteStep.to).content;
+    const ignoredNode = tr.docs[1].nodeAt(deleteStep.from);
+    Fragment.from(toNode)
+        .append(insertStep.slice.content)
+        .append(fromNodes)
+        .descendants((node) => {
+        var _a;
+        const moveNodeId = (_a = (getBlockInlineTrackedData(node) || []).find((c) => c.operation === CHANGE_OPERATION.structure)) === null || _a === void 0 ? void 0 : _a.moveNodeId;
+        moveNodeId && moveNodeIds.add(moveNodeId);
+    });
+    return moveNodeIds;
+};
+export const joinStructureChanges = (attrs, sliceContent, content, tr, newTr) => {
+    var _a, _b, _c;
+    const moveNodeId = attrs.moveNodeId;
+    let toNode = tr.docs[0].resolve(tr.steps[0].from).node();
+    toNode = ((_a = toNode === null || toNode === void 0 ? void 0 : toNode.type.spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) ? toNode : null;
+    const idsSet = groupStructureChanges(tr, toNode);
+    const changeSet = findChanges(EditorState.create({ doc: newTr.doc }));
+    const relatedChanges = changeSet.changes.filter((c) => c.dataTracked.moveNodeId && idsSet.has(c.dataTracked.moveNodeId));
+    relatedChanges.map((c) => updateChangeAttrs(newTr, c, Object.assign(Object.assign({}, c.dataTracked), { moveNodeId }), newTr.doc.type.schema));
+    const toInsertChange = toNode && ((_b = getBlockInlineTrackedData(toNode)) === null || _b === void 0 ? void 0 : _b.find((c) => c.operation === CHANGE_OPERATION.insert));
+    const fromInsertChange = sliceContent.firstChild &&
+        ((_c = getBlockInlineTrackedData(sliceContent.firstChild)) === null || _c === void 0 ? void 0 : _c.find((c) => c.operation === CHANGE_OPERATION.insert));
+    if (toInsertChange || fromInsertChange) {
+        return setFragmentAsInserted(content, createNewInsertAttrs(attrs), newTr.doc.type.schema);
+    }
+    return updateBlockNodesAttrs(sliceContent, (_, node) => {
+        return Object.assign(Object.assign({}, _), { dataTracked: [addTrackIdIfDoesntExist(createNewStructureAttrs(Object.assign(Object.assign({}, attrs), { moveNodeId })))] });
+    });
+};

package/dist/es/steps/trackReplaceStep.js

@@ -2,16 +2,16 @@ import { Slice } from 'prosemirror-model';
 import { getAction, TrackChangesAction } from '../actions';
 import { setFragmentAsInserted, setFragmentAsMoveChange, setFragmentAsNodeSplit, } from '../compute/setFragmentAsInserted';
 import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
+import { joinStructureChanges } from '../mutate/dropStructureChange';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isSplitStep } from '../utils/track-utils';
+import { isSplitStep, isStructureSteps } from '../utils/track-utils';
 export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, currentStepDoc, tr, moveID) {
     log.info('###### ReplaceStep ######');
     let selectionPos = 0;
     const changeSteps = [];
     const attrs = Object.assign({}, attrsTemplate);
     if (moveID) {
-        console.log('Detected Node Moving ReplaceStep and assigning the following movenodeID: ' + moveID);
         attrs.moveNodeId = moveID;
     }
     step.getMap().forEach((fromA, toA, fromB, toB) => {
@@ -42,10 +42,13 @@ export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResul
         if (!backSpacedText && newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
             let fragment = setFragmentAsInserted(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
-            if (isSplitStep(step, oldState.selection, tr.getMeta('uiEvent'))) {
+            if (isStructureSteps(tr)) {
+                fragment = joinStructureChanges(attrs, newSliceContent, fragment, tr, newTr);
+            }
+            else if (isSplitStep(step, oldState.selection, tr.getMeta('uiEvent'))) {
                 fragment = setFragmentAsNodeSplit(newTr.doc.resolve(step.from), newTr, fragment, attrs);
             }
-            if (moveID) {
+            else if (moveID) {
                 const indentationType = (_a = getAction(tr, TrackChangesAction.indentationAction)) === null || _a === void 0 ? void 0 : _a.action;
                 fragment = setFragmentAsMoveChange(newSliceContent, trackUtils.createNewMoveAttrs(attrs, indentationType));
             }

package/dist/es/steps/trackTransaction.js

@@ -8,7 +8,7 @@ import { getNodeTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
 import { mapChangeSteps } from '../utils/mapChangeStep';
-import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, } from '../utils/track-utils';
+import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, isStructureSteps, } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 import trackAttrsChange from './trackAttrsChange';
 import { trackReplaceAroundStep } from './trackReplaceAroundStep';
@@ -68,7 +68,7 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const invertedStep = step.invert(tr.docs[i]);
             const isDelete = step.from !== step.to && step.slice.content.size < invertedStep.slice.content.size;
             let thisStepMapping = tr.mapping.slice(i + 1, i + 1);
-            if (isDelete) {
+            if (isDelete || isStructureSteps(tr)) {
                 thisStepMapping = deletedNodeMapping;
             }
             const newStep = new ReplaceStep(thisStepMapping.map(invertedStep.from), thisStepMapping.map(invertedStep.to), invertedStep.slice);
@@ -118,7 +118,19 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     }
     if (setsNewSelection && tr.selection instanceof TextSelection) {
-        const newPos = newTr.doc.resolve(tr.selection.from);
+        let from = tr.selection.from;
+        if (isStructureSteps(tr)) {
+            const selectionMapping = new Mapping();
+            tr.steps.map((step) => {
+                const isDeleteStep = step instanceof ReplaceStep && step.from !== step.to && step.slice.size === 0;
+                if (isDeleteStep) {
+                    selectionMapping.appendMap(step.getMap().invert());
+                }
+            });
+            selectionMapping.appendMapping(deletedNodeMapping);
+            from = selectionMapping.map(tr.selection.from);
+        }
+        const newPos = newTr.doc.resolve(from);
         newTr.setSelection(new TextSelection(newPos));
     }
     if (wasNodeSelection) {

package/dist/es/types/change.js

@@ -22,6 +22,7 @@ export var CHANGE_OPERATION;
     CHANGE_OPERATION["node_split"] = "node_split";
     CHANGE_OPERATION["reference"] = "reference";
     CHANGE_OPERATION["move"] = "move";
+    CHANGE_OPERATION["structure"] = "structure";
 })(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
 export var CHANGE_STATUS;
 (function (CHANGE_STATUS) {

package/dist/es/utils/track-utils.js

@@ -9,7 +9,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+import { Fragment } from 'prosemirror-model';
 import { ReplaceStep } from 'prosemirror-transform';
+import { TrackChangesAction } from '../actions';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { uuidv4 } from './uuidv4';
 export function createNewInsertAttrs(attrs) {
@@ -34,6 +36,9 @@ 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 const isSplitStep = (step, selection, uiEvent) => {
     var _a, _b, _c, _d;
     const { from, to, slice } = step;
@@ -75,12 +80,22 @@ export const isLiftStep = (step) => {
 export function stepIsLift(gap, node, to) {
     return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
 }
+export const isStructureSteps = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof ReplaceStep &&
+    tr.steps[1] instanceof ReplaceStep;
 export const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 export const HasMoveOperations = (tr) => {
     const movingAssoc = new Map();
     if (tr.steps.length < 2) {
         return movingAssoc;
     }
+    if (tr.getMeta(TrackChangesAction.structuralChangeAction)) {
+        const commonID = 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)) {
@@ -191,7 +206,7 @@ export const filterMeaninglessMoveSteps = (tr, movingSteps) => {
                 });
                 continue;
             }
-            if (step instanceof ReplaceStep) {
+            if (step instanceof ReplaceStep && !tr.getMeta(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;
@@ -208,3 +223,16 @@ export const filterMeaninglessMoveSteps = (tr, movingSteps) => {
     }
     return cleanSteps;
 };
+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);
+};

package/dist/types/ChangeSet.d.ts

@@ -1,4 +1,4 @@
-import { IncompleteChange, NodeAttrChange, NodeChange, ReferenceChange, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+import { IncompleteChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
 export declare class ChangeSet {
     #private;
     constructor(changes?: (TrackedChange | IncompleteChange)[]);
@@ -23,6 +23,7 @@ export declare class ChangeSet {
         root: NodeChange;
     } | undefined;
     canJoinAdjacentInlineChanges(change: TrackedChange, index: number): boolean | undefined;
+    joinRelatedStructuralChanges(rootNodes: RootChanges, change: TrackedChange): true | undefined;
     static flattenTreeToIds(changes: TrackedChange[]): string[];
     static shouldDeleteChange(change: TrackedChange): boolean;
     static isValidDataTracked(dataTracked?: Partial<TrackedAttrs>): boolean;

package/dist/types/actions.d.ts

@@ -1,5 +1,5 @@
 import { Transaction } from 'prosemirror-state';
-import { CHANGE_STATUS } from './types/change';
+import { CHANGE_STATUS, StructureAttrs } from './types/change';
 import { TrackChangesStatus } from './types/track';
 export declare enum TrackChangesAction {
     skipTrack = "track-changes-skip-tracking",
@@ -8,6 +8,7 @@ export declare enum TrackChangesAction {
     setChangeStatuses = "track-changes-set-change-statuses",
     refreshChanges = "track-changes-refresh-changes",
     updateMetaNode = "track-changes-update-meta-node",
+    structuralChangeAction = "track-changes-structural-change-action",
     indentationAction = "track-changes-indentation-action"
 }
 export type TrackChangesActionParams = {
@@ -20,6 +21,7 @@ export type TrackChangesActionParams = {
     };
     [TrackChangesAction.refreshChanges]: boolean;
     [TrackChangesAction.updateMetaNode]: boolean;
+    [TrackChangesAction.structuralChangeAction]: StructureAttrs['action'];
     [TrackChangesAction.indentationAction]: {
         action: 'indent' | 'unindent';
     };

package/dist/types/mutate/deleteNode.d.ts

@@ -3,3 +3,4 @@ import { Transaction } from 'prosemirror-state';
 import { NewDeleteAttrs } from '../types/track';
 export declare function deleteNode(node: PMNode, pos: number, tr: Transaction): Transaction;
 export declare function deleteOrSetNodeDeleted(node: PMNode, pos: number, newTr: Transaction, deleteAttrs: NewDeleteAttrs): Transaction | undefined;
+export declare const keepPairedChanges: (node: PMNode) => Partial<import("../types/change").TrackedAttrs>[] | null;

package/dist/types/mutate/dropStructureChange.d.ts

@@ -0,0 +1,6 @@
+import { Fragment } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { NewEmptyAttrs } from '../types/track';
+export declare const dropStructuralChangeShadow: (moveNodeId: string | undefined, tr: Transaction) => Transaction;
+export declare const dropOrphanChanges: (newTr: Transaction) => void;
+export declare const joinStructureChanges: (attrs: NewEmptyAttrs, sliceContent: Fragment, content: Fragment, tr: Transaction, newTr: Transaction) => Fragment;

package/dist/types/types/change.d.ts

@@ -21,7 +21,8 @@ export declare enum CHANGE_OPERATION {
     wrap_with_node = "wrap_with_node",
     node_split = "node_split",
     reference = "reference",
-    move = "move"
+    move = "move",
+    structure = "structure"
 }
 export declare enum CHANGE_STATUS {
     accepted = "accepted",
@@ -57,7 +58,11 @@ export type NodeMoveAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
     operation: CHANGE_OPERATION.move;
     indentationType?: 'indent' | 'unindent';
 };
-export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs | WrapAttrs | NodeSplitAttrs | ReferenceAttrs | NodeMoveAttrs;
+export type StructureAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
+    operation: CHANGE_OPERATION.structure;
+    action: string;
+};
+export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs | WrapAttrs | NodeSplitAttrs | ReferenceAttrs | NodeMoveAttrs | StructureAttrs;
 type Change = {
     id: string;
     from: number;

package/dist/types/types/track.d.ts

@@ -16,7 +16,7 @@ export interface TrackChangesState {
 }
 export type NewEmptyAttrs = Omit<TrackedAttrs, 'id' | 'operation'>;
 export type NewInsertAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
-    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.wrap_with_node;
+    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.wrap_with_node | CHANGE_OPERATION.structure;
 };
 export type NewDeleteAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
     operation: CHANGE_OPERATION.delete;

package/dist/types/utils/track-utils.d.ts

@@ -1,4 +1,4 @@
-import { Node as PMNode, Slice } from 'prosemirror-model';
+import { Attrs, Fragment, Node as PMNode, Slice } from 'prosemirror-model';
 import { Selection, Transaction } from 'prosemirror-state';
 import { ReplaceAroundStep, ReplaceStep, Step } from 'prosemirror-transform';
 import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
@@ -10,6 +10,7 @@ export declare function createNewReferenceAttrs(attrs: NewEmptyAttrs, id: string
 export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
 export declare function createNewMoveAttrs(attrs: NewEmptyAttrs, indentationType?: 'indent' | 'unindent'): NewMoveAttrs;
 export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
+export declare function createNewStructureAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
 export declare const isSplitStep: (step: ReplaceStep, selection: Selection, uiEvent: string) => boolean;
 export declare const isWrapStep: (step: ReplaceAroundStep) => boolean;
 export declare const isLiftStep: (step: ReplaceAroundStep) => boolean;
@@ -19,6 +20,7 @@ export declare function stepIsLift(gap: {
     slice: Slice;
     insert: number;
 }, node: PMNode, to: number): boolean;
+export declare const isStructureSteps: (tr: Transaction) => any;
 export declare const trFromHistory: (tr: Transaction) => string | undefined;
 export declare const HasMoveOperations: (tr: Transaction) => Map<ReplaceStep, string>;
 export declare const isPendingChange: (trackedAttrs: TrackedAttrs[] | undefined, operation: CHANGE_OPERATION) => boolean;
@@ -26,3 +28,4 @@ export declare const isDeletingPendingMovedNode: (step: ReplaceStep, doc: PMNode
 export declare const isDirectPendingMoveDeletion: (step: ReplaceStep, doc: PMNode, movingSteps: Map<ReplaceStep, string>) => boolean;
 export declare const handleDirectPendingMoveDeletions: (tr: Transaction, newTr: Transaction, movingSteps: Map<ReplaceStep, string>) => void;
 export declare const filterMeaninglessMoveSteps: (tr: Transaction, movingSteps: Map<ReplaceStep, string>) => Step[];
+export declare const updateBlockNodesAttrs: (fragment: Fragment, predicate: (attrs: Attrs, node: PMNode) => Attrs) => Fragment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",