@manuscripts/track-changes-plugin 1.7.2 → 1.7.3

package/dist/es/compute/splitSliceIntoMergedParts.js

@@ -0,0 +1,53 @@
+import { Fragment } from 'prosemirror-model';
+function getMergedNode(node, currentDepth, depth, first) {
+    if (currentDepth === depth) {
+        return {
+            mergedNodeContent: node.content,
+            unmergedContent: undefined,
+        };
+    }
+    const result = [];
+    let merged = 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 ? Fragment.fromArray(result) : undefined,
+    };
+}
+export 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,
+    };
+}

package/dist/es/index.js

@@ -0,0 +1,7 @@
+export { trackChangesPluginKey, trackChangesPlugin } from './plugin';
+export { skipTracking } from './actions';
+export * as trackCommands from './commands';
+export { enableDebug } from './utils/logger';
+export { ChangeSet } from './ChangeSet';
+export * from './types/change';
+export * from './types/track';

package/dist/es/mutate/deleteAndMergeSplitNodes.js

@@ -0,0 +1,78 @@
+import { Fragment } from 'prosemirror-model';
+import { splitSliceIntoMergedParts } from '../compute/splitSliceIntoMergedParts';
+import { setFragmentAsInserted } from '../compute/setFragmentAsInserted';
+import * as trackUtils from '../utils/track-utils';
+export 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 } = 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: 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
+            ? Fragment.fromArray(updatedSliceNodes)
+            : insertSlice.content,
+        steps,
+    };
+}

package/dist/es/mutate/deleteNode.js

@@ -0,0 +1,38 @@
+import { Fragment } from 'prosemirror-model';
+import { liftTarget } from 'prosemirror-transform';
+import { log } from '../utils/logger';
+import { CHANGE_OPERATION } from '../types/change';
+import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
+export 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 && 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, Fragment.empty);
+    }
+    else {
+        return tr.delete(pos, pos + node.nodeSize);
+    }
+}
+export function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
+    const dataTracked = getBlockInlineTrackedData(node);
+    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.insert);
+    const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.delete);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
+    if (inserted && inserted.authorID === deleteAttrs.authorID) {
+        return deleteNode(node, pos, newTr);
+    }
+    if (!newTr.doc.nodeAt(pos)) {
+        log.error(`deleteOrSetNodeDeleted: no node found for deletion`, { pos, node, newTr });
+        return;
+    }
+    const newDeleted = deleted
+        ? Object.assign(Object.assign({}, deleted), { updatedAt: deleteAttrs.updatedAt }) : addTrackIdIfDoesntExist(deleteAttrs);
+    newTr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: updated ? [newDeleted, updated] : [newDeleted] }), node.marks);
+}

package/dist/es/mutate/deleteText.js

@@ -0,0 +1,25 @@
+import { Fragment } from 'prosemirror-model';
+import { addTrackIdIfDoesntExist, getMergeableMarkTrackedAttrs } from '../compute/nodeHelpers';
+export 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, Fragment.empty);
+        return start;
+    }
+    else {
+        const leftNode = newTr.doc.resolve(start).nodeBefore;
+        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
+        const rightNode = newTr.doc.resolve(end).nodeAfter;
+        const rightMarks = 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 = 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;
+    }
+}

package/dist/es/mutate/mergeNode.js

@@ -0,0 +1,17 @@
+import { Fragment } from 'prosemirror-model';
+import { canJoin } from 'prosemirror-transform';
+export function mergeNode(node, pos, tr) {
+    var _a;
+    if (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, Fragment.empty);
+    }
+    return undefined;
+}

package/dist/es/mutate/mergeTrackedMarks.js

@@ -0,0 +1,21 @@
+import { shouldMergeTrackedAttributes } from '../compute/nodeHelpers';
+export 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 (!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 })));
+}

package/dist/es/plugin.js

