# ViewNode class Abstract view node class. This is an abstract class. Its constructor should not be used directly. Use the [`ViewDowncastWriter`](module_engine_view_downcastwriter-ViewDowncastWriter.md) or [`ViewUpcastWriter`](module_engine_view_upcastwriter-ViewUpcastWriter.md) to create new instances of view nodes. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L32) ## Properties ### `document: ViewDocument` _(readonly)_ The document instance to which this node belongs. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L36) ### `index: number | null` _(readonly)_ Index of the node in the parent element or null if the node has no parent. Accessing this property throws an error if this node's parent element does not contain it. This means that view tree got broken. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L61) ### `nextSibling: ViewNode | null` _(readonly)_ Node's next sibling, or `null` if it is the last child. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L84) ### `parent: ViewElement | ViewDocumentFragment | null` _(readonly)_ Parent element. Null by default. Set by [`_insertChild`](module_engine_view_element-ViewElement.md#function-_insertChild). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L41) ### `previousSibling: ViewNode | null` _(readonly)_ Node's previous sibling, or `null` if it is the first child. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L93) ### `root: ViewElement | ViewDocumentFragment` _(readonly)_ Top-most ancestor of the node. If the node has no parent it is the root itself. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L102) ## Methods ### `constructor( document )` _(protected)_ Creates a tree view node. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L48) #### Parameters * `document: ViewDocument` The document instance to which this node belongs. ### `delegate( events ) → EmitterMixinDelegateChain` _(inherited)_ Delegates selected events to another [`Emitter`](module_utils_emittermixin-Emitter.md). For instance: ```typescript emitterA.delegate( 'eventX' ).to( emitterB ); emitterA.delegate( 'eventX', 'eventY' ).to( emitterC ); ``` then `eventX` is delegated (fired by) `emitterB` and `emitterC` along with `data`: ```typescript emitterA.fire( 'eventX', data ); ``` and `eventY` is delegated (fired by) `emitterC` along with `data`: ```typescript emitterA.fire( 'eventY', data ); ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L539) #### Parameters * `events: Array` Event names that will be delegated to another emitter. #### Returns * `EmitterMixinDelegateChain` ### `fire( eventOrInfo, args ) → GetEventInfo[ 'return' ]` _(inherited)_ Fires an event, executing all callbacks registered for it. The first parameter passed to callbacks is an [`EventInfo`](module_utils_eventinfo-EventInfo.md) object, followed by the optional `args` provided in the `fire()` method call. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L512) #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `eventOrInfo: GetNameOrEventInfo` The name of the event or `EventInfo` object if event is delegated. * `args: TEvent[ 'args' ]` Additional arguments to be passed to the callbacks. #### Returns * `GetEventInfo[ 'return' ]` By default the method returns `undefined`. However, the return value can be changed by listeners through modification of the [`evt.return`](module_utils_eventinfo-EventInfo.md#member-return)'s property (the event info is the first param of every callback). ### `getAncestors( options = { options.includeSelf?, options.parentFirst? } ) → Array` Returns ancestors array of this node. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L159) #### Parameters * `options: object` Options object. Properties * `options.includeSelf?: boolean` When set to `true` this node will be also included in parent's array. * `options.parentFirst?: boolean` When set to `true`, array will be sorted from node's parent to root element, otherwise root element will be the first item in the array. Defaults to `{}` #### Returns * `Array` Array with ancestors. ### `getCommonAncestor( node, options = { options.includeSelf? } ) → ViewElement | ViewDocumentFragment | null` Returns a [`ViewElement`](module_engine_view_element-ViewElement.md) or [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md) which is a common ancestor of both nodes. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L180) #### Parameters * `node: ViewNode` The second node. * `options: object` Options object. Properties * `options.includeSelf?: boolean` When set to `true` both nodes will be considered "ancestors" too. Which means that if e.g. node A is inside B, then their common ancestor will be B. Defaults to `{}` #### Returns * `ViewElement | ViewDocumentFragment | null` ### `getPath() → Array` Gets a path to the node. The path is an array containing indices of consecutive ancestors of this node, beginning from [root](#member-root), down to this node's index. ```typescript const abc = downcastWriter.createText( 'abc' ); const foo = downcastWriter.createText( 'foo' ); const h1 = downcastWriter.createElement( 'h1', null, downcastWriter.createText( 'header' ) ); const p = downcastWriter.createElement( 'p', null, [ abc, foo ] ); const div = downcastWriter.createElement( 'div', null, [ h1, p ] ); foo.getPath(); // Returns [ 1, 3 ]. `foo` is in `p` which is in `div`. `p` starts at offset 1, while `foo` at 3. h1.getPath(); // Returns [ 0 ]. div.getPath(); // Returns []. ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L137) #### Returns * `Array` The path. ### `is( type ) → this is ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` _(inherited)_ Checks whether this object is of type [`ViewElement`](module_engine_view_element-ViewElement.md) or its subclass. ```typescript element.is( 'element' ); // -> true element.is( 'node' ); // -> true element.is( 'view:element' ); // -> true element.is( 'view:node' ); // -> true element.is( 'model:element' ); // -> false element.is( 'documentSelection' ); // -> false ``` Assuming that the object being checked is an element, you can also check its [name](module_engine_view_element-ViewElement.md#member-name): ```typescript element.is( 'element', 'img' ); // -> true if this is an element text.is( 'element', 'img' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L93) #### Parameters * `type: 'element' | 'view:element'` #### Returns * `this is ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` ### `is( type ) → this is ViewAttributeElement` _(inherited)_ Checks whether this object is of type [`ViewAttributeElement`](module_engine_view_attributeelement-ViewAttributeElement.md). ```typescript attributeElement.is( 'attributeElement' ); // -> true attributeElement.is( 'element' ); // -> true attributeElement.is( 'node' ); // -> true attributeElement.is( 'view:attributeElement' ); // -> true attributeElement.is( 'view:element' ); // -> true attributeElement.is( 'view:node' ); // -> true attributeElement.is( 'model:element' ); // -> false attributeElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is an attribute element, you can also check its [name](module_engine_view_attributeelement-ViewAttributeElement.md#member-name): ```typescript attributeElement.is( 'element', 'b' ); // -> true if this is a bold element attributeElement.is( 'attributeElement', 'b' ); // -> same as above text.is( 'element', 'b' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L130) #### Parameters * `type: 'attributeElement' | 'view:attributeElement'` #### Returns * `this is ViewAttributeElement` ### `is( type ) → this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement` _(inherited)_ Checks whether this object is of type [`ViewContainerElement`](module_engine_view_containerelement-ViewContainerElement.md) or its subclass. ```typescript containerElement.is( 'containerElement' ); // -> true containerElement.is( 'element' ); // -> true containerElement.is( 'node' ); // -> true containerElement.is( 'view:containerElement' ); // -> true containerElement.is( 'view:element' ); // -> true containerElement.is( 'view:node' ); // -> true containerElement.is( 'model:element' ); // -> false containerElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is a container element, you can also check its [name](module_engine_view_containerelement-ViewContainerElement.md#member-name): ```typescript containerElement.is( 'element', 'div' ); // -> true if this is a div container element containerElement.is( 'contaienrElement', 'div' ); // -> same as above text.is( 'element', 'div' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L158) #### Parameters * `type: 'containerElement' | 'view:containerElement'` #### Returns * `this is ViewContainerElement | ViewEditableElement | ViewRootEditableElement` ### `is( type ) → this is ViewRootEditableElement` _(inherited)_ Checks whether this object is of type [`ViewRootEditableElement`](module_engine_view_rooteditableelement-ViewRootEditableElement.md). ```typescript rootEditableElement.is( 'rootElement' ); // -> true rootEditableElement.is( 'editableElement' ); // -> true rootEditableElement.is( 'element' ); // -> true rootEditableElement.is( 'node' ); // -> true rootEditableElement.is( 'view:editableElement' ); // -> true rootEditableElement.is( 'view:element' ); // -> true rootEditableElement.is( 'view:node' ); // -> true rootEditableElement.is( 'model:element' ); // -> false rootEditableElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is a root editable element, you can also check its [name](module_engine_view_rooteditableelement-ViewRootEditableElement.md#member-name): ```typescript rootEditableElement.is( 'element', 'div' ); // -> true if this is a div root editable element rootEditableElement.is( 'rootElement', 'div' ); // -> same as above text.is( 'element', 'div' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L272) #### Parameters * `type: 'rootElement' | 'view:rootElement'` #### Returns * `this is ViewRootEditableElement` ### `is( type ) → this is ViewUIElement` _(inherited)_ Checks whether this object is of type [`ViewUIElement`](module_engine_view_uielement-ViewUIElement.md). ```typescript uiElement.is( 'uiElement' ); // -> true uiElement.is( 'element' ); // -> true uiElement.is( 'node' ); // -> true uiElement.is( 'view:uiElement' ); // -> true uiElement.is( 'view:element' ); // -> true uiElement.is( 'view:node' ); // -> true uiElement.is( 'model:element' ); // -> false uiElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is an ui element, you can also check its [name](module_engine_view_uielement-ViewUIElement.md#member-name): ```typescript uiElement.is( 'element', 'span' ); // -> true if this is a span ui element uiElement.is( 'uiElement', 'span' ); // -> same as above text.is( 'element', 'span' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L300) #### Parameters * `type: 'uiElement' | 'view:uiElement'` #### Returns * `this is ViewUIElement` ### `is( type ) → this is ViewRawElement` _(inherited)_ Checks whether this object is of type [`ViewRawElement`](module_engine_view_rawelement-ViewRawElement.md). ```typescript rawElement.is( 'rawElement' ); // -> true rawElement.is( 'element' ); // -> true rawElement.is( 'node' ); // -> true rawElement.is( 'view:rawElement' ); // -> true rawElement.is( 'view:element' ); // -> true rawElement.is( 'view:node' ); // -> true rawElement.is( 'model:element' ); // -> false rawElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is a raw element, you can also check its [name](module_engine_view_rawelement-ViewRawElement.md#member-name): ```typescript rawElement.is( 'img' ); // -> true if this is an img element rawElement.is( 'rawElement', 'img' ); // -> same as above text.is( 'img' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L243) #### Parameters * `type: 'rawElement' | 'view:rawElement'` #### Returns * `this is ViewRawElement` ### `is( type ) → this is ViewEmptyElement` _(inherited)_ Checks whether this object is of type [`ViewEmptyElement`](module_engine_view_emptyelement-ViewEmptyElement.md). ```typescript emptyElement.is( 'emptyElement' ); // -> true emptyElement.is( 'element' ); // -> true emptyElement.is( 'node' ); // -> true emptyElement.is( 'view:emptyElement' ); // -> true emptyElement.is( 'view:element' ); // -> true emptyElement.is( 'view:node' ); // -> true emptyElement.is( 'model:element' ); // -> false emptyElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is an empty element, you can also check its [name](module_engine_view_emptyelement-ViewEmptyElement.md#member-name): ```typescript emptyElement.is( 'element', 'img' ); // -> true if this is a img element emptyElement.is( 'emptyElement', 'img' ); // -> same as above text.is( 'element', 'img' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L215) #### Parameters * `type: 'emptyElement' | 'view:emptyElement'` #### Returns * `this is ViewEmptyElement` ### `is( type ) → this is ViewEditableElement | ViewRootEditableElement` _(inherited)_ Checks whether this object is of type [`ViewEditableElement`](module_engine_view_editableelement-ViewEditableElement.md) or its subclass. ```typescript editableElement.is( 'editableElement' ); // -> true editableElement.is( 'element' ); // -> true editableElement.is( 'node' ); // -> true editableElement.is( 'view:editableElement' ); // -> true editableElement.is( 'view:element' ); // -> true editableElement.is( 'view:node' ); // -> true editableElement.is( 'model:element' ); // -> false editableElement.is( 'documentFragment' ); // -> false ``` Assuming that the object being checked is an editbale element, you can also check its [name](module_engine_view_editableelement-ViewEditableElement.md#member-name): ```typescript editableElement.is( 'element', 'div' ); // -> true if this is a div element editableElement.is( 'editableElement', 'div' ); // -> same as above text.is( 'element', 'div' ); -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L187) #### Parameters * `type: 'editableElement' | 'view:editableElement'` #### Returns * `this is ViewEditableElement | ViewRootEditableElement` ### `is( type ) → this is ViewText` _(inherited)_ Checks whether this object is of type [`ViewText`](module_engine_view_text-ViewText.md). ```typescript text.is( '$text' ); // -> true text.is( 'node' ); // -> true text.is( 'view:$text' ); // -> true text.is( 'view:node' ); // -> true text.is( 'model:$text' ); // -> false text.is( 'element' ); // -> false text.is( 'range' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L318) #### Parameters * `type: '$text' | 'view:$text'` #### Returns * `this is ViewText` ### `is( type ) → this is ViewTextProxy` _(inherited)_ Checks whether this object is of type [`ViewTextProxy`](module_engine_view_textproxy-ViewTextProxy.md). ```typescript textProxy.is( '$textProxy' ); // -> true textProxy.is( 'view:$textProxy' ); // -> true textProxy.is( 'model:$textProxy' ); // -> false textProxy.is( 'element' ); // -> false textProxy.is( 'range' ); // -> false ``` **Note:** Until version 20.0.0 this method wasn't accepting `'$textProxy'` type. The legacy `'textProxy'` type is still accepted for backward compatibility. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L353) #### Parameters * `type: '$textProxy' | 'view:$textProxy'` #### Returns * `this is ViewTextProxy` ### `is( type ) → this is ViewRange` _(inherited)_ Checks whether this object is of type [`ViewRange`](module_engine_view_range-ViewRange.md). ```typescript range.is( 'range' ); // -> true range.is( 'view:range' ); // -> true range.is( 'model:range' ); // -> false range.is( 'element' ); // -> false range.is( 'selection' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L385) #### Parameters * `type: 'range' | 'view:range'` #### Returns * `this is ViewRange` ### `is( type ) → this is ViewDocumentSelection` _(inherited)_ Checks whether this object is of type [`ViewDocumentSelection`](module_engine_view_documentselection-ViewDocumentSelection.md). ```typescript `docSelection.is( 'selection' ); // -> true docSelection.is( 'documentSelection' ); // -> true docSelection.is( 'view:selection' ); // -> true docSelection.is( 'view:documentSelection' ); // -> true docSelection.is( 'model:documentSelection' ); // -> false docSelection.is( 'element' ); // -> false docSelection.is( 'node' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L420) #### Parameters * `type: 'documentSelection' | 'view:documentSelection'` #### Returns * `this is ViewDocumentSelection` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewAttributeElement`](module_engine_view_attributeelement-ViewAttributeElement.md) and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L443) #### Type parameters * `N: extends string` #### Parameters * `type: 'attributeElement' | 'view:attributeElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewEditableElement`](module_engine_view_editableelement-ViewEditableElement.md) or its subclass and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L463) #### Type parameters * `N: extends string` #### Parameters * `type: 'editableElement' | 'view:editableElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewRawElement`](module_engine_view_rawelement-ViewRawElement.md) and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L480) #### Type parameters * `N: extends string` #### Parameters * `type: 'rawElement' | 'view:rawElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewUIElement`](module_engine_view_uielement-ViewUIElement.md) and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L495) #### Type parameters * `N: extends string` #### Parameters * `type: 'uiElement' | 'view:uiElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewRootEditableElement`](module_engine_view_rooteditableelement-ViewRootEditableElement.md) and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L488) #### Type parameters * `N: extends string` #### Parameters * `type: 'rootElement' | 'view:rootElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewEmptyElement`](module_engine_view_emptyelement-ViewEmptyElement.md) has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L473) #### Type parameters * `N: extends string` #### Parameters * `type: 'emptyElement' | 'view:emptyElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewContainerElement`](module_engine_view_containerelement-ViewContainerElement.md) or its subclass and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L451) #### Type parameters * `N: extends string` #### Parameters * `type: 'containerElement' | 'view:containerElement'` * `name: N` #### Returns * `boolean` ### `is( type, name ) → boolean` _(inherited)_ Checks whether the object is of type [`ViewElement`](module_engine_view_element-ViewElement.md) or its subclass and has the specified `name`. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L427) #### Type parameters * `N: extends string` #### Parameters * `type: 'element' | 'view:element'` * `name: N` #### Returns * `boolean` ### `is( type ) → this is ViewSelection | ViewDocumentSelection` _(inherited)_ Checks whether this object is of type [`ViewSelection`](module_engine_view_selection-ViewSelection.md) or [`ViewDocumentSelection`](module_engine_view_documentselection-ViewDocumentSelection.md). ```typescript selection.is( 'selection' ); // -> true selection.is( 'view:selection' ); // -> true selection.is( 'model:selection' ); // -> false selection.is( 'element' ); // -> false selection.is( 'range' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L402) #### Parameters * `type: 'selection' | 'view:selection'` #### Returns * `this is ViewSelection | ViewDocumentSelection` ### `is( type ) → this is ViewPosition` _(inherited)_ Checks whether this object is of type [`ViewPosition`](module_engine_view_position-ViewPosition.md). ```typescript position.is( 'position' ); // -> true position.is( 'view:position' ); // -> true position.is( 'model:position' ); // -> false position.is( 'element' ); // -> false position.is( 'range' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L369) #### Parameters * `type: 'position' | 'view:position'` #### Returns * `this is ViewPosition` ### `is( type ) → this is ViewDocumentFragment` _(inherited)_ hecks whether this object is of type [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md). ```typescript docFrag.is( 'documentFragment' ); // -> true docFrag.is( 'view:documentFragment' ); // -> true docFrag.is( 'model:documentFragment' ); // -> false docFrag.is( 'element' ); // -> false docFrag.is( 'node' ); // -> false ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L334) #### Parameters * `type: 'documentFragment' | 'view:documentFragment'` #### Returns * `this is ViewDocumentFragment` ### `is( type ) → this is ViewText | ViewNode | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` _(inherited)_ Checks whether this object is of type [`ViewNode`](module_engine_view_node-ViewNode.md) or its subclass. This method is useful when processing view objects that are of unknown type. For example, a function may return a [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md) or a [`ViewNode`](module_engine_view_node-ViewNode.md) that can be either a text node or an element. This method can be used to check what kind of object is returned. ```typescript someObject.is( 'element' ); // -> true if this is an element someObject.is( 'node' ); // -> true if this is a node (a text node or an element) someObject.is( 'documentFragment' ); // -> true if this is a document fragment ``` Since this method is also available on a range of model objects, you can prefix the type of the object with `model:` or `view:` to check, for example, if this is the model's or view's element: ```typescript viewElement.is( 'view:element' ); // -> true viewElement.is( 'model:element' ); // -> false ``` By using this method it is also possible to check a name of an element: ```typescript imgElement.is( 'element', 'img' ); // -> true imgElement.is( 'view:element', 'img' ); // -> same as above, but more precise ``` [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/typecheckable.ts#L57) #### Parameters * `type: 'node' | 'view:node'` #### Returns * `this is ViewText | ViewNode | ViewElement | ViewAttributeElement | ViewContainerElement | ViewEditableElement | ViewEmptyElement | ViewRawElement | ViewRootEditableElement | ViewUIElement` ### `isAfter( node ) → boolean` Returns whether this node is after given node. `false` is returned if nodes are in different trees (for example, in different [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md)s). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L233) #### Parameters * `node: ViewNode` Node to compare with. #### Returns * `boolean` ### `isAttached() → boolean` Returns true if the node is in a tree rooted in the document (is a descendant of one of its roots). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L116) #### Returns * `boolean` ### `isBefore( node ) → boolean` Returns whether this node is before given node. `false` is returned if nodes are in different trees (for example, in different [`ViewDocumentFragment`](module_engine_view_documentfragment-ViewDocumentFragment.md)s). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L199) #### Parameters * `node: ViewNode` Node to compare with. #### Returns * `boolean` ### `isSimilar( other ) → boolean` Checks if provided node is similar to this node. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L303) #### Parameters * `other: ViewNode` #### Returns * `boolean` True if nodes are similar. ### `listenTo( emitter, event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired in a specific (emitter) object. Events can be grouped in namespaces using `:`. When namespaced event is fired, it additionally fires all callbacks for that namespace. ```typescript // myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ). myEmitter.on( 'myGroup', genericCallback ); myEmitter.on( 'myGroup:myEvent', specificCallback ); // genericCallback is fired. myEmitter.fire( 'myGroup' ); // both genericCallback and specificCallback are fired. myEmitter.fire( 'myGroup:myEvent' ); // genericCallback is fired even though there are no callbacks for "foo". myEmitter.fire( 'myGroup:foo' ); ``` An event callback can [stop the event](module_utils_eventinfo-EventInfo.md#member-stop) and set the [return value](module_utils_eventinfo-EventInfo.md#member-return) of the [`fire`](#function-fire) method. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L475) #### Type parameters * `TEvent: extends BaseEvent` The type describing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `emitter: Emitter` The object that fires the event. * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `off( event, callback ) → void` _(inherited)_ Stops executing the callback on the given event. Shorthand for [`this.stopListening( this, event, callback )`](#function-stopListening:BASE_STOP). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L444) #### Parameters * `event: string` The name of the event. * `callback: Function` The function to stop being called. #### Returns * `void` ### `on( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed when an event is fired. Shorthand for [`this.listenTo( this, event, callback, options )`](#function-listenTo:BASE_EMITTER) (it makes the emitter listen on itself). [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L416) #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `once( event, callback, options? ) → void` _(inherited)_ Registers a callback function to be executed on the next time the event is fired only. This is similar to calling [`on`](#function-on) followed by [`off`](#function-off) in the callback. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L431) #### Type parameters * `TEvent: extends BaseEvent` The type descibing the event. See [`BaseEvent`](module_utils_emittermixin-BaseEvent.md). #### Parameters * `event: TEvent[ 'name' ]` The name of the event. * `callback: GetCallback` The function to be called on event. * `options?: GetCallbackOptions` Additional options. #### Returns * `void` ### `stopDelegating( event?, emitter? ) → void` _(inherited)_ Stops delegating events. It can be used at different levels: * To stop delegating all events. * To stop delegating a specific event to all emitters. * To stop delegating a specific event to a specific emitter. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L552) #### Parameters * `event?: string` The name of the event to stop delegating. If omitted, stops it all delegations. * `emitter?: Emitter` (requires `event`) The object to stop delegating a particular event to. If omitted, stops delegation of `event` to all emitters. #### Returns * `void` ### `stopListening( emitter?, event?, callback? ) → void` _(inherited)_ Stops listening for events. It can be used at different levels: * To stop listening to a specific callback. * To stop listening to a specific event. * To stop listening to all events fired by a specific object. * To stop listening to all events fired by all objects. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-utils/src/emittermixin.ts#L497) #### Parameters * `emitter?: Emitter` The object to stop listening to. If omitted, stops it for all objects. * `event?: string` (Requires the `emitter`) The name of the event to stop listening to. If omitted, stops it for all events from `emitter`. * `callback?: Function` (Requires the `event`) The function to be removed from the call list for the given `event`. #### Returns * `void` ### `toJSON() → unknown` Converts `ViewNode` to plain object and returns it. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L277) #### Returns * `unknown` `ViewNode` converted to plain object. ### `_clone( deep? ) → ViewNode` _(internal)_ Clones this node. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L296) #### Parameters * `deep?: boolean` #### Returns * `ViewNode` Clone of this node. ### `_fireChange( type, node, data? = { data.index } ) → void` _(internal)_ [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L264) #### Parameters * `type: ViewDocumentChangeType` Type of the change. * `node: ViewNode` Changed node. * `data?: object` Additional data. Properties * `data.index: number` #### Returns * `void` #### Fires * [change](#event-change) ### `_remove() → void` _(internal)_ Removes node from parent. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L253) #### Returns * `void` ## Events ### `change( eventInfo, changedNode, data? )` Fired when list of [elements](module_engine_view_element-ViewElement.md) children, attributes or text changes. Change event is bubbled – it is fired on all ancestors. All change events as the first parameter receive the node that has changed (the node for which children, attributes or text changed). If `change:children` event is fired, there is an additional second parameter, which is an object with additional data related to change. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L326) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `changedNode: ViewNode` * `data?: object` ### `change:attributes( eventInfo, changedNode, data? )` Fired when list of [elements](module_engine_view_element-ViewElement.md) children, attributes or text changes. Change event is bubbled – it is fired on all ancestors. All change events as the first parameter receive the node that has changed (the node for which children, attributes or text changed). If `change:children` event is fired, there is an additional second parameter, which is an object with additional data related to change. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L326) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `changedNode: ViewNode` * `data?: object` ### `change:children( eventInfo, changedNode, data? )` Fired when list of [elements](module_engine_view_element-ViewElement.md) children, attributes or text changes. Change event is bubbled – it is fired on all ancestors. All change events as the first parameter receive the node that has changed (the node for which children, attributes or text changed). If `change:children` event is fired, there is an additional second parameter, which is an object with additional data related to change. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L326) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `changedNode: ViewNode` * `data?: object` ### `change:text( eventInfo, changedNode, data? )` Fired when list of [elements](module_engine_view_element-ViewElement.md) children, attributes or text changes. Change event is bubbled – it is fired on all ancestors. All change events as the first parameter receive the node that has changed (the node for which children, attributes or text changed). If `change:children` event is fired, there is an additional second parameter, which is an object with additional data related to change. [See source](https://github.com/ckeditor/ckeditor5/blob/master/packages/ckeditor5-engine/src/view/node.ts#L326) #### Parameters * `eventInfo: EventInfo` An object containing information about the fired event. * `changedNode: ViewNode` * `data?: object` --- Full index of the CKEditor 5 API reference: [llms.txt](llms.txt)