@manuscripts/track-changes-plugin 2.0.10 → 2.0.12

package/dist/es/steps/trackTransaction.js

@@ -1,5 +1,6 @@
 import { NodeSelection as NodeSelectionClass, TextSelection, } from 'prosemirror-state';
 import { AddMarkStep, AttrStep, Mapping, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
+import { getAction, TrackChangesAction } from '../actions';
 import { diffChangeSteps } from '../change-steps/diffChangeSteps';
 import { processChangeSteps } from '../change-steps/processChangeSteps';
 import { updateChangeAttrs } from '../changes/updateChangeAttrs';
@@ -7,7 +8,7 @@ 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, } from '../utils/track-utils';
+import { filterMeaninglessMoveSteps, handleDirectPendingMoveDeletions, HasMoveOperations, isStructureSteps, } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 import trackAttrsChange from './trackAttrsChange';
 import { trackReplaceAroundStep } from './trackReplaceAroundStep';
@@ -15,7 +16,7 @@ import { trackReplaceStep } from './trackReplaceStep';
 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) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const emptyAttrs = {
         authorID,
         reviewedByID: null,
@@ -24,13 +25,23 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
         statusUpdateAt: 0,
         status: CHANGE_STATUS.pending,
     };
+    const action = (_a = getAction(tr, TrackChangesAction.indentationAction)) === null || _a === void 0 ? void 0 : _a.action;
+    const isIndentation = action === 'indent' || action === 'unindent';
     const wasNodeSelection = tr.selection instanceof NodeSelectionClass;
     const setsNewSelection = tr.selectionSet;
     const deletedNodeMapping = new Mapping();
     let iters = 0;
     log.info('ORIGINAL transaction', tr);
     let trContext = {};
-    const movingStepsAssociated = HasMoveOperations(tr);
+    let movingStepsAssociated = HasMoveOperations(tr);
+    if (isIndentation) {
+        const moveId = uuidv4();
+        tr.steps.forEach((step) => {
+            if (step instanceof ReplaceStep) {
+                movingStepsAssociated.set(step, moveId);
+            }
+        });
+    }
     handleDirectPendingMoveDeletions(tr, newTr, movingStepsAssociated);
     const cleanSteps = filterMeaninglessMoveSteps(tr, movingStepsAssociated);
     for (let i = cleanSteps.length - 1; i >= 0; i--) {
@@ -51,13 +62,13 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
         }
         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])) {
+            if (((_c = (_b = slice === null || slice === void 0 ? void 0 : slice.content) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.length) === 1 && isHighlightMarkerNode(slice.content.content[0])) {
                 continue;
             }
             const invertedStep = step.invert(tr.docs[i]);
             const isDelete = step.from !== step.to && step.slice.content.size < invertedStep.slice.content.size;
             let thisStepMapping = tr.mapping.slice(i + 1, i + 1);
-            if (isDelete) {
+            if (isDelete || isStructureSteps(tr)) {
                 thisStepMapping = deletedNodeMapping;
             }
             const newStep = new ReplaceStep(thisStepMapping.map(invertedStep.from), thisStepMapping.map(invertedStep.to), invertedStep.slice);
@@ -65,7 +76,7 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
             let [steps, startPos] = trackReplaceStep(step, oldState, newTr, emptyAttrs, stepResult, tr.docs[i], tr, movingStepsAssociated.get(step));
             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]))) {
+                if (isHighlightMarkerNode((step === null || step === void 0 ? void 0 : step.node) || ((_e = (_d = step === null || step === void 0 ? void 0 : step.slice) === null || _d === void 0 ? void 0 : _d.content) === null || _e === void 0 ? void 0 : _e.content[0]))) {
                     continue;
                 }
             }
@@ -98,7 +109,7 @@ 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) {
-            const dataTracked = (_e = getNodeTrackedData(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _e === void 0 ? void 0 : _e.pop();
+            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);
             }
@@ -107,7 +118,19 @@ export function trackTransaction(tr, oldState, newTr, authorID, changeSet) {
         tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
     }
     if (setsNewSelection && tr.selection instanceof TextSelection) {
-        const newPos = newTr.doc.resolve(tr.selection.from);
+        let from = tr.selection.from;
+        if (isStructureSteps(tr)) {
+            const selectionMapping = new Mapping();
+            tr.steps.map((step) => {
+                const isDeleteStep = step instanceof ReplaceStep && step.from !== step.to && step.slice.size === 0;
+                if (isDeleteStep) {
+                    selectionMapping.appendMap(step.getMap().invert());
+                }
+            });
+            selectionMapping.appendMapping(deletedNodeMapping);
+            from = selectionMapping.map(tr.selection.from);
+        }
+        const newPos = newTr.doc.resolve(from);
         newTr.setSelection(new TextSelection(newPos));
     }
     if (wasNodeSelection) {

package/dist/es/types/change.js

@@ -22,6 +22,7 @@ export var CHANGE_OPERATION;
     CHANGE_OPERATION["node_split"] = "node_split";
     CHANGE_OPERATION["reference"] = "reference";
     CHANGE_OPERATION["move"] = "move";
+    CHANGE_OPERATION["structure"] = "structure";
 })(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
 export var CHANGE_STATUS;
 (function (CHANGE_STATUS) {

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

@@ -9,7 +9,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+import { Fragment } from 'prosemirror-model';
 import { ReplaceStep } from 'prosemirror-transform';
+import { TrackChangesAction } from '../actions';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { uuidv4 } from './uuidv4';
 export function createNewInsertAttrs(attrs) {
@@ -27,13 +29,16 @@ export function createNewReferenceAttrs(attrs, id) {
 export function createNewDeleteAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.delete });
 }
-export function createNewMoveAttrs(attrs) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.move });
+export function createNewMoveAttrs(attrs, indentationType) {
+    return Object.assign(Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.move }), (indentationType && { indentationType }));
 }
 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)) });
 }
