@manuscripts/track-changes-plugin 1.7.2 → 1.7.3

package/dist/cjs/ChangeSet.js

@@ -0,0 +1,155 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSet = void 0;
+const change_1 = require("./types/change");
+const logger_1 = require("./utils/logger");
+class ChangeSet {
+    constructor(changes = []) {
+        _ChangeSet_instances.add(this);
+        _ChangeSet_changes.set(this, void 0);
+        __classPrivateFieldSet(this, _ChangeSet_changes, changes, "f");
+    }
+    get changes() {
+        const iteratedIds = new Set();
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => {
+            const valid = !iteratedIds.has(c.dataTracked.id) && ChangeSet.isValidDataTracked(c.dataTracked);
+            iteratedIds.add(c.dataTracked.id);
+            return valid;
+        });
+    }
+    get invalidChanges() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => !this.changes.find((cc) => c.id === cc.id));
+    }
+    get changeTree() {
+        const rootNodes = [];
+        let currentNodeChange;
+        this.changes.forEach((c) => {
+            if (currentNodeChange && c.from >= currentNodeChange.to) {
+                rootNodes.push(currentNodeChange);
+                currentNodeChange = undefined;
+            }
+            if (currentNodeChange &&
+                c.from < currentNodeChange.to &&
+                !(__classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isSameNodeChange).call(this, currentNodeChange, c) &&
+                    __classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isNotPendingOrDeleted).call(this, currentNodeChange))) {
+                currentNodeChange.children.push(c);
+            }
+            else if (c.type === 'node-change') {
+                currentNodeChange = Object.assign(Object.assign({}, c), { children: [] });
+            }
+            else {
+                rootNodes.push(c);
+            }
+        });
+        if (currentNodeChange) {
+            rootNodes.push(currentNodeChange);
+        }
+        return rootNodes;
+    }
+    get pending() {
+        return this.changeTree.filter((c) => c.dataTracked.status === change_1.CHANGE_STATUS.pending);
+    }
+    get accepted() {
+        return this.changeTree.filter((c) => c.dataTracked.status === change_1.CHANGE_STATUS.accepted);
+    }
+    get rejected() {
+        return this.changeTree.filter((c) => c.dataTracked.status === change_1.CHANGE_STATUS.rejected);
+    }
+    get textChanges() {
+        return this.changes.filter((c) => c.type === 'text-change');
+    }
+    get nodeChanges() {
+        return this.changes.filter((c) => c.type === 'node-change');
+    }
+    get nodeAttrChanges() {
+        return this.changes.filter((c) => c.type === 'node-attr-change');
+    }
+    get bothNodeChanges() {
+        return this.changes.filter((c) => c.type === 'node-change' || c.type === 'node-attr-change');
+    }
+    get isEmpty() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
+    }
+    get hasInconsistentData() {
+        return this.hasDuplicateIds || this.hasIncompleteAttrs;
+    }
+    get hasDuplicateIds() {
+        const iterated = new Set();
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => {
+            if (iterated.has(c.id)) {
+                return true;
+            }
+            iterated.add(c.id);
+        });
+    }
+    get hasIncompleteAttrs() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidDataTracked(c.dataTracked));
+    }
+    get(id) {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id);
+    }
+    getIn(ids) {
+        return ids
+            .map((id) => __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id))
+            .filter((c) => c !== undefined);
+    }
+    getNotIn(ids) {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => ids.includes(c.id));
+    }
+    static flattenTreeToIds(changes) {
+        return changes.flatMap((c) => this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id);
+    }
+    static shouldDeleteChange(change) {
+        const { status, operation } = change.dataTracked;
+        return ((operation === change_1.CHANGE_OPERATION.insert && status === change_1.CHANGE_STATUS.rejected) ||
+            (operation === change_1.CHANGE_OPERATION.delete && status === change_1.CHANGE_STATUS.accepted));
+    }
+    static isValidDataTracked(dataTracked = {}) {
+        if ('dataTracked' in dataTracked) {
+            logger_1.log.warn('passed "dataTracked" as property to isValidTrackedAttrs()', dataTracked);
+        }
+        const trackedKeys = [
+            'id',
+            'authorID',
+            'operation',
+            'status',
+            'createdAt',
+            'updatedAt',
+        ];
+        const optionalKeys = ['reviewedByID'];
+        const entries = Object.entries(dataTracked).filter(([key, val]) => trackedKeys.includes(key));
+        const optionalEntries = Object.entries(dataTracked).filter(([key, val]) => optionalKeys.includes(key));
+        return (entries.length === trackedKeys.length &&
+            entries.every(([key, val]) => trackedKeys.includes(key) && val !== undefined) &&
+            optionalEntries.every(([key, val]) => optionalKeys.includes(key) && val !== undefined) &&
+            (dataTracked.id || '').length > 0);
+    }
+    static isTextChange(change) {
+        return change.type === 'text-change';
+    }
+    static isNodeChange(change) {
+        return change.type === 'node-change';
+    }
+    static isNodeAttrChange(change) {
+        return change.type === 'node-attr-change';
+    }
+}
+exports.ChangeSet = ChangeSet;
+_ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
+    return currentChange.from === nextChange.from && currentChange.to === nextChange.to;
+}, _ChangeSet_isNotPendingOrDeleted = function _ChangeSet_isNotPendingOrDeleted(change) {
+    return (change.dataTracked.operation !== change_1.CHANGE_OPERATION.delete &&
+        change.dataTracked.status !== change_1.CHANGE_STATUS.pending);
+};

