Differ

• isEmpty : boolean

  readonly

  module:engine/model/differ~Differ#isEmpty

  Informs whether there are any changes buffered in Differ.

  See source (with github icon)

• _cachedChanges : Array<DifferItem> | null

  private

  module:engine/model/differ~Differ#_cachedChanges

  For efficiency purposes, Differ stores the change set returned by the differ after getChanges call. Cache is reset each time a new operation is buffered. If the cache has not been reset, getChanges will return the cached value instead of calculating it again.

  This property stores those changes that did not take place in graveyard root.

  See source (with github icon)

• _cachedChangesWithGraveyard : Array<DifferItem> | null

  private

  module:engine/model/differ~Differ#_cachedChangesWithGraveyard

  For efficiency purposes, Differ stores the change set returned by the differ after the getChanges call. The cache is reset each time a new operation is buffered. If the cache has not been reset, getChanges will return the cached value instead of calculating it again.

  This property stores all changes evaluated by Differ, including those that took place in the graveyard.

  See source (with github icon)

• _changeCount : number

  private

  module:engine/model/differ~Differ#_changeCount

  Stores the number of changes that were processed. Used to order the changes chronologically. It is important when changes are sorted.

  See source (with github icon)

• _changedMarkers : Map<string, object>

  privatereadonly

  module:engine/model/differ~Differ#_changedMarkers

  A map that stores all changed markers.

  The keys of the map are marker names.

  The values of the map are objects with the following properties:

  • oldMarkerData,
  • newMarkerData.

  See source (with github icon)

• _changedRoots : Map<string, DifferItemRoot>

  privatereadonly

  module:engine/model/differ~Differ#_changedRoots

  A map that stores all roots that have been changed.

  The keys are the names of the roots while value represents the changes.

  See source (with github icon)

• _changesInElement : Map<ModelElement | ModelDocumentFragment, Array<ChangeItem>>

  privatereadonly

  module:engine/model/differ~Differ#_changesInElement

  A map that stores changes that happened in a given element.

  The keys of the map are references to the model elements. The values of the map are arrays with changes that were done on this element.

  See source (with github icon)

• _elementChildrenSnapshots : Map<ModelElement | ModelDocumentFragment, Array<DifferSnapshot>>

  privatereadonly

  module:engine/model/differ~Differ#_elementChildrenSnapshots

  For each element or document fragment inside which there was a change, it stores a snapshot of the child nodes list (an array of children snapshots that represent the state in the element / fragment before any change has happened).

  This complements _elementsSnapshots.

  See also DifferSnapshot.

  See source (with github icon)

• _elementState : Map<ModelElement, 'rename' | 'move' | 'refresh'>

  privatereadonly

  module:engine/model/differ~Differ#_elementState

  Keeps the state for a given element, describing how the element was changed so far. It is used to evaluate the action property of diff items returned by getChanges.

  Possible values, in the order from the lowest priority to the highest priority:

  • 'refresh' - element was refreshed,
  • 'rename' - element was renamed,
  • 'move' - element was moved (or, usually, removed, that is moved to the graveyard).

  Element that was refreshed, may change its state to 'rename' if it was later renamed, or to 'move' if it was removed. But the element cannot change its state from 'move' to 'rename', or from 'rename' to 'refresh'.

  Only already existing elements are registered in _elementState. If a new element was inserted as a result of a buffered operation, it is not be registered in _elementState.

  See source (with github icon)

• _elementsSnapshots : Map<ModelNode, DifferSnapshot>

  privatereadonly

  module:engine/model/differ~Differ#_elementsSnapshots

  Stores a snapshot for these model nodes that might have changed.

  This complements _elementChildrenSnapshots.

  See also DifferSnapshot.

  See source (with github icon)

• _markerCollection : MarkerCollection

  privatereadonly

  module:engine/model/differ~Differ#_markerCollection

  Reference to the model's marker collection.

  See source (with github icon)

• _refreshedItems : Set<ModelItem>

  private

  module:engine/model/differ~Differ#_refreshedItems

  Set of model items that were marked to get refreshed in _refreshItem.

  See source (with github icon)

Static properties

• _statesPriority : Array<string | undefined>

  privatereadonlystatic

  module:engine/model/differ~Differ._statesPriority

  Priority of the element states. States on higher indexes of the array can overwrite states on the lower indexes.

  See source (with github icon)

