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

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

@@ -0,0 +1,59 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { log } from '../utils/logger';
+import { matchInserted } from './matchInserted';
+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, Fragment.fromArray(newContent)];
+}
+export function diffChangeSteps(deleted, inserted) {
+    const updated = [];
+    let updatedDeleted = [...deleted];
+    inserted.forEach((ins) => {
+        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] = 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 Slice(newInserted, ins.slice.openStart, ins.slice.openEnd) }));
+        }
+    });
+    log.info('FINISH DIFF: ', [...updatedDeleted, ...updated]);
+    return [...updatedDeleted, ...updated];
+}

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

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

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

@@ -0,0 +1,115 @@
+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 { Mapping, ReplaceStep } from 'prosemirror-transform';
+import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
+import { deleteOrSetNodeDeleted } from '../mutate/deleteNode';
+import { deleteTextIfInserted } from '../mutate/deleteText';
+import { mergeTrackedMarks } from '../mutate/mergeTrackedMarks';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
+import { log } from '../utils/logger';
+import * as trackUtils from '../utils/track-utils';
+export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
+    const mapping = new 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 = getBlockInlineTrackedData(c.node);
+                const inserted = trackedData === null || trackedData === void 0 ? void 0 : trackedData.find((d) => d.operation === CHANGE_OPERATION.insert);
+                isInserted = !!inserted || (!trackedData && isInserted);
+                if (isInserted && deletesCounter > 1) {
+                    return false;
+                }
+                deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
+                const newestStep = newTr.steps[newTr.steps.length - 1];
+                if (step !== newestStep) {
+                    mapping.appendMap(newestStep.getMap());
+                    step = newestStep;
+                }
+                mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+                break;
+            case 'delete-text':
+                const node = newTr.doc.nodeAt(mapping.map(c.pos));
+                if (!node) {
+                    log.error(`processChangeSteps: no text node found for text-change`, c);
+                    return;
+                }
+                const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                mergeTrackedMarks(where, newTr.doc, newTr, schema);
+                break;
+            case 'merge-fragment':
+                let insertPos = mapping.map(c.mergePos);
+                if (c.node.isText) {
+                    insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                    const newestStep = newTr.steps[newTr.steps.length - 1];
+                    if (step !== newestStep) {
+                        mapping.appendMap(newestStep.getMap());
+                        step = newestStep;
+                    }
+                }
+                if (c.fragment.size > 0) {
+                    newTr.insert(insertPos, c.fragment);
+                }
+                break;
+            case 'insert-slice':
+                const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
+                const stepResult = newTr.maybeStep(newStep);
+                if (stepResult.failed) {
+                    log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
+                    return;
+                }
+                mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+                const to = mapping.map(c.to) + c.slice.size;
+                mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), newTr.doc, newTr, schema);
+                selectionPos = mapping.map(c.to) + c.slice.size;
+                break;
+            case 'update-node-attrs':
+                const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+                const oldUpdate = oldDataTracked.reverse().find((d) => {
+                    if (d.operation === CHANGE_OPERATION.set_node_attributes &&
+                        (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
+                        return true;
+                    }
+                    return false;
+                });
+                const lastChangeRejected = oldUpdate && oldUpdate.status === 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_STATUS.rejected
+                    ? Object.assign(Object.assign({}, oldUpdate), { updatedAt: emptyAttrs.updatedAt }) : 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_OPERATION.insert && d.status === 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:
+                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];
+}

package/dist/es/changes/applyChanges.js