package/dist/cjs/actions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipTracking = exports.setAction = exports.getAction = exports.TrackChangesAction = void 0;
+var TrackChangesAction;
+(function (TrackChangesAction) {
+    TrackChangesAction["skipTrack"] = "track-changes-skip-tracking";
+    TrackChangesAction["setUserID"] = "track-changes-set-user-id";
+    TrackChangesAction["setPluginStatus"] = "track-changes-set-track-status";
+    TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
+    TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
+    TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
+    TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
+})(TrackChangesAction = exports.TrackChangesAction || (exports.TrackChangesAction = {}));
+function getAction(tr, action) {
+    return tr.getMeta(action);
+}
+exports.getAction = getAction;
+function setAction(tr, action, payload) {
+    return tr.setMeta(action, payload);
+}
+exports.setAction = setAction;
+const skipTracking = (tr) => setAction(tr, TrackChangesAction.skipTrack, true);
+exports.skipTracking = skipTracking;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffChangeSteps = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const matchInserted_1 = require("./matchInserted");
+const logger_1 = require("../utils/logger");
+function cutFragment(matched, deleted, content) {
+    const newContent = [];
+    for (let i = 0; matched <= deleted && i < content.childCount; i += 1) {
+        const child = content.child(i);
+        if (!child.isText && child.content.size > 0) {
+            const cut = cutFragment(matched + 1, deleted, child.content);
+            matched = cut[0];
+            newContent.push(...cut[1].content);
+        }
+        else if (child.isText && matched + child.nodeSize > deleted) {
+            if (deleted - matched > 0) {
+                newContent.push(child.cut(deleted - matched));
+            }
+            else {
+                newContent.push(child);
+            }
+            matched = deleted + 1;
+        }
+        else {
+            matched += child.nodeSize;
+        }
+    }
+    return [matched, prosemirror_model_1.Fragment.fromArray(newContent)];
+}
+function diffChangeSteps(deleted, inserted) {
+    const updated = [];
+    let updatedDeleted = [...deleted];
+    inserted.forEach((ins) => {
+        logger_1.log.info('DIFF ins ', ins);
+        if (ins.sliceWasSplit) {
+            updated.push(ins);
+            return;
+        }
+        const deleteStart = updatedDeleted.reduce((acc, cur) => {
+            if (cur.type === 'delete-node') {
+                return Math.min(acc, cur.pos);
+            }
+            else if (cur.type === 'delete-text') {
+                return Math.min(acc, cur.from);
+            }
+            return acc;
+        }, Number.MAX_SAFE_INTEGER);
+        const [matchedDeleted, updatedDel] = (0, matchInserted_1.matchInserted)(deleteStart, updatedDeleted, ins.slice.content);
+        if (matchedDeleted === deleteStart) {
+            updated.push(ins);
+            return;
+        }
+        updatedDeleted = updatedDel;
+        const [_, newInserted] = cutFragment(0, matchedDeleted - deleteStart, ins.slice.content);
+        if (newInserted.size > 0) {
+            updated.push(Object.assign(Object.assign({}, ins), { slice: new prosemirror_model_1.Slice(newInserted, ins.slice.openStart, ins.slice.openEnd) }));
+        }
+    });
+    logger_1.log.info('FINISH DIFF: ', [...updatedDeleted, ...updated]);
+    return [...updatedDeleted, ...updated];
+}
+exports.diffChangeSteps = diffChangeSteps;

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

