@manuscripts/track-changes-plugin 2.0.10 → 2.0.12

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) {
@@ -38,13 +41,16 @@ function createNewReferenceAttrs(attrs, id) {
 function createNewDeleteAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.delete });
 }
-function createNewMoveAttrs(attrs) {
-    return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.move });
+function createNewMoveAttrs(attrs, indentationType) {
+    return Object.assign(Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.move }), (indentationType && { indentationType }));
 }
 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,8 @@ 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) {
     return Object.values(TrackChangesAction).some((action) => !!tr.getMeta(action));

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,15 +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;
-                if ((isInserted && deletesCounter > 1) || (childOfDeleted && prevDeletedNodeInserted) || nodeWasAlreadyDeleted) {
+                const isMoveOperation = !!emptyAttrs.moveNodeId;
+                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,11 +1,26 @@
 import { Mapping } from 'prosemirror-transform';
 import { ChangeSet } from '../ChangeSet';
-import { deleteNode } from '../mutate/deleteNode';
+import { deleteNode, keepDeleteWithMoveNodeId } from '../mutate/deleteNode';
 import { mergeNode } from '../mutate/mergeNode';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
 import { revertSplitNodeChange, revertWrapNodeChange } from './revertChange';
-import { updateChangeChildrenAttributes } from './updateChangeAttrs';
+import { restoreNode, updateChangeChildrenAttributes } from './updateChangeAttrs';
+function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
+    const moveNodeIds = new Set();
+    moveNodeIds.add(primaryMoveNodeId);
+    containerNode.descendants((childNode) => {
+        const dataTracked = childNode.attrs.dataTracked;
+        if (Array.isArray(dataTracked)) {
+            dataTracked.forEach((trackingData) => {
+                if (trackingData.moveNodeId) {
+                    moveNodeIds.add(trackingData.moveNodeId);
+                }
+            });
+        }
+    });
+    return moveNodeIds;
+}
 export function getUpdatedDataTracked(dataTracked, changeId) {
     if (!dataTracked) {
         return null;
@@ -22,7 +37,11 @@ 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) {
             return;
         }
         const { pos: from, deleted } = deleteMap.mapResult(change.from);
@@ -52,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: keepDeleteWithMoveNodeId(node) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             if (node.isAtom) {
                 tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
@@ -78,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);
@@ -90,25 +110,49 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             return;
         }
         if (change.dataTracked.status === CHANGE_STATUS.accepted) {
-            const originalChange = changeSet.changes.find((c) => c.dataTracked.moveNodeId === change.dataTracked.moveNodeId &&
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) });
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            const originalChanges = changeSet.changes.filter((c) => c.dataTracked.moveNodeId === change.dataTracked.moveNodeId &&
                 c.dataTracked.operation === CHANGE_OPERATION.delete);
-            if (originalChange) {
-                const { pos: originalFrom } = deleteMap.mapResult(originalChange.from);
+            if (originalChanges.length === 0) {
+                log.warn('No original change found for move operation', { change });
+            }
+            originalChanges.forEach((originalChange) => {
+                const { pos: originalFrom, deleted } = deleteMap.mapResult(originalChange.from);
+                if (deleted) {
+                    return;
+                }
                 const originalNode = tr.doc.nodeAt(originalFrom);
-                const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) });
-                tr.setNodeMarkup(from, undefined, attrs, node.marks);
                 if (originalNode) {
                     tr.delete(originalFrom, originalFrom + originalNode.nodeSize);
                     deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
                 }
-            }
-            else {
-                log.warn('No original change found for move operation', { change });
-            }
+            });
         }
         else if (change.dataTracked.status === CHANGE_STATUS.rejected) {
+            const moveNodeIdsToRestore = collectMoveNodeIds(node, change.dataTracked.moveNodeId);
             tr.delete(from, from + node.nodeSize);
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+            changeSet.changes
+                .filter((c) => c.dataTracked.operation === CHANGE_OPERATION.delete &&
+                c.dataTracked.moveNodeId &&
+                moveNodeIdsToRestore.has(c.dataTracked.moveNodeId) &&
+                ChangeSet.isNodeChange(c))
+                .forEach((orig) => {
+                const { pos } = deleteMap.mapResult(orig.from);
+                const node = tr.doc.nodeAt(pos);
+                if (!node) {
+                    return;
+                }
+                const dataTracked = node.attrs.dataTracked || [];
+                const hasMoved = dataTracked.some((d) => d.operation === CHANGE_OPERATION.move && d.status === CHANGE_STATUS.pending);
+                if (hasMoved) {
+                    tr.delete(pos, pos + node.nodeSize);
+                    deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+                    return;
+                }
+                restoreNode(tr, node, pos, schema);
+            });
         }
     });
     return deleteMap;

