ModelLiveRange

• end : ModelPosition

  readonlyinherited

  module:engine/model/liverange~ModelLiveRange#end

  End position.

  See source (with github icon)

• isCollapsed : boolean

  readonlyinherited

  module:engine/model/liverange~ModelLiveRange#isCollapsed

  Describes whether the range is collapsed, that is if start and end positions are equal.

  See source (with github icon)

• isFlat : boolean

  readonlyinherited

  module:engine/model/liverange~ModelLiveRange#isFlat

  Describes whether this range is flat, that is if start position and end position are in the same parent.

  See source (with github icon)

• root : ModelElement | ModelDocumentFragment

  readonlyinherited

  module:engine/model/liverange~ModelLiveRange#root

  Range root element.

  See source (with github icon)

• start : ModelPosition

  readonlyinherited

  module:engine/model/liverange~ModelLiveRange#start

  Start position.

  See source (with github icon)

Static properties

• _createFromPositionAndShift : ( position: ModelPosition, shift: number ) => ModelLiveRange

  internalreadonlystatic

  module:engine/model/liverange~ModelLiveRange._createFromPositionAndShift
  See source (with github icon)

  Related:

  • ModelRange._createFromPositionAndShift

• _createIn : ( element: ModelElement | ModelDocumentFragment ) => ModelLiveRange

  internalreadonlystatic

  module:engine/model/liverange~ModelLiveRange._createIn
  See source (with github icon)

  Related:

  • ModelRange._createIn

• _createOn : ( element: ModelDocumentFragment | ModelItem ) => ModelLiveRange

  internalreadonlystatic

  module:engine/model/liverange~ModelLiveRange._createOn
  See source (with github icon)

  Related:

  • ModelRange._createOn

• constructor( start, [ end ] )

  module:engine/model/liverange~ModelLiveRange#constructor

  Creates a live range.

  See source (with github icon)

  Parameters

  start : ModelPosition

  [ end ] : null | ModelPosition

  Related:

  • ModelRange

• Symbol.iterator() → IterableIterator<ModelTreeWalkerValue>

  inherited

  module:engine/model/liverange~ModelLiveRange#Symbol.iterator

  Iterable interface.

  Iterates over all items that are in this range and returns them together with additional information like length or positions, grouped as ModelTreeWalkerValue. It iterates over all text contents that are inside the range and all the ModelElements that are entered into when iterating over this range.

  This iterator uses ModelTreeWalker with boundaries set to this range and ignoreElementEnd option set to true.

  See source (with github icon)

  Returns

  IterableIterator<ModelTreeWalkerValue>

• clone() → this

  inherited

  module:engine/model/liverange~ModelLiveRange#clone

  Returns a new range that is equal to current range.

  See source (with github icon)

  Returns

  this

