ModelPosition

• index : number

  readonly

  module:engine/model/position~ModelPosition#index

  Position offset converted to an index in position's parent node. It is equal to the index of a node after this position. If position is placed in text node, position index is equal to the index of that text node.

  See source (with github icon)

• isAtEnd : boolean

  readonly

  module:engine/model/position~ModelPosition#isAtEnd

  Is true if position is at the end of its parent, false otherwise.

  See source (with github icon)

• isAtStart : boolean

  readonly

  module:engine/model/position~ModelPosition#isAtStart

  Is true if position is at the beginning of its parent, false otherwise.

  See source (with github icon)

• nodeAfter : null | ModelNode

  readonly

  module:engine/model/position~ModelPosition#nodeAfter

  Node directly after this position. Returns null if this position is at the end of its parent, or if it is in a text node.

  See source (with github icon)

• nodeBefore : null | ModelNode

  readonly

  module:engine/model/position~ModelPosition#nodeBefore

  Node directly before this position. Returns null if this position is at the start of its parent, or if it is in a text node.

  See source (with github icon)

• offset : number

  module:engine/model/position~ModelPosition#offset

  Offset at which this position is located in its parent. It is equal to the last item in position path.

  See source (with github icon)

  Parameters

  newOffset : number

• parent : ModelElement | ModelDocumentFragment

  readonly

  module:engine/model/position~ModelPosition#parent

  Parent element of this position.

  Keep in mind that parent value is calculated when the property is accessed. If position path leads to a non-existing element, parent property will throw error.

  Also it is a good idea to cache parent property if it is used frequently in an algorithm (i.e. in a long loop).

  See source (with github icon)

• path : readonly Array<number>

  readonly

  module:engine/model/position~ModelPosition#path

  Position of the node in the tree. Path contains offsets, not indexes.

  Position can be placed before, after or in a node if that node has offsetSize greater than 1. Items in position path are starting offsets of position ancestors, starting from direct root children, down to the position offset in it's parent.

  ROOT
   |- P            before: [ 0 ]         after: [ 1 ]
   |- UL           before: [ 1 ]         after: [ 2 ]
      |- LI        before: [ 1, 0 ]      after: [ 1, 1 ]
      |  |- foo    before: [ 1, 0, 0 ]   after: [ 1, 0, 3 ]
      |- LI        before: [ 1, 1 ]      after: [ 1, 2 ]
         |- bar    before: [ 1, 1, 0 ]   after: [ 1, 1, 3 ]
  

  Copy code

  foo and bar are representing text nodes. Since text nodes has offset size greater than 1 you can place position offset between their start and end:

  ROOT
   |- P
   |- UL
      |- LI
      |  |- f^o|o  ^ has path: [ 1, 0, 1 ]   | has path: [ 1, 0, 2 ]
      |- LI
         |- b^a|r  ^ has path: [ 1, 1, 1 ]   | has path: [ 1, 1, 2 ]
  

  Copy code

  See source (with github icon)

• root : ModelElement | ModelDocumentFragment

  readonly

  module:engine/model/position~ModelPosition#root

  Root of the position path.

  See source (with github icon)

• stickiness : ModelPositionStickiness

  module:engine/model/position~ModelPosition#stickiness

  Position stickiness. See ModelPositionStickiness.

  See source (with github icon)

• textNode : null | ModelText

  readonly

  module:engine/model/position~ModelPosition#textNode

  Returns text node instance in which this position is placed or null if this position is not in a text node.

  See source (with github icon)

• constructor( root, path, stickiness )

  module:engine/model/position~ModelPosition#constructor

  Creates a position.

  See source (with github icon)

  Parameters

  root : ModelElement | ModelDocumentFragment

  Root of the position.

  path : readonly Array<number>

  Position path. See path.

  stickiness : ModelPositionStickiness

  Position stickiness. See ModelPositionStickiness.

  Defaults to 'toNone'

• clone() → this

  module:engine/model/position~ModelPosition#clone

  Returns a new position that is equal to current position.

  See source (with github icon)

  Returns

  this

• compareWith( otherPosition ) → ModelPositionRelation

  module:engine/model/position~ModelPosition#compareWith

  Checks whether this position is before or after given position.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  otherPosition : ModelPosition

  Returns

  ModelPositionRelation