@@ -0,0 +1,81 @@
+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 { Mapping } from 'prosemirror-transform';
+import { ChangeSet } from '../ChangeSet';
+import { deleteNode } from '../mutate/deleteNode';
+import { mergeNode } from '../mutate/mergeNode';
+import { CHANGE_STATUS } from '../types/change';
+import { log } from '../utils/logger';
+import { updateChangeChildrenAttributes } from './updateChangeAttrs';
+function getUpdatedDataTracked(dataTracked, changeId) {
+    if (!dataTracked) {
+        return null;
+    }
+    console.log(dataTracked);
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
+    return newDataTracked.length ? newDataTracked : null;
+}
+export function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new 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.shouldDeleteChange(change);
+        if (!node) {
+            !deleted && log.warn('no node found to update for change', change);
+            return;
+        }
+        if (change.dataTracked.status === CHANGE_STATUS.pending) {
+            if (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.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.isTextChange(change)) {
+            tr.delete(from, deleteMap.map(change.to));
+            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+        }
+        else if (ChangeSet.isNodeChange(change) && noChangeNeeded) {
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            updateChangeChildrenAttributes(change.children, tr, deleteMap);
+        }
+        else if (ChangeSet.isNodeChange(change)) {
+            const merged = mergeNode(node, from, tr);
+            if (merged === undefined) {
+                deleteNode(node, from, tr);
+            }
+            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+        }
+        else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === 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.isNodeAttrChange(change) && change.dataTracked.status === CHANGE_STATUS.rejected) {
+            console.log('GETTING IN ---- 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;
+}

package/dist/es/changes/findChanges.js

@@ -0,0 +1,68 @@
+import { ChangeSet } from '../ChangeSet';
+import { equalMarks, getNodeTrackedData } from '../compute/nodeHelpers';
+import { CHANGE_OPERATION, } from '../types/change';
+export function findChanges(state) {
+    const changes = [];
+    let current;
+    state.doc.descendants((node, pos) => {
+        const tracked = 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 &&
+                !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_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(changes);
+}

package/dist/es/changes/fixInconsistentChanges.js

@@ -0,0 +1,17 @@
+import { CHANGE_STATUS } from '../types/change';
+import { uuidv4 } from '../utils/uuidv4';
+import { updateChangeAttrs } from './updateChangeAttrs';
+export function fixInconsistentChanges(changeSet, currentUserID, newTr, schema) {
+    const iteratedIds = new Set();
+    let changed = false;
+    changeSet.invalidChanges.forEach((c) => {
+        const { id, authorID, operation, reviewedByID, status, createdAt, statusUpdateAt, updatedAt } = c.dataTracked;
+        const newAttrs = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() })), (!authorID && { authorID: currentUserID })), (!reviewedByID && { reviewedByID: null })), (!status && { status: CHANGE_STATUS.pending })), (!createdAt && { createdAt: Date.now() })), (!updatedAt && { updatedAt: Date.now() })), (!statusUpdateAt && { statusUpdateAt: 0 }));
+        if (Object.keys(newAttrs).length > 0) {
+            updateChangeAttrs(newTr, c, Object.assign(Object.assign({}, c.dataTracked), newAttrs), schema);
+            changed = true;
+        }
+        iteratedIds.add(newAttrs.id || id);
+    });
+    return changed;
+}

package/dist/es/changes/updateChangeAttrs.js

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

package/dist/es/commands.js

@@ -0,0 +1,39 @@
+import { setAction, TrackChangesAction } from './actions';
+import { trackChangesPluginKey } from './plugin';
+import { TrackChangesStatus } from './types/track';
+export const setTrackingStatus = (status) => (state, dispatch) => {
+    var _a;
+    const currentStatus = (_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status;
+    if (currentStatus) {
+        let newStatus = status;
+        if (newStatus === undefined) {
+            newStatus =
+                currentStatus === TrackChangesStatus.enabled
+                    ? TrackChangesStatus.disabled
+                    : TrackChangesStatus.enabled;
+        }
+        dispatch && dispatch(setAction(state.tr, TrackChangesAction.setPluginStatus, newStatus));
+        return true;
+    }
+    return false;
+};
+export const setChangeStatuses = (status, ids) => (state, dispatch) => {
+    dispatch &&
+        dispatch(setAction(state.tr, TrackChangesAction.setChangeStatuses, {
+            status,
+            ids,
+        }));
+    return true;
+};
+export const setUserID = (userID) => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.setUserID, userID));
+    return true;
+};
+export const applyAndRemoveChanges = () => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.applyAndRemoveChanges, true));
+    return true;
+};
+export const refreshChanges = () => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.refreshChanges, true));
+    return true;
+};

package/dist/es/compute/nodeHelpers.js

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

package/dist/es/compute/setFragmentAsInserted.js

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