@ckeditor/ckeditor5-engine 0.0.0-internal-20241017.0

package/src/model/operation/splitoperation.js

@@ -0,0 +1,194 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/model/operation/splitoperation
+ */
+import Operation from './operation.js';
+import MergeOperation from './mergeoperation.js';
+import Position from '../position.js';
+import Range from '../range.js';
+import { _insert, _move } from './utils.js';
+import { CKEditorError } from '@ckeditor/ckeditor5-utils';
+/**
+ * Operation to split {@link module:engine/model/element~Element an element} at given
+ * {@link module:engine/model/operation/splitoperation~SplitOperation#splitPosition split position} into two elements,
+ * both containing a part of the element's original content.
+ */
+export default class SplitOperation extends Operation {
+    /**
+     * Creates a split operation.
+     *
+     * @param splitPosition Position at which an element should be split.
+     * @param howMany Total offset size of elements that are in the split element after `position`.
+     * @param insertionPosition Position at which the clone of split element (or element from graveyard) will be inserted.
+     * @param graveyardPosition Position in the graveyard root before the element which
+     * should be used as a parent of the nodes after `position`. If it is not set, a copy of the the `position` parent will be used.
+     * @param baseVersion Document {@link module:engine/model/document~Document#version} on which operation
+     * can be applied or `null` if the operation operates on detached (non-document) tree.
+     */
+    constructor(splitPosition, howMany, insertionPosition, graveyardPosition, baseVersion) {
+        super(baseVersion);
+        this.splitPosition = splitPosition.clone();
+        // Keep position sticking to the next node. This way any new content added at the place where the element is split
+        // will be left in the original element.
+        this.splitPosition.stickiness = 'toNext';
+        this.howMany = howMany;
+        this.insertionPosition = insertionPosition;
+        this.graveyardPosition = graveyardPosition ? graveyardPosition.clone() : null;
+        if (this.graveyardPosition) {
+            this.graveyardPosition.stickiness = 'toNext';
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    get type() {
+        return 'split';
+    }
+    /**
+     * Position inside the new clone of a split element.
+     *
+     * This is a position where nodes that are after the split position will be moved to.
+     */
+    get moveTargetPosition() {
+        const path = this.insertionPosition.path.slice();
+        path.push(0);
+        return new Position(this.insertionPosition.root, path);
+    }
+    /**
+     * Artificial range that contains all the nodes from the split element that will be moved to the new element.
+     * The range starts at {@link #splitPosition} and ends in the same parent, at `POSITIVE_INFINITY` offset.
+     */
+    get movedRange() {
+        const end = this.splitPosition.getShiftedBy(Number.POSITIVE_INFINITY);
+        return new Range(this.splitPosition, end);
+    }
+    /**
+     * @inheritDoc
+     */
+    get affectedSelectable() {
+        // These could be positions but `Selectable` type only supports `Iterable<Range>`.
+        const ranges = [
+            Range._createFromPositionAndShift(this.splitPosition, 0),
+            Range._createFromPositionAndShift(this.insertionPosition, 0)
+        ];
+        if (this.graveyardPosition) {
+            ranges.push(Range._createFromPositionAndShift(this.graveyardPosition, 0));
+        }
+        return ranges;
+    }
+    /**
+     * Creates and returns an operation that has the same parameters as this operation.
+     *
+     * @returns Clone of this operation.
+     */
+    clone() {
+        return new SplitOperation(this.splitPosition, this.howMany, this.insertionPosition, this.graveyardPosition, this.baseVersion);
+    }
+    /**
+     * See {@link module:engine/model/operation/operation~Operation#getReversed `Operation#getReversed()`}.
+     */
+    getReversed() {
+        const graveyard = this.splitPosition.root.document.graveyard;
+        const graveyardPosition = new Position(graveyard, [0]);
+        return new MergeOperation(this.moveTargetPosition, this.howMany, this.splitPosition, graveyardPosition, this.baseVersion + 1);
+    }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _validate() {
+        const element = this.splitPosition.parent;
+        const offset = this.splitPosition.offset;
+        // Validate whether split operation has correct parameters.
+        if (!element || element.maxOffset < offset) {
+            /**
+             * Split position is invalid.
+             *
+             * @error split-operation-position-invalid
+             */
+            throw new CKEditorError('split-operation-position-invalid', this);
+        }
+        else if (!element.parent) {
+            /**
+             * Cannot split root element.
+             *
+             * @error split-operation-split-in-root
+             */
+            throw new CKEditorError('split-operation-split-in-root', this);
+        }
+        else if (this.howMany != element.maxOffset - this.splitPosition.offset) {
+            /**
+             * Split operation specifies wrong number of nodes to move.
+             *
+             * @error split-operation-how-many-invalid
+             */
+            throw new CKEditorError('split-operation-how-many-invalid', this);
+        }
+        else if (this.graveyardPosition && !this.graveyardPosition.nodeAfter) {
+            /**
+             * Graveyard position invalid.
+             *
+             * @error split-operation-graveyard-position-invalid
+             */
+            throw new CKEditorError('split-operation-graveyard-position-invalid', this);
+        }
+    }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _execute() {
+        const splitElement = this.splitPosition.parent;
+        if (this.graveyardPosition) {
+            _move(Range._createFromPositionAndShift(this.graveyardPosition, 1), this.insertionPosition);
+        }
+        else {
+            const newElement = splitElement._clone();
+            _insert(this.insertionPosition, newElement);
+        }
+        const sourceRange = new Range(Position._createAt(splitElement, this.splitPosition.offset), Position._createAt(splitElement, splitElement.maxOffset));
+        _move(sourceRange, this.moveTargetPosition);
+    }
+    /**
+     * @inheritDoc
+     */
+    toJSON() {
+        const json = super.toJSON();
+        json.splitPosition = this.splitPosition.toJSON();
+        json.insertionPosition = this.insertionPosition.toJSON();
+        if (this.graveyardPosition) {
+            json.graveyardPosition = this.graveyardPosition.toJSON();
+        }
+        return json;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get className() {
+        return 'SplitOperation';
+    }
+    /**
+     * Helper function that returns a default insertion position basing on given `splitPosition`. The default insertion
+     * position is after the split element.
+     */
+    static getInsertionPosition(splitPosition) {
+        const path = splitPosition.path.slice(0, -1);
+        path[path.length - 1]++;
+        return new Position(splitPosition.root, path, 'toPrevious');
+    }
+    /**
+     * Creates `SplitOperation` object from deserialized object, i.e. from parsed JSON string.
+     *
+     * @param json Deserialized JSON object.
+     * @param document Document on which this operation will be applied.
+     */
+    static fromJSON(json, document) {
+        const splitPosition = Position.fromJSON(json.splitPosition, document);
+        const insertionPosition = Position.fromJSON(json.insertionPosition, document);
+        const graveyardPosition = json.graveyardPosition ? Position.fromJSON(json.graveyardPosition, document) : null;
+        return new this(splitPosition, json.howMany, insertionPosition, graveyardPosition, json.baseVersion);
+    }
+}

package/src/model/operation/transform.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type Operation from './operation.js';
+import type Document from '../document.js';
+/**
+ * Transforms operation `a` by operation `b`.
+ *
+ * @param a Operation to be transformed.
+ * @param b Operation to transform by.
+ * @param context Transformation context for this transformation.
+ * @returns Transformation result.
+ */
+export declare function transform(a: Operation, b: Operation, context?: TransformationContext): Array<Operation>;
+/**
+ * Performs a transformation of two sets of operations - `operationsA` and `operationsB`. The transformation is two-way -
+ * both transformed `operationsA` and transformed `operationsB` are returned.
+ *
+ * Note, that the first operation in each set should base on the same document state (
+ * {@link module:engine/model/document~Document#version document version}).
+ *
+ * It is assumed that `operationsA` are "more important" during conflict resolution between two operations.
+ *
+ * New copies of both passed arrays and operations inside them are returned. Passed arguments are not altered.
+ *
+ * Base versions of the transformed operations sets are updated accordingly. For example, assume that base versions are `4`
+ * and there are `3` operations in `operationsA` and `5` operations in `operationsB`. Then:
+ *
+ * * transformed `operationsA` will start from base version `9` (`4` base version + `5` operations B),
+ * * transformed `operationsB` will start from base version `7` (`4` base version + `3` operations A).
+ *
+ * If no operation was broken into two during transformation, then both sets will end up with an operation that bases on version `11`:
+ *
+ * * transformed `operationsA` start from `9` and there are `3` of them, so the last will have `baseVersion` equal to `11`,
+ * * transformed `operationsB` start from `7` and there are `5` of them, so the last will have `baseVersion` equal to `11`.
+ *
+ * @param operationsA
+ * @param operationsB
+ * @param options Additional transformation options.
+ * @param options.document Document which the operations change.
+ * @param options.useRelations Whether during transformation relations should be used (used during undo for better conflict resolution).
+ * @param options.padWithNoOps Whether additional {@link module:engine/model/operation/nooperation~NoOperation}s
+ * should be added to the transformation results to force the same last base version for both transformed sets (in case
+ * if some operations got broken into multiple operations during transformation).
+ * @param options.forceWeakRemove If set to `false`, remove operation will be always stronger than move operation,
+ * so the removed nodes won't end up back in the document root. When set to `true`, context data will be used.
+ * @returns Transformation result.
+ */
+export declare function transformSets(operationsA: Array<Operation>, operationsB: Array<Operation>, options: {
+    document: Document;
+    useRelations?: boolean;
+    padWithNoOps?: boolean;
+    forceWeakRemove?: boolean;
+}): TransformSetsResult;
+/**
+ * The result of {@link module:engine/model/operation/transform~transformSets}.
+ */
+export interface TransformSetsResult {
+    /**
+     * Transformed `operationsA`.
+     */
+    operationsA: Array<Operation>;
+    /**
+     * Transformed `operationsB`.
+     */
+    operationsB: Array<Operation>;
+    /**
+     * A map that links transformed operations to original operations. The keys are the transformed
+     * operations and the values are the original operations from the input (`operationsA` and `operationsB`).
+     */
+    originalOperations: Map<Operation, Operation>;
+}
+/**
+ * Holds additional contextual information about a transformed pair of operations (`a` and `b`). Those information
+ * can be used for better conflict resolving.
+ */
+export type TransformationContext = {
+    /**
+     * Whether `a` is strong operation in this transformation, or weak.
+     */
+    aIsStrong?: boolean;
+    /**
+     * Whether `a` operation was undone.
+     */
+    aWasUndone?: boolean;
+    /**
+     * Whether `b` operation was undone.
+     */
+    bWasUndone?: boolean;
+    /**
+     * The relation between `a` operation and an operation undone by `b` operation.
+     */
+    abRelation?: any;
+    /**
+     * The relation between `b` operation and an operation undone by `a` operation.
+     */
+    baRelation?: any;
+    forceWeakRemove?: boolean;
+};