• findAncestor( parentName ) → null | ModelElement

  module:engine/model/position~ModelPosition#findAncestor

  Returns the parent element of the given name. Returns null if the position is not inside the desired parent.

  See source (with github icon)

  Parameters

  parentName : string

  The name of the parent element to find.

  Returns

  null | ModelElement

• getAncestors() → Array<ModelElement | ModelDocumentFragment>

  module:engine/model/position~ModelPosition#getAncestors

  Returns ancestors array of this position, that is this position's parent and its ancestors.

  See source (with github icon)

  Returns

  Array<ModelElement | ModelDocumentFragment>

  Array with ancestors.

• getCommonAncestor( position ) → null | ModelElement | ModelDocumentFragment

  module:engine/model/position~ModelPosition#getCommonAncestor

  Returns an ModelElement or ModelDocumentFragment which is a common ancestor of both positions. The roots of these two positions must be identical.

  See source (with github icon)

  Parameters

  position : ModelPosition

  The second position.

  Returns

  null | ModelElement | ModelDocumentFragment

• getCommonPath( position ) → Array<number>

  module:engine/model/position~ModelPosition#getCommonPath

  Returns the slice of two position paths which is identical. The roots of these two paths must be identical.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  position : ModelPosition

  The second position.

  Returns

  Array<number>

  The common path.

• getLastMatchingPosition( skip, options ) → ModelPosition

  module:engine/model/position~ModelPosition#getLastMatchingPosition

  Gets the farthest position which matches the callback using TreeWalker.

  For example:

  getLastMatchingPosition( value => value.type == 'text' );
  // <paragraph>[]foo</paragraph> -> <paragraph>foo[]</paragraph>
  
  getLastMatchingPosition( value => value.type == 'text', { direction: 'backward' } );
  // <paragraph>foo[]</paragraph> -> <paragraph>[]foo</paragraph>
  
  getLastMatchingPosition( value => false );
  // Do not move the position.
  

  Copy code

  See source (with github icon)

  Parameters

  skip : ( value: ModelTreeWalkerValue ) => boolean

  Callback function. Gets ModelTreeWalkerValue and should return true if the value should be skipped or false if not.

  options : ModelTreeWalkerOptions

  Object with configuration options. See ModelTreeWalker.

  Defaults to {}

  Returns

  ModelPosition

  The position after the last item which matches the skip callback test.

• getParentPath() → Array<number>

  module:engine/model/position~ModelPosition#getParentPath

  Returns a path to this position's parent. Parent path is equal to position path but without the last item.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Returns

  Array<number>

  Path to the parent.

• getShiftedBy( shift ) → ModelPosition

  module:engine/model/position~ModelPosition#getShiftedBy

  Returns a new instance of Position, that has same parent but it's offset is shifted by shift value (can be a negative value).

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  shift : number

  Offset shift. Can be a negative value.

  Returns

  ModelPosition

  Shifted position.

• getTransformedByOperation( operation ) → ModelPosition

  module:engine/model/position~ModelPosition#getTransformedByOperation

  Returns a copy of this position that is transformed by given operation.

  The new position's parameters are updated accordingly to the effect of the operation.

  For example, if n nodes are inserted before the position, the returned position offset will be increased by n. If the position was in a merged element, it will be accordingly moved to the new element, etc.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  operation : Operation

  Operation to transform by.

  Returns

  ModelPosition

  Transformed position.

• hasSameParentAs( position ) → boolean

  module:engine/model/position~ModelPosition#hasSameParentAs

  Checks if two positions are in the same parent.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  position : ModelPosition

  Position to compare with.

  Returns

  boolean

  true if positions have the same parent, false otherwise.

• is( type ) → this is ModelElement | ModelRootElement

  inherited

  module:engine/model/position~ModelPosition#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 ModelRootElement

  inherited

  module:engine/model/position~ModelPosition#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 ModelPosition | ModelLivePosition

  inherited

  module:engine/model/position~ModelPosition#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 ModelRange | ModelLiveRange

  inherited

  module:engine/model/position~ModelPosition#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 ModelLivePosition

  inherited

  module:engine/model/position~ModelPosition#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 ModelText

  inherited

  module:engine/model/position~ModelPosition#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 ModelDocumentFragment

  inherited

  module:engine/model/position~ModelPosition#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 ModelTextProxy

  inherited

  module:engine/model/position~ModelPosition#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, name ) → boolean

  inherited

  module:engine/model/position~ModelPosition#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/position~ModelPosition#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 Marker

  inherited

  module:engine/model/position~ModelPosition#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 ModelDocumentSelection

  inherited

  module:engine/model/position~ModelPosition#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 ) → this is ModelSelection | ModelDocumentSelection

  inherited

  module:engine/model/position~ModelPosition#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 ModelLiveRange

  inherited

  module:engine/model/position~ModelPosition#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 ModelNode | ModelText | ModelElement | ModelRootElement

  inherited

  module:engine/model/position~ModelPosition#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

