@manuscripts/track-changes-plugin 1.7.2 → 1.7.3-LEAN-2832-v4

package/dist/cjs/plugin.js

@@ -0,0 +1,125 @@
+"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.trackChangesPlugin = exports.trackChangesPluginKey = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const actions_1 = require("./actions");
+const applyChanges_1 = require("./changes/applyChanges");
+const findChanges_1 = require("./changes/findChanges");
+const fixInconsistentChanges_1 = require("./changes/fixInconsistentChanges");
+const updateChangeAttrs_1 = require("./changes/updateChangeAttrs");
+const ChangeSet_1 = require("./ChangeSet");
+const trackTransaction_1 = require("./steps/trackTransaction");
+const track_1 = require("./types/track");
+const logger_1 = require("./utils/logger");
+exports.trackChangesPluginKey = new prosemirror_state_1.PluginKey('track-changes');
+const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
+    const { userID, debug, skipTrsWithMetas = [] } = opts;
+    let editorView;
+    if (debug) {
+        (0, logger_1.enableDebug)(true);
+    }
+    return new prosemirror_state_1.Plugin({
+        key: exports.trackChangesPluginKey,
+        props: {
+            editable(state) {
+                var _a;
+                return ((_a = exports.trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status) !== track_1.TrackChangesStatus.viewSnapshots;
+            },
+        },
+        state: {
+            init(_config, state) {
+                return {
+                    status: track_1.TrackChangesStatus.enabled,
+                    userID,
+                    changeSet: (0, findChanges_1.findChanges)(state),
+                };
+            },
+            apply(tr, pluginState, _oldState, newState) {
+                const setUserID = (0, actions_1.getAction)(tr, actions_1.TrackChangesAction.setUserID);
+                const setStatus = (0, actions_1.getAction)(tr, actions_1.TrackChangesAction.setPluginStatus);
+                if (setUserID) {
+                    return Object.assign(Object.assign({}, pluginState), { userID: setUserID });
+                }
+                else if (setStatus) {
+                    return Object.assign(Object.assign({}, pluginState), { status: setStatus, changeSet: setStatus === track_1.TrackChangesStatus.disabled ? new ChangeSet_1.ChangeSet() : (0, findChanges_1.findChanges)(newState) });
+                }
+                else if (pluginState.status === track_1.TrackChangesStatus.disabled) {
+                    return Object.assign(Object.assign({}, pluginState), { changeSet: new ChangeSet_1.ChangeSet() });
+                }
+                let { changeSet } = pluginState, rest = __rest(pluginState, ["changeSet"]);
+                if ((0, actions_1.getAction)(tr, actions_1.TrackChangesAction.refreshChanges)) {
+                    changeSet = (0, findChanges_1.findChanges)(newState);
+                }
+                return Object.assign({ changeSet }, rest);
+            },
+        },
+        view(p) {
+            editorView = p;
+            return {
+                update: undefined,
+                destroy: undefined,
+            };
+        },
+        appendTransaction(trs, oldState, newState) {
+            const pluginState = exports.trackChangesPluginKey.getState(newState);
+            if (!pluginState || pluginState.status === track_1.TrackChangesStatus.disabled || !(editorView === null || editorView === void 0 ? void 0 : editorView.editable)) {
+                return null;
+            }
+            const { userID, changeSet } = pluginState;
+            let createdTr = newState.tr, docChanged = false;
+            logger_1.log.info('TRS', trs);
+            trs.forEach((tr) => {
+                const wasAppended = tr.getMeta('appendedTransaction');
+                const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
+                const skipTrackUsed = (0, actions_1.getAction)(tr, actions_1.TrackChangesAction.skipTrack) ||
+                    (wasAppended && (0, actions_1.getAction)(wasAppended, actions_1.TrackChangesAction.skipTrack));
+                if (tr.docChanged &&
+                    !skipMetaUsed &&
+                    !skipTrackUsed &&
+                    !tr.getMeta('history$') &&
+                    !(wasAppended && tr.getMeta('origin') === 'paragraphs')) {
+                    createdTr = (0, trackTransaction_1.trackTransaction)(tr, oldState, createdTr, userID);
+                }
+                docChanged = docChanged || tr.docChanged;
+                const setChangeStatuses = (0, actions_1.getAction)(tr, actions_1.TrackChangesAction.setChangeStatuses);
+                if (setChangeStatuses) {
+                    const { status, ids } = setChangeStatuses;
+                    const changeTime = new Date().getTime();
+                    ids.forEach((changeId) => {
+                        const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
+                        if (change) {
+                            createdTr = (0, updateChangeAttrs_1.updateChangeAttrs)(createdTr, change, Object.assign(Object.assign({}, change.dataTracked), { status, statusUpdateAt: changeTime, reviewedByID: userID }), oldState.schema);
+                        }
+                    });
+                }
+                else if ((0, actions_1.getAction)(tr, actions_1.TrackChangesAction.applyAndRemoveChanges)) {
+                    const mapping = (0, applyChanges_1.applyAcceptedRejectedChanges)(createdTr, oldState.schema, changeSet.bothNodeChanges);
+                    (0, applyChanges_1.applyAcceptedRejectedChanges)(createdTr, oldState.schema, changeSet.textChanges, mapping);
+                    (0, actions_1.setAction)(createdTr, actions_1.TrackChangesAction.refreshChanges, true);
+                }
+            });
+            const changed = pluginState.changeSet.hasInconsistentData &&
+                (0, fixInconsistentChanges_1.fixInconsistentChanges)(pluginState.changeSet, userID, createdTr, oldState.schema);
+            if (changed) {
+                logger_1.log.warn('had to fix inconsistent changes in', createdTr);
+            }
+            if (docChanged || createdTr.docChanged || changed) {
+                createdTr.setMeta('origin', exports.trackChangesPluginKey);
+                return (0, actions_1.setAction)(createdTr, actions_1.TrackChangesAction.refreshChanges, true);
+            }
+            return null;
+        },
+    });
+};
+exports.trackChangesPlugin = trackChangesPlugin;

