@manuscripts/track-changes-plugin 2.0.12 → 2.1.0

package/dist/es/steps/trackMarkSteps.js

@@ -0,0 +1,134 @@
+import { AddMarkStep, AddNodeMarkStep, RemoveMarkStep } from 'prosemirror-transform';
+import { CHANGE_OPERATION } from '../types/change';
+import { createNewDeleteAttrs, createNewInsertAttrs, isValidTrackableMark } from '../utils/track-utils';
+import { uuidv4 } from '../utils/uuidv4';
+function markHasOp(mark, operation) {
+    if (mark.attrs.dataTracked && Array.isArray(mark.attrs.dataTracked)) {
+        const dtAttrs = mark.attrs.dataTracked;
+        return dtAttrs.some((at) => at.operation === operation);
+    }
+}
+export function trackRemoveMarkStep(step, emptyAttrs, newTr, doc) {
+    if (isValidTrackableMark(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[step.mark.type.name];
+        let sameMark = null;
+        const targetNode = doc.nodeAt(step.from);
+        if (targetNode) {
+            let targetNodePos = -1;
+            doc.descendants((node, pos) => {
+                if (node === targetNode) {
+                    targetNodePos = pos;
+                }
+                if (targetNodePos >= 0) {
+                    return false;
+                }
+            });
+            const parentsSameMark = targetNode.marks.find((mark) => {
+                var _a;
+                if (mark.type.name === markName && ((_a = mark.attrs.dataTracked) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return mark;
+                }
+            });
+            const nodeEnd = targetNodePos + targetNode.nodeSize;
+            if (parentsSameMark && step.from <= nodeEnd && step.to <= nodeEnd) {
+                sameMark = parentsSameMark;
+            }
+        }
+        const newDataTracked = createNewDeleteAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        let newStep = new AddMarkStep(step.from, step.to, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, CHANGE_OPERATION.delete)) {
+                newStep = new AddMarkStep(step.from, step.to, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, CHANGE_OPERATION.insert)) {
+                newStep = new RemoveMarkStep(step.from, step.to, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveMarkStep with error: ' + e);
+        }
+    }
+}
+export function trackRemoveNodeMarkStep(step, emptyAttrs, newTr, doc) {
+    if (isValidTrackableMark(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[markName];
+        let sameMark = null;
+        const targetNode = doc.nodeAt(step.pos);
+        if (targetNode) {
+            targetNode.marks.find((mark) => {
+                var _a;
+                if (mark.type.name === markName && ((_a = mark.attrs.dataTracked) === null || _a === void 0 ? void 0 : _a.length)) {
+                    sameMark = mark;
+                }
+            });
+        }
+        const newDataTracked = createNewDeleteAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        let newStep = new AddNodeMarkStep(step.pos, newMark);
+        if (sameMark) {
+            if (markHasOp(step.mark, CHANGE_OPERATION.delete)) {
+                newStep = new AddNodeMarkStep(step.pos, markSource.create({
+                    dataTracked: [],
+                }));
+            }
+            if (markHasOp(step.mark, CHANGE_OPERATION.insert)) {
+                newStep = new AddNodeMarkStep(step.pos, step.mark);
+            }
+        }
+        try {
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a RemoveNodeMarkStep with error: ' + e);
+        }
+    }
+}
+export function trackAddMarkStep(step, emptyAttrs, newTr, doc) {
+    if (isValidTrackableMark(step.mark)) {
+        const markName = step.mark.type.name;
+        const markSource = step.mark.type.schema.marks[markName];
+        const newDataTracked = createNewInsertAttrs(emptyAttrs);
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        const newStep = new AddMarkStep(step.from, step.to, newMark);
+        try {
+            const inverted = step.invert();
+            newTr.step(inverted);
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record a remove node mark step: ' + e);
+        }
+    }
+}
+export function trackAddNodeMarkStep(step, emptyAttrs, newTr, stepDoc) {
+    if (isValidTrackableMark(step.mark)) {
+        const newDataTracked = createNewInsertAttrs(emptyAttrs);
+        const markSource = step.mark.type.schema.marks[step.mark.type.name];
+        const newMark = markSource.create({
+            dataTracked: [Object.assign(Object.assign({}, newDataTracked), { id: uuidv4() })],
+        });
+        const newStep = new AddNodeMarkStep(step.pos, newMark);
+        try {
+            const inverted = step.invert(stepDoc);
+            newTr.step(inverted);
+            newTr.step(newStep);
+        }
+        catch (e) {
+            console.error('Unable to record an AddNodeMarkStep with error: ' + e);
+        }
+    }
+}

package/dist/es/steps/trackReplaceAroundStep.js

@@ -4,7 +4,7 @@ import { setFragmentAsInserted, setFragmentAsWrapChange } from '../compute/setFr
 import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isLiftStep, isWrapStep } from '../utils/track-utils';
+import { isLiftStep, isWrapStep } from './utils';
 function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
     const prevDoc = newTr.docs[newTr.docs.length - 2];
     if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {

package/dist/es/steps/trackReplaceStep.js

@@ -5,7 +5,7 @@ import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
 import { joinStructureChanges } from '../mutate/dropStructureChange';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isSplitStep, isStructureSteps } from '../utils/track-utils';
+import { isSplitStep, isStructureSteps } from './utils';
 export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, currentStepDoc, tr, moveID) {
     log.info('###### ReplaceStep ######');
     let selectionPos = 0;

package/dist/es/steps/trackTransaction.js

@@ -1,5 +1,5 @@
 import { NodeSelection as NodeSelectionClass, TextSelection, } from 'prosemirror-state';
-import { AddMarkStep, AttrStep, Mapping, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
+import { AddMarkStep, AddNodeMarkStep, AttrStep, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
 import { getAction, TrackChangesAction } from '../actions';
 import { diffChangeSteps } from '../change-steps/diffChangeSteps';
 import { processChangeSteps } from '../change-steps/processChangeSteps';
@@ -8,11 +8,13 @@ import { getNodeTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
 import { mapChangeSteps } from '../utils/mapChangeStep';
-import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, isStructureSteps, } from '../utils/track-utils';
+import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 import trackAttrsChange from './trackAttrsChange';
+import { trackAddMarkStep, trackAddNodeMarkStep, trackRemoveMarkStep, trackRemoveNodeMarkStep, } from './trackMarkSteps';
 import { trackReplaceAroundStep } from './trackReplaceAroundStep';
 import { trackReplaceStep } from './trackReplaceStep';
+import { isStructureSteps } from './utils';
 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, changeSet) {
@@ -109,11 +111,21 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             const [mapping, selectionPos] = processChangeSteps(changeSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema, deletedNodeMapping);
         }
         else if (step instanceof AddMarkStep) {
+            trackAddMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
             const dataTracked = (_f = getNodeTrackedData(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _f === void 0 ? void 0 : _f.pop();
             if (dataTracked) {
                 updateChangeAttrs(newTr, { id: dataTracked.id, from: step.from, to: step.to, type: 'text-change', dataTracked }, Object.assign(Object.assign({}, dataTracked), { id: uuidv4() }), oldState.schema);
             }
         }
+        else if (step instanceof RemoveMarkStep) {
+            trackRemoveMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof RemoveNodeMarkStep) {
+            trackRemoveNodeMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof AddNodeMarkStep) {
+            trackAddNodeMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
         tr.getMeta('inputType') && newTr.setMeta('inputType', tr.getMeta('inputType'));
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     }

package/dist/es/steps/utils.js

@@ -0,0 +1,62 @@
+/*!
+ * © 2023 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ReplaceStep } from 'prosemirror-transform';
+import { TrackChangesAction } from '../actions';
+export const isSplitStep = (step, selection, uiEvent) => {
+    var _a, _b, _c, _d;
+    const { from, to, slice } = step;
+    if (from !== to ||
+        slice.content.childCount < 2 ||
+        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
+        return false;
+    }
+    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
+    const parentSize = $from.node().content.size;
+    if (uiEvent === 'paste') {
+        return !((startOffset === 0 && endOffset === 0) ||
+            (startOffset === parentSize && endOffset === parentSize));
+    }
+    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
+    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
+        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
+        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
+    }
+    return (openStart === openEnd &&
+        firstChild.type === lastChild.type &&
+        firstChild.inlineContent &&
+        lastChild.inlineContent &&
+        !(startOffset === parentSize && endOffset === parentSize));
+};
+export const isWrapStep = (step) => step.from === step.gapFrom &&
+    step.to === step.gapTo &&
+    step.slice.openStart === 0 &&
+    step.slice.openEnd === 0;
+export const isLiftStep = (step) => {
+    if (step.from < step.gapFrom &&
+        step.to > step.gapTo &&
+        step.slice.size === 0 &&
+        step.gapTo - step.gapFrom > 0) {
+        return true;
+    }
+    return false;
+};
+export function stepIsLift(gap, node, to) {
+    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
+}
+export const isStructureSteps = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof ReplaceStep &&
+    tr.steps[1] instanceof ReplaceStep;

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

@@ -39,51 +39,6 @@ export function createNewUpdateAttrs(attrs, oldAttrs) {
 export function createNewStructureAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.structure });
 }
-export const isSplitStep = (step, selection, uiEvent) => {
-    var _a, _b, _c, _d;
-    const { from, to, slice } = step;
-    if (from !== to ||
-        slice.content.childCount < 2 ||
-        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
-        return false;
-    }
-    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
-    const parentSize = $from.node().content.size;
-    if (uiEvent === 'paste') {
-        return !((startOffset === 0 && endOffset === 0) ||
-            (startOffset === parentSize && endOffset === parentSize));
-    }
-    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
-    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
-        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
-        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
-    }
-    return (openStart === openEnd &&
-        firstChild.type === lastChild.type &&
-        firstChild.inlineContent &&
-        lastChild.inlineContent &&
-        !(startOffset === parentSize && endOffset === parentSize));
-};
-export const isWrapStep = (step) => step.from === step.gapFrom &&
-    step.to === step.gapTo &&
-    step.slice.openStart === 0 &&
-    step.slice.openEnd === 0;
-export const isLiftStep = (step) => {
-    if (step.from < step.gapFrom &&
-        step.to > step.gapTo &&
-        step.slice.size === 0 &&
-        step.gapTo - step.gapFrom > 0) {
-        return true;
-    }
-    return false;
-};
-export function stepIsLift(gap, node, to) {
-    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
-}
-export const isStructureSteps = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
-    tr.steps.length === 2 &&
-    tr.steps[0] instanceof ReplaceStep &&
-    tr.steps[1] instanceof ReplaceStep;
 export const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 export const HasMoveOperations = (tr) => {
     const movingAssoc = new Map();
@@ -236,3 +191,27 @@ export const updateBlockNodesAttrs = (fragment, predicate) => {
     });
     return Fragment.fromArray(updatedNodes);
 };
+export function isValidTrackableMark(mark) {
+    var _a, _b;
+    const spec = mark.type.spec;
+    const name = mark.type.name;
+    if (!name.startsWith('tracked_') &&
+        ((_a = spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) &&
+        typeof ((_b = spec.attrs) === null || _b === void 0 ? void 0 : _b.dataTracked) === 'object') {
+        return true;
+    }
+    return false;
+}
+export function excludeFromTracked(dataTracked, changeIdToExclude) {
+    if (!dataTracked) {
+        return null;
+    }
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeIdToExclude);
+    return newDataTracked.length ? newDataTracked : null;
+}
+export function isInlineMarkChange(change) {
+    if (change.type == 'mark-change') {
+        return change.nodeType.isInline || change.nodeType.isText;
+    }
+    return false;
+}

package/dist/es/utils/uuidv4.js

@@ -1,4 +1,7 @@
 export function uuidv4() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
     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);

package/dist/types/ChangeSet.d.ts

@@ -1,4 +1,4 @@
-import { IncompleteChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+import { IncompleteChange, MarkChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
 export declare class ChangeSet {
     #private;
     constructor(changes?: (TrackedChange | IncompleteChange)[]);
@@ -22,12 +22,15 @@ export declare class ChangeSet {
         index: number;
         root: NodeChange;
     } | undefined;
-    canJoinAdjacentInlineChanges(change: TrackedChange, index: number): boolean | undefined;
+    areMatchingWrapOperations(c1: TrackedChange, c2: TrackedChange): boolean;
+    areMatchingMarkOperations(c1: TrackedChange, c2: TrackedChange): boolean;
+    canJoinAdjacentInlineChanges(change: TrackedChange, index: number): boolean;
     joinRelatedStructuralChanges(rootNodes: RootChanges, change: TrackedChange): true | undefined;
     static flattenTreeToIds(changes: TrackedChange[]): string[];
     static shouldDeleteChange(change: TrackedChange): boolean;
     static isValidDataTracked(dataTracked?: Partial<TrackedAttrs>): boolean;
     static isTextChange(change: TrackedChange): change is TextChange;
+    static isMarkChange(change: TrackedChange): change is MarkChange;
     static isNodeChange(change: TrackedChange): change is NodeChange;
     static isNodeAttrChange(change: TrackedChange): change is NodeAttrChange;
     static isReferenceChange(change: TrackedChange): change is ReferenceChange;

package/dist/types/changes/applyChanges.d.ts

@@ -2,6 +2,5 @@ import { Schema } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
 import { Mapping } from 'prosemirror-transform';
 import { ChangeSet } from '../ChangeSet';
-import { TrackedAttrs, TrackedChange } from '../types/change';
-export declare function getUpdatedDataTracked(dataTracked: TrackedAttrs[] | null, changeId: string): TrackedAttrs[] | null;
+import { TrackedChange } from '../types/change';
 export declare function applyAcceptedRejectedChanges(tr: Transaction, schema: Schema, changes: TrackedChange[], changeSet: ChangeSet, deleteMap?: Mapping): Mapping;

package/dist/types/compute/nodeHelpers.d.ts

@@ -1,10 +1,11 @@
-import { Node as PMNode, Schema } from 'prosemirror-model';
+import { Mark, Node as PMNode, Schema } from 'prosemirror-model';
 import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
 export declare function addTrackIdIfDoesntExist(attrs: Partial<TrackedAttrs>): Partial<TrackedAttrs>;
 export declare function getTextNodeTrackedMarkData(node: PMNode | undefined | null, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
     operation: CHANGE_OPERATION;
 }) | undefined;
 export declare function getBlockInlineTrackedData(node: PMNode): Partial<TrackedAttrs>[] | undefined;
+export declare function getMarkTrackedData(node: PMNode | undefined | null): Map<Mark, Partial<TrackedAttrs>[]>;
 export declare function getNodeTrackedData(node: PMNode | undefined | null, schema: Schema): Partial<TrackedAttrs>[] | undefined;
 export declare function equalMarks(n1: PMNode, n2: PMNode): boolean;
 export declare function shouldMergeTrackedAttributes(left?: Partial<TrackedAttrs>, right?: Partial<TrackedAttrs>): boolean;

package/dist/types/mutate/deleteNode.d.ts

@@ -3,4 +3,4 @@ import { Transaction } from 'prosemirror-state';
 import { NewDeleteAttrs } from '../types/track';
 export declare function deleteNode(node: PMNode, pos: number, tr: Transaction): Transaction;
 export declare function deleteOrSetNodeDeleted(node: PMNode, pos: number, newTr: Transaction, deleteAttrs: NewDeleteAttrs): Transaction | undefined;
-export declare const keepDeleteWithMoveNodeId: (node: PMNode) => Partial<import("../types/change").TrackedAttrs>[] | null;
+export declare const keepPairedChanges: (node: PMNode) => Partial<import("../types/change").TrackedAttrs>[] | null;

package/dist/types/mutate/dropStructureChange.d.ts

@@ -2,5 +2,5 @@ import { Fragment } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
 import { NewEmptyAttrs } from '../types/track';
 export declare const dropStructuralChangeShadow: (moveNodeId: string | undefined, tr: Transaction) => Transaction;
-export declare const dropOrphanChanges: (newTr: Transaction, dropDataTracked?: boolean) => void;
+export declare const dropOrphanChanges: (newTr: Transaction) => void;
 export declare const joinStructureChanges: (attrs: NewEmptyAttrs, sliceContent: Fragment, content: Fragment, tr: Transaction, newTr: Transaction) => Fragment;

package/dist/types/steps/trackMarkSteps.d.ts

@@ -0,0 +1,8 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { AddMarkStep, AddNodeMarkStep, RemoveMarkStep, RemoveNodeMarkStep } from 'prosemirror-transform';
+import { NewEmptyAttrs } from '../types/track';
+export declare function trackRemoveMarkStep(step: RemoveMarkStep, emptyAttrs: NewEmptyAttrs, newTr: Transaction, doc: PMNode): void;
+export declare function trackRemoveNodeMarkStep(step: RemoveNodeMarkStep, emptyAttrs: NewEmptyAttrs, newTr: Transaction, doc: PMNode): void;
+export declare function trackAddMarkStep(step: AddMarkStep, emptyAttrs: NewEmptyAttrs, newTr: Transaction, doc: PMNode): void;
+export declare function trackAddNodeMarkStep(step: AddNodeMarkStep, emptyAttrs: NewEmptyAttrs, newTr: Transaction, stepDoc: PMNode): void;

package/dist/types/steps/utils.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * © 2023 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Node as PMNode, Slice } from 'prosemirror-model';
+import { Selection, Transaction } from 'prosemirror-state';
+import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
+export declare const isSplitStep: (step: ReplaceStep, selection: Selection, uiEvent: string) => boolean;
+export declare const isWrapStep: (step: ReplaceAroundStep) => boolean;
+export declare const isLiftStep: (step: ReplaceAroundStep) => boolean;
+export declare function stepIsLift(gap: {
+    start: number;
+    end: number;
+    slice: Slice;
+    insert: number;
+}, node: PMNode, to: number): boolean;
+export declare const isStructureSteps: (tr: Transaction) => any;

package/dist/types/types/change.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Node, NodeType } from 'prosemirror-model';
+import { Mark, Node, NodeType } from 'prosemirror-model';
 export declare enum CHANGE_OPERATION {
     insert = "insert",
     delete = "delete",
@@ -95,6 +95,9 @@ export type ReferenceChange = Change & {
 };
 export type MarkChange = Change & {
     type: 'mark-change';
+    nodeType: NodeType;
+    mark: Mark;
+    node: Node;
 };
 export type TrackedChange = TextChange | NodeChange | NodeAttrChange | WrapChange | ReferenceChange | MarkChange;
 export type PartialChange<T extends TrackedChange> = Omit<T, 'dataTracked'> & {

package/dist/types/utils/track-utils.d.ts

@@ -1,7 +1,7 @@
-import { Attrs, Fragment, Node as PMNode, Slice } from 'prosemirror-model';
-import { Selection, Transaction } from 'prosemirror-state';
-import { ReplaceAroundStep, ReplaceStep, Step } from 'prosemirror-transform';
-import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
+import { Attrs, Fragment, Mark, Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { ReplaceStep, Step } from 'prosemirror-transform';
+import { CHANGE_OPERATION, TrackedAttrs, TrackedChange } from '../types/change';
 import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewMoveAttrs, NewReferenceAttrs, NewSplitNodeAttrs, NewUpdateAttrs } from '../types/track';
 export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
 export declare function createNewWrapAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
@@ -11,16 +11,6 @@ export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAtt
 export declare function createNewMoveAttrs(attrs: NewEmptyAttrs, indentationType?: 'indent' | 'unindent'): NewMoveAttrs;
 export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
 export declare function createNewStructureAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
-export declare const isSplitStep: (step: ReplaceStep, selection: Selection, uiEvent: string) => boolean;
-export declare const isWrapStep: (step: ReplaceAroundStep) => boolean;
-export declare const isLiftStep: (step: ReplaceAroundStep) => boolean;
-export declare function stepIsLift(gap: {
-    start: number;
-    end: number;
-    slice: Slice;
-    insert: number;
-}, node: PMNode, to: number): boolean;
-export declare const isStructureSteps: (tr: Transaction) => any;
 export declare const trFromHistory: (tr: Transaction) => string | undefined;
 export declare const HasMoveOperations: (tr: Transaction) => Map<ReplaceStep, string>;
 export declare const isPendingChange: (trackedAttrs: TrackedAttrs[] | undefined, operation: CHANGE_OPERATION) => boolean;
@@ -29,3 +19,6 @@ export declare const isDirectPendingMoveDeletion: (step: ReplaceStep, doc: PMNod
 export declare const handleDirectPendingMoveDeletions: (tr: Transaction, newTr: Transaction, movingSteps: Map<ReplaceStep, string>) => void;
 export declare const filterMeaninglessMoveSteps: (tr: Transaction, movingSteps: Map<ReplaceStep, string>) => Step[];
 export declare const updateBlockNodesAttrs: (fragment: Fragment, predicate: (attrs: Attrs, node: PMNode) => Attrs) => Fragment;
+export declare function isValidTrackableMark(mark: Mark): boolean;
+export declare function excludeFromTracked(dataTracked: TrackedAttrs[] | null, changeIdToExclude: string): TrackedAttrs[] | null;
+export declare function isInlineMarkChange(change: TrackedChange): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "2.0.12",
+  "version": "2.1.0",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",