• constructor( markerCollection )

  module:engine/model/differ~Differ#constructor

  Creates a Differ instance.

  See source (with github icon)

  Parameters

  markerCollection : MarkerCollection

  Model's marker collection.

  bufferMarkerChange( markerName, oldMarkerData, newMarkerData ) → void

  module:engine/model/differ~Differ#bufferMarkerChange

  Buffers a marker change.

  See source (with github icon)

  Parameters

  markerName : string

  The name of the marker that changed.

  oldMarkerData : MarkerData

  Marker data before the change.

  newMarkerData : MarkerData

  Marker data after the change.

  Returns

  void

  bufferOperation( operationToBuffer ) → void

  module:engine/model/differ~Differ#bufferOperation

  Buffers the given operation. An operation has to be buffered before it is executed.

  See source (with github icon)

  Parameters

  operationToBuffer : Operation

  An operation to buffer.

  Returns

  void

  getChangedMarkers() → Array<object>

  module:engine/model/differ~Differ#getChangedMarkers

  Returns all markers which changed.

  See source (with github icon)

  Returns

  Array<object>

  getChangedRoots() → Array<DifferItemRoot>

  module:engine/model/differ~Differ#getChangedRoots

  Returns all roots that have changed (either were attached, or detached, or their attributes changed).

  See source (with github icon)

  Returns

  Array<DifferItemRoot>

  Diff between the old and the new roots state.

  getChanges( options = { [options.includeChangesInGraveyard] } ) → Array<DifferItem>

  module:engine/model/differ~Differ#getChanges

  Calculates the diff between the old model tree state (the state before the first buffered operations since the last reset call) and the new model tree state (actual one). It should be called after all buffered operations are executed.

  The diff set is returned as an array of diff items, each describing a change done on the model. The items are sorted by the position on which the change happened. If a position is before another one, it will be on an earlier index in the diff set.

  Note: Elements inside inserted element will not have a separate diff item, only the top most element change will be reported.

  Because calculating the diff is a costly operation, the result is cached. If no new operation was buffered since the previous getChanges call, the next call will return the cached value.

  See source (with github icon)

  Parameters

  options : object

  Additional options.

  Properties

  [ options.includeChangesInGraveyard ] : boolean

  If set to true, also changes that happened in the graveyard root will be returned. By default, changes in the graveyard root are not returned.

  Defaults to {}

  Returns

  Array<DifferItem>

  Diff between the old and the new model tree state.

  getMarkersToAdd() → Array<object>

  module:engine/model/differ~Differ#getMarkersToAdd

  Returns all markers which should be added as a result of buffered changes.

  See source (with github icon)

  Returns

  Array<object>

  Markers to add. Each array item is an object containing the name and range properties.

  getMarkersToRemove() → Array<object>

  module:engine/model/differ~Differ#getMarkersToRemove

  Returns all markers that should be removed as a result of buffered changes.

  See source (with github icon)

  Returns

  Array<object>

  Markers to remove. Each array item is an object containing the name and range properties.

  getRefreshedItems() → Set<ModelItem>

  module:engine/model/differ~Differ#getRefreshedItems

  Returns a set of model items that were marked to get refreshed.

  See source (with github icon)

  Returns

  Set<ModelItem>

  hasDataChanges() → boolean

  module:engine/model/differ~Differ#hasDataChanges

  Checks whether some of the buffered changes affect the editor data.

  Types of changes which affect the editor data:

  • model structure changes,
  • attribute changes,
  • a root is added or detached,
  • changes of markers which were defined as affectsData,
  • changes of markers' affectsData property.

  See source (with github icon)

  Returns

  boolean

  reset() → void

  module:engine/model/differ~Differ#reset

  Resets Differ. Removes all buffered changes.

  See source (with github icon)

  Returns

  void

  _bufferRootLoad( root ) → void

  internal

  module:engine/model/differ~Differ#_bufferRootLoad

  Buffers all the data related to given root like it was all just added to the editor.

  Following changes are buffered:

  • root is attached,
  • all root content is inserted,
  • all root attributes are added,
  • all markers inside the root are added.

  See source (with github icon)

  Parameters

  root : ModelRootElement

  Returns

  void

  _refreshItem( item ) → void

  internal

  module:engine/model/differ~Differ#_refreshItem

  Marks the given item in differ to be "refreshed". It means that the item will be marked as removed and inserted in the differ changes set, so it will be effectively re-converted when the differ changes are handled by a dispatcher.

  See source (with github icon)

  Parameters

  item : ModelItem

  Item to refresh.

  Returns

  void

  _bufferRootAttributeChange( rootName, key, oldValue, newValue ) → void

  private

  module:engine/model/differ~Differ#_bufferRootAttributeChange

  Buffers a root attribute change.

  See source (with github icon)

  Parameters

  rootName : string

  key : string

  oldValue : unknown

  newValue : unknown

  Returns

  void

  _bufferRootStateChange( rootName, isAttached ) → void

  private

  module:engine/model/differ~Differ#_bufferRootStateChange

  Buffers the root state change after the root was attached or detached

  See source (with github icon)

  Parameters

  rootName : string

  isAttached : boolean

  Returns

  void

  _getAttributesDiff( range, oldAttributes, newAttributes ) → Array<object>

  private

  module:engine/model/differ~Differ#_getAttributesDiff

  Returns an array of objects where each one is a single attribute change description.

  See source (with github icon)

  Parameters

  range : ModelRange

  The range where the change happened.

  oldAttributes : Map<string, unknown>

  A map, map iterator or compatible object that contains attributes before the change.

  newAttributes : Map<string, unknown>

  A map, map iterator or compatible object that contains attributes after the change.

  Returns

  Array<object>

  An array containing one or more diff items.

  _getChangesForElement( element ) → Array<ChangeItem>

  private

  module:engine/model/differ~Differ#_getChangesForElement

  Gets an array of changes that have already been saved for a given element.

  See source (with github icon)

  Parameters

  element : ModelElement | ModelDocumentFragment

  Returns

  Array<ChangeItem>

  _getDiffActionForNode( node, diffItemType ) → DifferItemAction

  private

  module:engine/model/differ~Differ#_getDiffActionForNode

  Returns a value for action property for diff items returned by getChanges. This method aims to return 'rename' or 'refresh' when it should, and diffItemType ("default action") in all other cases.

  It bases on a few factors:

  • for text nodes, the method always returns diffItemType,
  • for newly inserted element, the method returns diffItemType,
  • if element state was not recorded, the method returns diffItemType,
  • if state was recorded, and it was 'move' (default action), the method returns diffItemType,
  • finally, if state was 'refresh' or 'rename', the method returns the state value.

  See source (with github icon)

  Parameters

  node : ModelNode

  diffItemType : 'insert' | 'remove'

  Returns

  DifferItemAction

  _getInsertDiff( parent, offset, action, elementSnapshot, [ elementSnapshotBefore ] ) → object

  private

  module:engine/model/differ~Differ#_getInsertDiff

  Returns an object with a single insert change description.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  The element in which the change happened.

  offset : number

  The offset at which change happened.

  action : DifferItemAction

  Further specifies what kind of action led to generating this change.

  elementSnapshot : DifferSnapshot

  Snapshot of the inserted node after changes.

  [ elementSnapshotBefore ] : DifferSnapshot

  Snapshot of the inserted node before changes.

  Returns

  object

  The diff item.

  _getRemoveDiff( parent, offset, action, elementSnapshot ) → object

  private

  module:engine/model/differ~Differ#_getRemoveDiff

  Returns an object with a single remove change description.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  The element in which change happened.

  offset : number

  The offset at which change happened.

  action : DifferItemAction

  Further specifies what kind of action led to generating this change.

  elementSnapshot : DifferSnapshot

  The snapshot of the removed node before changes.

  Returns

  object

  The diff item.

  _handleChange( inc, changes ) → void

  private

  module:engine/model/differ~Differ#_handleChange

  For a given newly saved change, compares it with a change already done on the element and modifies the incoming change and/or the old change.

  See source (with github icon)

  Parameters

  inc : ChangeItem

  Incoming (new) change.

  changes : Array<ChangeItem>

  An array containing all the changes done on that element.

  Returns

  void

  _isInInsertedElement( element ) → boolean

  private

  module:engine/model/differ~Differ#_isInInsertedElement

  Checks whether given element or any of its parents is an element that is buffered as an inserted element.

  See source (with github icon)

  Parameters

  element : ModelElement | ModelDocumentFragment

  Returns

  boolean

  _makeSnapshots( element ) → void

  private

  module:engine/model/differ~Differ#_makeSnapshots

  Creates and saves a snapshot for all children of the given element.

  See source (with github icon)

  Parameters

  element : ModelElement | ModelDocumentFragment

  Returns

  void

  _markAttribute( item ) → void

  private

  module:engine/model/differ~Differ#_markAttribute

  Saves and handles an attribute change.

  See source (with github icon)

  Parameters

  item : ModelItem

  Returns

  void

  _markChange( parent, changeItem ) → void

  private

  module:engine/model/differ~Differ#_markChange

  Saves and handles a model change.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  changeItem : ChangeItem

  Returns

  void

  _markInsert( parent, offset, howMany ) → void

  private

  module:engine/model/differ~Differ#_markInsert

  Saves and handles an insert change.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  offset : number

  howMany : number

  Returns

  void

  _markRemove( parent, offset, howMany ) → void

  private

  module:engine/model/differ~Differ#_markRemove

  Saves and handles a remove change.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  offset : number

  howMany : number

  Returns

  void

  _removeAllNestedChanges( parent, offset, howMany ) → void

  private

  module:engine/model/differ~Differ#_removeAllNestedChanges

  Removes deeply all buffered changes that are registered in elements from range specified by parent, offset and howMany.

  See source (with github icon)

  Parameters

  parent : ModelElement | ModelDocumentFragment

  offset : number

  howMany : number

  Returns

  void

  _setElementState( node, state ) → void

  private

  module:engine/model/differ~Differ#_setElementState

  Tries to set given state for given item.

  This method does simple validation (it sets the state only for model elements, not for text proxy nodes). It also follows state setting rules, that is, 'refresh' cannot overwrite 'rename', and 'rename' cannot overwrite 'move'.

  See source (with github icon)

  Parameters

  node : ModelItem

  state : 'rename' | 'move' | 'refresh'

  Returns

  void