package/dist/cjs/steps/trackReplaceAroundStep.js

@@ -0,0 +1,72 @@
+"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.trackReplaceAroundStep = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const actions_1 = require("../actions");
+const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
+const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes");
+const logger_1 = require("../utils/logger");
+const trackUtils = __importStar(require("../utils/track-utils"));
+function trackReplaceAroundStep(step, oldState, tr, newTr, attrs) {
+    logger_1.log.info('###### ReplaceAroundStep ######');
+    const { from, to, gapFrom, gapTo, insert, slice, structure, } = step;
+    const newStep = step.invert(oldState.doc);
+    const stepResult = newTr.maybeStep(newStep);
+    if (stepResult.failed) {
+        logger_1.log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
+        return [];
+    }
+    const gap = oldState.doc.slice(gapFrom, gapTo);
+    logger_1.log.info('RETAINED GAP CONTENT', gap);
+    const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = (0, deleteAndMergeSplitNodes_1.deleteAndMergeSplitNodes)(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    const steps = deleteSteps;
+    logger_1.log.info('TR: new steps after applying delete', [...newTr.steps]);
+    logger_1.log.info('DELETE STEPS: ', deleteSteps);
+    if (gap.size > 0 ||
+        (!structure && newSliceContent.size > 0) ||
+        tr.getMeta(actions_1.TrackChangesAction.updateMetaNode)) {
+        logger_1.log.info('newSliceContent', newSliceContent);
+        const openStart = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openStart;
+        const openEnd = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openEnd;
+        let insertedSlice = new prosemirror_model_1.Slice((0, setFragmentAsInserted_1.setFragmentAsInserted)(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
+        if (gap.size > 0 || tr.getMeta(actions_1.TrackChangesAction.updateMetaNode)) {
+            logger_1.log.info('insertedSlice before inserted gap', insertedSlice);
+            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
+            logger_1.log.info('insertedSlice after inserted gap', insertedSlice);
+        }
+        deleteSteps.push({
+            type: 'insert-slice',
+            from: gapFrom,
+            to: gapTo,
+            slice: insertedSlice,
+            sliceWasSplit,
+        });
+    }
+    else {
+    }
+    return steps;
+}
+exports.trackReplaceAroundStep = trackReplaceAroundStep;

package/dist/cjs/steps/trackReplaceStep.js

@@ -0,0 +1,81 @@
+"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.trackReplaceStep = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
+const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes");
+const logger_1 = require("../utils/logger");
+const trackUtils = __importStar(require("../utils/track-utils"));
+function trackReplaceStep(step, oldState, newTr, attrs, stepResult, currentStepDoc) {
+    logger_1.log.info('###### ReplaceStep ######');
+    let selectionPos = 0;
+    const changeSteps = [];
+    step.getMap().forEach((fromA, toA, fromB, toB) => {
+        var _a, _b;
+        logger_1.log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
+        const { slice } = step;
+        logger_1.log.info('TR: steps before applying delete', [...newTr.steps]);
+        if (stepResult.failed) {
+            logger_1.log.error(`invert ReplaceStep failed: "${stepResult.failed}"`);
+            return;
+        }
+        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = (0, deleteAndMergeSplitNodes_1.deleteAndMergeSplitNodes)(fromA, toA, undefined, currentStepDoc, newTr, oldState.schema, attrs, slice);
+        changeSteps.push(...deleteSteps);
+        logger_1.log.info('TR: steps after applying delete', [...newTr.steps]);
+        logger_1.log.info('DELETE STEPS: ', changeSteps);
+        function sameThingBackSpaced() {
+            if (changeSteps.length == 2 && newSliceContent.size > 0) {
+                const correspondingDeletion = changeSteps.find((step) => step.node.text === newSliceContent.content[0].text);
+                return correspondingDeletion;
+            }
+            return undefined;
+        }
+        const backSpacedText = sameThingBackSpaced();
+        if (backSpacedText) {
+            changeSteps.splice(changeSteps.indexOf(backSpacedText));
+        }
+        const textWasDeleted = !!changeSteps.length;
+        if (!backSpacedText && newSliceContent.size > 0) {
+            logger_1.log.info('newSliceContent', newSliceContent);
+            const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
+            const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
+            changeSteps.push({
+                type: 'insert-slice',
+                from: textWasDeleted ? fromB : toA,
+                to: textWasDeleted ? toB - 1 : toA,
+                sliceWasSplit,
+                slice: new prosemirror_model_1.Slice((0, setFragmentAsInserted_1.setFragmentAsInserted)(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd),
+            });
+        }
+        else {
+            const isDeleteEvent = ((_a = window.event) === null || _a === void 0 ? void 0 : _a.code) === 'Delete';
+            const isDeleteContentForward = ((_b = window.event) === null || _b === void 0 ? void 0 : _b.inputType) === 'deleteContentForward';
+            selectionPos = isDeleteEvent || isDeleteContentForward ? toA : fromA;
+        }
+    });
+    return [changeSteps, selectionPos];
+}
+exports.trackReplaceStep = trackReplaceStep;

package/dist/cjs/steps/trackTransaction.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackTransaction = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_transform_1 = require("prosemirror-transform");
+const diffChangeSteps_1 = require("../change-steps/diffChangeSteps");
+const processChangeSteps_1 = require("../change-steps/processChangeSteps");
+const change_1 = require("../types/change");
+const logger_1 = require("../utils/logger");
+const trackReplaceAroundStep_1 = require("./trackReplaceAroundStep");
+const trackReplaceStep_1 = require("./trackReplaceStep");
+const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
+const isHighlightMarkerNode = (node) => node && node.type === node.type.schema.nodes.highlight_marker;
+function trackTransaction(tr, oldState, newTr, authorID) {
+    var _a, _b, _c, _d;
+    const emptyAttrs = {
+        authorID,
+        reviewedByID: null,
+        createdAt: tr.time,
+        updatedAt: tr.time,
+        statusUpdateAt: 0,
+        status: change_1.CHANGE_STATUS.pending,
+    };
+    const wasNodeSelection = tr.selection instanceof prosemirror_state_1.NodeSelection;
+    let iters = 0;
+    logger_1.log.info('ORIGINAL transaction', tr);
+    for (let i = tr.steps.length - 1; i >= 0; i--) {
+        const step = tr.steps[i];
+        logger_1.log.info('transaction step', step);
+        iters += 1;
+        if (iters > 20) {
+            console.error('@manuscripts/track-changes-plugin: Possible infinite loop in iterating tr.steps, tracking skipped!\n' +
+                'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
+            continue;
+        }
+        else if (!(step instanceof prosemirror_transform_1.ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+            console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
+                'or instanceof checks fail as well as creating new steps');
+            continue;
+        }
+        else if (step instanceof prosemirror_transform_1.ReplaceStep) {
+            const { slice } = step;
+            if (((_b = (_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.length) === 1 && isHighlightMarkerNode(slice.content.content[0])) {
+                continue;
+            }
+            const newStep = step.invert(tr.docs[i]);
+            const stepResult = newTr.maybeStep(newStep);
+            let [steps, startPos] = (0, trackReplaceStep_1.trackReplaceStep)(step, oldState, newTr, emptyAttrs, stepResult, tr.docs[i]);
+            if (steps.length === 1) {
+                const step = steps[0];
+                if (isHighlightMarkerNode((step === null || step === void 0 ? void 0 : step.node) || ((_d = (_c = step === null || step === void 0 ? void 0 : step.slice) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.content[0]))) {
+                    continue;
+                }
+            }
+            logger_1.log.info('CHANGES: ', steps);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            steps = (0, diffChangeSteps_1.diffChangeSteps)(deleted, inserted);
+            logger_1.log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(steps, startPos || tr.selection.head, newTr, emptyAttrs, oldState.schema);
+            if (!wasNodeSelection) {
+                const sel = getSelectionStaticConstructor(tr.selection);
+                const near = sel.near(newTr.doc.resolve(selectionPos), -1);
+                newTr.setSelection(near);
+            }
+        }
+        else if (step instanceof prosemirror_transform_1.ReplaceAroundStep) {
+            let steps = (0, trackReplaceAroundStep_1.trackReplaceAroundStep)(step, oldState, tr, newTr, emptyAttrs);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            logger_1.log.info('INSERT STEPS: ', inserted);
+            steps = (0, diffChangeSteps_1.diffChangeSteps)(deleted, inserted);
+            logger_1.log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
+        }
+        tr.getMeta('inputType') && newTr.setMeta('inputType', tr.getMeta('inputType'));
+        tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
+    }
+    if (wasNodeSelection) {
+        console.log('%c Getting into node select! ', 'background: #222; color: #bada55');
+        const mappedPos = newTr.mapping.map(tr.selection.from, -1);
+        const sel = getSelectionStaticConstructor(tr.selection);
+        newTr.setSelection(sel.create(newTr.doc, mappedPos));
+    }
+    logger_1.log.info('NEW transaction', newTr);
+    return newTr;
+}
+exports.trackTransaction = trackTransaction;

package/dist/cjs/types/change.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANGE_STATUS = exports.CHANGE_OPERATION = void 0;
+var CHANGE_OPERATION;
+(function (CHANGE_OPERATION) {
+    CHANGE_OPERATION["insert"] = "insert";
+    CHANGE_OPERATION["delete"] = "delete";
+    CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+})(CHANGE_OPERATION = exports.CHANGE_OPERATION || (exports.CHANGE_OPERATION = {}));
+var CHANGE_STATUS;
+(function (CHANGE_STATUS) {
+    CHANGE_STATUS["accepted"] = "accepted";
+    CHANGE_STATUS["rejected"] = "rejected";
+    CHANGE_STATUS["pending"] = "pending";
+})(CHANGE_STATUS = exports.CHANGE_STATUS || (exports.CHANGE_STATUS = {}));

package/dist/cjs/types/pm.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/step.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/track.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackChangesStatus = void 0;
+var TrackChangesStatus;
+(function (TrackChangesStatus) {
+    TrackChangesStatus["enabled"] = "enabled";
+    TrackChangesStatus["viewSnapshots"] = "view-snapshots";
+    TrackChangesStatus["disabled"] = "disabled";
+})(TrackChangesStatus = exports.TrackChangesStatus || (exports.TrackChangesStatus = {}));

package/dist/cjs/utils/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDebug = exports.log = exports.logger = void 0;
+const debug_1 = __importDefault(require("debug"));
+exports.logger = (0, debug_1.default)('track');
+exports.log = {
+    info(str, obj) {
+        if (obj) {
+            (0, exports.logger)(str, obj);
+        }
+        else {
+            (0, exports.logger)(str);
+        }
+    },
+    warn(str, obj) {
+        if (obj) {
+            (0, exports.logger)(`%c WARNING ${str}`, 'color: #f3f32c', obj);
+        }
+        else {
+            (0, exports.logger)(`%c WARNING ${str}`, 'color: #f3f32c');
+        }
+    },
+    error(str, obj) {
+        if (obj) {
+            (0, exports.logger)(`%c ERROR ${str}`, 'color: #ff4242', obj);
+        }
+        else {
+            (0, exports.logger)(`%c ERROR ${str}`, 'color: #ff4242');
+        }
+    },
+};
+const enableDebug = (enabled) => {
+    if (enabled) {
+        debug_1.default.enable('track');
+    }
+    else {
+        debug_1.default.disable();
+    }
+};
+exports.enableDebug = enableDebug;

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

@@ -0,0 +1,28 @@
+"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.createNewUpdateAttrs = exports.createNewDeleteAttrs = exports.createNewInsertAttrs = void 0;
+const change_1 = require("../types/change");
+function createNewInsertAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.insert });
+}
+exports.createNewInsertAttrs = createNewInsertAttrs;
+function createNewDeleteAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.delete });
+}
+exports.createNewDeleteAttrs = createNewDeleteAttrs;
+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)) });
+}
+exports.createNewUpdateAttrs = createNewUpdateAttrs;