package/dist/es/changes/updateChangeAttrs.js

@@ -79,3 +79,9 @@ export function updateChangeChildrenAttributes(changes, tr, mapping) {
         }
     });
 }
+export function restoreNode(tr, node, pos, schema) {
+    const updatedAttrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+    tr.setNodeMarkup(pos, undefined, updatedAttrs, node.marks);
+    tr.removeMark(pos, pos + node.nodeSize, schema.marks.tracked_insert);
+    tr.removeMark(pos, pos + node.nodeSize, schema.marks.tracked_delete);
+}

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/compute/setFragmentAsInserted.js

@@ -56,10 +56,10 @@ export function setFragmentAsWrapChange(inserted, attrs, schema) {
     });
     return Fragment.from(content);
 }
-export function setFragmentAsMoveChange(fragment, attrs) {
+export function setFragmentAsMoveChange(fragment, moveAttrs) {
     const content = [];
     fragment.forEach((node) => {
-        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(trackUtils.createNewMoveAttrs(attrs))] }), node.content, node.marks));
+        content.push(node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [addTrackIdIfDoesntExist(moveAttrs)] }), node.content, node.marks));
     });
     return Fragment.from(content);
 }

package/dist/es/index.js

@@ -1,5 +1,5 @@
 export { trackChangesPluginKey, trackChangesPlugin } from './plugin';
-export { skipTracking } from './actions';
+export { skipTracking, setAction, TrackChangesAction } from './actions';
 export * as trackCommands from './commands';
 export { enableDebug } from './utils/logger';
 export { ChangeSet } from './ChangeSet';

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,14 @@ 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);
     }
@@ -31,5 +39,13 @@ export function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
         return;
     }
     const newDeleted = addTrackIdIfDoesntExist(deleteAttrs);
-    newTr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: updated ? [newDeleted, updated] : [newDeleted] }), node.marks);
+    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 keepDeleteWithMoveNodeId = (node) => {
+    var _a;
+    const dataTracked = (_a = getBlockInlineTrackedData(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => c.operation === CHANGE_OPERATION.delete && c.moveNodeId);
+    return (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.length) ? dataTracked : null;
+};

package/dist/es/mutate/dropStructureChange.js

@@ -0,0 +1,100 @@
+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, dropDataTracked) => {
+    const changeSet = findChanges(EditorState.create({ doc: newTr.doc }));
+    const shadowIds = 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 (!shadowIds.size && !changesIds.size) {
+        return;
+    }
+    changeSet.changes.forEach((c) => {
+        if (c.dataTracked.moveNodeId &&
+            !(shadowIds.has(c.dataTracked.moveNodeId) && changesIds.has(c.dataTracked.moveNodeId))) {
+            if (c.dataTracked.operation === CHANGE_OPERATION.delete || dropDataTracked) {
+                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 _a = c.dataTracked, { id, moveNodeId } = _a, attrs = __rest(_a, ["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

@@ -1,20 +1,21 @@
 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) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
         const { slice } = step;
         log.info('TR: steps before applying delete', [...newTr.steps]);
@@ -41,16 +42,20 @@ 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) {
-                fragment = setFragmentAsMoveChange(newSliceContent, trackUtils.createNewMoveAttrs(attrs));
+            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));
             }
             const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
             const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
             const textWasDeleted = !!changeSteps.length && !(fromA === fromB);
-            const isBlock = !!((_a = fragment.firstChild) === null || _a === void 0 ? void 0 : _a.isBlock);
+            const isBlock = !!((_b = fragment.firstChild) === null || _b === void 0 ? void 0 : _b.isBlock);
             changeSteps.push({
                 type: 'insert-slice',
                 from: textWasDeleted ? fromB : isBlock ? toA : fromA,
@@ -60,8 +65,8 @@ export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResul
             });
         }
         else {
-            const isDeleteEvent = ((_b = window.event) === null || _b === void 0 ? void 0 : _b.code) === 'Delete';
-            const isDeleteContentForward = ((_c = window.event) === null || _c === void 0 ? void 0 : _c.inputType) === 'deleteContentForward';
+            const isDeleteEvent = ((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Delete';
+            const isDeleteContentForward = ((_d = window.event) === null || _d === void 0 ? void 0 : _d.inputType) === 'deleteContentForward';
             selectionPos = isDeleteEvent || isDeleteContentForward ? toA : fromA;
         }
     });