• containsItem( item ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#containsItem

  Checks whether given ModelItem is inside this range.

  See source (with github icon)

  Parameters

  item : ModelItem

  Returns

  boolean

• containsPosition( position ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#containsPosition

  Checks whether this range contains given position.

  See source (with github icon)

  Parameters

  position : ModelPosition

  Position to check.

  Returns

  boolean

  true if given position is contained in this range,false otherwise.

• containsRange( otherRange, loose ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#containsRange

  Checks whether this range contains given range.

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to check.

  loose : boolean

  Whether the check is loose or strict. If the check is strict (false), compared range cannot start or end at the same position as this range boundaries. If the check is loose (true), compared range can start, end or even be equal to this range. Note that collapsed ranges are always compared in strict mode.

  Defaults to false

  Returns

  boolean

  true if given range boundaries are contained by this range, false otherwise.

• delegate( events ) → EmitterMixinDelegateChain

  inherited

  module:engine/model/liverange~ModelLiveRange#delegate

  Delegates selected events to another Emitter. For instance:

  emitterA.delegate( 'eventX' ).to( emitterB );
  emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
  

  Copy code

  then eventX is delegated (fired by) emitterB and emitterC along with data:

  emitterA.fire( 'eventX', data );
  

  Copy code

  and eventY is delegated (fired by) emitterC along with data:

  emitterA.fire( 'eventY', data );
  

  Copy code

  See source (with github icon)

  Parameters

  events : Array<string>

  Event names that will be delegated to another emitter.

  Returns

  EmitterMixinDelegateChain

• detach() → void

  module:engine/model/liverange~ModelLiveRange#detach

  Unbinds all events previously bound by ModelLiveRange. Use it whenever you don't need ModelLiveRange instance anymore (i.e. when leaving scope in which it was declared or before re-assigning variable that was referring to it).

  See source (with github icon)

  Returns

  void

• fire( eventOrInfo, args ) → GetEventInfo<TEvent>[ 'return' ]

  inherited

  module:engine/model/liverange~ModelLiveRange#fire

  Fires an event, executing all callbacks registered for it.

  The first parameter passed to callbacks is an EventInfo object, followed by the optional args provided in the fire() method call.

  See source (with github icon)

  Type parameters

  TEvent : extends BaseEvent

  The type describing the event. See BaseEvent.

  Parameters

  eventOrInfo : GetNameOrEventInfo<TEvent>

  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<TEvent>[ 'return' ]

  By default the method returns undefined. However, the return value can be changed by listeners through modification of the evt.return's property (the event info is the first param of every callback).

• getCommonAncestor() → null | ModelElement | ModelDocumentFragment

  inherited

  module:engine/model/liverange~ModelLiveRange#getCommonAncestor

  Returns an ModelElement or ModelDocumentFragment which is a common ancestor of the range's both ends (in which the entire range is contained).

  See source (with github icon)

  Returns

  null | ModelElement | ModelDocumentFragment

• getContainedElement() → null | ModelElement

  inherited

  module:engine/model/liverange~ModelLiveRange#getContainedElement

  Returns an Element contained by the range. The element will be returned when it is the only node within the range and fully–contained at the same time.

  See source (with github icon)

  Returns

  null | ModelElement

• getDifference( otherRange ) → Array<ModelRange>

  inherited

  module:engine/model/liverange~ModelLiveRange#getDifference

  Computes which part(s) of this range is not a part of given range. Returned array contains zero, one or two ranges.

  Examples:

  let range = model.createRange(
  	model.createPositionFromPath( root, [ 2, 7 ] ),
  	model.createPositionFromPath( root, [ 4, 0, 1 ] )
  );
  let otherRange = model.createRange( model.createPositionFromPath( root, [ 1 ] ), model.createPositionFromPath( root, [ 5 ] ) );
  let transformed = range.getDifference( otherRange );
  // transformed array has no ranges because `otherRange` contains `range`
  
  otherRange = model.createRange( model.createPositionFromPath( root, [ 1 ] ), model.createPositionFromPath( root, [ 3 ] ) );
  transformed = range.getDifference( otherRange );
  // transformed array has one range: from [ 3 ] to [ 4, 0, 1 ]
  
  otherRange = model.createRange( model.createPositionFromPath( root, [ 3 ] ), model.createPositionFromPath( root, [ 4 ] ) );
  transformed = range.getDifference( otherRange );
  // transformed array has two ranges: from [ 2, 7 ] to [ 3 ] and from [ 4 ] to [ 4, 0, 1 ]
  

  Copy code

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to differentiate against.

  Returns

  Array<ModelRange>

  The difference between ranges.

• getIntersection( otherRange ) → null | ModelRange

  inherited

  module:engine/model/liverange~ModelLiveRange#getIntersection

  Returns an intersection of this range and given range. Intersection is a common part of both of those ranges. If ranges has no common part, returns null.

  Examples:

  let range = model.createRange(
  	model.createPositionFromPath( root, [ 2, 7 ] ),
  	model.createPositionFromPath( root, [ 4, 0, 1 ] )
  );
  let otherRange = model.createRange( model.createPositionFromPath( root, [ 1 ] ), model.createPositionFromPath( root, [ 2 ] ) );
  let transformed = range.getIntersection( otherRange ); // null - ranges have no common part
  
  otherRange = model.createRange( model.createPositionFromPath( root, [ 3 ] ), model.createPositionFromPath( root, [ 5 ] ) );
  transformed = range.getIntersection( otherRange ); // range from [ 3 ] to [ 4, 0, 1 ]
  

  Copy code

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to check for intersection.

  Returns

  null | ModelRange

  A common part of given ranges or null if ranges have no common part.

• getItems( options ) → IterableIterator<ModelItem>

  inherited

  module:engine/model/liverange~ModelLiveRange#getItems

  Returns an iterator that iterates over all items that are in this range and returns them.

  This method uses ModelTreeWalker with boundaries set to this range and ignoreElementEnd option set to true. However it returns only model items, not ModelTreeWalkerValue.

  You may specify additional options for the tree walker. See ModelTreeWalker for a full list of available options.

  See source (with github icon)

  Parameters

  options : ModelTreeWalkerOptions

  Object with configuration options. See ModelTreeWalker.

  Defaults to {}

  Returns

  IterableIterator<ModelItem>

• getJoined( otherRange, loose ) → null | ModelRange

  inherited

  module:engine/model/liverange~ModelLiveRange#getJoined

  Returns a range created by joining this range with the given range. If ranges have no common part, returns null.

  Examples:

  let range = model.createRange(
  	model.createPositionFromPath( root, [ 2, 7 ] ),
  	model.createPositionFromPath( root, [ 4, 0, 1 ] )
  );
  let otherRange = model.createRange(
  	model.createPositionFromPath( root, [ 1 ] ),
  	model.createPositionFromPath( root, [ 2 ] )
   * );
  let transformed = range.getJoined( otherRange ); // null - ranges have no common part
  
  otherRange = model.createRange(
  	model.createPositionFromPath( root, [ 3 ] ),
  	model.createPositionFromPath( root, [ 5 ] )
  );
  transformed = range.getJoined( otherRange ); // range from [ 2, 7 ] to [ 5 ]
  

  Copy code

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to be joined.

  loose : boolean

  Whether the intersection check is loose or strict. If the check is strict (false), ranges are tested for intersection or whether start/end positions are equal. If the check is loose (true), compared range is also checked if it's touching current range.

  Defaults to false

  Returns

  null | ModelRange

  A sum of given ranges or null if ranges have no common part.

• getMinimalFlatRanges() → Array<ModelRange>

  inherited

  module:engine/model/liverange~ModelLiveRange#getMinimalFlatRanges

  Computes and returns the smallest set of flat ranges, that covers this range in whole.

  See an example of a model structure ([ and ] are range boundaries):

  root                                                            root
   |- element DIV                         DIV             P2              P3             DIV
   |   |- element H                   H        P1        f o o           b a r       H         P4
   |   |   |- "fir[st"             fir[st     lorem                               se]cond     ipsum
   |   |- element P1
   |   |   |- "lorem"                                              ||
   |- element P2                                                   ||
   |   |- "foo"                                                    VV
   |- element P3
   |   |- "bar"                                                   root
   |- element DIV                         DIV             [P2             P3]             DIV
   |   |- element H                   H       [P1]       f o o           b a r        H         P4
   |   |   |- "se]cond"            fir[st]    lorem                               [se]cond     ipsum
   |   |- element P4
   |   |   |- "ipsum"
  

  Copy code

  As it can be seen, letters contained in the range are: stloremfoobarse, spread across different parents. We are looking for minimal set of flat ranges that contains the same nodes.

  Minimal flat ranges for above range ( [ 0, 0, 3 ], [ 3, 0, 2 ] ) will be:

  ( [ 0, 0, 3 ], [ 0, 0, 5 ] ) = "st"
  ( [ 0, 1 ], [ 0, 2 ] ) = element P1 ("lorem")
  ( [ 1 ], [ 3 ] ) = element P2, element P3 ("foobar")
  ( [ 3, 0, 0 ], [ 3, 0, 2 ] ) = "se"
  

  Copy code

  Note: if an element is not wholly contained in this range, it won't be returned in any of the returned flat ranges. See in the example how H elements at the beginning and at the end of the range were omitted. Only their parts that were wholly in the range were returned.

  Note: this method is not returning flat ranges that contain no nodes.

  See source (with github icon)

  Returns

  Array<ModelRange>

  Array of flat ranges covering this range.

• getPositions( options ) → IterableIterator<ModelPosition>

  inherited

  module:engine/model/liverange~ModelLiveRange#getPositions

  Returns an iterator that iterates over all positions that are boundaries or contained in this range.

  This method uses ModelTreeWalker with boundaries set to this range. However it returns only positions, not ModelTreeWalkerValue.

  You may specify additional options for the tree walker. See ModelTreeWalker for a full list of available options.

  See source (with github icon)

  Parameters

  options : ModelTreeWalkerOptions

  Object with configuration options. See ModelTreeWalker.

  Defaults to {}

  Returns

  IterableIterator<ModelPosition>

• getTransformedByOperation( operation ) → Array<ModelRange>

  inherited

  module:engine/model/liverange~ModelLiveRange#getTransformedByOperation

  Returns a range that is a result of transforming this range by given operation.

  Note: transformation may break one range into multiple ranges (for example, when a part of the range is moved to a different part of document tree). For this reason, an array is returned by this method and it may contain one or more Range instances.

  See source (with github icon)

  Parameters

  operation : Operation

  Operation to transform range by.

  Returns

  Array<ModelRange>

  Range which is the result of transformation.

• getTransformedByOperations( operations ) → Array<ModelRange>

  inherited

  module:engine/model/liverange~ModelLiveRange#getTransformedByOperations

  Returns a range that is a result of transforming this range by multiple operations.

  See source (with github icon)

  Parameters

  operations : Iterable<Operation>

  Operations to transform the range by.

  Returns

  Array<ModelRange>

  Range which is the result of transformation.

  Related:

  • ModelRange#getTransformedByOperation

• getWalker( options ) → ModelTreeWalker

  inherited

  module:engine/model/liverange~ModelLiveRange#getWalker

  Creates a TreeWalker instance with this range as a boundary.

  For example, to iterate over all items in the entire document root:

  // Create a range spanning over the entire root content:
  const range = editor.model.createRangeIn( editor.model.document.getRoot() );
  
  // Iterate over all items in this range:
  for ( const value of range.getWalker() ) {
  	console.log( value.item );
  }
  

  Copy code

  See source (with github icon)

  Parameters

  options : ModelTreeWalkerOptions

  Object with configuration options. See ModelTreeWalker.

  Defaults to {}

  Returns

  ModelTreeWalker

• is( type ) → this is ModelElement | ModelRootElement

  inherited

  module:engine/model/liverange~ModelLiveRange#is:ELEMENT

  Checks whether the object is of type 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
  

  Copy code

  Assuming that the object being checked is an element, you can also check its name:

  element.is( 'element', 'imageBlock' ); // -> true if this is an <imageBlock> element
  text.is( 'element', 'imageBlock' ); -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'element' | 'model:element'

  Returns

  this is ModelElement | ModelRootElement

• is( type ) → this is ModelText

  inherited

  module:engine/model/liverange~ModelLiveRange#is:TEXT

  Checks whether the object is of type 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
  

  Copy code

  Note: Until version 20.0.0 this method wasn't accepting '$text' type. The legacy 'text' type is still accepted for backward compatibility.

  See source (with github icon)

  Parameters

  type : '$text' | 'model:$text'

  Returns

  this is ModelText

• is( type ) → this is ModelRootElement

  inherited

  module:engine/model/liverange~ModelLiveRange#is:ROOT_ELEMENT

  Checks whether the object is of type 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
  

  Copy code

  Assuming that the object being checked is an element, you can also check its name:

  rootElement.is( 'rootElement', '$root' ); // -> same as above
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'rootElement' | 'model:rootElement'

  Returns

  this is ModelRootElement

• is( type ) → this is ModelRange | ModelLiveRange

  inherited

  module:engine/model/liverange~ModelLiveRange#is:RANGE

  Checks whether the object is of type ModelRange or its subclass.

  range.is( 'range' ); // -> true
  range.is( 'model:range' ); // -> true
  
  range.is( 'view:range' ); // -> false
  range.is( 'documentSelection' ); // -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'range' | 'model:range'

  Returns

  this is ModelRange | ModelLiveRange

• is( type ) → this is ModelDocumentFragment

  inherited

  module:engine/model/liverange~ModelLiveRange#is:DOCUMENT_FRAGMENT

  Checks whether the object is of type ModelDocumentFragment.

  docFrag.is( 'documentFragment' ); // -> true
  docFrag.is( 'model:documentFragment' ); // -> true
  
  docFrag.is( 'view:documentFragment' ); // -> false
  docFrag.is( 'element' ); // -> false
  docFrag.is( 'node' ); // -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'documentFragment' | 'model:documentFragment'

  Returns

  this is ModelDocumentFragment

• is( type ) → this is ModelLiveRange

  inherited

  module:engine/model/liverange~ModelLiveRange#is:LIVE_RANGE

  Checks whether the object is of type 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
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'liveRange' | 'model:liveRange'

  Returns

  this is ModelLiveRange

• is( type ) → this is ModelLivePosition

  inherited

  module:engine/model/liverange~ModelLiveRange#is:LIVE_POSITION

  Checks whether the object is of type 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
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'livePosition' | 'model:livePosition'

  Returns

  this is ModelLivePosition

• is( type ) → this is ModelPosition | ModelLivePosition

  inherited

  module:engine/model/liverange~ModelLiveRange#is:POSITION

  Checks whether the object is of type ModelPosition or its subclass.

  position.is( 'position' ); // -> true
  position.is( 'model:position' ); // -> true
  
  position.is( 'view:position' ); // -> false
  position.is( 'documentSelection' ); // -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'position' | 'model:position'

  Returns

  this is ModelPosition | ModelLivePosition

• is( type ) → this is ModelDocumentSelection

  inherited

  module:engine/model/liverange~ModelLiveRange#is:DOCUMENT_SELECTION

  Checks whether the object is of type 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
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'documentSelection' | 'model:documentSelection'

  Returns

  this is ModelDocumentSelection

• is( type, name ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#is:ROOT_ELEMENT_NAME

  Checks whether the object is of type ModelRootElement and has the specified name.

  rootElement.is( 'rootElement', '$root' );
  

  Copy code

  See source (with github icon)

  Type parameters

  N : extends string

  Parameters

  type : 'rootElement' | 'model:rootElement'

  name : N

  Returns

  boolean

• is( type, name ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#is:ELEMENT_NAME

  Checks whether the object is of type 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
  

  Copy code

  See source (with github icon)

  Type parameters

  N : extends string

  Parameters

  type : 'element' | 'model:element'

  name : N

  Returns

  boolean

• is( type ) → this is ModelTextProxy

  inherited

  module:engine/model/liverange~ModelLiveRange#is:TEXT_PROXY

  Checks whether the object is of type ModelTextProxy.

  textProxy.is( '$textProxy' ); // -> true
  textProxy.is( 'model:$textProxy' ); // -> true
  
  textProxy.is( 'view:$textProxy' ); // -> false
  textProxy.is( 'range' ); // -> false
  

  Copy code

  Note: Until version 20.0.0 this method wasn't accepting '$textProxy' type. The legacy 'textProxt' type is still accepted for backward compatibility.

  See source (with github icon)

  Parameters

  type : '$textProxy' | 'model:$textProxy'

  Returns

  this is ModelTextProxy

• is( type ) → this is Marker

  inherited

  module:engine/model/liverange~ModelLiveRange#is:MARKER

  Checks whether the object is of type Marker.

  marker.is( 'marker' ); // -> true
  marker.is( 'model:marker' ); // -> true
  
  marker.is( 'view:element' ); // -> false
  marker.is( 'documentSelection' ); // -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'marker' | 'model:marker'

  Returns

  this is Marker

• is( type ) → this is ModelSelection | ModelDocumentSelection

  inherited

  module:engine/model/liverange~ModelLiveRange#is:SELECTION

  Checks whether the object is of type ModelSelection or ModelDocumentSelection.

  selection.is( 'selection' ); // -> true
  selection.is( 'model:selection' ); // -> true
  
  selection.is( 'view:selection' ); // -> false
  selection.is( 'range' ); // -> false
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'selection' | 'model:selection'

  Returns

  this is ModelSelection | ModelDocumentSelection

• is( type ) → this is ModelNode | ModelText | ModelElement | ModelRootElement

  inherited

  module:engine/model/liverange~ModelLiveRange#is:NODE

  Checks whether the object is of type ModelNode or its subclass.

  This method is useful when processing model objects that are of unknown type. For example, a function may return a ModelDocumentFragment or a 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
  

  Copy code

  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
  

  Copy code

  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
  

  Copy code

  See source (with github icon)

  Parameters

  type : 'node' | 'model:node'

  Returns

  this is ModelNode | ModelText | ModelElement | ModelRootElement

• isEqual( otherRange ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#isEqual

  Two ranges are equal if their start and end positions are equal.

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to compare with.

  Returns

  boolean

  true if ranges are equal, false otherwise.

• isIntersecting( otherRange ) → boolean

  inherited

  module:engine/model/liverange~ModelLiveRange#isIntersecting

  Checks and returns whether this range intersects with given range.

  See source (with github icon)

  Parameters

  otherRange : ModelRange

  Range to compare with.

  Returns

  boolean

  true if ranges intersect, false otherwise.

• listenTo( emitter, event, callback, [ options ] ) → void

  inherited

  module:engine/model/liverange~ModelLiveRange#listenTo:BASE_EMITTER

  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.

  // 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' );
  

  Copy code

  An event callback can stop the event and set the return value of the fire method.

  See source (with github icon)

  Type parameters

  TEvent : extends BaseEvent

  The type describing the event. See BaseEvent.

  Parameters

  emitter : Emitter

  The object that fires the event.

  event : TEvent[ 'name' ]

  The name of the event.

  callback : GetCallback<TEvent>

  The function to be called on event.

  [ options ] : GetCallbackOptions<TEvent>

  Additional options.

  Returns

  void

• off( event, callback ) → void

  inherited

  module:engine/model/liverange~ModelLiveRange#off

  Stops executing the callback on the given event. Shorthand for this.stopListening( this, event, callback ).

  See source (with github icon)

  Parameters

  event : string

  The name of the event.

  callback : Function

  The function to stop being called.

  Returns

  void

• on( event, callback, [ options ] ) → void

  inherited

  module:engine/model/liverange~ModelLiveRange#on

  Registers a callback function to be executed when an event is fired.

  Shorthand for this.listenTo( this, event, callback, options ) (it makes the emitter listen on itself).

  See source (with github icon)

  Type parameters

  TEvent : extends BaseEvent

  The type descibing the event. See BaseEvent.

  Parameters

  event : TEvent[ 'name' ]

  The name of the event.

  callback : GetCallback<TEvent>

  The function to be called on event.

  [ options ] : GetCallbackOptions<TEvent>

  Additional options.

  Returns

  void

• once( event, callback, [ options ] ) → void

  inherited

  module:engine/model/liverange~ModelLiveRange#once

  Registers a callback function to be executed on the next time the event is fired only. This is similar to calling on followed by off in the callback.

  See source (with github icon)

  Type parameters

  TEvent : extends BaseEvent

  The type descibing the event. See BaseEvent.

  Parameters

  event : TEvent[ 'name' ]

  The name of the event.

  callback : GetCallback<TEvent>

  The function to be called on event.

  [ options ] : GetCallbackOptions<TEvent>

  Additional options.

  Returns

  void

• stopDelegating( [ event ], [ emitter ] ) → void

  inherited

  module:engine/model/liverange~ModelLiveRange#stopDelegating

  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 (with github icon)

  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

  module:engine/model/liverange~ModelLiveRange#stopListening:BASE_STOP

  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 (with github icon)

  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

  inherited

  module:engine/model/liverange~ModelLiveRange#toJSON

  Converts Range to plain object and returns it.

  See source (with github icon)

  Returns

  unknown

  Range converted to plain object.

• toRange() → ModelRange

  module:engine/model/liverange~ModelLiveRange#toRange

  Creates a range instance that is equal to this live range.

  See source (with github icon)

  Returns

  ModelRange

• _getTransformedByDeletion( deletePosition, howMany ) → null | ModelRange

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByDeletion

  Returns a copy of this range that is transformed by deletion of howMany nodes from deletePosition.

  If the deleted range is intersecting with the transformed range, the transformed range will be shrank.

  If the deleted range contains transformed range, null will be returned.

  See source (with github icon)

  Parameters

  deletePosition : ModelPosition

  Position from which nodes are removed.

  howMany : number

  How many nodes are removed.

  Returns

  null | ModelRange

  Result of the transformation.

• _getTransformedByInsertOperation( operation, spread ) → Array<ModelRange>

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByInsertOperation

  Returns a result of transforming a copy of this range by insert operation.

  One or more ranges may be returned as a result of this transformation.

  See source (with github icon)

  Parameters

  operation : InsertOperation

  spread : boolean

  Defaults to false

  Returns

  Array<ModelRange>

• _getTransformedByInsertion( insertPosition, howMany, spread ) → Array<ModelRange>

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByInsertion

  Returns an array containing one or two ranges that are a result of transforming this range by inserting howMany nodes at insertPosition. Two ranges are returned if the insertion was inside this range and spread is set to true.

  Examples:

  let range = model.createRange(
  	model.createPositionFromPath( root, [ 2, 7 ] ),
  	model.createPositionFromPath( root, [ 4, 0, 1 ] )
  );
  let transformed = range._getTransformedByInsertion( model.createPositionFromPath( root, [ 1 ] ), 2 );
  // transformed array has one range from [ 4, 7 ] to [ 6, 0, 1 ]
  
  transformed = range._getTransformedByInsertion( model.createPositionFromPath( root, [ 4, 0, 0 ] ), 4 );
  // transformed array has one range from [ 2, 7 ] to [ 4, 0, 5 ]
  
  transformed = range._getTransformedByInsertion( model.createPositionFromPath( root, [ 3, 2 ] ), 4 );
  // transformed array has one range, which is equal to original range
  
  transformed = range._getTransformedByInsertion( model.createPositionFromPath( root, [ 3, 2 ] ), 4, true );
  // transformed array has two ranges: from [ 2, 7 ] to [ 3, 2 ] and from [ 3, 6 ] to [ 4, 0, 1 ]
  

  Copy code

  See source (with github icon)

  Parameters

  insertPosition : ModelPosition

  Position where nodes are inserted.

  howMany : number

  How many nodes are inserted.

  spread : boolean

  Flag indicating whether this range should be spread if insertion was inside the range. Defaults to false.

  Defaults to false

  Returns

  Array<ModelRange>

  Result of the transformation.

• _getTransformedByMergeOperation( operation ) → ModelRange

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByMergeOperation

  Returns a result of transforming a copy of this range by merge operation.

  Always one range is returned. The transformation is done in a way to not break the range.

  See source (with github icon)

  Parameters

  operation : MergeOperation

  Returns

  ModelRange

• _getTransformedByMove( sourcePosition, targetPosition, howMany, spread ) → Array<ModelRange>

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByMove

  Returns an array containing ranges that are a result of transforming this range by moving howMany nodes from sourcePosition to targetPosition.

  See source (with github icon)

  Parameters

  sourcePosition : ModelPosition

  Position from which nodes are moved.

  targetPosition : ModelPosition

  Position to where nodes are moved.

  howMany : number

  How many nodes are moved.

  spread : boolean

  Whether the range should be spread if the move points inside the range.

  Defaults to false

  Returns

  Array<ModelRange>

  Result of the transformation.

• _getTransformedByMoveOperation( operation, spread ) → Array<ModelRange>

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedByMoveOperation

  Returns a result of transforming a copy of this range by move operation.

  One or more ranges may be returned as a result of this transformation.

  See source (with github icon)

  Parameters

  operation : MoveOperation

  spread : boolean

  Defaults to false

  Returns

  Array<ModelRange>

• _getTransformedBySplitOperation( operation ) → ModelRange

  internalinherited

  module:engine/model/liverange~ModelLiveRange#_getTransformedBySplitOperation

  Returns a result of transforming a copy of this range by split operation.

  Always one range is returned. The transformation is done in a way to not break the range.

  See source (with github icon)

  Parameters

  operation : SplitOperation

  Returns

  ModelRange

Static methods

• fromJSON( json, doc ) → ModelRange

  inheritedstatic

  module:engine/model/liverange~ModelLiveRange.fromJSON

  Creates a Range instance from given plain object (i.e. parsed JSON string).

  See source (with github icon)

  Parameters

  json : any

  Plain object to be converted to Range.

  doc : ModelDocument

  Document object that will be range owner.

  Returns

  ModelRange

  Range instance created using given plain object.

• fromRange( range ) → ModelLiveRange

  static

  module:engine/model/liverange~ModelLiveRange.fromRange

  Creates a ModelLiveRange instance that is equal to the given range.

  See source (with github icon)

  Parameters

  range : ModelRange

  Returns

  ModelLiveRange

• _createFromRanges( ranges ) → ModelRange

  internalinheritedstatic

  module:engine/model/liverange~ModelLiveRange._createFromRanges

  Combines all ranges from the passed array into a one range. At least one range has to be passed. Passed ranges must not have common parts.

  The first range from the array is a reference range. If other ranges start or end on the exactly same position where the reference range, they get combined into one range.

  [  ][]  [    ][ ][             ][ ][]  [  ]  // Passed ranges, shown sorted
  [    ]                                       // The result of the function if the first range was a reference range.
          [                           ]        // The result of the function if the third-to-seventh range was a reference range.
                                         [  ]  // The result of the function if the last range was a reference range.
  

  Copy code

  See source (with github icon)

  Parameters

  ranges : Array<ModelRange>

  Ranges to combine.

  Returns

  ModelRange

  Combined range.

• change( eventInfo, range, data )

  module:engine/model/liverange~ModelLiveRange#event:change

  Describes change:range or change:content event.

  See source (with github icon)

  Parameters

  eventInfo : EventInfo

  An object containing information about the fired event.

  range : ModelRange

  data : object

• change:content( eventInfo, range, data )

  module:engine/model/liverange~ModelLiveRange#event:change:content

  Fired when ModelLiveRange instance boundaries have not changed after a change in document but the change took place inside the range, effectively changing its content.

  See source (with github icon)

  Parameters

  eventInfo : EventInfo

  An object containing information about the fired event.

  range : ModelRange

  Range with start and end position equal to start and end position of change range.

  data : object

  Object with additional information about the change.

• change:range( eventInfo, range, data )

  module:engine/model/liverange~ModelLiveRange#event:change:range

  Fired when ModelLiveRange instance boundaries have changed due to changes in the document.

  See source (with github icon)

  Parameters

  eventInfo : EventInfo

  An object containing information about the fired event.

  range : ModelRange

  data : object

  Object with additional information about the change.