@manuscripts/track-changes-plugin 1.7.11 → 1.7.12-LEAN-3608.0

package/dist/cjs/ChangeSet.js

@@ -80,6 +80,9 @@ class ChangeSet {
     get nodeAttrChanges() {
         return this.changes.filter((c) => c.type === 'node-attr-change');
     }
+    get nodeTypeChange() {
+        return this.changes.filter((c) => c.type === 'node-type-change');
+    }
     get bothNodeChanges() {
         return this.changes.filter((c) => c.type === 'node-change' || c.type === 'node-attr-change');
     }
@@ -147,6 +150,9 @@ class ChangeSet {
     static isNodeAttrChange(change) {
         return change.type === 'node-attr-change';
     }
+    static isNodeTypeChange(change) {
+        return change.type === 'node-type-change';
+    }
 }
 exports.ChangeSet = ChangeSet;
 _ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {

package/dist/cjs/actions.js

@@ -10,6 +10,7 @@ var TrackChangesAction;
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
     TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
+    TrackChangesAction["updateNodeType"] = "track-changes-update-node-type";
 })(TrackChangesAction = exports.TrackChangesAction || (exports.TrackChangesAction = {}));
 function getAction(tr, action) {
     return tr.getMeta(action);

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

@@ -91,6 +91,12 @@ function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
                     newTr.insert(insertPos, c.fragment);
                 }
                 break;
+            case 'update-node-type':
+                const nodeName = c.node.type.name;
+                const attr = (0, nodeHelpers_1.addTrackIdIfDoesntExist)(trackUtils.createNewUpdateType(emptyAttrs, nodeName));
+                const newNode = c.nodeType.content.firstChild;
+                newTr.setNodeMarkup(c.from, newNode.type, Object.assign(Object.assign({}, newNode.attrs), { dataTracked: [attr] }));
+                break;
             case 'insert-slice':
                 const newStep = new prosemirror_transform_1.ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
                 const stepResult = newTr.maybeStep(newStep);

package/dist/cjs/changes/findChanges.js

@@ -45,6 +45,17 @@ function findChanges(state) {
                     oldAttrs: dataTracked.oldAttrs,
                 };
             }
