@manuscripts/track-changes-plugin 2.1.1 → 2.2.1

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

@@ -1,217 +0,0 @@
-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 { 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) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.insert });
-}
-export function createNewWrapAttrs(attrs) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.wrap_with_node });
-}
-export function createNewSplitAttrs(attrs) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.node_split });
-}
-export function createNewReferenceAttrs(attrs, id) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.reference, referenceId: id });
-}
-export function createNewDeleteAttrs(attrs) {
-    return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.delete });
-}
-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 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)) {
-            continue;
-        }
-        const step = tr.steps[i];
-        const doc = tr.docs[i];
-        if (!step.slice) {
-            continue;
-        }
-        const stepDeletesContent = step.from !== step.to && step.slice.size === 0;
-        const stepInsertsContent = step.slice.size && step.slice.content.firstChild ? true : false;
-        for (let g = 0; g < tr.steps.length; g++) {
-            if (g === i || matched.includes(g)) {
-                continue;
-            }
-            const peerStep = tr.steps[g];
-            if (!peerStep.slice) {
-                continue;
-            }
-            const peerStepInsertsContent = peerStep.slice.size && peerStep.slice.content.firstChild;
-            const peerStepDeletesContent = peerStep.from !== peerStep.to && peerStep.slice.size === 0;
-            if (stepDeletesContent) {
-                const deletedContent = doc.slice(step.from, step.to);
-                if (peerStepInsertsContent &&
-                    deletedContent.content.firstChild &&
-                    peerStep.slice.content.firstChild.toString() === deletedContent.content.firstChild.toString()) {
-                    const commonID = uuidv4();
-                    movingAssoc.set(peerStep, commonID);
-                    movingAssoc.set(step, commonID);
-                    matched.push(i, g);
-                }
-                continue;
-            }
-            if (stepInsertsContent && peerStepDeletesContent) {
-                const insertedContent = step.slice;
-                const deletedPeerContent = tr.docs[g].slice(peerStep.from, peerStep.to);
-                if (insertedContent.content.firstChild &&
-                    deletedPeerContent.content.firstChild &&
-                    insertedContent.content.firstChild.toString() === deletedPeerContent.content.firstChild.toString()) {
-                    const commonID = uuidv4();
-                    movingAssoc.set(peerStep, commonID);
-                    movingAssoc.set(step, commonID);
-                }
-                matched.push(i, g);
-            }
-        }
-    }
-    return movingAssoc;
-};
-export const isPendingChange = (trackedAttrs, operation) => {
-    return !!(trackedAttrs === null || trackedAttrs === void 0 ? void 0 : trackedAttrs.some((t) => t.operation === operation));
-};
-export const isDeletingPendingMovedNode = (step, doc) => {
-    if (!step.slice || step.from === step.to || step.slice.content.size > 0) {
-        return undefined;
-    }
-    const node = doc.nodeAt(step.from);
-    if (!node) {
-        return undefined;
-    }
-    const trackedAttrs = node.attrs.dataTracked;
-    const found = trackedAttrs === null || trackedAttrs === void 0 ? void 0 : trackedAttrs.find((tracked) => tracked.operation === CHANGE_OPERATION.move && tracked.status === CHANGE_STATUS.pending);
-    if (found === null || found === void 0 ? void 0 : found.moveNodeId) {
-        return found.moveNodeId;
-    }
-    return undefined;
-};
-export const isDirectPendingMoveDeletion = (step, doc, movingSteps) => {
-    if (step.from === step.to || step.slice.content.size > 0) {
-        return false;
-    }
-    if (movingSteps.has(step)) {
-        return false;
-    }
-    const node = doc.nodeAt(step.from);
-    if (!node) {
-        return false;
-    }
-    return isPendingChange(node.attrs.dataTracked, CHANGE_OPERATION.move);
-};
-export const handleDirectPendingMoveDeletions = (tr, newTr, movingSteps) => {
-    tr.steps.forEach((step) => {
-        if (step instanceof ReplaceStep) {
-            const doc = tr.docs[tr.steps.indexOf(step)];
-            if (isDirectPendingMoveDeletion(step, doc, movingSteps)) {
-                const node = doc.nodeAt(step.from);
-                if (node === null || node === void 0 ? void 0 : node.attrs.dataTracked) {
-                    newTr.setNodeMarkup(step.from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: node.attrs.dataTracked.filter((t) => !(t.operation === CHANGE_OPERATION.move && t.status === CHANGE_STATUS.pending)) }));
-                }
-            }
-        }
-    });
-};
-export const filterMeaninglessMoveSteps = (tr, movingSteps) => {
-    var _a;
-    const cleanSteps = [];
-    for (let i = 0; i < tr.steps.length; i++) {
-        const step = tr.steps[i];
-        const moveID = movingSteps.get(step);
-        if (moveID) {
-            const prevMoveID = isDeletingPendingMovedNode(step, tr.docs[i]);
-            if (prevMoveID) {
-                movingSteps.forEach((replaceStepMoveID, replaceStep) => {
-                    if (replaceStep !== step && moveID === replaceStepMoveID) {
-                        movingSteps.set(replaceStep, prevMoveID);
-                    }
-                });
-                continue;
-            }
-            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;
-                    if (insertedNode.attrs.dataTracked) {
-                        const isPendingInsert = isPendingChange(insertedNode.attrs.dataTracked, CHANGE_OPERATION.insert);
-                        if (isPendingInsert) {
-                            continue;
-                        }
-                    }
-                }
-            }
-        }
-        cleanSteps.push(step);
-    }
-    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);
-};
-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/types/change-steps/diffChangeSteps.d.ts

