InternalCreates a text proxy.
Text node which part is represented by this text proxy.
Offset in module:engine/model/textproxy~ModelTextProxy#textNode text node from which the text proxy starts.
Text proxy length, that is how many text node's characters, starting from offsetInText it represents.
ReadonlydataText data represented by this text proxy.
ReadonlyoffsetOffset in module:engine/model/textproxy~ModelTextProxy#textNode text node from which the text proxy starts.
ReadonlytextText node which part is represented by this text proxy.
Flag indicating whether ModelTextProxy instance covers only part of the original
module:engine/model/text~ModelText text node (true) or the whole text node (false).
This is false when text proxy starts at the very beginning of
module:engine/model/textproxy~ModelTextProxy#textNode textNode
(module:engine/model/textproxy~ModelTextProxy#offsetInText offsetInText equals 0) and text proxy sizes is equal to
text node size.
Parent of this text proxy, which is same as parent of text node represented by this text proxy.
Root of this text proxy, which is same as root of text node represented by this text proxy.
Returns ancestors array of this text proxy.
Optionaloptions: { includeSelf?: boolean; parentFirst?: boolean }Options object.
OptionalincludeSelf?: booleanWhen set to true this text proxy will be also included in parent's array.
OptionalparentFirst?: booleanWhen set to true, array will be sorted from text proxy parent to root element,
otherwise root element will be the first item in the array.
Array with ancestors.
Gets an attribute value for given key or undefined if that attribute is not set on text proxy.
Key of attribute to look for.
Attribute value or undefined.
Returns iterator that iterates over this node's attribute keys.
Returns iterator that iterates over this node's attributes. Attributes are returned as arrays containing two items. First one is attribute key and second is attribute value.
This format is accepted by native Map object and also can be passed in Node constructor.
Checks if this text proxy has an attribute for given key.
Key of attribute to check.
true if attribute with given key is set on text proxy, false otherwise.
Checks whether the object is of type module:engine/model/node~ModelNode or its subclass.
This method is useful when processing model objects that are of unknown type. For example, a function may return a module:engine/model/documentfragment~ModelDocumentFragment or a module:engine/model/node~ModelNode that can be either a text node or an element. This method can be used to check what kind of object is returned.
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 view 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:
modelElement.is( 'model:element' ); // -> true
modelElement.is( 'view:element' ); // -> false
By using this method it is also possible to check a name of an element:
imageElement.is( 'element', 'imageBlock' ); // -> true
imageElement.is( 'element', 'imageBlock' ); // -> same as above
imageElement.is( 'model:element', 'imageBlock' ); // -> same as above, but more precise
Checks whether the object is of type module:engine/model/element~ModelElement or its subclass.
element.is( 'element' ); // -> true
element.is( 'node' ); // -> true
element.is( 'model:element' ); // -> true
element.is( 'model:node' ); // -> true
element.is( 'view:element' ); // -> false
element.is( 'documentSelection' ); // -> false
Assuming that the object being checked is an element, you can also check its module:engine/model/element~ModelElement#name name:
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
Checks whether the object is of type module:engine/model/rootelement~ModelRootElement.
rootElement.is( 'rootElement' ); // -> true
rootElement.is( 'element' ); // -> true
rootElement.is( 'node' ); // -> true
rootElement.is( 'model:rootElement' ); // -> true
rootElement.is( 'model:element' ); // -> true
rootElement.is( 'model:node' ); // -> true
rootElement.is( 'view:element' ); // -> false
rootElement.is( 'documentFragment' ); // -> false
Assuming that the object being checked is an element, you can also check its module:engine/model/element~ModelElement#name name:
rootElement.is( 'rootElement', '$root' ); // -> same as above
Checks whether the object is of type module:engine/model/text~ModelText.
text.is( '$text' ); // -> true
text.is( 'node' ); // -> true
text.is( 'model:$text' ); // -> true
text.is( 'model:node' ); // -> true
text.is( 'view:$text' ); // -> false
text.is( 'documentSelection' ); // -> false
Note: Until version 20.0.0 this method wasn't accepting '$text' type. The legacy 'text' type is still
accepted for backward compatibility.
Checks whether the object is of type module:engine/model/position~ModelPosition or its subclass.
position.is( 'position' ); // -> true
position.is( 'model:position' ); // -> true
position.is( 'view:position' ); // -> false
position.is( 'documentSelection' ); // -> false
Checks whether the object is of type module:engine/model/liveposition~ModelLivePosition.
livePosition.is( 'position' ); // -> true
livePosition.is( 'model:position' ); // -> true
livePosition.is( 'liveposition' ); // -> true
livePosition.is( 'model:livePosition' ); // -> true
livePosition.is( 'view:position' ); // -> false
livePosition.is( 'documentSelection' ); // -> false
Checks whether the object is of type module:engine/model/range~ModelRange or its subclass.
range.is( 'range' ); // -> true
range.is( 'model:range' ); // -> true
range.is( 'view:range' ); // -> false
range.is( 'documentSelection' ); // -> false
Checks whether the object is of type module:engine/model/liverange~ModelLiveRange.
liveRange.is( 'range' ); // -> true
liveRange.is( 'model:range' ); // -> true
liveRange.is( 'liveRange' ); // -> true
liveRange.is( 'model:liveRange' ); // -> true
liveRange.is( 'view:range' ); // -> false
liveRange.is( 'documentSelection' ); // -> false
Checks whether the object is of type module:engine/model/documentfragment~ModelDocumentFragment.
docFrag.is( 'documentFragment' ); // -> true
docFrag.is( 'model:documentFragment' ); // -> true
docFrag.is( 'view:documentFragment' ); // -> false
docFrag.is( 'element' ); // -> false
docFrag.is( 'node' ); // -> false
Checks whether the object is of type module:engine/model/selection~ModelSelection or module:engine/model/documentselection~ModelDocumentSelection.
selection.is( 'selection' ); // -> true
selection.is( 'model:selection' ); // -> true
selection.is( 'view:selection' ); // -> false
selection.is( 'range' ); // -> false
Checks whether the object is of type module:engine/model/documentselection~ModelDocumentSelection.
selection.is( 'selection' ); // -> true
selection.is( 'documentSelection' ); // -> true
selection.is( 'model:selection' ); // -> true
selection.is( 'model:documentSelection' ); // -> true
selection.is( 'view:selection' ); // -> false
selection.is( 'element' ); // -> false
selection.is( 'node' ); // -> false
Checks whether the object is of type module:engine/model/markercollection~Marker.
marker.is( 'marker' ); // -> true
marker.is( 'model:marker' ); // -> true
marker.is( 'view:element' ); // -> false
marker.is( 'documentSelection' ); // -> false
Checks whether the object is of type module:engine/model/textproxy~ModelTextProxy.
textProxy.is( '$textProxy' ); // -> true
textProxy.is( 'model:$textProxy' ); // -> true
textProxy.is( 'view:$textProxy' ); // -> false
textProxy.is( 'range' ); // -> false
Note: Until version 20.0.0 this method wasn't accepting '$textProxy' type. The legacy 'textProxt' type is still
accepted for backward compatibility.
Checks whether the object is of type module:engine/model/element~ModelElement or its subclass and has the specified name.
element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
text.is( 'element', 'imageBlock' ); -> false
Checks whether the object is of type module:engine/model/rootelement~ModelRootElement and has the specified name.
rootElement.is( 'rootElement', '$root' );
ModelTextProxyrepresents a part of module:engine/model/text~ModelText text node.Since module:engine/model/position~ModelPosition positions can be placed between characters of a text node, module:engine/model/range~ModelRange ranges may contain only parts of text nodes. When module:engine/model/range~ModelRange#getItems getting items contained in such range, we need to represent a part of that text node, since returning the whole text node would be incorrect.
ModelTextProxysolves this issue.ModelTextProxyhas an API similar to module:engine/model/text~ModelText Text and allows to do most of the common tasks performed on model nodes.Note: Some
ModelTextProxyinstances may represent whole text node, not just a part of it. See module:engine/model/textproxy~ModelTextProxy#isPartial.Note:
ModelTextProxyis not an instance of module:engine/model/node~ModelNode node. Keep this in mind when using it as a parameter of methods.Note:
ModelTextProxyis a readonly interface. If you want to perform changes on model data represented by aModelTextProxyuse module:engine/model/writer~ModelWriter model writer API.Note:
ModelTextProxyinstances are created on the fly, basing on the current state of model. Because of this, it is highly unrecommended to store references toModelTextProxyinstances.ModelTextProxyinstances are not refreshed when model changes, so they might get invalidated. Instead, consider creating module:engine/model/liveposition~ModelLivePosition live position.ModelTextProxyinstances are created by module:engine/model/treewalker~ModelTreeWalker model tree walker. You should not need to create an instance of this class by your own.