InternalCreates an empty ModelDocumentFragment.
Note: Constructor of this class shouldn't be used directly in the code. Use the module:engine/model/writer~ModelWriter#createDocumentFragment method instead.
ReadonlymarkersModelDocumentFragment static markers map. This is a list of names and module:engine/model/range~ModelRange ranges which will be set as Markers to module:engine/model/model~Model#markers model markers collection when ModelDocumentFragment will be inserted to the document.
OptionalnameArtificial element name. Returns undefined. Added for compatibility reasons.
OptionalrootArtificial root name. Returns undefined. Added for compatibility reasons.
Number of this document fragment's children.
Artificial owner of ModelDocumentFragment. Returns null. Added for compatibility reasons.
Is true if there are no nodes inside this document fragment, false otherwise.
Sum of module:engine/model/node~ModelNode#offsetSize offset sizes of all of this document fragment's children.
Artificial next sibling. Returns null. Added for compatibility reasons.
Artificial parent of ModelDocumentFragment. Returns null. Added for compatibility reasons.
Artificial previous sibling. Returns null. Added for compatibility reasons.
Artificial root of ModelDocumentFragment. Returns itself. Added for compatibility reasons.
InternalRemoves one or more nodes starting at the given index
and sets module:engine/model/node~ModelNode#parent parent of these nodes to null.
Index of the first node to remove.
OptionalhowMany: numberNumber of nodes to remove.
Array containing removed nodes.
InternalRemoves children nodes provided as an array and sets
the module:engine/model/node~ModelNode#parent parent of these nodes to null.
These nodes do not need to be direct siblings.
This method is faster than removing nodes one by one, as it recalculates offsets only once.
Array of nodes.
Returns an iterator that iterates over all nodes contained inside this document fragment.
Returns empty array. Added for compatibility reasons.
Gets the child at the given index. Returns null if incorrect index was passed.
Index in this document fragment.
Child node.
Gets the child at the given offset. Returns null if incorrect index was passed.
Offset in this document fragment.
Child node.
Returns an index of the given child node. Returns null if given node is not a child of this document fragment.
Child node to look for.
Child node's index.
Returns an iterator that iterates over all of this document fragment's children.
Returns the starting offset of given child. Starting offset is equal to the sum of
module:engine/model/node~ModelNode#offsetSize offset sizes of all node's siblings that are before it. Returns null if
given node is not a child of this document fragment.
Child node to look for.
Child node's starting offset.
Returns a descendant node by its path relative to this element.
// <this>a<b>c</b></this>
this.getNodeByPath( [ 0 ] ); // -> "a"
this.getNodeByPath( [ 1 ] ); // -> <b>
this.getNodeByPath( [ 1, 0 ] ); // -> "c"
Path of the node to find, relative to this element.
Returns path to a ModelDocumentFragment, which is an empty array. Added for compatibility reasons.
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' );
Returns false as ModelDocumentFragment by definition is not attached to a document. Added for compatibility reasons.
Converts offset "position" to index "position".
Returns index of a node that occupies given offset. If given offset is too low, returns 0. If given offset is
too high, returns index after last child.
const textNode = new Text( 'foo' );
const pElement = new Element( 'p' );
const docFrag = new ModelDocumentFragment( [ textNode, pElement ] );
docFrag.offsetToIndex( -1 ); // Returns 0, because offset is too low.
docFrag.offsetToIndex( 0 ); // Returns 0, because offset 0 is taken by `textNode` which is at index 0.
docFrag.offsetToIndex( 1 ); // Returns 0, because `textNode` has `offsetSize` equal to 3, so it occupies offset 1 too.
docFrag.offsetToIndex( 2 ); // Returns 0.
docFrag.offsetToIndex( 3 ); // Returns 1.
docFrag.offsetToIndex( 4 ); // Returns 2. There are no nodes at offset 4, so last available index is returned.
Offset to look for.
Index of a node that occupies given offset.
Converts ModelDocumentFragment instance to plain object and returns it.
Takes care of converting all of this document fragment's children.
ModelDocumentFragment instance converted to plain object.
StaticfromCreates a ModelDocumentFragment instance from given plain object (i.e. parsed JSON string).
Converts ModelDocumentFragment children to proper nodes.
Plain object to be converted to ModelDocumentFragment.
ModelDocumentFragment instance created using given plain object.
ModelDocumentFragment represents a part of model which does not have a common root but its top-level nodes can be seen as siblings. In other words, it is a detached part of model tree, without a root.
ModelDocumentFragment has own module:engine/model/markercollection~MarkerCollection. Markers from this collection will be set to the module:engine/model/model~Model#markers model markers by a module:engine/model/writer~ModelWriter#insert function.