@ckeditor/ckeditor5-engine 39.0.1 → 40.0.0

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

@@ -1,100 +1,100 @@
-/**
- * @license Copyright (c) 2003-2023, 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';
-import type Document from '../document';
-/**
- * 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;
-};
+/**
+ * @license Copyright (c) 2003-2023, 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';
+import type Document from '../document';
+/**
+ * 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;
+};