@manuscripts/track-changes-plugin 1.7.2 → 1.7.3

package/dist/cjs/changes/updateChangeAttrs.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateChangeChildrenAttributes = exports.updateChangeAttrs = void 0;
+const logger_1 = require("../utils/logger");
+const ChangeSet_1 = require("../ChangeSet");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+function updateChangeAttrs(tr, change, trackedAttrs, schema) {
+    const node = tr.doc.nodeAt(change.from);
+    if (!node) {
+        logger_1.log.error('updateChangeAttrs: no node at the from of change ', change);
+        return tr;
+    }
+    const { operation } = trackedAttrs;
+    const oldTrackData = change.type === 'text-change' ? (0, nodeHelpers_1.getTextNodeTrackedMarkData)(node, schema) : (0, nodeHelpers_1.getBlockInlineTrackedData)(node);
+    if (!operation) {
+        logger_1.log.warn('updateChangeAttrs: unable to determine operation of change ', change);
+    }
+    else if (!oldTrackData) {
+        logger_1.log.warn('updateChangeAttrs: no old dataTracked for change ', change);
+    }
+    if (change.type === 'text-change') {
+        const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
+        if (!oldMark) {
+            logger_1.log.warn('updateChangeAttrs: no track marks for a text-change ', change);
+            return tr;
+        }
+        tr.addMark(change.from, change.to, oldMark.type.create(Object.assign(Object.assign({}, oldMark.attrs), { dataTracked: Object.assign(Object.assign({}, oldTrackData), trackedAttrs) })));
+    }
+    else if ((change.type === 'node-change' || change.type === 'node-attr-change') && !operation) {
+        tr.setNodeMarkup(change.from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: null }), node.marks);
+    }
+    else if (change.type === 'node-change' || change.type === 'node-attr-change') {
+        const trackedDataSource = (0, nodeHelpers_1.getBlockInlineTrackedData)(node) || [];
+        const targetDataTracked = trackedDataSource.find((t) => change.id === t.id);
+        const newDataTracked = trackedDataSource.map((oldTrack) => {
+            if (targetDataTracked) {
+                if (oldTrack.id === targetDataTracked.id) {
+                    return Object.assign(Object.assign({}, oldTrack), trackedAttrs);
+                }
+                return oldTrack;
+            }
+            if (oldTrack.operation === operation) {
+                return Object.assign(Object.assign({}, oldTrack), trackedAttrs);
+            }
+            return oldTrack;
+        });
+        tr.setNodeMarkup(change.from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: newDataTracked.length === 0 ? null : newDataTracked }), node.marks);
+    }
+    return tr;
+}
+exports.updateChangeAttrs = updateChangeAttrs;
+function updateChangeChildrenAttributes(changes, tr, mapping) {
+    changes.forEach((c) => {
+        if (c.type === 'node-change' && !ChangeSet_1.ChangeSet.shouldDeleteChange(c)) {
+            const from = mapping.map(c.from);
+            const node = tr.doc.nodeAt(from);
+            if (!node) {
+                return;
+            }
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
+    });
+}
+exports.updateChangeChildrenAttributes = updateChangeChildrenAttributes;

package/dist/cjs/commands.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshChanges = exports.applyAndRemoveChanges = exports.setUserID = exports.setChangeStatuses = exports.setTrackingStatus = void 0;
+const actions_1 = require("./actions");
+const plugin_1 = require("./plugin");
+const track_1 = require("./types/track");
+const setTrackingStatus = (status) => (state, dispatch) => {
+    var _a;
+    const currentStatus = (_a = plugin_1.trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status;
+    if (currentStatus) {
+        let newStatus = status;
+        if (newStatus === undefined) {
+            newStatus =
+                currentStatus === track_1.TrackChangesStatus.enabled
+                    ? track_1.TrackChangesStatus.disabled
+                    : track_1.TrackChangesStatus.enabled;
+        }
+        dispatch && dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.setPluginStatus, newStatus));
+        return true;
+    }
+    return false;
+};
+exports.setTrackingStatus = setTrackingStatus;
+const setChangeStatuses = (status, ids) => (state, dispatch) => {
+    dispatch &&
+        dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.setChangeStatuses, {
+            status,
+            ids,
+        }));
+    return true;
+};
+exports.setChangeStatuses = setChangeStatuses;
+const setUserID = (userID) => (state, dispatch) => {
+    dispatch && dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.setUserID, userID));
+    return true;
+};
+exports.setUserID = setUserID;
+const applyAndRemoveChanges = () => (state, dispatch) => {
+    dispatch && dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.applyAndRemoveChanges, true));
+    return true;
+};
+exports.applyAndRemoveChanges = applyAndRemoveChanges;
+const refreshChanges = () => (state, dispatch) => {
+    dispatch && dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.refreshChanges, true));
+    return true;
+};
+exports.refreshChanges = refreshChanges;

