@manuscripts/track-changes-plugin 2.0.13 → 2.1.1

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/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.13",
+  "version": "2.1.1",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",