@@ -0,0 +1,70 @@
+"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.matchInserted = void 0;
+function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
+    const { pos, from, to, node: delNode } = adjDeleted;
+    let j = offset, d = from - pos, maxSteps = to - Math.max(pos, from);
+    for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
+        matchedDeleted += 1;
+    }
+    deleted = deleted.filter((d) => d !== adjDeleted);
+    if (maxSteps !== j) {
+        deleted.push({
+            pos,
+            from: from + j - offset,
+            to,
+            type: 'delete-text',
+            node: delNode,
+        });
+        return [matchedDeleted, deleted];
+    }
+    const nextTextDelete = deleted.find((d) => d.type === 'delete-text' && d.pos === to);
+    if (nextTextDelete) {
+        return matchText(nextTextDelete, insNode, j, matchedDeleted, deleted);
+    }
+    return [matchedDeleted, deleted];
+}
+function matchInserted(matchedDeleted, deleted, inserted) {
+    var _a;
+    let matched = [matchedDeleted, deleted];
+    for (let i = 0;; i += 1) {
+        if (inserted.childCount === i) {
+            return matched;
+        }
+        const insNode = inserted.child(i);
+        const adjDeleted = matched[1].find((d) => (d.type === 'delete-text' && Math.max(d.pos, d.from) === matched[0]) ||
+            (d.type === 'delete-node' && d.pos === matched[0]));
+        if (insNode.type !== ((_a = adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node) === null || _a === void 0 ? void 0 : _a.type)) {
+            return matched;
+        }
+        else if (insNode.isText && (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node)) {
+            matched = matchText(adjDeleted, insNode, 0, matched[0], matched[1]);
+            continue;
+        }
+        else if (insNode.content.size > 0 || (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node.content.size) > 0) {
+            matched = matchInserted(matched[0] + 1, matched[1].filter((d) => d !== adjDeleted), insNode.content);
+        }
+        else {
+            matched = [matched[0] + insNode.nodeSize, matched[1].filter((d) => d !== adjDeleted)];
+        }
+        const _b = insNode.attrs || {}, { dataTracked } = _b, newAttrs = __rest(_b, ["dataTracked"]);
+        matched[1].push({
+            pos: adjDeleted.pos,
+            type: 'update-node-attrs',
+            node: adjDeleted.node,
+            newAttrs,
+        });
+    }
+}
+exports.matchInserted = matchInserted;

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