package/dist/cjs/compute/nodeHelpers.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMergeableMarkTrackedAttrs = exports.shouldMergeTrackedAttributes = exports.equalMarks = exports.getNodeTrackedData = exports.getBlockInlineTrackedData = exports.getTextNodeTrackedMarkData = exports.addTrackIdIfDoesntExist = void 0;
+const change_1 = require("../types/change");
+const logger_1 = require("../utils/logger");
+const uuidv4_1 = require("../utils/uuidv4");
+function addTrackIdIfDoesntExist(attrs) {
+    if (!attrs.id) {
+        return Object.assign({ id: (0, uuidv4_1.uuidv4)() }, attrs);
+    }
+    return attrs;
+}
+exports.addTrackIdIfDoesntExist = addTrackIdIfDoesntExist;
+function getTextNodeTrackedMarkData(node, schema) {
+    if (!node || !node.isText) {
+        return undefined;
+    }
+    const marksTrackedData = [];
+    node.marks.forEach((mark) => {
+        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
+            const operation = mark.type === schema.marks.tracked_insert
+                ? change_1.CHANGE_OPERATION.insert
+                : change_1.CHANGE_OPERATION.delete;
+            marksTrackedData.push(Object.assign(Object.assign({}, mark.attrs.dataTracked), { operation }));
+        }
+    });
+    if (marksTrackedData.length > 1) {
+        logger_1.log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
+    }
+    return marksTrackedData[0] || undefined;
+}
+exports.getTextNodeTrackedMarkData = getTextNodeTrackedMarkData;
+function getBlockInlineTrackedData(node) {
+    const { dataTracked } = node.attrs;
+    if (dataTracked && !Array.isArray(dataTracked)) {
+        return [dataTracked];
+    }
+    return dataTracked;
+}
+exports.getBlockInlineTrackedData = getBlockInlineTrackedData;
+function getNodeTrackedData(node, schema) {
+    let tracked;
+    if (node && !node.isText) {
+        tracked = getBlockInlineTrackedData(node);
+    }
+    else if (node === null || node === void 0 ? void 0 : node.isText) {
+        tracked = getTextNodeTrackedMarkData(node, schema);
+    }
+    if (tracked && !Array.isArray(tracked)) {
+        tracked = [tracked];
+    }
+    return tracked;
+}
+exports.getNodeTrackedData = getNodeTrackedData;
+function equalMarks(n1, n2) {
+    return (n1.marks.length === n2.marks.length &&
+        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
+}
+exports.equalMarks = equalMarks;
+function shouldMergeTrackedAttributes(left, right) {
+    if (!left || !right) {
+        logger_1.log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
+            left,
+            right,
+        });
+        return false;
+    }
+    return (left.status === right.status &&
+        left.operation === right.operation &&
+        left.authorID === right.authorID);
+}
+exports.shouldMergeTrackedAttributes = shouldMergeTrackedAttributes;
+function getMergeableMarkTrackedAttrs(node, attrs, schema) {
+    const nodeAttrs = getTextNodeTrackedMarkData(node, schema);
+    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
+}
+exports.getMergeableMarkTrackedAttrs = getMergeableMarkTrackedAttrs;