+            else if (dataTracked.operation === change_1.CHANGE_OPERATION.set_node_type) {
+                change = {
+                    id,
+                    type: 'node-type-change',
+                    from: pos,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    newAttrs: node.attrs,
+                    oldAttrs: dataTracked.oldAttrs,
+                };
+            }
             else {
                 change = {
                     id,

package/dist/cjs/changes/updateChangeAttrs.js

@@ -26,10 +26,15 @@ function updateChangeAttrs(tr, change, trackedAttrs, schema) {
         }
         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) {
+    else if ((change.type === 'node-change' ||
+        change.type === 'node-attr-change' ||
+        change.type === 'node-type-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') {
+    else if (change.type === 'node-change' ||
+        change.type === 'node-attr-change' ||
+        change.type === 'node-type-change') {
         const trackedDataSource = (0, nodeHelpers_1.getBlockInlineTrackedData)(node) || [];
         const targetDataTracked = trackedDataSource.find((t) => change.id === t.id);
         const newDataTracked = trackedDataSource.map((oldTrack) => {

package/dist/cjs/commands.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshChanges = exports.applyAndRemoveChanges = exports.setUserID = exports.setChangeStatuses = exports.setTrackingStatus = void 0;
+const transform_1 = require("@manuscripts/transform");
 const actions_1 = require("./actions");
 const plugin_1 = require("./plugin");
 const track_1 = require("./types/track");
@@ -22,8 +23,27 @@ const setTrackingStatus = (status) => (state, dispatch) => {
 };
 exports.setTrackingStatus = setTrackingStatus;
 const setChangeStatuses = (status, ids) => (state, dispatch) => {
+    var _a;
+    const tr = state.tr;
+    const nodeTypeChanges = (_a = plugin_1.trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.changeSet.nodeTypeChange;
+    if (nodeTypeChanges) {
+        nodeTypeChanges.map((change) => {
+            var _a;
+            if (ids.includes(change.id)) {
+                let node = state.doc.nodeAt(change.from);
+                if (status == 'pending' && node) {
+                    console.log('is pending', change);
+                    let oppositeType = (node === null || node === void 0 ? void 0 : node.type) !== transform_1.schema.nodes.bullet_list ? transform_1.schema.nodes.bullet_list : transform_1.schema.nodes.ordered_list;
+                    tr.setMeta(actions_1.TrackChangesAction.updateNodeType, true).setNodeMarkup(change.from, oppositeType, node.attrs, node.marks);
+                }
+                else if (status == 'rejected' && node) {
+                    (0, actions_1.skipTracking)(tr.setNodeMarkup(change.from, (_a = state.doc.nodeAt(change.from)) === null || _a === void 0 ? void 0 : _a.type.schema.nodes[change.oldAttrs], node.attrs, node.marks));
+                }
+            }
+        });
+    }
     dispatch &&
-        dispatch((0, actions_1.setAction)(state.tr, actions_1.TrackChangesAction.setChangeStatuses, {
+        dispatch((0, actions_1.setAction)(tr, actions_1.TrackChangesAction.setChangeStatuses, {
             status,
             ids,
         }));

package/dist/cjs/index.js

@@ -26,12 +26,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSet = exports.enableDebug = exports.trackCommands = exports.skipTracking = exports.trackChangesPlugin = exports.trackChangesPluginKey = void 0;
+exports.ChangeSet = exports.enableDebug = exports.trackCommands = exports.TrackChangesAction = exports.skipTracking = exports.trackChangesPlugin = exports.trackChangesPluginKey = void 0;
 var plugin_1 = require("./plugin");
 Object.defineProperty(exports, "trackChangesPluginKey", { enumerable: true, get: function () { return plugin_1.trackChangesPluginKey; } });
 Object.defineProperty(exports, "trackChangesPlugin", { enumerable: true, get: function () { return plugin_1.trackChangesPlugin; } });
 var actions_1 = require("./actions");
 Object.defineProperty(exports, "skipTracking", { enumerable: true, get: function () { return actions_1.skipTracking; } });
+Object.defineProperty(exports, "TrackChangesAction", { enumerable: true, get: function () { return actions_1.TrackChangesAction; } });
 exports.trackCommands = __importStar(require("./commands"));
 var logger_1 = require("./utils/logger");
 Object.defineProperty(exports, "enableDebug", { enumerable: true, get: function () { return logger_1.enableDebug; } });

package/dist/cjs/steps/trackReplaceAroundStep.js

@@ -57,13 +57,24 @@ function trackReplaceAroundStep(step, oldState, tr, newTr, attrs) {
             insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
             logger_1.log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        deleteSteps.push({
-            type: 'insert-slice',
-            from: gapFrom,
-            to: gapTo,
-            slice: insertedSlice,
-            sliceWasSplit,
-        });
+        if (tr.getMeta(actions_1.TrackChangesAction.updateNodeType)) {
+            console.log('steep', newTr.doc.nodeAt(from), slice);
+            deleteSteps.push({
+                type: 'update-node-type',
+                from: from,
+                nodeType: slice,
+                node: newTr.doc.nodeAt(from),
+            });
+        }
+        else {
+            deleteSteps.push({
+                type: 'insert-slice',
+                from: gapFrom,
+                to: gapTo,
+                slice: insertedSlice,
+                sliceWasSplit,
+            });
+        }
     }
     else {
     }

package/dist/cjs/types/change.js

@@ -6,6 +6,7 @@ var CHANGE_OPERATION;
     CHANGE_OPERATION["insert"] = "insert";
     CHANGE_OPERATION["delete"] = "delete";
     CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+    CHANGE_OPERATION["set_node_type"] = "set_type";
 })(CHANGE_OPERATION = exports.CHANGE_OPERATION || (exports.CHANGE_OPERATION = {}));
 var CHANGE_STATUS;
 (function (CHANGE_STATUS) {

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

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNewUpdateAttrs = exports.createNewDeleteAttrs = exports.createNewInsertAttrs = void 0;
+exports.createNewUpdateType = exports.createNewUpdateAttrs = exports.createNewDeleteAttrs = exports.createNewInsertAttrs = void 0;
 const change_1 = require("../types/change");
 function createNewInsertAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.insert });
@@ -26,3 +26,7 @@ function createNewUpdateAttrs(attrs, oldAttrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.set_node_attributes, oldAttrs: JSON.parse(JSON.stringify(restAttrs)) });
 }
 exports.createNewUpdateAttrs = createNewUpdateAttrs;
+function createNewUpdateType(attrs, oldAttrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.set_node_type, oldAttrs: oldAttrs });
+}
+exports.createNewUpdateType = createNewUpdateType;

package/dist/es/ChangeSet.js

@@ -77,6 +77,9 @@ export class ChangeSet {
     get nodeAttrChanges() {
         return this.changes.filter((c) => c.type === 'node-attr-change');
     }
+    get nodeTypeChange() {
+        return this.changes.filter((c) => c.type === 'node-type-change');
+    }
     get bothNodeChanges() {
         return this.changes.filter((c) => c.type === 'node-change' || c.type === 'node-attr-change');
     }
@@ -144,6 +147,9 @@ export class ChangeSet {
     static isNodeAttrChange(change) {
         return change.type === 'node-attr-change';
     }
+    static isNodeTypeChange(change) {
+        return change.type === 'node-type-change';
+    }
 }
 _ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
     return currentChange.from === nextChange.from && currentChange.to === nextChange.to;

package/dist/es/actions.js

@@ -7,6 +7,7 @@ export var TrackChangesAction;
     TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
     TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
     TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
+    TrackChangesAction["updateNodeType"] = "track-changes-update-node-type";
 })(TrackChangesAction || (TrackChangesAction = {}));
 export function getAction(tr, action) {
     return tr.getMeta(action);

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

@@ -65,6 +65,12 @@ export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema)
                     newTr.insert(insertPos, c.fragment);
                 }
                 break;
+            case 'update-node-type':
+                const nodeName = c.node.type.name;
+                const attr = addTrackIdIfDoesntExist(trackUtils.createNewUpdateType(emptyAttrs, nodeName));
+                const newNode = c.nodeType.content.firstChild;
+                newTr.setNodeMarkup(c.from, newNode.type, Object.assign(Object.assign({}, newNode.attrs), { dataTracked: [attr] }));
+                break;
             case 'insert-slice':
                 const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
                 const stepResult = newTr.maybeStep(newStep);

package/dist/es/changes/findChanges.js

@@ -42,6 +42,17 @@ export function findChanges(state) {
                     oldAttrs: dataTracked.oldAttrs,
                 };
             }
+            else if (dataTracked.operation === CHANGE_OPERATION.set_node_type) {
+                change = {
+                    id,
+                    type: 'node-type-change',
+                    from: pos,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    newAttrs: node.attrs,
+                    oldAttrs: dataTracked.oldAttrs,
+                };
+            }
             else {
                 change = {
                     id,

package/dist/es/changes/updateChangeAttrs.js

@@ -23,10 +23,15 @@ export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
         }
         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) {
+    else if ((change.type === 'node-change' ||
+        change.type === 'node-attr-change' ||
+        change.type === 'node-type-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') {
+    else if (change.type === 'node-change' ||
+        change.type === 'node-attr-change' ||
+        change.type === 'node-type-change') {
         const trackedDataSource = getBlockInlineTrackedData(node) || [];
         const targetDataTracked = trackedDataSource.find((t) => change.id === t.id);
         const newDataTracked = trackedDataSource.map((oldTrack) => {

package/dist/es/commands.js

@@ -1,4 +1,5 @@
-import { setAction, TrackChangesAction } from './actions';
+import { schema } from '@manuscripts/transform';
+import { setAction, skipTracking, TrackChangesAction } from './actions';
 import { trackChangesPluginKey } from './plugin';
 import { TrackChangesStatus } from './types/track';
 export const setTrackingStatus = (status) => (state, dispatch) => {
@@ -18,8 +19,27 @@ export const setTrackingStatus = (status) => (state, dispatch) => {
     return false;
 };
 export const setChangeStatuses = (status, ids) => (state, dispatch) => {
+    var _a;
+    const tr = state.tr;
+    const nodeTypeChanges = (_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.changeSet.nodeTypeChange;
+    if (nodeTypeChanges) {
+        nodeTypeChanges.map((change) => {
+            var _a;
+            if (ids.includes(change.id)) {
+                let node = state.doc.nodeAt(change.from);
+                if (status == 'pending' && node) {
+                    console.log('is pending', change);
+                    let oppositeType = (node === null || node === void 0 ? void 0 : node.type) !== schema.nodes.bullet_list ? schema.nodes.bullet_list : schema.nodes.ordered_list;
+                    tr.setMeta(TrackChangesAction.updateNodeType, true).setNodeMarkup(change.from, oppositeType, node.attrs, node.marks);
+                }
+                else if (status == 'rejected' && node) {
+                    skipTracking(tr.setNodeMarkup(change.from, (_a = state.doc.nodeAt(change.from)) === null || _a === void 0 ? void 0 : _a.type.schema.nodes[change.oldAttrs], node.attrs, node.marks));
+                }
+            }
+        });
+    }
     dispatch &&
-        dispatch(setAction(state.tr, TrackChangesAction.setChangeStatuses, {
+        dispatch(setAction(tr, TrackChangesAction.setChangeStatuses, {
             status,
             ids,
         }));

package/dist/es/index.js

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

package/dist/es/steps/trackReplaceAroundStep.js

@@ -31,13 +31,24 @@ export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs) {
             insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
             log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        deleteSteps.push({
-            type: 'insert-slice',
-            from: gapFrom,
-            to: gapTo,
-            slice: insertedSlice,
-            sliceWasSplit,
-        });
+        if (tr.getMeta(TrackChangesAction.updateNodeType)) {
+            console.log('steep', newTr.doc.nodeAt(from), slice);
+            deleteSteps.push({
+                type: 'update-node-type',
+                from: from,
+                nodeType: slice,
+                node: newTr.doc.nodeAt(from),
+            });
+        }
+        else {
+            deleteSteps.push({
+                type: 'insert-slice',
+                from: gapFrom,
+                to: gapTo,
+                slice: insertedSlice,
+                sliceWasSplit,
+            });
+        }
     }
     else {
     }

package/dist/es/types/change.js

@@ -3,6 +3,7 @@ export var CHANGE_OPERATION;
     CHANGE_OPERATION["insert"] = "insert";
     CHANGE_OPERATION["delete"] = "delete";
     CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+    CHANGE_OPERATION["set_node_type"] = "set_type";
 })(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
 export var CHANGE_STATUS;
 (function (CHANGE_STATUS) {

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

@@ -20,3 +20,6 @@ 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 createNewUpdateType(attrs, oldAttrs) {
+    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.set_node_type, oldAttrs: oldAttrs });
+}

package/dist/types/ChangeSet.d.ts

@@ -1,4 +1,4 @@
-import { IncompleteChange, NodeAttrChange, NodeChange, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+import { IncompleteChange, NodeAttrChange, NodeChange, NodeTypeChange, TextChange, TrackedAttrs, TrackedChange } from './types/change';
 export declare class ChangeSet {
     #private;
     constructor(changes?: (TrackedChange | IncompleteChange)[]);
@@ -11,6 +11,7 @@ export declare class ChangeSet {
     get textChanges(): TrackedChange[];
     get nodeChanges(): TrackedChange[];
     get nodeAttrChanges(): TrackedChange[];
+    get nodeTypeChange(): TrackedChange[];
     get bothNodeChanges(): TrackedChange[];
     get isEmpty(): boolean;
     get hasInconsistentData(): boolean;
@@ -25,4 +26,5 @@ export declare class ChangeSet {
     static isTextChange(change: TrackedChange): change is TextChange;
     static isNodeChange(change: TrackedChange): change is NodeChange;
     static isNodeAttrChange(change: TrackedChange): change is NodeAttrChange;
+    static isNodeTypeChange(change: TrackedChange): change is NodeTypeChange;
 }

package/dist/types/actions.d.ts

@@ -8,7 +8,8 @@ export declare enum TrackChangesAction {
     setChangeStatuses = "track-changes-set-change-statuses",
     refreshChanges = "track-changes-refresh-changes",
     applyAndRemoveChanges = "track-changes-apply-remove-changes",
-    updateMetaNode = "track-changes-update-meta-node"
+    updateMetaNode = "track-changes-update-meta-node",
+    updateNodeType = "track-changes-update-node-type"
 }
 export type TrackChangesActionParams = {
     [TrackChangesAction.skipTrack]: boolean;
@@ -21,6 +22,7 @@ export type TrackChangesActionParams = {
     [TrackChangesAction.refreshChanges]: boolean;
     [TrackChangesAction.applyAndRemoveChanges]: boolean;
     [TrackChangesAction.updateMetaNode]: boolean;
+    [TrackChangesAction.updateNodeType]: boolean;
 };
 export declare function getAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K): TrackChangesActionParams[K] | undefined;
 export declare function setAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K, payload: TrackChangesActionParams[K]): Transaction;

package/dist/types/index.d.ts

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

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

@@ -1,7 +1,8 @@
 export declare enum CHANGE_OPERATION {
     insert = "insert",
     delete = "delete",
-    set_node_attributes = "set_attrs"
+    set_node_attributes = "set_attrs",
+    set_node_type = "set_type"
 }
 export declare enum CHANGE_STATUS {
     accepted = "accepted",
@@ -22,7 +23,11 @@ export type UpdateAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
     operation: CHANGE_OPERATION.set_node_attributes;
     oldAttrs: Record<string, any>;
 };
-export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs;
+export type UpdateType = Omit<InsertDeleteAttrs, 'operation'> & {
+    operation: CHANGE_OPERATION.set_node_type;
+    oldAttrs: string;
+};
+export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs | UpdateType;
 type Change = {
     id: string;
     from: number;
@@ -44,6 +49,12 @@ export type NodeAttrChange = Change & {
     oldAttrs: Record<string, any>;
     newAttrs: Record<string, any>;
 };
+export type NodeTypeChange = Change & {
+    type: 'node-type-change';
+    nodeType: string;
+    oldAttrs: string;
+    newAttrs: Record<string, any>;
+};
 export type WrapChange = Change & {
     type: 'wrap-change';
     wrapperNode: string;
@@ -51,7 +62,7 @@ export type WrapChange = Change & {
 export type MarkChange = Change & {
     type: 'mark-change';
 };
-export type TrackedChange = TextChange | NodeChange | NodeAttrChange | WrapChange | MarkChange;
+export type TrackedChange = TextChange | NodeChange | NodeAttrChange | WrapChange | MarkChange | NodeTypeChange;
 export type PartialChange<T extends TrackedChange> = Omit<T, 'dataTracked'> & {
     dataTracked: Partial<TrackedAttrs>;
 };

package/dist/types/types/step.d.ts

@@ -1,4 +1,4 @@
-import { Node as PMNode } from 'prosemirror-model';
+import { Node as PMNode, Slice } from 'prosemirror-model';
 import { ExposedFragment, ExposedSlice } from './pm';
 export interface DeleteNodeStep {
     pos: number;
@@ -29,10 +29,16 @@ export interface InsertSliceStep {
     type: 'insert-slice';
     slice: ExposedSlice;
 }
+export interface TypeSliceStep {
+    type: 'update-node-type';
+    from: number;
+    nodeType: Slice;
+    node: PMNode;
+}
 export interface UpdateNodeAttrsStep {
     pos: number;
     type: 'update-node-attrs';
     node: PMNode;
     newAttrs: Record<string, any>;
 }
-export type ChangeStep = DeleteNodeStep | DeleteTextStep | MergeFragmentStep | InsertSliceStep | UpdateNodeAttrsStep;
+export type ChangeStep = DeleteNodeStep | DeleteTextStep | MergeFragmentStep | InsertSliceStep | UpdateNodeAttrsStep | TypeSliceStep;

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

@@ -23,6 +23,10 @@ export type NewUpdateAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
     operation: CHANGE_OPERATION.set_node_attributes;
     oldAttrs: Record<string, any>;
 };
+export type NewUpdateType = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.set_node_type;
+    oldAttrs: string;
+};
 export type NewTrackedAttrs = NewInsertAttrs | NewDeleteAttrs | NewUpdateAttrs;
 export declare enum TrackChangesStatus {
     enabled = "enabled",

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

@@ -1,4 +1,5 @@
-import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewUpdateAttrs } from '../types/track';
+import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewUpdateAttrs, NewUpdateType } from '../types/track';
 export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
 export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
 export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
+export declare function createNewUpdateType(attrs: NewEmptyAttrs, oldAttrs: string): NewUpdateType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "1.7.11",
+  "version": "1.7.12-LEAN-3608.0",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",
@@ -69,4 +69,4 @@
   "resolutions": {
     "eslint-mdx": "2.0.5"
   }
-}
+}