@@ -0,0 +1,141 @@
+"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 __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.processChangeSteps = void 0;
+const prosemirror_transform_1 = require("prosemirror-transform");
+const logger_1 = require("../utils/logger");
+const change_1 = require("../types/change");
+const deleteNode_1 = require("../mutate/deleteNode");
+const deleteText_1 = require("../mutate/deleteText");
+const mergeTrackedMarks_1 = require("../mutate/mergeTrackedMarks");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+const trackUtils = __importStar(require("../utils/track-utils"));
+function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
+    const mapping = new prosemirror_transform_1.Mapping();
+    const deleteAttrs = trackUtils.createNewDeleteAttrs(emptyAttrs);
+    let selectionPos = startPos;
+    let deletesCounter = 0;
+    let isInserted = false;
+    changes.forEach((c) => {
+        let step = newTr.steps[newTr.steps.length - 1];
+        switch (c.type) {
+            case "delete-node":
+                deletesCounter++;
+                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);
+                if (isInserted && deletesCounter > 1)
+                    return false;
+                (0, deleteNode_1.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;
+                }
+                (0, mergeTrackedMarks_1.mergeTrackedMarks)(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case "delete-text":
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    logger_1.log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
+                }
+                const where = (0, deleteText_1.deleteTextIfInserted)(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                (0, mergeTrackedMarks_1.mergeTrackedMarks)(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                if (c.node.isText) {
+                    insertPos = (0, deleteText_1.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;
+                    }
+                }
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new prosemirror_transform_1.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    logger_1.log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                (0, mergeTrackedMarks_1.mergeTrackedMarks)(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                (0, mergeTrackedMarks_1.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 = (0, nodeHelpers_1.getBlockInlineTrackedData)(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    if (d.operation === change_1.CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === change_1.CHANGE_STATUS.pending || d.status === change_1.CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                const lastChangeRejected = oldUpdate && oldUpdate.status === change_1.CHANGE_STATUS.rejected;
+                const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
+                const { dataTracked } = sourceAttrs, restAttrs = __rest(sourceAttrs, ["dataTracked"]);
+                const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
+                const newDataTracked = [
+                    ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
+                ];
+                const newUpdate = oldUpdate && oldUpdate.status !== change_1.CHANGE_STATUS.rejected
+                    ? Object.assign(Object.assign({}, oldUpdate), { updatedAt: emptyAttrs.updatedAt }) : (0, nodeHelpers_1.addTrackIdIfDoesntExist)(trackUtils.createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
+                if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
+                    c.node.type === c.node.type.schema.nodes.citation) &&
+                    !oldDataTracked.find((d) => d.operation === change_1.CHANGE_OPERATION.insert && d.status === change_1.CHANGE_STATUS.pending)) {
+                    newDataTracked.push(newUpdate);
+                }
+                newTr.setNodeMarkup(mapping.map(c.pos), undefined, Object.assign(Object.assign({}, c.newAttrs), { dataTracked: newDataTracked.length > 0 ? newDataTracked : null }), c.node.marks);
+                break;
+            default:
+                logger_1.log.error(`processChangeSteps: unknown change type`, c);
+                return;
+        }
+        const newestStep = newTr.steps[newTr.steps.length - 1];
+        if (step !== newestStep) {
+            mapping.appendMap(newestStep.getMap());
+        }
+    });
+    return [mapping, selectionPos];
+}
+exports.processChangeSteps = processChangeSteps;

package/dist/cjs/changes/applyChanges.js

@@ -0,0 +1,81 @@
+"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.applyAcceptedRejectedChanges = void 0;
+const prosemirror_transform_1 = require("prosemirror-transform");
+const ChangeSet_1 = require("../ChangeSet");
+const change_1 = require("../types/change");
+const logger_1 = require("../utils/logger");
+const deleteNode_1 = require("../mutate/deleteNode");
+const mergeNode_1 = require("../mutate/mergeNode");
+const updateChangeAttrs_1 = require("./updateChangeAttrs");
+function getUpdatedDataTracked(dataTracked, changeId) {
+    if (!dataTracked) {
+        return null;
+    }
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
+    return newDataTracked.length ? newDataTracked : null;
+}
+function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new prosemirror_transform_1.Mapping()) {
+    const attrsChangesLog = new Map();
+    function addAttrLog(nodeId, changeId) {
+        const arr = attrsChangesLog.get(nodeId) || attrsChangesLog.set(nodeId, []).get(nodeId);
+        arr.push(changeId);
+    }
+    changes.forEach((change) => {
+        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || !ChangeSet_1.ChangeSet.shouldDeleteChange(change);
+        if (!node) {
+            !deleted && logger_1.log.warn('no node found to update for change', change);
+            return;
+        }
+        if (change.dataTracked.status === change_1.CHANGE_STATUS.pending) {
+            if (ChangeSet_1.ChangeSet.isNodeAttrChange(change)) {
+                const _a = change.newAttrs, { dataTracked } = _a, attrs = __rest(_a, ["dataTracked"]);
+                const changeLog = attrsChangesLog.get(node.attrs.id);
+                const newDataTracked = changeLog && changeLog.length ? dataTracked.filter((c) => !changeLog.includes(c.id)) : dataTracked;
+                tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, attrs), { dataTracked: newDataTracked.length ? newDataTracked : null }), node.marks);
+            }
+            return;
+        }
+        if (ChangeSet_1.ChangeSet.isTextChange(change) && noChangeNeeded) {
+            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
+            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_delete);
+        }
+        else if (ChangeSet_1.ChangeSet.isTextChange(change)) {
+            tr.delete(from, deleteMap.map(change.to));
+            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 });
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            (0, updateChangeAttrs_1.updateChangeChildrenAttributes)(change.children, tr, deleteMap);
+        }
+        else if (ChangeSet_1.ChangeSet.isNodeChange(change)) {
+            const merged = (0, mergeNode_1.mergeNode)(node, from, tr);
+            if (merged === undefined) {
+                (0, deleteNode_1.deleteNode)(node, from, tr);
+            }
+            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+        }
+        else if (ChangeSet_1.ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === change_1.CHANGE_STATUS.accepted) {
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.newAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            addAttrLog(node.attrs.id, change.dataTracked.id);
+        }
+        else if (ChangeSet_1.ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === change_1.CHANGE_STATUS.rejected) {
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.oldAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            addAttrLog(node.attrs.id, change.dataTracked.id);
+        }
+    });
+    return deleteMap;
+}
+exports.applyAcceptedRejectedChanges = applyAcceptedRejectedChanges;