package/dist/cjs/compute/setFragmentAsInserted.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFragmentAsInserted = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const logger_1 = require("../utils/logger");
+const change_1 = require("../types/change");
+const nodeHelpers_1 = require("./nodeHelpers");
+function markInlineNodeChange(node, newTrackAttrs, schema) {
+    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
+    const mark = newTrackAttrs.operation === change_1.CHANGE_OPERATION.insert
+        ? schema.marks.tracked_insert
+        : schema.marks.tracked_delete;
+    const createdMark = mark.create({
+        dataTracked: (0, nodeHelpers_1.addTrackIdIfDoesntExist)(newTrackAttrs),
+    });
+    return node.mark(filtered.concat(createdMark));
+}
+function loopContentAndMergeText(content, newTrackAttrs, schema) {
+    var _a;
+    const updatedChildren = [];
+    for (let i = 0; i < content.childCount; i += 1) {
+        const recursed = recurseNodeContent(content.child(i), newTrackAttrs, schema);
+        const prev = i > 0 ? updatedChildren[i - 1] : null;
+        if ((prev === null || prev === void 0 ? void 0 : prev.isText) &&
+            recursed.isText &&
+            (0, nodeHelpers_1.equalMarks)(prev, recursed) &&
+            ((_a = (0, nodeHelpers_1.getTextNodeTrackedMarkData)(prev, schema)) === null || _a === void 0 ? void 0 : _a.operation) === change_1.CHANGE_OPERATION.insert) {
+            updatedChildren.splice(i - 1, 1, schema.text('' + prev.text + recursed.text, prev.marks));
+        }
+        else {
+            updatedChildren.push(recursed);
+        }
+    }
+    return updatedChildren;
+}
+function recurseNodeContent(node, newTrackAttrs, schema) {
+    if (node.isText) {
+        return markInlineNodeChange(node, newTrackAttrs, schema);
+    }
+    else if (node.isBlock || node.isInline) {
+        const updatedChildren = loopContentAndMergeText(node.content, newTrackAttrs, schema);
+        return node.type.create(Object.assign(Object.assign({}, node.attrs), { dataTracked: [(0, nodeHelpers_1.addTrackIdIfDoesntExist)(newTrackAttrs)] }), prosemirror_model_1.Fragment.fromArray(updatedChildren), node.marks);
+    }
+    else {
+        logger_1.log.error(`unhandled node type: "${node.type.name}"`, node);
+        return node;
+    }
+}
+function setFragmentAsInserted(inserted, insertAttrs, schema) {
+    const updatedInserted = loopContentAndMergeText(inserted, insertAttrs, schema);
+    return updatedInserted.length === 0 ? prosemirror_model_1.Fragment.empty : prosemirror_model_1.Fragment.fromArray(updatedInserted);
+}
+exports.setFragmentAsInserted = setFragmentAsInserted;

package/dist/cjs/compute/splitSliceIntoMergedParts.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSliceIntoMergedParts = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+function getMergedNode(node, currentDepth, depth, first) {
+    if (currentDepth === depth) {
+        return {
+            mergedNodeContent: node.content,
+            unmergedContent: undefined,
+        };
+    }
+    const result = [];
+    let merged = prosemirror_model_1.Fragment.empty;
+    node.content.forEach((n, _, i) => {
+        if ((first && i === 0) || (!first && i === node.childCount - 1)) {
+            const { mergedNodeContent, unmergedContent } = getMergedNode(n, currentDepth + 1, depth, first);
+            merged = mergedNodeContent;
+            if (unmergedContent) {
+                result.push(...unmergedContent.content);
+            }
+        }
+        else {
+            result.push(n);
+        }
+    });
+    return {
+        mergedNodeContent: merged,
+        unmergedContent: result.length > 0 ? prosemirror_model_1.Fragment.fromArray(result) : undefined,
+    };
+}
+function splitSliceIntoMergedParts(insertSlice, mergeEqualSides = false) {
+    const { openStart, openEnd, content: { firstChild, lastChild, content: nodes }, } = insertSlice;
+    let updatedSliceNodes = nodes;
+    const mergeSides = openStart !== openEnd || mergeEqualSides;
+    const firstMergedNode = openStart > 0 && mergeSides && firstChild
+        ? getMergedNode(firstChild, 1, openStart, true)
+        : undefined;
+    const lastMergedNode = openEnd > 0 && mergeSides && lastChild ? getMergedNode(lastChild, 1, openEnd, false) : undefined;
+    if (firstMergedNode) {
+        updatedSliceNodes = updatedSliceNodes.slice(1);
+        if (firstMergedNode.unmergedContent) {
+            updatedSliceNodes = [...firstMergedNode.unmergedContent.content, ...updatedSliceNodes];
+        }
+    }
+    if (lastMergedNode) {
+        updatedSliceNodes = updatedSliceNodes.slice(0, -1);
+        if (lastMergedNode.unmergedContent) {
+            updatedSliceNodes = [...updatedSliceNodes, ...lastMergedNode.unmergedContent.content];
+        }
+    }
+    return {
+        updatedSliceNodes,
+        firstMergedNode,
+        lastMergedNode,
+    };
+}
+exports.splitSliceIntoMergedParts = splitSliceIntoMergedParts;