@@ -1,2 +0,0 @@
-import { ChangeStep, InsertSliceStep } from '../types/step';
-export declare function diffChangeSteps(deleted: ChangeStep[], inserted: InsertSliceStep[]): ChangeStep[];

package/dist/types/change-steps/matchInserted.d.ts

@@ -1,3 +0,0 @@
-import { ExposedFragment } from '../types/pm';
-import { ChangeStep } from '../types/step';
-export declare function matchInserted(matchedDeleted: number, deleted: ChangeStep[], inserted: ExposedFragment): [number, ChangeStep[]];

package/dist/types/change-steps/processChangeSteps.d.ts

@@ -1,6 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import type { Transaction } from 'prosemirror-state';
-import { Mapping } from 'prosemirror-transform';
-import { ChangeStep } from '../types/step';
-import { NewEmptyAttrs } from '../types/track';
-export declare function processChangeSteps(changes: ChangeStep[], startPos: number, newTr: Transaction, emptyAttrs: NewEmptyAttrs, schema: Schema, deletedNodeMapping: Mapping): [Mapping, number];

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

@@ -1,6 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import { Transaction } from 'prosemirror-state';
-import { Mapping } from 'prosemirror-transform';
-import { ChangeSet } from '../ChangeSet';
-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,14 +0,0 @@
-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;
-export declare function getMergeableMarkTrackedAttrs(node: PMNode | undefined | null, attrs: Partial<TrackedAttrs>, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
-    operation: CHANGE_OPERATION;
-}) | null;

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

@@ -1,6 +0,0 @@
-import { Node as PMNode } from 'prosemirror-model';
-import type { EditorState, Transaction } from 'prosemirror-state';
-import { ReplaceStep, StepResult } from 'prosemirror-transform';
-import { ChangeStep } from '../types/step';
-import { NewEmptyAttrs } from '../types/track';
-export declare function trackReplaceStep(step: ReplaceStep, oldState: EditorState, newTr: Transaction, attrsTemplate: NewEmptyAttrs, stepResult: StepResult, currentStepDoc: PMNode, tr: Transaction, moveID?: string): [ChangeStep[], number];

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

@@ -1,3 +0,0 @@
-import { EditorState, Transaction } from 'prosemirror-state';
-import { ChangeSet } from '../ChangeSet';
-export declare function trackTransaction(tr: Transaction, oldState: EditorState, newTr: Transaction, authorID: string, changeSet: ChangeSet): Transaction;

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

@@ -1,40 +0,0 @@
-import { Node as PMNode } from 'prosemirror-model';
-import { ExposedFragment, ExposedSlice } from './pm';
-export interface DeleteNodeStep {
-    pos: number;
-    nodeEnd: number;
-    type: 'delete-node';
-    node: PMNode;
-    ref?: string;
-}
-export interface DeleteTextStep {
-    pos: number;
-    from: number;
-    to: number;
-    type: 'delete-text';
-    node: PMNode;
-    ref?: string;
-}
-export interface MergeFragmentStep {
-    pos: number;
-    mergePos: number;
-    from: number;
-    to: number;
-    type: 'merge-fragment';
-    node: PMNode;
-    fragment: ExposedFragment;
-}
-export interface InsertSliceStep {
-    from: number;
-    to: number;
-    sliceWasSplit: boolean;
-    type: 'insert-slice';
-    slice: ExposedSlice;
-}
-export interface UpdateNodeAttrsStep {
-    pos: number;
-    type: 'update-node-attrs';
-    node: PMNode;
-    newAttrs: Record<string, any>;
-}
-export type ChangeStep = DeleteNodeStep | DeleteTextStep | MergeFragmentStep | InsertSliceStep | UpdateNodeAttrsStep;

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

@@ -1,24 +0,0 @@
-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;
-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, 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 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;
-export declare const isDeletingPendingMovedNode: (step: ReplaceStep, doc: PMNode) => string | undefined;
-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;
-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;