@ckeditor/ckeditor5-engine 38.1.1 → 38.2.0-alpha.1

package/src/model/operation/rootoperation.js

@@ -1,114 +1,114 @@
-/**
- * @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
- */
-/**
- * @module engine/model/operation/rootoperation
- */
-import Operation from './operation';
-import { CKEditorError } from '@ckeditor/ckeditor5-utils';
-/**
- * Operation that creates (or attaches) or detaches a root element.
- */
-export default class RootOperation extends Operation {
-    /**
-     * Creates an operation that creates or removes a root element.
-     *
-     * @param rootName Root name to create or detach.
-     * @param elementName Root element name.
-     * @param isAdd Specifies whether the operation adds (`true`) or detaches the root (`false`).
-     * @param document Document which owns the root.
-     * @param baseVersion Document {@link module:engine/model/document~Document#version} on which operation can be applied.
-     */
-    constructor(rootName, elementName, isAdd, document, baseVersion) {
-        super(baseVersion);
-        this.rootName = rootName;
-        this.elementName = elementName;
-        this.isAdd = isAdd;
-        this._document = document;
-        // Make sure that the root exists ASAP, this is important for RTC.
-        // If the root was dynamically added, there will be more operations that operate on/in this root.
-        // These operations will require root element instance (in operation property or in position instance).
-        // If the root is not created ahead of time, instantiating such operations may fail.
-        if (!this._document.getRoot(this.rootName)) {
-            const root = this._document.createRoot(this.elementName, this.rootName);
-            root._isAttached = false;
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    get type() {
-        return this.isAdd ? 'addRoot' : 'detachRoot';
-    }
-    /**
-     * @inheritDoc
-     */
-    get affectedSelectable() {
-        return this._document.getRoot(this.rootName);
-    }
-    /**
-     * @inheritDoc
-     */
-    clone() {
-        return new RootOperation(this.rootName, this.elementName, this.isAdd, this._document, this.baseVersion);
-    }
-    /**
-     * @inheritDoc
-     */
-    getReversed() {
-        return new RootOperation(this.rootName, this.elementName, !this.isAdd, this._document, this.baseVersion + 1);
-    }
-    /**
-     * @inheritDoc
-     */
-    _validate() {
-        // Keep in mind that at this point the root will always exist as it was created in the `constructor()`, even for detach operation.
-        const root = this._document.getRoot(this.rootName);
-        if (root.isAttached() && this.isAdd) {
-            /**
-             * Trying to attach a root that is already attached.
-             *
-             * @error root-operation-root-attached
-             */
-            throw new CKEditorError('root-operation-root-attached', this);
-        }
-        else if (!root.isAttached() && !this.isAdd) {
-            /**
-             * Trying to detach a root that is already detached.
-             *
-             * @error root-operation-root-detached
-             */
-            throw new CKEditorError('root-operation-root-detached', this);
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    _execute() {
-        this._document.getRoot(this.rootName)._isAttached = this.isAdd;
-    }
-    /**
-     * @inheritDoc
-     */
-    toJSON() {
-        const json = super.toJSON();
-        delete json._document;
-        return json;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get className() {
-        return 'RootOperation';
-    }
-    /**
-     * Creates `RootOperation` 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) {
-        return new RootOperation(json.rootName, json.elementName, json.isAdd, document, json.baseVersion);
-    }
-}
+/**
+ * @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
+ */
+/**
+ * @module engine/model/operation/rootoperation
+ */
+import Operation from './operation.js';
+import { CKEditorError } from '@ckeditor/ckeditor5-utils';
+/**
+ * Operation that creates (or attaches) or detaches a root element.
+ */
+export default class RootOperation extends Operation {
+    /**
+     * Creates an operation that creates or removes a root element.
+     *
+     * @param rootName Root name to create or detach.
+     * @param elementName Root element name.
+     * @param isAdd Specifies whether the operation adds (`true`) or detaches the root (`false`).
+     * @param document Document which owns the root.
+     * @param baseVersion Document {@link module:engine/model/document~Document#version} on which operation can be applied.
+     */
+    constructor(rootName, elementName, isAdd, document, baseVersion) {
+        super(baseVersion);
+        this.rootName = rootName;
+        this.elementName = elementName;
+        this.isAdd = isAdd;
+        this._document = document;
+        // Make sure that the root exists ASAP, this is important for RTC.
+        // If the root was dynamically added, there will be more operations that operate on/in this root.
+        // These operations will require root element instance (in operation property or in position instance).
+        // If the root is not created ahead of time, instantiating such operations may fail.
+        if (!this._document.getRoot(this.rootName)) {
+            const root = this._document.createRoot(this.elementName, this.rootName);
+            root._isAttached = false;
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    get type() {
+        return this.isAdd ? 'addRoot' : 'detachRoot';
+    }
+    /**
+     * @inheritDoc
+     */
+    get affectedSelectable() {
+        return this._document.getRoot(this.rootName);
+    }
+    /**
+     * @inheritDoc
+     */
+    clone() {
+        return new RootOperation(this.rootName, this.elementName, this.isAdd, this._document, this.baseVersion);
+    }
+    /**
+     * @inheritDoc
+     */
+    getReversed() {
+        return new RootOperation(this.rootName, this.elementName, !this.isAdd, this._document, this.baseVersion + 1);
+    }
+    /**
+     * @inheritDoc
+     */
+    _validate() {
+        // Keep in mind that at this point the root will always exist as it was created in the `constructor()`, even for detach operation.
+        const root = this._document.getRoot(this.rootName);
+        if (root.isAttached() && this.isAdd) {
+            /**
+             * Trying to attach a root that is already attached.
+             *
+             * @error root-operation-root-attached
+             */
+            throw new CKEditorError('root-operation-root-attached', this);
+        }
+        else if (!root.isAttached() && !this.isAdd) {
+            /**
+             * Trying to detach a root that is already detached.
+             *
+             * @error root-operation-root-detached
+             */
+            throw new CKEditorError('root-operation-root-detached', this);
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    _execute() {
+        this._document.getRoot(this.rootName)._isAttached = this.isAdd;
+    }
+    /**
+     * @inheritDoc
+     */
+    toJSON() {
+        const json = super.toJSON();
+        delete json._document;
+        return json;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get className() {
+        return 'RootOperation';
+    }
+    /**
+     * Creates `RootOperation` 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) {
+        return new RootOperation(json.rootName, json.elementName, json.isAdd, document, json.baseVersion);
+    }
+}

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

@@ -1,109 +1,109 @@
-/**
- * @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
- */
-/**
- * @module engine/model/operation/splitoperation
- */
-import Operation from './operation';
-import Position from '../position';
-import Range from '../range';
-import type Document from '../document';
-import type { Selectable } from '../selection';
-/**
- * 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 {
-    /**
-     * Position at which an element should be split.
-     */
-    splitPosition: Position;
-    /**
-     * Total offset size of elements that are in the split element after `position`.
-     */
-    howMany: number;
-    /**
-     * Position at which the clone of split element (or element from graveyard) will be inserted.
-     */
-    insertionPosition: Position;
-    /**
-     * 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.
-     *
-     * The default behavior is to clone the split element. Element from graveyard is used during undo.
-     */
-    graveyardPosition: Position | null;
-    /**
-     * 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: Position, howMany: number, insertionPosition: Position, graveyardPosition: Position | null, baseVersion: number | null);
-    /**
-     * @inheritDoc
-     */
-    get type(): '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(): Position;
-    /**
-     * 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(): Range;
-    /**
-     * @inheritDoc
-     */
-    get affectedSelectable(): Selectable;
-    /**
-     * Creates and returns an operation that has the same parameters as this operation.
-     *
-     * @returns Clone of this operation.
-     */
-    clone(): SplitOperation;
-    /**
-     * See {@link module:engine/model/operation/operation~Operation#getReversed `Operation#getReversed()`}.
-     */
-    getReversed(): Operation;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _validate(): void;
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    _execute(): void;
-    /**
-     * @inheritDoc
-     */
-    toJSON(): unknown;
-    /**
-     * @inheritDoc
-     */
-    static get className(): string;
-    /**
-     * Helper function that returns a default insertion position basing on given `splitPosition`. The default insertion
-     * position is after the split element.
-     */
-    static getInsertionPosition(splitPosition: Position): Position;
-    /**
-     * 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: any, document: Document): SplitOperation;
-}
+/**
+ * @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
+ */
+/**
+ * @module engine/model/operation/splitoperation
+ */
+import Operation from './operation.js';
+import Position from '../position.js';
+import Range from '../range.js';
+import type Document from '../document.js';
+import type { Selectable } from '../selection.js';
+/**
+ * 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 {
+    /**
+     * Position at which an element should be split.
+     */
+    splitPosition: Position;
+    /**
+     * Total offset size of elements that are in the split element after `position`.
+     */
+    howMany: number;
+    /**
+     * Position at which the clone of split element (or element from graveyard) will be inserted.
+     */
+    insertionPosition: Position;
+    /**
+     * 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.
+     *
+     * The default behavior is to clone the split element. Element from graveyard is used during undo.
+     */
+    graveyardPosition: Position | null;
+    /**
+     * 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: Position, howMany: number, insertionPosition: Position, graveyardPosition: Position | null, baseVersion: number | null);
+    /**
+     * @inheritDoc
+     */
+    get type(): '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(): Position;
+    /**
+     * 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(): Range;
+    /**
+     * @inheritDoc
+     */
+    get affectedSelectable(): Selectable;
+    /**
+     * Creates and returns an operation that has the same parameters as this operation.
+     *
+     * @returns Clone of this operation.
+     */
+    clone(): SplitOperation;
+    /**
+     * See {@link module:engine/model/operation/operation~Operation#getReversed `Operation#getReversed()`}.
+     */
+    getReversed(): Operation;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _validate(): void;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _execute(): void;
+    /**
+     * @inheritDoc
+     */
+    toJSON(): unknown;
+    /**
+     * @inheritDoc
+     */
+    static get className(): string;
+    /**
+     * Helper function that returns a default insertion position basing on given `splitPosition`. The default insertion
+     * position is after the split element.
+     */
+    static getInsertionPosition(splitPosition: Position): Position;
+    /**
+     * 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: any, document: Document): SplitOperation;
+}