• isAfter( otherPosition ) → boolean

  module:engine/model/position~ModelPosition#isAfter

  Checks whether this position is after given position.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  otherPosition : ModelPosition

  Position to compare with.

  Returns

  boolean

  True if this position is after given position.

  Related:

  • ModelPosition#isBefore

• isBefore( otherPosition ) → boolean

  module:engine/model/position~ModelPosition#isBefore

  Checks whether this position is before given position.

  Note: watch out when using negation of the value returned by this method, because the negation will also be true if positions are in different roots and you might not expect this. You should probably use a.isAfter( b ) || a.isEqual( b ) or !a.isBefore( p ) && a.root == b.root in most scenarios. If your condition uses multiple isAfter and isBefore checks, build them so they do not use negated values, i.e.:

  if ( a.isBefore( b ) && c.isAfter( d ) ) {
  	// do A.
  } else {
  	// do B.
  }
  

  Copy code

  or, if you have only one if-branch:

  if ( !( a.isBefore( b ) && c.isAfter( d ) ) {
  	// do B.
  }
  

  Copy code

  rather than:

  if ( !a.isBefore( b ) || && !c.isAfter( d ) ) {
  	// do B.
  } else {
  	// do A.
  }
  

  Copy code

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  otherPosition : ModelPosition

  Position to compare with.

  Returns

  boolean

  True if this position is before given position.

• isEqual( otherPosition ) → boolean

  module:engine/model/position~ModelPosition#isEqual

  Checks whether this position is equal to given position.

  This method is safe to use it on non-existing positions (for example during operational transformation).

  See source (with github icon)

  Parameters

  otherPosition : ModelPosition

  Position to compare with.

  Returns

  boolean

  True if positions are same.

• isTouching( otherPosition ) → boolean

  module:engine/model/position~ModelPosition#isTouching

  Checks whether this position is touching given position. Positions touch when there are no text nodes or empty nodes in a range between them. Technically, those positions are not equal but in many cases they are very similar or even indistinguishable.

  See source (with github icon)

  Parameters

  otherPosition : ModelPosition

  Position to compare with.

  Returns

  boolean

  True if positions touch.

• isValid() → boolean

  module:engine/model/position~ModelPosition#isValid

  Checks whether the position is valid in current model tree, that is whether it points to an existing place in the model.

  See source (with github icon)

  Returns

  boolean

• toJSON() → unknown

  module:engine/model/position~ModelPosition#toJSON
  See source (with github icon)

  Returns

  unknown

• _getCombined( source, target ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getCombined

  Returns a new position that is a combination of this position and given positions.

  The combined position is a copy of this position transformed by moving a range starting at source position to the target position. It is expected that this position is inside the moved range.

  Example:

  let original = model.createPositionFromPath( root, [ 2, 3, 1 ] );
  let source = model.createPositionFromPath( root, [ 2, 2 ] );
  let target = model.createPositionFromPath( otherRoot, [ 1, 1, 3 ] );
  original._getCombined( source, target ); // path is [ 1, 1, 4, 1 ], root is `otherRoot`
  

  Copy code

  Explanation:

  We have a position [ 2, 3, 1 ] and move some nodes from [ 2, 2 ] to [ 1, 1, 3 ]. The original position was inside moved nodes and now should point to the new place. The moved nodes will be after positions [ 1, 1, 3 ], [ 1, 1, 4 ], [ 1, 1, 5 ]. Since our position was in the second moved node, the transformed position will be in a sub-tree of a node at [ 1, 1, 4 ]. Looking at original path, we took care of [ 2, 3 ] part of it. Now we have to add the rest of the original path to the transformed path. Finally, the transformed position will point to [ 1, 1, 4, 1 ].

  See source (with github icon)

  Parameters

  source : ModelPosition

  Beginning of the moved range.

  target : ModelPosition

  Position where the range is moved.

  Returns

  ModelPosition

  Combined position.

• _getTransformedByDeletion( deletePosition, howMany ) → null | ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByDeletion

  Returns a copy of this position that is updated by removing howMany nodes starting from deletePosition. It may happen that this position is in a removed node. If that is the case, null is returned instead.

  See source (with github icon)

  Parameters

  deletePosition : ModelPosition

  Position before the first removed node.

  howMany : number

  How many nodes are removed.

  Returns

  null | ModelPosition

  Transformed position or null.

• _getTransformedByInsertOperation( operation ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByInsertOperation

  Returns a copy of this position transformed by an insert operation.

  See source (with github icon)

  Parameters

  operation : InsertOperation

  Returns

  ModelPosition

• _getTransformedByInsertion( insertPosition, howMany ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByInsertion

  Returns a copy of this position that is updated by inserting howMany nodes at insertPosition.

  See source (with github icon)

  Parameters

  insertPosition : ModelPosition

  Position where nodes are inserted.

  howMany : number

  How many nodes are inserted.

  Returns

  ModelPosition

  Transformed position.

• _getTransformedByMergeOperation( operation ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByMergeOperation

  Returns a copy of this position transformed by merge operation.

  See source (with github icon)

  Parameters

  operation : MergeOperation

  Returns

  ModelPosition

• _getTransformedByMove( sourcePosition, targetPosition, howMany ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByMove

  Returns a copy of this position that is updated by moving howMany nodes from sourcePosition to targetPosition.

  See source (with github icon)

  Parameters

  sourcePosition : ModelPosition

  Position before the first element to move.

  targetPosition : ModelPosition

  Position where moved elements will be inserted.

  howMany : number

  How many consecutive nodes to move, starting from sourcePosition.

  Returns

  ModelPosition

  Transformed position.

• _getTransformedByMoveOperation( operation ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedByMoveOperation

  Returns a copy of this position transformed by a move operation.

  See source (with github icon)

  Parameters

  operation : MoveOperation

  Returns

  ModelPosition

• _getTransformedBySplitOperation( operation ) → ModelPosition

  internal

  module:engine/model/position~ModelPosition#_getTransformedBySplitOperation

  Returns a copy of this position transformed by a split operation.

  See source (with github icon)

  Parameters

  operation : SplitOperation

  Returns

  ModelPosition

Static methods

• fromJSON( json, doc ) → ModelPosition

  static

  module:engine/model/position~ModelPosition.fromJSON

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

  See source (with github icon)

  Parameters

  json : any

  Plain object to be converted to Position.

  doc : ModelDocument

  Document object that will be position owner.

  Returns

  ModelPosition

  Position instance created using given plain object.

• _createAfter( item, [ stickiness ] ) → ModelPosition

  internalstatic

  module:engine/model/position~ModelPosition._createAfter

  Creates a new position, after given model item.

  See source (with github icon)

  Parameters

  item : ModelDocumentFragment | ModelItem

  Item after which the position should be placed.

  [ stickiness ] : ModelPositionStickiness

  Position stickiness.

  Returns

  ModelPosition

• _createAt( itemOrPosition, [ offset ], stickiness ) → ModelPosition

  internalstatic

  module:engine/model/position~ModelPosition._createAt

  Creates position at the given location. The location can be specified as:

  • a position,
  • parent element and offset (offset defaults to 0),
  • parent element and 'end' (sets position at the end of that element),
  • model item and 'before' or 'after' (sets position before or after given model item).

  This method is a shortcut to other factory methods such as:

  • _createBefore,
  • _createAfter.

  See source (with github icon)

  Parameters

  itemOrPosition : ModelDocumentFragment | ModelPosition | ModelItem

  [ offset ] : ModelPositionOffset

  Offset or one of the flags. Used only when the first parameter is a model item.

  stickiness : ModelPositionStickiness

  Position stickiness. Used only when the first parameter is a model item.

  Defaults to 'toNone'

  Returns

  ModelPosition

• _createBefore( item, [ stickiness ] ) → ModelPosition

  internalstatic

  module:engine/model/position~ModelPosition._createBefore

  Creates a new position, before the given model item.

  See source (with github icon)

  Parameters

  item : ModelDocumentFragment | ModelItem

  Item before which the position should be placed.

  [ stickiness ] : ModelPositionStickiness

  Position stickiness.

  Returns

  ModelPosition