package/dist/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSet = exports.enableDebug = exports.trackCommands = exports.skipTracking = exports.trackChangesPlugin = exports.trackChangesPluginKey = void 0;
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "trackChangesPluginKey", { enumerable: true, get: function () { return plugin_1.trackChangesPluginKey; } });
+Object.defineProperty(exports, "trackChangesPlugin", { enumerable: true, get: function () { return plugin_1.trackChangesPlugin; } });
+var actions_1 = require("./actions");
+Object.defineProperty(exports, "skipTracking", { enumerable: true, get: function () { return actions_1.skipTracking; } });
+exports.trackCommands = __importStar(require("./commands"));
+var logger_1 = require("./utils/logger");
+Object.defineProperty(exports, "enableDebug", { enumerable: true, get: function () { return logger_1.enableDebug; } });
+var ChangeSet_1 = require("./ChangeSet");
+Object.defineProperty(exports, "ChangeSet", { enumerable: true, get: function () { return ChangeSet_1.ChangeSet; } });
+__exportStar(require("./types/change"), exports);
+__exportStar(require("./types/track"), exports);

package/dist/cjs/mutate/deleteAndMergeSplitNodes.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteAndMergeSplitNodes = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const splitSliceIntoMergedParts_1 = require("../compute/splitSliceIntoMergedParts");
+const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
+const trackUtils = __importStar(require("../utils/track-utils"));
+function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
+    const steps = [];
+    if (from === to) {
+        return {
+            newSliceContent: insertSlice.content,
+            sliceWasSplit: false,
+            steps,
+        };
+    }
+    const { openStart, openEnd } = insertSlice;
+    const { updatedSliceNodes, firstMergedNode, lastMergedNode } = (0, splitSliceIntoMergedParts_1.splitSliceIntoMergedParts)(insertSlice, gap !== undefined);
+    let mergingStartSide = true;
+    startDoc.nodesBetween(from, to, (node, pos) => {
+        const nodeEnd = pos + node.nodeSize;
+        const wasWithinGap = gap &&
+            ((!node.isText && pos >= gap.start) ||
+                (node.isText && pos >= gap.start && nodeEnd <= gap.end));
+        if (nodeEnd > from && !wasWithinGap) {
+            const nodeCompletelyDeleted = pos >= from && nodeEnd <= to;
+            const endTokenDeleted = nodeEnd <= to;
+            const startTokenDeleted = pos >= from;
+            if (node.isText ||
+                (!endTokenDeleted && startTokenDeleted) ||
+                (endTokenDeleted && !startTokenDeleted)) {
+                if (!endTokenDeleted && startTokenDeleted) {
+                    mergingStartSide = false;
+                }
+                const depth = newTr.doc.resolve(pos).depth;
+                const mergeContent = mergingStartSide
+                    ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
+                    : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
+                const mergeStartNode = endTokenDeleted && openStart > 0 && depth === openStart && mergeContent !== undefined;
+                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent !== undefined;
+                if (mergeStartNode || mergeEndNode) {
+                    steps.push({
+                        type: 'merge-fragment',
+                        pos,
+                        mergePos: mergeStartNode ? nodeEnd - openStart : pos + openEnd,
+                        from,
+                        to,
+                        node,
+                        fragment: (0, setFragmentAsInserted_1.setFragmentAsInserted)(mergeContent, trackUtils.createNewInsertAttrs(trackAttrs), schema),
+                    });
+                }
+                else if (node.isText) {
+                    steps.push({
+                        type: 'delete-text',
+                        pos,
+                        from: Math.max(pos, from),
+                        to: Math.min(nodeEnd, to),
+                        node,
+                    });
+                }
+                else if (startTokenDeleted) {
+                }
+            }
+            else if (nodeCompletelyDeleted) {
+                steps.push({
+                    type: 'delete-node',
+                    pos,
+                    nodeEnd,
+                    node,
+                });
+            }
+        }
+    });
+    return {
+        sliceWasSplit: !!(firstMergedNode || lastMergedNode),
+        newSliceContent: updatedSliceNodes
+            ? prosemirror_model_1.Fragment.fromArray(updatedSliceNodes)
+            : insertSlice.content,
+        steps,
+    };
+}
+exports.deleteAndMergeSplitNodes = deleteAndMergeSplitNodes;