+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;
@@ -75,12 +80,22 @@ export const isLiftStep = (step) => {
 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();
     if (tr.steps.length < 2) {
         return movingAssoc;
     }
+    if (tr.getMeta(TrackChangesAction.structuralChangeAction)) {
+        const commonID = uuidv4();
+        movingAssoc.set(tr.steps[0], commonID);
+        movingAssoc.set(tr.steps[1], commonID);
+        return movingAssoc;
+    }
     const matched = [];
     for (let i = 0; i < tr.steps.length; i++) {
         if (matched.includes(i)) {
@@ -191,7 +206,7 @@ export const filterMeaninglessMoveSteps = (tr, movingSteps) => {
                 });
                 continue;
             }
-            if (step instanceof ReplaceStep) {
+            if (step instanceof ReplaceStep && !tr.getMeta(TrackChangesAction.structuralChangeAction)) {
                 const { slice } = step;
                 if ((_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.firstChild) {
                     const insertedNode = slice.content.firstChild;
@@ -208,3 +223,16 @@ export const filterMeaninglessMoveSteps = (tr, movingSteps) => {
     }
     return cleanSteps;
 };
+export const updateBlockNodesAttrs = (fragment, predicate) => {
+    const updatedNodes = [];
+    fragment.forEach((child) => {
+        if (!child.isBlock) {
+            updatedNodes.push(child);
+            return;
+        }
+        const newContent = child.content.size ? updateBlockNodesAttrs(child.content, predicate) : child.content;
+        const newAttrs = predicate(child.attrs, child);
+        updatedNodes.push(child.type.create(newAttrs, newContent, child.marks));
+    });
+    return Fragment.fromArray(updatedNodes);
+};

package/dist/types/ChangeSet.d.ts

@@ -1,4 +1,4 @@
-import { IncompleteChange, NodeAttrChange, NodeChange, ReferenceChange, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+import { IncompleteChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
 export declare class ChangeSet {
     #private;
     constructor(changes?: (TrackedChange | IncompleteChange)[]);
@@ -23,6 +23,7 @@ export declare class ChangeSet {
         root: NodeChange;
     } | undefined;
     canJoinAdjacentInlineChanges(change: TrackedChange, index: number): boolean | undefined;
+    joinRelatedStructuralChanges(rootNodes: RootChanges, change: TrackedChange): true | undefined;
     static flattenTreeToIds(changes: TrackedChange[]): string[];
     static shouldDeleteChange(change: TrackedChange): boolean;
     static isValidDataTracked(dataTracked?: Partial<TrackedAttrs>): boolean;

package/dist/types/actions.d.ts

@@ -1,5 +1,5 @@
 import { Transaction } from 'prosemirror-state';
-import { CHANGE_STATUS } from './types/change';
+import { CHANGE_STATUS, StructureAttrs } from './types/change';
 import { TrackChangesStatus } from './types/track';
 export declare enum TrackChangesAction {
     skipTrack = "track-changes-skip-tracking",
@@ -7,7 +7,9 @@ export declare enum TrackChangesAction {
     setPluginStatus = "track-changes-set-track-status",
     setChangeStatuses = "track-changes-set-change-statuses",
     refreshChanges = "track-changes-refresh-changes",
-    updateMetaNode = "track-changes-update-meta-node"
+    updateMetaNode = "track-changes-update-meta-node",
+    structuralChangeAction = "track-changes-structural-change-action",
+    indentationAction = "track-changes-indentation-action"
 }
 export type TrackChangesActionParams = {
     [TrackChangesAction.skipTrack]: boolean;
@@ -19,6 +21,10 @@ export type TrackChangesActionParams = {
     };
     [TrackChangesAction.refreshChanges]: boolean;
     [TrackChangesAction.updateMetaNode]: boolean;
+    [TrackChangesAction.structuralChangeAction]: StructureAttrs['action'];
+    [TrackChangesAction.indentationAction]: {
+        action: 'indent' | 'unindent';
+    };
 };
 export declare function hasAction(tr: Transaction): boolean;
 export declare function getAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K): TrackChangesActionParams[K] | undefined;

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

@@ -4,3 +4,4 @@ import { Mapping } from 'prosemirror-transform';
 import { IncompleteChange, TrackedAttrs, TrackedChange } from '../types/change';
 export declare function updateChangeAttrs(tr: Transaction, change: IncompleteChange, trackedAttrs: Partial<TrackedAttrs>, schema: Schema): Transaction;
 export declare function updateChangeChildrenAttributes(changes: TrackedChange[], tr: Transaction, mapping: Mapping): void;
+export declare function restoreNode(tr: Transaction, node: any, pos: number, schema: Schema): void;

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

@@ -1,7 +1,7 @@
 import { Fragment, ResolvedPos, Schema } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
-import { NewEmptyAttrs, NewInsertAttrs } from '../types/track';
+import { NewEmptyAttrs, NewInsertAttrs, NewMoveAttrs } from '../types/track';
 export declare function setFragmentAsInserted(inserted: Fragment, insertAttrs: NewInsertAttrs, schema: Schema): Fragment;
 export declare function setFragmentAsWrapChange(inserted: Fragment, attrs: NewEmptyAttrs, schema: Schema): Fragment;
-export declare function setFragmentAsMoveChange(fragment: Fragment, attrs: NewEmptyAttrs): Fragment;
+export declare function setFragmentAsMoveChange(fragment: Fragment, moveAttrs: NewMoveAttrs): Fragment;
 export declare function setFragmentAsNodeSplit($pos: ResolvedPos, newTr: Transaction, inserted: Fragment, attrs: NewEmptyAttrs): Fragment;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { trackChangesPluginKey, trackChangesPlugin } from './plugin';
-export { skipTracking } from './actions';
+export { skipTracking, setAction, TrackChangesAction } from './actions';
 export * as trackCommands from './commands';
 export { enableDebug } from './utils/logger';
 export { ChangeSet } from './ChangeSet';

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

@@ -3,3 +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;

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

@@ -0,0 +1,6 @@
+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 joinStructureChanges: (attrs: NewEmptyAttrs, sliceContent: Fragment, content: Fragment, tr: Transaction, newTr: Transaction) => Fragment;

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

@@ -21,7 +21,8 @@ export declare enum CHANGE_OPERATION {
     wrap_with_node = "wrap_with_node",
     node_split = "node_split",
     reference = "reference",
-    move = "move"
+    move = "move",
+    structure = "structure"
 }
 export declare enum CHANGE_STATUS {
     accepted = "accepted",
@@ -55,8 +56,13 @@ export type ReferenceAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
 };
 export type NodeMoveAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
     operation: CHANGE_OPERATION.move;
+    indentationType?: 'indent' | 'unindent';
 };
-export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs | WrapAttrs | NodeSplitAttrs | ReferenceAttrs | NodeMoveAttrs;
+export type StructureAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
+    operation: CHANGE_OPERATION.structure;
+    action: string;
+};
+export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs | WrapAttrs | NodeSplitAttrs | ReferenceAttrs | NodeMoveAttrs | StructureAttrs;
 type Change = {
     id: string;
     from: number;

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

@@ -16,7 +16,7 @@ export interface TrackChangesState {
 }
 export type NewEmptyAttrs = Omit<TrackedAttrs, 'id' | 'operation'>;
 export type NewInsertAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
-    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.wrap_with_node | CHANGE_OPERATION.move;
+    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.wrap_with_node | CHANGE_OPERATION.structure;
 };
 export type NewDeleteAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
     operation: CHANGE_OPERATION.delete;
@@ -28,11 +28,15 @@ export type NewUpdateAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
 export type NewSplitNodeAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
     operation: CHANGE_OPERATION.node_split;
 };
+export type NewMoveAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.move;
+    indentationType?: 'indent' | 'unindent';
+};
 export type NewReferenceAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
     operation: CHANGE_OPERATION.reference;
     referenceId: string;
 };
-export type NewTrackedAttrs = NewInsertAttrs | NewDeleteAttrs | NewUpdateAttrs;
+export type NewTrackedAttrs = NewInsertAttrs | NewDeleteAttrs | NewUpdateAttrs | NewMoveAttrs;
 export declare enum TrackChangesStatus {
     enabled = "enabled",
     viewSnapshots = "view-snapshots",

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

@@ -1,15 +1,16 @@
-import { Node as PMNode, Slice } from 'prosemirror-model';
+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 { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewReferenceAttrs, NewSplitNodeAttrs, NewUpdateAttrs } from '../types/track';
+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;
 export declare function createNewSplitAttrs(attrs: NewEmptyAttrs): NewSplitNodeAttrs;
 export declare function createNewReferenceAttrs(attrs: NewEmptyAttrs, id: string): NewReferenceAttrs;
 export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
-export declare function createNewMoveAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
+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;
@@ -19,6 +20,7 @@ export declare function stepIsLift(gap: {
     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;
@@ -26,3 +28,4 @@ export declare const isDeletingPendingMovedNode: (step: ReplaceStep, doc: PMNode
 export declare const isDirectPendingMoveDeletion: (step: ReplaceStep, doc: PMNode, movingSteps: Map<ReplaceStep, string>) => boolean;
 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;

package/package.json

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