@@ -0,0 +1,114 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { getAction, setAction, TrackChangesAction } from './actions';
+import { ChangeSet } from './ChangeSet';
+import { log, enableDebug } from './utils/logger';
+import { applyAcceptedRejectedChanges } from './changes/applyChanges';
+import { findChanges } from './changes/findChanges';
+import { fixInconsistentChanges } from './changes/fixInconsistentChanges';
+import { trackTransaction } from './steps/trackTransaction';
+import { updateChangeAttrs } from './changes/updateChangeAttrs';
+import { TrackChangesStatus } from './types/track';
+export const trackChangesPluginKey = new PluginKey('track-changes');
+export const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
+    const { userID, debug, skipTrsWithMetas = [] } = opts;
+    let editorView;
+    if (debug) {
+        enableDebug(true);
+    }
+    return new Plugin({
+        key: trackChangesPluginKey,
+        props: {
+            editable(state) {
+                var _a;
+                return ((_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status) !== TrackChangesStatus.viewSnapshots;
+            },
+        },
+        state: {
+            init(_config, state) {
+                return {
+                    status: TrackChangesStatus.enabled,
+                    userID,
+                    changeSet: findChanges(state),
+                };
+            },
+            apply(tr, pluginState, _oldState, newState) {
+                const setUserID = getAction(tr, TrackChangesAction.setUserID);
+                const setStatus = getAction(tr, 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 === TrackChangesStatus.disabled ? new ChangeSet() : findChanges(newState) });
+                }
+                else if (pluginState.status === TrackChangesStatus.disabled) {
+                    return Object.assign(Object.assign({}, pluginState), { changeSet: new ChangeSet() });
+                }
+                let { changeSet } = pluginState, rest = __rest(pluginState, ["changeSet"]);
+                if (getAction(tr, TrackChangesAction.refreshChanges)) {
+                    changeSet = findChanges(newState);
+                }
+                return Object.assign({ changeSet }, rest);
+            },
+        },
+        view(p) {
+            editorView = p;
+            return {
+                update: undefined,
+                destroy: undefined,
+            };
+        },
+        appendTransaction(trs, oldState, newState) {
+            const pluginState = trackChangesPluginKey.getState(newState);
+            if (!pluginState || pluginState.status === TrackChangesStatus.disabled || !(editorView === null || editorView === void 0 ? void 0 : editorView.editable)) {
+                return null;
+            }
+            const { userID, changeSet } = pluginState;
+            let createdTr = newState.tr, docChanged = false;
+            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 = getAction(tr, TrackChangesAction.skipTrack) || (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
+                if (tr.docChanged && !skipMetaUsed && !skipTrackUsed && !tr.getMeta('history$') && !(wasAppended && tr.getMeta('origin') === 'paragraphs')) {
+                    createdTr = trackTransaction(tr, oldState, createdTr, userID);
+                }
+                docChanged = docChanged || tr.docChanged;
+                const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
+                if (setChangeStatuses) {
+                    const { status, ids } = setChangeStatuses;
+                    ids.forEach((changeId) => {
+                        const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
+                        if (change) {
+                            createdTr = updateChangeAttrs(createdTr, change, Object.assign(Object.assign({}, change.dataTracked), { status, reviewedByID: userID }), oldState.schema);
+                        }
+                    });
+                }
+                else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
+                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.bothNodeChanges);
+                    applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.textChanges, mapping);
+                    setAction(createdTr, TrackChangesAction.refreshChanges, true);
+                }
+            });
+            const changed = pluginState.changeSet.hasInconsistentData && fixInconsistentChanges(pluginState.changeSet, userID, createdTr, oldState.schema);
+            if (changed) {
+                log.warn('had to fix inconsistent changes in', createdTr);
+            }
+            if (docChanged || createdTr.docChanged || changed) {
+                createdTr.setMeta('origin', trackChangesPluginKey);
+                return setAction(createdTr, TrackChangesAction.refreshChanges, true);
+            }
+            return null;
+        },
+    });
+};

package/dist/es/steps/trackReplaceAroundStep.js

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

package/dist/es/steps/trackReplaceStep.js

@@ -0,0 +1,52 @@
+import { Slice } from 'prosemirror-model';
+import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
+import { setFragmentAsInserted } from '../compute/setFragmentAsInserted';
+import { log } from '../utils/logger';
+import * as trackUtils from '../utils/track-utils';
+export function trackReplaceStep(step, oldState, newTr, attrs, stepResult, currentStepDoc) {
+    log.info('###### ReplaceStep ######');
+    let selectionPos = 0;
+    const changeSteps = [];
+    step.getMap().forEach((fromA, toA, fromB, toB) => {
+        var _a, _b;
+        log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
+        const { slice } = step;
+        log.info('TR: steps before applying delete', [...newTr.steps]);
+        if (stepResult.failed) {
+            log.error(`invert ReplaceStep failed: "${stepResult.failed}"`);
+            return;
+        }
+        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, currentStepDoc, newTr, oldState.schema, attrs, slice);
+        changeSteps.push(...deleteSteps);
+        log.info('TR: steps after applying delete', [...newTr.steps]);
+        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) {
+            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 Slice(setFragmentAsInserted(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd),
+            });
+        }
+        else {
+            selectionPos = ((_a = window.event) === null || _a === void 0 ? void 0 : _a.code) === 'Delete' || ((_b = window.event) === null || _b === void 0 ? void 0 : _b.inputType) === 'deleteContentForward' ? toA : fromA;
+        }
+    });
+    return [changeSteps, selectionPos];
+}