package/dist/cjs/mutate/deleteNode.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteOrSetNodeDeleted = exports.deleteNode = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_transform_1 = require("prosemirror-transform");
+const logger_1 = require("../utils/logger");
+const change_1 = require("../types/change");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+function deleteNode(node, pos, tr) {
+    var _a;
+    const startPos = tr.doc.resolve(pos + 1);
+    const range = startPos.blockRange(tr.doc.resolve(startPos.pos - 2 + node.nodeSize));
+    const targetDepth = range && (0, prosemirror_transform_1.liftTarget)(range);
+    if (range && typeof targetDepth === 'number') {
+        return tr.lift(range, targetDepth);
+    }
+    const resPos = tr.doc.resolve(pos);
+    const canMergeToNodeAbove = resPos.parent !== tr.doc && resPos.nodeBefore && node.isBlock && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
+    if (canMergeToNodeAbove) {
+        return tr.replaceWith(pos - 1, pos + 1, prosemirror_model_1.Fragment.empty);
+    }
+    else {
+        return tr.delete(pos, pos + node.nodeSize);
+    }
+}
+exports.deleteNode = deleteNode;
+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);
+    const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.delete);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.set_node_attributes);
+    if (inserted && inserted.authorID === deleteAttrs.authorID) {
+        return deleteNode(node, pos, newTr);
+    }
+    if (!newTr.doc.nodeAt(pos)) {
+        logger_1.log.error(`deleteOrSetNodeDeleted: no node found for deletion`, { pos, node, newTr });
+        return;
+    }
+    const newDeleted = deleted
+        ? Object.assign(Object.assign({}, deleted), { updatedAt: deleteAttrs.updatedAt }) : (0, nodeHelpers_1.addTrackIdIfDoesntExist)(deleteAttrs);
+    newTr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: updated ? [newDeleted, updated] : [newDeleted] }), node.marks);
+}
+exports.deleteOrSetNodeDeleted = deleteOrSetNodeDeleted;

package/dist/cjs/mutate/deleteText.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTextIfInserted = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
+    const start = from ? Math.max(pos, from) : pos;
+    const nodeEnd = pos + node.nodeSize;
+    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
+    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
+        newTr.replaceWith(start, end, prosemirror_model_1.Fragment.empty);
+        return start;
+    }
+    else {
+        const leftNode = newTr.doc.resolve(start).nodeBefore;
+        const leftMarks = (0, nodeHelpers_1.getMergeableMarkTrackedAttrs)(leftNode, deleteAttrs, schema);
+        const rightNode = newTr.doc.resolve(end).nodeAfter;
+        const rightMarks = (0, nodeHelpers_1.getMergeableMarkTrackedAttrs)(rightNode, deleteAttrs, schema);
+        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
+        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
+        const createdAt = Math.min((leftMarks === null || leftMarks === void 0 ? void 0 : leftMarks.createdAt) || Number.MAX_VALUE, (rightMarks === null || rightMarks === void 0 ? void 0 : rightMarks.createdAt) || Number.MAX_VALUE, deleteAttrs.createdAt);
+        const dataTracked = (0, nodeHelpers_1.addTrackIdIfDoesntExist)(Object.assign(Object.assign(Object.assign(Object.assign({}, leftMarks), rightMarks), deleteAttrs), { createdAt }));
+        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
+            dataTracked,
+        }));
+        return toEndOfMark;
+    }
+}
+exports.deleteTextIfInserted = deleteTextIfInserted;

package/dist/cjs/mutate/mergeNode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeNode = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_transform_1 = require("prosemirror-transform");
+function mergeNode(node, pos, tr) {
+    var _a;
+    if ((0, prosemirror_transform_1.canJoin)(tr.doc, pos)) {
+        return tr.join(pos);
+    }
+    else if (!tr.doc.resolve(pos).nodeBefore) {
+        return undefined;
+    }
+    const resPos = tr.doc.resolve(pos);
+    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
+    if (canMergeToNodeAbove) {
+        return tr.replaceWith(pos - 1, pos + 1, prosemirror_model_1.Fragment.empty);
+    }
+    return undefined;
+}
+exports.mergeNode = mergeNode;

package/dist/cjs/mutate/mergeTrackedMarks.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTrackedMarks = void 0;
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+function mergeTrackedMarks(pos, doc, newTr, schema) {
+    const resolved = doc.resolve(pos);
+    const { nodeAfter, nodeBefore } = resolved;
+    const leftMark = nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    const rightMark = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
+        return;
+    }
+    const leftDataTracked = leftMark.attrs.dataTracked;
+    const rightDataTracked = rightMark.attrs.dataTracked;
+    if (!(0, nodeHelpers_1.shouldMergeTrackedAttributes)(leftDataTracked, rightDataTracked)) {
+        return;
+    }
+    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
+    const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
+    const dataTracked = Object.assign(Object.assign({}, ancestorAttrs), { updatedAt: Date.now() });
+    const fromStartOfMark = pos - nodeBefore.nodeSize;
+    const toEndOfMark = pos + nodeAfter.nodeSize;
+    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create(Object.assign(Object.assign({}, leftMark.attrs), { dataTracked })));
+}
+exports.mergeTrackedMarks = mergeTrackedMarks;