@ckeditor/ckeditor5-engine 45.2.1 → 46.0.0-alpha.0

package/src/view/treewalker.js

@@ -2,13 +2,13 @@
  * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import TextProxy from './textproxy.js';
-import Position from './position.js';
+import { ViewTextProxy } from './textproxy.js';
+import { ViewPosition } from './position.js';
 import { CKEditorError } from '@ckeditor/ckeditor5-utils';
 /**
  * Position iterator class. It allows to iterate forward and backward over the document.
  */
-export default class TreeWalker {
+export class ViewTreeWalker {
     /**
      * Walking direction. Defaults `'forward'`.
      */
@@ -23,8 +23,8 @@ export default class TreeWalker {
      */
     boundaries;
     /**
-     * Flag indicating whether all characters from {@link module:engine/view/text~Text} should be returned as one
-     * {@link module:engine/view/text~Text} or one by one as {@link module:engine/view/textproxy~TextProxy}.
+     * Flag indicating whether all characters from {@link module:engine/view/text~ViewText} should be returned as one
+     * {@link module:engine/view/text~ViewText} or one by one as {@link module:engine/view/textproxy~ViewTextProxy}.
      */
     singleCharacters;
     /**
@@ -34,7 +34,7 @@ export default class TreeWalker {
     shallow;
     /**
      * Flag indicating whether iterator should ignore `elementEnd` tags. If set to `true`, walker will not
-     * return a parent node of the start position. Each {@link module:engine/view/element~Element} will be returned once.
+     * return a parent node of the start position. Each {@link module:engine/view/element~ViewElement} will be returned once.
      * When set to `false` each element might be returned twice: for `'elementStart'` and `'elementEnd'`.
      */
     ignoreElementEnd;
@@ -75,10 +75,10 @@ export default class TreeWalker {
         }
         this.boundaries = options.boundaries || null;
         if (options.startPosition) {
-            this._position = Position._createAt(options.startPosition);
+            this._position = ViewPosition._createAt(options.startPosition);
         }
         else {
-            this._position = Position._createAt(options.boundaries[options.direction == 'backward' ? 'end' : 'start']);
+            this._position = ViewPosition._createAt(options.boundaries[options.direction == 'backward' ? 'end' : 'start']);
         }
         this.direction = options.direction || 'forward';
         this.singleCharacters = !!options.singleCharacters;
@@ -111,7 +111,7 @@ export default class TreeWalker {
      * walker.skip( value => false ); // Do not move the position.
      * ```
      *
-     * @param skip Callback function. Gets {@link module:engine/view/treewalker~TreeWalkerValue} and should
+     * @param skip Callback function. Gets {@link module:engine/view/treewalker~ViewTreeWalkerValue} and should
      * return `true` if the value should be skipped or `false` if not.
      */
     skip(skip) {
@@ -129,9 +129,9 @@ export default class TreeWalker {
      * Moves tree walker {@link #position} to provided `position`. Tree walker will
      * continue traversing from that position.
      *
-     * Note: in contrary to {@link ~TreeWalker#skip}, this method does not iterate over the nodes along the way.
+     * Note: in contrary to {@link ~ViewTreeWalker#skip}, this method does not iterate over the nodes along the way.
      * It simply sets the current tree walker position to a new one.
-     * From the performance standpoint, it is better to use {@link ~TreeWalker#jumpTo} rather than {@link ~TreeWalker#skip}.
+     * From the performance standpoint, it is better to use {@link ~ViewTreeWalker#jumpTo} rather than {@link ~ViewTreeWalker#skip}.
      *
      * If the provided position is before the start boundary, the position will be
      * set to the start boundary. If the provided position is after the end boundary,
@@ -184,7 +184,7 @@ export default class TreeWalker {
         if (parent && parent.is('view:$text')) {
             if (position.isAtEnd) {
                 // Prevent returning "elementEnd" for Text node. Skip that value and return the next walker step.
-                this._position = Position._createAfter(parent);
+                this._position = ViewPosition._createAfter(parent);
                 return this._next();
             }
             node = parent.data[position.offset];
@@ -202,14 +202,14 @@ export default class TreeWalker {
                 const endOffset = parent === this._boundaryEndParent ? this.boundaries.end.offset : parent.data.length;
                 textLength = endOffset - position.offset;
             }
-            const textProxy = new TextProxy(parent, position.offset, textLength);
+            const textProxy = new ViewTextProxy(parent, position.offset, textLength);
             position.offset += textLength;
             this._position = position;
             return this._formatReturnValue('text', textProxy, previousPosition, position, textLength);
         }
         if (node && node.is('view:element')) {
             if (!this.shallow) {
-                position = new Position(node, 0);
+                position = new ViewPosition(node, 0);
             }
             else {
                 // We are past the walker boundaries.
@@ -223,20 +223,20 @@ export default class TreeWalker {
         }
         if (node && node.is('view:$text')) {
             if (this.singleCharacters) {
-                position = new Position(node, 0);
+                position = new ViewPosition(node, 0);
                 this._position = position;
                 return this._next();
             }
             let charactersCount = node.data.length;
             let item;
-            // If text stick out of walker range, we need to cut it and wrap in TextProxy.
+            // If text stick out of walker range, we need to cut it and wrap in ViewTextProxy.
             if (node == this._boundaryEndParent) {
                 charactersCount = this.boundaries.end.offset;
-                item = new TextProxy(node, 0, charactersCount);
-                position = Position._createAfter(item);
+                item = new ViewTextProxy(node, 0, charactersCount);
+                position = ViewPosition._createAfter(item);
             }
             else {
-                item = new TextProxy(node, 0, node.data.length);
+                item = new ViewTextProxy(node, 0, node.data.length);
                 // If not just keep moving forward.
                 position.offset++;
             }
@@ -244,7 +244,7 @@ export default class TreeWalker {
             return this._formatReturnValue('text', item, previousPosition, position, charactersCount);
         }
         // `node` is not set, we reached the end of current `parent`.
-        position = Position._createAfter(parent);
+        position = ViewPosition._createAfter(parent);
         this._position = position;
         if (this.ignoreElementEnd) {
             return this._next();
@@ -268,11 +268,11 @@ export default class TreeWalker {
         }
         // Get node just before current position.
         let node;
-        // Text {@link module:engine/view/text~Text} element is a specific parent because contains string instead of child nodes.
+        // Text {@link module:engine/view/text~ViewText} element is a specific parent because contains string instead of child nodes.
         if (parent.is('view:$text')) {
             if (position.isAtStart) {
                 // Prevent returning "elementStart" for Text node. Skip that value and return the next walker step.
-                this._position = Position._createBefore(parent);
+                this._position = ViewPosition._createBefore(parent);
                 return this._previous();
             }
             node = parent.data[position.offset - 1];
@@ -291,7 +291,7 @@ export default class TreeWalker {
                 textLength = 1;
             }
             position.offset -= textLength;
-            const textProxy = new TextProxy(parent, position.offset, textLength);
+            const textProxy = new ViewTextProxy(parent, position.offset, textLength);
             this._position = position;
             return this._formatReturnValue('text', textProxy, previousPosition, position, textLength);
         }
@@ -301,7 +301,7 @@ export default class TreeWalker {
                 this._position = position;
                 return this._formatReturnValue('elementStart', node, previousPosition, position, 1);
             }
-            position = new Position(node, node.childCount);
+            position = new ViewPosition(node, node.childCount);
             this._position = position;
             if (this.ignoreElementEnd) {
                 return this._previous();
@@ -310,21 +310,21 @@ export default class TreeWalker {
         }
         if (node && node.is('view:$text')) {
             if (this.singleCharacters) {
-                position = new Position(node, node.data.length);
+                position = new ViewPosition(node, node.data.length);
                 this._position = position;
                 return this._previous();
             }
             let charactersCount = node.data.length;
             let item;
-            // If text stick out of walker range, we need to cut it and wrap in TextProxy.
+            // If text stick out of walker range, we need to cut it and wrap in ViewTextProxy.
             if (node == this._boundaryStartParent) {
                 const offset = this.boundaries.start.offset;
-                item = new TextProxy(node, offset, node.data.length - offset);
+                item = new ViewTextProxy(node, offset, node.data.length - offset);
                 charactersCount = item.data.length;
-                position = Position._createBefore(item);
+                position = ViewPosition._createBefore(item);
             }
             else {
-                item = new TextProxy(node, 0, node.data.length);
+                item = new ViewTextProxy(node, 0, node.data.length);
                 // If not just keep moving backward.
                 position.offset--;
             }
@@ -332,12 +332,13 @@ export default class TreeWalker {
             return this._formatReturnValue('text', item, previousPosition, position, charactersCount);
         }
         // `node` is not set, we reached the beginning of current `parent`.
-        position = Position._createBefore(parent);
+        position = ViewPosition._createBefore(parent);
         this._position = position;
         return this._formatReturnValue('elementStart', parent, previousPosition, position, 1);
     }
     /**
-     * Format returned data and adjust `previousPosition` and `nextPosition` if reach the bound of the {@link module:engine/view/text~Text}.
+     * Format returned data and adjust `previousPosition` and `nextPosition` if
+     * reach the bound of the {@link module:engine/view/text~ViewText}.
      *
      * @param type Type of step.
      * @param item Item between old and new position.
@@ -354,23 +355,23 @@ export default class TreeWalker {
             // Position is at the end of Text.
             if (item.offsetInText + item.data.length == item.textNode.data.length) {
                 if (this.direction == 'forward' && !(this.boundaries && this.boundaries.end.isEqual(this.position))) {
-                    nextPosition = Position._createAfter(item.textNode);
+                    nextPosition = ViewPosition._createAfter(item.textNode);
                     // When we change nextPosition of returned value we need also update walker current position.
                     this._position = nextPosition;
                 }
                 else {
-                    previousPosition = Position._createAfter(item.textNode);
+                    previousPosition = ViewPosition._createAfter(item.textNode);
                 }
             }
             // Position is at the begining ot the text.
             if (item.offsetInText === 0) {
                 if (this.direction == 'backward' && !(this.boundaries && this.boundaries.start.isEqual(this.position))) {
-                    nextPosition = Position._createBefore(item.textNode);
+                    nextPosition = ViewPosition._createBefore(item.textNode);
                     // When we change nextPosition of returned value we need also update walker current position.
                     this._position = nextPosition;
                 }
                 else {
-                    previousPosition = Position._createBefore(item.textNode);
+                    previousPosition = ViewPosition._createBefore(item.textNode);
                 }
             }
         }

package/src/view/typecheckable.d.ts

@@ -2,31 +2,31 @@
  * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import type AttributeElement from './attributeelement.js';
-import type ContainerElement from './containerelement.js';
-import type DocumentFragment from './documentfragment.js';
-import type DocumentSelection from './documentselection.js';
-import type EditableElement from './editableelement.js';
-import type Element from './element.js';
-import type EmptyElement from './emptyelement.js';
-import type Node from './node.js';
-import type Position from './position.js';
-import type Range from './range.js';
-import type RawElement from './rawelement.js';
-import type RootEditableElement from './rooteditableelement.js';
-import type Selection from './selection.js';
-import type Text from './text.js';
-import type TextProxy from './textproxy.js';
-import type UIElement from './uielement.js';
+import { type ViewAttributeElement } from './attributeelement.js';
+import { type ViewContainerElement } from './containerelement.js';
+import { type ViewDocumentFragment } from './documentfragment.js';
+import { type ViewDocumentSelection } from './documentselection.js';
+import { type ViewEditableElement } from './editableelement.js';
+import { type ViewElement } from './element.js';
+import { type ViewEmptyElement } from './emptyelement.js';
+import { type ViewNode } from './node.js';
+import { type ViewPosition } from './position.js';
+import { type ViewRange } from './range.js';
+import { type ViewRawElement } from './rawelement.js';
+import { type ViewRootEditableElement } from './rooteditableelement.js';
+import { type ViewSelection } from './selection.js';
+import { type ViewText } from './text.js';
+import { type ViewTextProxy } from './textproxy.js';
+import { type ViewUIElement } from './uielement.js';
 /**
  * @module engine/view/typecheckable
  */
-export default abstract class TypeCheckable {
+export declare abstract class ViewTypeCheckable {
     /**
-     * Checks whether this object is of type {@link module:engine/view/node~Node} or its subclass.
+     * Checks whether this object is of type {@link module:engine/view/node~ViewNode} or its subclass.
      *
      * This method is useful when processing view objects that are of unknown type. For example, a function
-     * may return a {@link module:engine/view/documentfragment~DocumentFragment} or a {@link module:engine/view/node~Node}
+     * may return a {@link module:engine/view/documentfragment~ViewDocumentFragment} or a {@link module:engine/view/node~ViewNode}
      * that can be either a text node or an element. This method can be used to check what kind of object is returned.
      *
      * ```ts
@@ -51,9 +51,9 @@ export default abstract class TypeCheckable {
      * ```
      * @label NODE
      */
-    is(type: 'node' | 'view:node'): this is (Node | Text | Element | AttributeElement | ContainerElement | EditableElement | EmptyElement | RawElement | RootEditableElement | UIElement);
+    is(type: 'node' | 'view:node'): this is (ViewNode | ViewText | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
     /**
-     * Checks whether this object is of type {@link module:engine/view/element~Element} or its subclass.
+     * Checks whether this object is of type {@link module:engine/view/element~ViewElement} or its subclass.
      *
      * ```ts
      * element.is( 'element' ); // -> true
@@ -66,7 +66,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is an element, you can also check its
-     * {@link module:engine/view/element~Element#name name}:
+     * {@link module:engine/view/element~ViewElement#name name}:
      *
      * ```ts
      * element.is( 'element', 'img' ); // -> true if this is an <img> element
@@ -75,9 +75,9 @@ export default abstract class TypeCheckable {
      *
      * @label ELEMENT
      */
-    is(type: 'element' | 'view:element'): this is (Element | AttributeElement | ContainerElement | EditableElement | EmptyElement | RawElement | RootEditableElement | UIElement);
+    is(type: 'element' | 'view:element'): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement);
     /**
-     * Checks whether this object is of type {@link module:engine/view/attributeelement~AttributeElement}.
+     * Checks whether this object is of type {@link module:engine/view/attributeelement~ViewAttributeElement}.
      *
      * ```ts
      * attributeElement.is( 'attributeElement' ); // -> true
@@ -92,7 +92,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is an attribute element, you can also check its
-     * {@link module:engine/view/attributeelement~AttributeElement#name name}:
+     * {@link module:engine/view/attributeelement~ViewAttributeElement#name name}:
      *
      * ```ts
      * attributeElement.is( 'element', 'b' ); // -> true if this is a bold element
@@ -102,9 +102,9 @@ export default abstract class TypeCheckable {
      *
      * @label ATTRIBUTE_ELEMENT
      */
-    is(type: 'attributeElement' | 'view:attributeElement'): this is AttributeElement;
+    is(type: 'attributeElement' | 'view:attributeElement'): this is ViewAttributeElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/containerelement~ContainerElement} or its subclass.
+     * Checks whether this object is of type {@link module:engine/view/containerelement~ViewContainerElement} or its subclass.
      *
      * ```ts
      * containerElement.is( 'containerElement' ); // -> true
@@ -119,7 +119,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is a container element, you can also check its
-     * {@link module:engine/view/containerelement~ContainerElement#name name}:
+     * {@link module:engine/view/containerelement~ViewContainerElement#name name}:
      *
      * ```ts
      * containerElement.is( 'element', 'div' ); // -> true if this is a div container element
@@ -129,9 +129,9 @@ export default abstract class TypeCheckable {
      *
      * @label CONTAINER_ELEMENT
      */
-    is(type: 'containerElement' | 'view:containerElement'): this is ContainerElement | EditableElement | RootEditableElement;
+    is(type: 'containerElement' | 'view:containerElement'): this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/editableelement~EditableElement} or its subclass.
+     * Checks whether this object is of type {@link module:engine/view/editableelement~ViewEditableElement} or its subclass.
      *
      * ```ts
      * editableElement.is( 'editableElement' ); // -> true
@@ -146,7 +146,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is an editbale element, you can also check its
-     * {@link module:engine/view/editableelement~EditableElement#name name}:
+     * {@link module:engine/view/editableelement~ViewEditableElement#name name}:
      *
      * ```ts
      * editableElement.is( 'element', 'div' ); // -> true if this is a div element
@@ -156,9 +156,9 @@ export default abstract class TypeCheckable {
      *
      * @label EDITABLE_ELEMENT
      */
-    is(type: 'editableElement' | 'view:editableElement'): this is EditableElement | RootEditableElement;
+    is(type: 'editableElement' | 'view:editableElement'): this is ViewEditableElement | ViewRootEditableElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/emptyelement~EmptyElement}.
+     * Checks whether this object is of type {@link module:engine/view/emptyelement~ViewEmptyElement}.
      *
      * ```ts
      * emptyElement.is( 'emptyElement' ); // -> true
@@ -173,7 +173,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is an empty element, you can also check its
-     * {@link module:engine/view/emptyelement~EmptyElement#name name}:
+     * {@link module:engine/view/emptyelement~ViewEmptyElement#name name}:
      *
      * ```ts
      * emptyElement.is( 'element', 'img' ); // -> true if this is a img element
@@ -183,9 +183,9 @@ export default abstract class TypeCheckable {
      *
      * @label EMPTY_ELEMENT
      */
-    is(type: 'emptyElement' | 'view:emptyElement'): this is EmptyElement;
+    is(type: 'emptyElement' | 'view:emptyElement'): this is ViewEmptyElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/rawelement~RawElement}.
+     * Checks whether this object is of type {@link module:engine/view/rawelement~ViewRawElement}.
      *
      * ```ts
      * rawElement.is( 'rawElement' ); // -> true
@@ -200,7 +200,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is a raw element, you can also check its
-     * {@link module:engine/view/rawelement~RawElement#name name}:
+     * {@link module:engine/view/rawelement~ViewRawElement#name name}:
      *
      * ```ts
      * rawElement.is( 'img' ); // -> true if this is an img element
@@ -210,9 +210,9 @@ export default abstract class TypeCheckable {
      *
      * @label RAW_ELEMENT
      */
-    is(type: 'rawElement' | 'view:rawElement'): this is RawElement;
+    is(type: 'rawElement' | 'view:rawElement'): this is ViewRawElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/rooteditableelement~RootEditableElement}.
+     * Checks whether this object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}.
      *
      * ```ts
      * rootEditableElement.is( 'rootElement' ); // -> true
@@ -228,7 +228,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is a root editable element, you can also check its
-     * {@link module:engine/view/rooteditableelement~RootEditableElement#name name}:
+     * {@link module:engine/view/rooteditableelement~ViewRootEditableElement#name name}:
      *
      * ```ts
      * rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element
@@ -238,9 +238,9 @@ export default abstract class TypeCheckable {
      *
      * @label ROOT_ELEMENT
      */
-    is(type: 'rootElement' | 'view:rootElement'): this is RootEditableElement;
+    is(type: 'rootElement' | 'view:rootElement'): this is ViewRootEditableElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/uielement~UIElement}.
+     * Checks whether this object is of type {@link module:engine/view/uielement~ViewUIElement}.
      *
      * ```ts
      * uiElement.is( 'uiElement' ); // -> true
@@ -255,7 +255,7 @@ export default abstract class TypeCheckable {
      * ```
      *
      * Assuming that the object being checked is an ui element, you can also check its
-     * {@link module:engine/view/uielement~UIElement#name name}:
+     * {@link module:engine/view/uielement~ViewUIElement#name name}:
      *
      * ```ts
      * uiElement.is( 'element', 'span' ); // -> true if this is a span ui element
@@ -265,9 +265,9 @@ export default abstract class TypeCheckable {
      *
      * @label UI_ELEMENT
      */
-    is(type: 'uiElement' | 'view:uiElement'): this is UIElement;
+    is(type: 'uiElement' | 'view:uiElement'): this is ViewUIElement;
     /**
-     * Checks whether this object is of type {@link module:engine/view/text~Text}.
+     * Checks whether this object is of type {@link module:engine/view/text~ViewText}.
      *
      * ```ts
      * text.is( '$text' ); // -> true
@@ -282,9 +282,9 @@ export default abstract class TypeCheckable {
      *
      * @label TEXT
      */
-    is(type: '$text' | 'view:$text'): this is Text;
+    is(type: '$text' | 'view:$text'): this is ViewText;
     /**
-     * hecks whether this object is of type {@link module:engine/view/documentfragment~DocumentFragment}.
+     * hecks whether this object is of type {@link module:engine/view/documentfragment~ViewDocumentFragment}.
      *
      * ```ts
      * docFrag.is( 'documentFragment' ); // -> true
@@ -297,9 +297,9 @@ export default abstract class TypeCheckable {
      *
      * @label DOCUMENT_FRAGMENT
      */
-    is(type: 'documentFragment' | 'view:documentFragment'): this is DocumentFragment;
+    is(type: 'documentFragment' | 'view:documentFragment'): this is ViewDocumentFragment;
     /**
-     * Checks whether this object is of type {@link module:engine/view/textproxy~TextProxy}.
+     * Checks whether this object is of type {@link module:engine/view/textproxy~ViewTextProxy}.
      *
      * ```ts
      * textProxy.is( '$textProxy' ); // -> true
@@ -315,9 +315,9 @@ export default abstract class TypeCheckable {
      *
      * @label TEXT_PROXY
      */
-    is(type: '$textProxy' | 'view:$textProxy'): this is TextProxy;
+    is(type: '$textProxy' | 'view:$textProxy'): this is ViewTextProxy;
     /**
-     * Checks whether this object is of type {@link module:engine/view/position~Position}.
+     * Checks whether this object is of type {@link module:engine/view/position~ViewPosition}.
      *
      * ```ts
      * position.is( 'position' ); // -> true
@@ -330,9 +330,9 @@ export default abstract class TypeCheckable {
      *
      * @label POSITION
      */
-    is(type: 'position' | 'view:position'): this is Position;
+    is(type: 'position' | 'view:position'): this is ViewPosition;
     /**
-     * Checks whether this object is of type {@link module:engine/view/range~Range}.
+     * Checks whether this object is of type {@link module:engine/view/range~ViewRange}.
      *
      * ```ts
      * range.is( 'range' ); // -> true
@@ -345,10 +345,10 @@ export default abstract class TypeCheckable {
      *
      * @label RANGE
      */
-    is(type: 'range' | 'view:range'): this is Range;
+    is(type: 'range' | 'view:range'): this is ViewRange;
     /**
-     * Checks whether this object is of type {@link module:engine/view/selection~Selection} or
-     * {@link module:engine/view/documentselection~DocumentSelection}.
+     * Checks whether this object is of type {@link module:engine/view/selection~ViewSelection} or
+     * {@link module:engine/view/documentselection~ViewDocumentSelection}.
      *
      * ```ts
      * selection.is( 'selection' ); // -> true
@@ -361,9 +361,9 @@ export default abstract class TypeCheckable {
      *
      * @label SELECTION
      */
-    is(type: 'selection' | 'view:selection'): this is Selection | DocumentSelection;
+    is(type: 'selection' | 'view:selection'): this is ViewSelection | ViewDocumentSelection;
     /**
-     * Checks whether this object is of type {@link module:engine/view/documentselection~DocumentSelection}.
+     * Checks whether this object is of type {@link module:engine/view/documentselection~ViewDocumentSelection}.
      *
      * ```ts
      * `docSelection.is( 'selection' ); // -> true
@@ -378,71 +378,72 @@ export default abstract class TypeCheckable {
      *
      * @label DOCUMENT_SELECTION
      */
-    is(type: 'documentSelection' | 'view:documentSelection'): this is DocumentSelection;
+    is(type: 'documentSelection' | 'view:documentSelection'): this is ViewDocumentSelection;
     /**
-     * Checks whether the object is of type {@link module:engine/view/element~Element} or its subclass and has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/element~ViewElement} or its subclass and has the specified `name`.
      *
      * @label ELEMENT_NAME
      */
-    is<N extends string>(type: 'element' | 'view:element', name: N): this is (Element | AttributeElement | ContainerElement | EditableElement | EmptyElement | RawElement | RootEditableElement | UIElement) & {
+    is<N extends string>(type: 'element' | 'view:element', name: N): this is (ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement) & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/attributeelement~AttributeElement} and has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/attributeelement~ViewAttributeElement} and has the specified `name`.
      *
      * @label ATTRIBUTE_ELEMENT_NAME
      */
-    is<N extends string>(type: 'attributeElement' | 'view:attributeElement', name: N): this is AttributeElement & {
+    is<N extends string>(type: 'attributeElement' | 'view:attributeElement', name: N): this is ViewAttributeElement & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/containerelement~ContainerElement}
+     * Checks whether the object is of type {@link module:engine/view/containerelement~ViewContainerElement}
      * or its subclass and has the specified `name`.
      *
      * @label CONTAINER_ELEMENT_NAME
      */
-    is<N extends string>(type: 'containerElement' | 'view:containerElement', name: N): this is (ContainerElement | EditableElement | RootEditableElement) & {
+    is<N extends string>(type: 'containerElement' | 'view:containerElement', name: N): this is (ViewContainerElement | ViewEditableElement | ViewRootEditableElement) & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/editableelement~EditableElement}
+     * Checks whether the object is of type {@link module:engine/view/editableelement~ViewEditableElement}
      * or its subclass and has the specified `name`.
      *
      * @label EDITABLE_ELEMENT_NAME
      */
-    is<N extends string>(type: 'editableElement' | 'view:editableElement', name: N): this is (EditableElement | RootEditableElement) & {
+    is<N extends string>(type: 'editableElement' | 'view:editableElement', name: N): this is (ViewEditableElement | ViewRootEditableElement) & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/emptyelement~EmptyElement} has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/emptyelement~ViewEmptyElement} has the specified `name`.
      *
      * @label EMPTY_ELEMENT_NAME
      */
-    is<N extends string>(type: 'emptyElement' | 'view:emptyElement', name: N): this is EmptyElement & {
+    is<N extends string>(type: 'emptyElement' | 'view:emptyElement', name: N): this is ViewEmptyElement & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/rawelement~RawElement} and has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/rawelement~ViewRawElement} and has the specified `name`.
      *
      * @label RAW_ELEMENT_NAME
      */
-    is<N extends string>(type: 'rawElement' | 'view:rawElement', name: N): this is RawElement & {
+    is<N extends string>(type: 'rawElement' | 'view:rawElement', name: N): this is ViewRawElement & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/rooteditableelement~RootEditableElement} and has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/rooteditableelement~ViewRootEditableElement}
+     * and has the specified `name`.
      *
      * @label ROOT_ELEMENT_NAME
      */
-    is<N extends string>(type: 'rootElement' | 'view:rootElement', name: N): this is RootEditableElement & {
+    is<N extends string>(type: 'rootElement' | 'view:rootElement', name: N): this is ViewRootEditableElement & {
         name: N;
     };
     /**
-     * Checks whether the object is of type {@link module:engine/view/uielement~UIElement} and has the specified `name`.
+     * Checks whether the object is of type {@link module:engine/view/uielement~ViewUIElement} and has the specified `name`.
      *
      * @label UI_ELEMENT_NAME
      */
-    is<N extends string>(type: 'uiElement' | 'view:uiElement', name: N): this is UIElement & {
+    is<N extends string>(type: 'uiElement' | 'view:uiElement', name: N): this is ViewUIElement & {
         name: N;
     };
 }

package/src/view/typecheckable.js

@@ -5,7 +5,7 @@
 /**
  * @module engine/view/typecheckable
  */
-export default class TypeCheckable {
+export class ViewTypeCheckable {
     /* istanbul ignore next -- @preserve */
     is() {
         // There are a lot of overloads above.