package/dist/cjs/utils/uuidv4.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidv4 = void 0;
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuidv4 = uuidv4;

package/dist/es/ChangeSet.js

@@ -0,0 +1,150 @@
+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;
+import { CHANGE_OPERATION, CHANGE_STATUS, } from './types/change';
+import { log } from './utils/logger';
+export 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 ||
+                    c.dataTracked.statusUpdateAt !== currentNodeChange.dataTracked.statusUpdateAt)) {
+                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_STATUS.pending);
+    }
+    get accepted() {
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.accepted);
+    }
+    get rejected() {
+        return this.changeTree.filter((c) => c.dataTracked.status === 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_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
+            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
+    }
+    static isValidDataTracked(dataTracked = {}) {
+        if ('dataTracked' in dataTracked) {
+            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';
+    }
+}
+_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_OPERATION.delete &&
+        change.dataTracked.status !== CHANGE_STATUS.pending);
+};

package/dist/es/actions.js

@@ -0,0 +1,17 @@
+export 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 || (TrackChangesAction = {}));
+export function getAction(tr, action) {
+    return tr.getMeta(action);
+}
+export function setAction(tr, action, payload) {
+    return tr.setMeta(action, payload);
+}
+export const skipTracking = (tr) => setAction(tr, TrackChangesAction.skipTrack, true);