package/dist/cjs/changes/findChanges.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findChanges = void 0;
+const ChangeSet_1 = require("../ChangeSet");
+const change_1 = require("../types/change");
+const nodeHelpers_1 = require("../compute/nodeHelpers");
+function findChanges(state) {
+    const changes = [];
+    let current;
+    state.doc.descendants((node, pos) => {
+        const tracked = (0, nodeHelpers_1.getNodeTrackedData)(node, state.schema) || [];
+        for (let i = 0; i < tracked.length; i += 1) {
+            const dataTracked = tracked[i];
+            const id = dataTracked.id || '';
+            if (current &&
+                current.change.id === id &&
+                current.node.isText &&
+                node.isText &&
+                !(0, nodeHelpers_1.equalMarks)(node, current.node)) {
+                current.change.to = pos + node.nodeSize;
+                current.node = node;
+                continue;
+            }
+            current && changes.push(current.change);
+            let change;
+            if (node.isText) {
+                change = {
+                    id,
+                    type: 'text-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    text: node.text,
+                };
+            }
+            else if (dataTracked.operation === change_1.CHANGE_OPERATION.set_node_attributes) {
+                change = {
+                    id,
+                    type: 'node-attr-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    newAttrs: node.attrs,
+                    oldAttrs: dataTracked.oldAttrs,
+                };
+            }
+            else {
+                change = {
+                    id,
+                    type: 'node-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    children: [],
+                };
+            }
+            current = {
+                change,
+                node,
+            };
+        }
+        if (tracked.length === 0 && current) {
+            changes.push(current.change);
+            current = undefined;
+        }
+    });
+    current && changes.push(current.change);
+    return new ChangeSet_1.ChangeSet(changes);
+}
+exports.findChanges = findChanges;

package/dist/cjs/changes/fixInconsistentChanges.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixInconsistentChanges = void 0;
+const change_1 = require("../types/change");
+const uuidv4_1 = require("../utils/uuidv4");
+const updateChangeAttrs_1 = require("./updateChangeAttrs");
+function fixInconsistentChanges(changeSet, currentUserID, newTr, schema) {
+    const iteratedIds = new Set();
+    let changed = false;
+    changeSet.invalidChanges.forEach((c) => {
+        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.dataTracked;
+        const newAttrs = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ((!id || iteratedIds.has(id) || id.length === 0) && { id: (0, uuidv4_1.uuidv4)() })), (!authorID && { authorID: currentUserID })), (!reviewedByID && { reviewedByID: null })), (!status && { status: change_1.CHANGE_STATUS.pending })), (!createdAt && { createdAt: Date.now() })), (!updatedAt && { updatedAt: Date.now() }));
+        if (Object.keys(newAttrs).length > 0) {
+            (0, updateChangeAttrs_1.updateChangeAttrs)(newTr, c, Object.assign(Object.assign({}, c.dataTracked), newAttrs), schema);
+            changed = true;
+        }
+        iteratedIds.add(newAttrs.id || id);
+    });
+    return changed;
+}
+exports.fixInconsistentChanges = fixInconsistentChanges;