@manuscripts/track-changes-plugin 1.7.2-LEAN-2832 → 1.7.2-LEAN-3046

package/dist/index.cjs

@@ -478,7 +478,7 @@ function deleteNode(node, pos, tr) {
  */
 function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
     const dataTracked = getBlockInlineTrackedData(node);
-    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert && d.status === exports.CHANGE_STATUS.pending);
+    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert);
     const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.delete);
     const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.set_node_attributes);
     if (inserted && inserted.authorID === deleteAttrs.authorID) {
@@ -1412,95 +1412,105 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
     let selectionPos = startPos;
     // @TODO add custom handler / condition?
+    let deletesCounter = 0; // counter for deletion
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
-        log.info('process change: ', c);
-        // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
-        if (c.type === 'delete-node') {
-            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-            const newestStep = newTr.steps[newTr.steps.length - 1];
-            if (step !== newestStep) {
-                mapping.appendMap(newestStep.getMap());
-                step = newestStep;
-            }
-            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'delete-text') {
-            const node = newTr.doc.nodeAt(mapping.map(c.pos));
-            if (!node) {
-                log.error(`processChangeSteps: no text node found for text-change`, c);
-                return;
-            }
-            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
-            mergeTrackedMarks(where, newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'merge-fragment') {
-            let insertPos = mapping.map(c.mergePos);
-            // The default insert position for block nodes is either the start of the merged content or the end.
-            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-            // actual position of the merge. Currently the inserted content is inserted at the start or end
-            // of the merged content, TODO reverse the start/end when end/start token?
-            if (c.node.isText) {
-                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                // the text node.
-                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+        switch (c.type) {
+            case "delete-node":
+                deletesCounter++; // increase the counter for deleted nodes
+                let trackedData = getBlockInlineTrackedData(c.node);
+                const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === exports.CHANGE_OPERATION.insert);
+                // For inserted node: the top node and its content (children nodes) is deleted in the first step
+                if (inserted && deletesCounter > 1)
+                    return false;
+                deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
                 if (step !== newestStep) {
                     mapping.appendMap(newestStep.getMap());
                     step = newestStep;
                 }
-            }
-            if (c.fragment.size > 0) {
-                newTr.insert(insertPos, c.fragment);
-            }
-        }
-        else if (c.type === 'insert-slice') {
-            const newStep = new prosemirrorTransform.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
-            const stepResult = newTr.maybeStep(newStep);
-            if (stepResult.failed) {
-                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
-                return;
-            }
-            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
-            const to = mapping.map(c.to) + c.slice.size;
-            mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
-            selectionPos = mapping.map(c.to) + c.slice.size;
-        }
-        else if (c.type === 'update-node-attrs') {
-            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
-            const oldUpdate = oldDataTracked.reverse().find((d) => {
-                // reversing to start from the most recent change
-                if (d.operation === exports.CHANGE_OPERATION.set_node_attributes &&
-                    (d.status === exports.CHANGE_STATUS.pending || d.status === exports.CHANGE_STATUS.rejected)) {
-                    return true;
+                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case "delete-text":
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
                 }
-                return false;
-            });
-            // if the selected last change is with status "rejected" we need to use oldAttrs from it because
-            // node's actual attributes represent the "rejected" values
-            const lastChangeRejected = oldUpdate && oldUpdate.status === exports.CHANGE_STATUS.rejected;
-            const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
-            const { dataTracked, ...restAttrs } = sourceAttrs;
-            const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
-            const newDataTracked = [
-                ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
-            ];
-            const newUpdate = oldUpdate && oldUpdate.status !== exports.CHANGE_STATUS.rejected
-                ? {
-                    ...oldUpdate,
-                    updatedAt: emptyAttrs.updatedAt,
+                const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                mergeTrackedMarks(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                // The default insert position for block nodes is either the start of the merged content or the end.
+                // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+                // actual position of the merge. Currently the inserted content is inserted at the start or end
+                // of the merged content, TODO reverse the start/end when end/start token?
+                if (c.node.isText) {
+                    // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                    // the text node.
+                    insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                    const newestStep = newTr.steps[newTr.steps.length - 1];
+                    if (step !== newestStep) {
+                        mapping.appendMap(newestStep.getMap());
+                        step = newestStep;
+                    }
                 }
-                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
-            // Dont add update changes if there exists already an insert change for this node
-            if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
-                c.node.type === c.node.type.schema.nodes.citation) &&
-                !oldDataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert && d.status === exports.CHANGE_STATUS.pending)) {
-                newDataTracked.push(newUpdate);
-            }
-            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
-                ...c.newAttrs,
-                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
-            }, c.node.marks);
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new prosemirrorTransform.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
+                selectionPos = mapping.map(c.to) + c.slice.size;
+                break;
+            case 'update-node-attrs':
+                const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    // reversing to start from the most recent change
+                    if (d.operation === exports.CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === exports.CHANGE_STATUS.pending || d.status === exports.CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                // if the selected last change is with status "rejected" we need to use oldAttrs from it because
+                // node's actual attributes represent the "rejected" values
+                const lastChangeRejected = oldUpdate && oldUpdate.status === exports.CHANGE_STATUS.rejected;
+                const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+                const { dataTracked, ...restAttrs } = sourceAttrs;
+                const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
+                const newDataTracked = [
+                    ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
+                ];
+                const newUpdate = oldUpdate && oldUpdate.status !== exports.CHANGE_STATUS.rejected
+                    ? {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    }
+                    : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
+                // Dont add update changes if there exists already an insert change for this node
+                if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
+                    c.node.type === c.node.type.schema.nodes.citation) &&
+                    !oldDataTracked.find((d) => d.operation === exports.CHANGE_OPERATION.insert && d.status === exports.CHANGE_STATUS.pending)) {
+                    newDataTracked.push(newUpdate);
+                }
+                newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                    ...c.newAttrs,
+                    dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+                }, c.node.marks);
+                break;
+            default:
+                log.error(`processChangeSteps: unknown change type`, c);
+                return;
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
         if (step !== newestStep) {

package/dist/index.js

@@ -470,7 +470,7 @@ function deleteNode(node, pos, tr) {
  */
 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.status === CHANGE_STATUS.pending);
+    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.insert);
     const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.delete);
     const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
     if (inserted && inserted.authorID === deleteAttrs.authorID) {
@@ -1404,95 +1404,105 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
     const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
     let selectionPos = startPos;
     // @TODO add custom handler / condition?
+    let deletesCounter = 0; // counter for deletion
     changes.forEach((c) => {
         let step = newTr.steps[newTr.steps.length - 1];
-        log.info('process change: ', c);
-        // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
-        if (c.type === 'delete-node') {
-            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
-            const newestStep = newTr.steps[newTr.steps.length - 1];
-            if (step !== newestStep) {
-                mapping.appendMap(newestStep.getMap());
-                step = newestStep;
-            }
-            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'delete-text') {
-            const node = newTr.doc.nodeAt(mapping.map(c.pos));
-            if (!node) {
-                log.error(`processChangeSteps: no text node found for text-change`, c);
-                return;
-            }
-            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
-            mergeTrackedMarks(where, newTr.doc, newTr, schema);
-        }
-        else if (c.type === 'merge-fragment') {
-            let insertPos = mapping.map(c.mergePos);
-            // The default insert position for block nodes is either the start of the merged content or the end.
-            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-            // actual position of the merge. Currently the inserted content is inserted at the start or end
-            // of the merged content, TODO reverse the start/end when end/start token?
-            if (c.node.isText) {
-                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                // the text node.
-                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+        switch (c.type) {
+            case "delete-node":
+                deletesCounter++; // increase the counter for deleted nodes
+                let trackedData = getBlockInlineTrackedData(c.node);
+                const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === CHANGE_OPERATION.insert);
+                // For inserted node: the top node and its content (children nodes) is deleted in the first step
+                if (inserted && deletesCounter > 1)
+                    return false;
+                deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
                 const newestStep = newTr.steps[newTr.steps.length - 1];
                 if (step !== newestStep) {
                     mapping.appendMap(newestStep.getMap());
                     step = newestStep;
                 }
-            }
-            if (c.fragment.size > 0) {
-                newTr.insert(insertPos, c.fragment);
-            }
-        }
-        else if (c.type === 'insert-slice') {
-            const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
-            const stepResult = newTr.maybeStep(newStep);
-            if (stepResult.failed) {
-                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
-                return;
-            }
-            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
-            const to = mapping.map(c.to) + c.slice.size;
-            mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
-            selectionPos = mapping.map(c.to) + c.slice.size;
-        }
-        else if (c.type === 'update-node-attrs') {
-            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
-            const oldUpdate = oldDataTracked.reverse().find((d) => {
-                // reversing to start from the most recent change
-                if (d.operation === CHANGE_OPERATION.set_node_attributes &&
-                    (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
-                    return true;
+                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case "delete-text":
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
                 }
-                return false;
-            });
-            // if the selected last change is with status "rejected" we need to use oldAttrs from it because
-            // node's actual attributes represent the "rejected" values
-            const lastChangeRejected = oldUpdate && oldUpdate.status === CHANGE_STATUS.rejected;
-            const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
-            const { dataTracked, ...restAttrs } = sourceAttrs;
-            const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
-            const newDataTracked = [
-                ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
-            ];
-            const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
-                ? {
-                    ...oldUpdate,
-                    updatedAt: emptyAttrs.updatedAt,
+                const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                mergeTrackedMarks(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                // The default insert position for block nodes is either the start of the merged content or the end.
+                // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+                // actual position of the merge. Currently the inserted content is inserted at the start or end
+                // of the merged content, TODO reverse the start/end when end/start token?
+                if (c.node.isText) {
+                    // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                    // the text node.
+                    insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                    const newestStep = newTr.steps[newTr.steps.length - 1];
+                    if (step !== newestStep) {
+                        mapping.appendMap(newestStep.getMap());
+                        step = newestStep;
+                    }
                 }
-                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
-            // Dont add update changes if there exists already an insert change for this node
-            if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
-                c.node.type === c.node.type.schema.nodes.citation) &&
-                !oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.insert && d.status === CHANGE_STATUS.pending)) {
-                newDataTracked.push(newUpdate);
-            }
-            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
-                ...c.newAttrs,
-                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
-            }, c.node.marks);
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
+                selectionPos = mapping.map(c.to) + c.slice.size;
+                break;
+            case 'update-node-attrs':
+                const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    // reversing to start from the most recent change
+                    if (d.operation === CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                // if the selected last change is with status "rejected" we need to use oldAttrs from it because
+                // node's actual attributes represent the "rejected" values
+                const lastChangeRejected = oldUpdate && oldUpdate.status === CHANGE_STATUS.rejected;
+                const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+                const { dataTracked, ...restAttrs } = sourceAttrs;
+                const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
+                const newDataTracked = [
+                    ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
+                ];
+                const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
+                    ? {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    }
+                    : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
+                // Dont add update changes if there exists already an insert change for this node
+                if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
+                    c.node.type === c.node.type.schema.nodes.citation) &&
+                    !oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.insert && d.status === CHANGE_STATUS.pending)) {
+                    newDataTracked.push(newUpdate);
+                }
+                newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                    ...c.newAttrs,
+                    dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+                }, c.node.marks);
+                break;
+            default:
+                log.error(`processChangeSteps: unknown change type`, c);
+                return;
         }
         const newestStep = newTr.steps[newTr.steps.length - 1];
         if (step !== newestStep) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "1.7.2-LEAN-2832",
+  "version": "1.7.2-LEAN-3046",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-quarterback/tree/main/quarterback-packages/track-changes-plugin",