package/dist/es/steps/trackTransaction.js

@@ -0,0 +1,84 @@
+import { NodeSelection as NodeSelectionClass } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+import { log } from '../utils/logger';
+import { CHANGE_STATUS } from '../types/change';
+import { trackReplaceAroundStep } from './trackReplaceAroundStep';
+import { trackReplaceStep } from './trackReplaceStep';
+import { processChangeSteps } from '../change-steps/processChangeSteps';
+import { diffChangeSteps } from '../change-steps/diffChangeSteps';
+const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
+const isHighlightMarkerNode = (node) => node && node.type === node.type.schema.nodes.highlight_marker;
+export function trackTransaction(tr, oldState, newTr, authorID) {
+    var _a, _b, _c, _d;
+    const emptyAttrs = {
+        authorID,
+        reviewedByID: null,
+        createdAt: tr.time,
+        updatedAt: tr.time,
+        status: CHANGE_STATUS.pending,
+    };
+    const wasNodeSelection = tr.selection instanceof NodeSelectionClass;
+    let iters = 0;
+    log.info('ORIGINAL transaction', tr);
+    for (let i = tr.steps.length - 1; i >= 0; i--) {
+        const step = tr.steps[i];
+        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 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 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] = 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;
+                }
+            }
+            log.info('CHANGES: ', steps);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            steps = diffChangeSteps(deleted, inserted);
+            log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = 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 ReplaceAroundStep) {
+            let steps = trackReplaceAroundStep(step, oldState, tr, newTr, emptyAttrs);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            log.info('INSERT STEPS: ', inserted);
+            steps = diffChangeSteps(deleted, inserted);
+            log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = 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));
+    }
+    log.info('NEW transaction', newTr);
+    return newTr;
+}

package/dist/es/types/change.js

@@ -0,0 +1,12 @@
+export var CHANGE_OPERATION;
+(function (CHANGE_OPERATION) {
+    CHANGE_OPERATION["insert"] = "insert";
+    CHANGE_OPERATION["delete"] = "delete";
+    CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+})(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
+export var CHANGE_STATUS;
+(function (CHANGE_STATUS) {
+    CHANGE_STATUS["accepted"] = "accepted";
+    CHANGE_STATUS["rejected"] = "rejected";
+    CHANGE_STATUS["pending"] = "pending";
+})(CHANGE_STATUS || (CHANGE_STATUS = {}));

package/dist/es/types/pm.js

@@ -0,0 +1 @@
+export {};

package/dist/es/types/step.js

@@ -0,0 +1 @@
+export {};

package/dist/es/types/track.js

@@ -0,0 +1,6 @@
+export var TrackChangesStatus;
+(function (TrackChangesStatus) {
+    TrackChangesStatus["enabled"] = "enabled";
+    TrackChangesStatus["viewSnapshots"] = "view-snapshots";
+    TrackChangesStatus["disabled"] = "disabled";
+})(TrackChangesStatus || (TrackChangesStatus = {}));

package/dist/es/utils/logger.js

@@ -0,0 +1,36 @@
+import debug from 'debug';
+export const logger = debug('track');
+export const log = {
+    info(str, obj) {
+        if (obj) {
+            logger(str, obj);
+        }
+        else {
+            logger(str);
+        }
+    },
+    warn(str, obj) {
+        if (obj) {
+            logger(`%c WARNING ${str}`, 'color: #f3f32c', obj);
+        }
+        else {
+            logger(`%c WARNING ${str}`, 'color: #f3f32c');
+        }
+    },
+    error(str, obj) {
+        if (obj) {
+            logger(`%c ERROR ${str}`, 'color: #ff4242', obj);
+        }
+        else {
+            logger(`%c ERROR ${str}`, 'color: #ff4242');
+        }
+    },
+};
+export const enableDebug = (enabled) => {
+    if (enabled) {
+        debug.enable('track');
+    }
+    else {
+        debug.disable();
+    }
+};

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

@@ -0,0 +1,22 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { CHANGE_OPERATION } from '../types/change';
+export function createNewInsertAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.insert });
+}
+export function createNewDeleteAttrs(attrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.delete });
+}
+export function createNewUpdateAttrs(attrs, oldAttrs) {
+    const { dataTracked } = oldAttrs, restAttrs = __rest(oldAttrs, ["dataTracked"]);
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.set_node_attributes, oldAttrs: JSON.parse(JSON.stringify(restAttrs)) });
+}

package/dist/es/utils/uuidv4.js

@@ -0,0 +1,6 @@
+export 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);
+    });
+}