TrackChangesEditing

class

Provides editing part of the track changes plugin.

Properties

activeMarkers : Array<string>
observable

List of names of active (highlighted) markers.
adapter : null | TrackChangesAdapter

Parameters
adapter : null | TrackChangesAdapter
descriptionFactory : SuggestionDescriptionFactory

Descriptions factory which generates descriptions for the suggestions created by the track changes plugin.
editor : Editor
readonlyinherited
module:track-changes/trackchangesediting~TrackChangesEditing#editor
The editor instance.
Note that most editors implement the ui property. However, editors with an external UI (i.e. Bootstrap-based) or a headless editor may not have this property or throw an error when accessing it.
Because of above, to make plugins more universal, it is recommended to split features into:
- The "editing" part that uses the Editor class without ui property.
- The "UI" part that uses the Editor class and accesses ui property.
isEnabled : boolean
readonlyinheritedobservable
module:track-changes/trackchangesediting~TrackChangesEditing#isEnabled
Flag indicating whether a plugin is enabled or disabled. A disabled plugin will not transform text.
Plugin can be simply disabled like that:
```
// Disable the plugin so that no toolbars are visible.
editor.plugins.get( 'TextTransformation' ).isEnabled = false;
```
Copy code
You can also use forceDisabled method.
trackChangesCommand : TrackChangesCommand

Reference to command that turns the track changes mode on and off.

Static properties

isContextPlugin : false
readonlyinheritedstatic
pluginName : 'TrackChangesEditing'
readonlystatic
requires : readonly tuple
readonlystatic

Methods

constructor( editor )

Parameters
editor : Editor
acceptSuggestion( suggestion ) → void

Accept all adjacent suggestions.
Parameters
suggestion : Suggestion
Returns
void
addSuggestionData( data ) → Suggestion

Adds suggestion data.
Parameters
data : SuggestionData
Returns
Suggestion
afterInit() → void

Returns
void
bind( bindProperty1, bindProperty2 ) → ObservableDualBindChain<K1, TrackChangesEditing[ K1 ], K2, TrackChangesEditing[ K2 ]>
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#bind:DUAL_BIND
Binds observable properties to other objects implementing the Observable interface.
Read more in the dedicated guide covering the topic of property bindings with some additional examples.
Consider two objects: a button and an associated command (both Observable).
A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
Copy code
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
Copy code
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use unbind.
You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
Copy code
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
Copy code
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
Copy code
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Copy code
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
Copy code
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Copy code
Type parameters
K1
K2
Parameters
bindProperty1 : K1
Observable property that will be bound to other observable(s).
bindProperty2 : K2
Observable property that will be bound to other observable(s).
Returns
ObservableDualBindChain<K1, TrackChangesEditing[ K1 ], K2, TrackChangesEditing[ K2 ]>
The bind chain with the to() and toMany() methods.
bind( bindProperties ) → ObservableMultiBindChain
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#bind:MANY_BIND
Binds observable properties to other objects implementing the Observable interface.
Read more in the dedicated guide covering the topic of property bindings with some additional examples.
Consider two objects: a button and an associated command (both Observable).
A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
Copy code
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
Copy code
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use unbind.
You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
Copy code
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
Copy code
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
Copy code
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Copy code
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
Copy code
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Copy code
Parameters
bindProperties : Array<'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'destroy' | 'init' | 'isEnabled' | 'editor' | 'forceDisabled' | 'clearForceDisabled' | 'afterInit' | 'adapter' | '_adapter' | 'getSuggestions' | 'getSuggestion' | 'activeMarkers' | 'descriptionFactory' | 'trackChangesCommand' | '_suggestionFactory' | '_isForcedDefaultExecutionBlock' | '_recordAttributeSuggestions' | 'acceptSuggestion' | 'discardSuggestion' | 'hasSuggestion' | 'addSuggestionData' | 'enableCommand' | 'forceDefaultExecution' | 'markInsertion' | 'markMultiRangeInsertion' | 'markInlineFormat' | 'markBlockFormat' | 'markMultiRangeBlockFormat' | 'markDeletion' | 'markMultiRangeDeletion' | 'markAttributeChange' | 'enableDefaultAttributesIntegration' | 'registerBlockAttribute' | 'registerInlineAttribute' | 'startTrackingSession' | '_getAttributeKey' | '_applyOperationsAsSuggestions' | '_splitMarkerName' | '_findSuggestions' | '_setSuggestionData' | '_isBlockAttribute' | '_isInlineAttribute' | 'recordAttributeChanges' | '_isRegisteredAttribute'>
Observable properties that will be bound to other observable(s).
Returns
ObservableMultiBindChain
The bind chain with the to() and toMany() methods.
bind( bindProperty ) → ObservableSingleBindChain<K, TrackChangesEditing[ K ]>
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#bind:SINGLE_BIND
Binds observable properties to other objects implementing the Observable interface.
Read more in the dedicated guide covering the topic of property bindings with some additional examples.
Consider two objects: a button and an associated command (both Observable).
A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
Copy code
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
Copy code
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use unbind.
You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
Copy code
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
Copy code
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
Copy code
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Copy code
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
Copy code
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Copy code
Type parameters
K
Parameters
bindProperty : K
Observable property that will be bound to other observable(s).
Returns
ObservableSingleBindChain<K, TrackChangesEditing[ K ]>
The bind chain with the to() and toMany() methods.
clearForceDisabled( id ) → void
inherited

Clears forced disable previously set through forceDisabled. See forceDisabled.
Parameters
id : string
Unique identifier, equal to the one passed in forceDisabled call.
Returns
void
decorate( methodName ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#decorate
Turns the given methods of this object into event-based ones. This means that the new method will fire an event (named after the method) and the original action will be plugged as a listener to that event.
Read more in the dedicated guide covering the topic of decorating methods with some additional examples.
Decorating the method does not change its behavior (it only adds an event), but it allows to modify it later on by listening to the method's event.
For example, to cancel the method execution the event can be stopped:
```
class Foo extends ObservableMixin() {
	constructor() {
		super();
		this.decorate( 'method' );
	}

	method() {
		console.log( 'called!' );
	}
}

const foo = new Foo();
foo.on( 'method', ( evt ) => {
	evt.stop();
}, { priority: 'high' } );

foo.method(); // Nothing is logged.
```
Copy code
Note: The high priority listener has been used to execute this particular callback before the one which calls the original method (which uses the "normal" priority).
It is also possible to change the returned value:
```
foo.on( 'method', ( evt ) => {
	evt.return = 'Foo!';
} );

foo.method(); // -> 'Foo'
```
Copy code
Finally, it is possible to access and modify the arguments the method is called with:
```
method( a, b ) {
	console.log( `${ a }, ${ b }`  );
}

// ...

foo.on( 'method', ( evt, args ) => {
	args[ 0 ] = 3;

	console.log( args[ 1 ] ); // -> 2
}, { priority: 'high' } );

foo.method( 1, 2 ); // -> '3, 2'
```
Copy code
Parameters
methodName : 'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'destroy' | 'init' | 'isEnabled' | 'editor' | 'forceDisabled' | 'clearForceDisabled' | 'afterInit' | 'adapter' | '_adapter' | 'getSuggestions' | 'getSuggestion' | 'activeMarkers' | 'descriptionFactory' | 'trackChangesCommand' | '_suggestionFactory' | '_isForcedDefaultExecutionBlock' | '_recordAttributeSuggestions' | 'acceptSuggestion' | 'discardSuggestion' | 'hasSuggestion' | 'addSuggestionData' | 'enableCommand' | 'forceDefaultExecution' | 'markInsertion' | 'markMultiRangeInsertion' | 'markInlineFormat' | 'markBlockFormat' | 'markMultiRangeBlockFormat' | 'markDeletion' | 'markMultiRangeDeletion' | 'markAttributeChange' | 'enableDefaultAttributesIntegration' | 'registerBlockAttribute' | 'registerInlineAttribute' | 'startTrackingSession' | '_getAttributeKey' | '_applyOperationsAsSuggestions' | '_splitMarkerName' | '_findSuggestions' | '_setSuggestionData' | '_isBlockAttribute' | '_isInlineAttribute' | 'recordAttributeChanges' | '_isRegisteredAttribute'
Name of the method to decorate.
Returns
void
delegate( events ) → EmitterMixinDelegateChain
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#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
Parameters
events : Array<string>
Event names that will be delegated to another emitter.
Returns
EmitterMixinDelegateChain
destroy() → void
inherited

Destroys the plugin.
Note: This method is optional. A plugin instance does not need to have it defined.
Returns
void
discardSuggestion( suggestion ) → void

Discard all adjacent suggestions.
Parameters
suggestion : Suggestion
Returns
void
enableCommand( commandName, [ callback ] ) → void
module:track-changes/trackchangesediting~TrackChangesEditing#enableCommand
Enables command with given commandName in track changes mode.
When a command gets enabled in track changes mode, its original execute() method is overwritten by provided callback() function. The callback() should provide alternative logic to be executed instead.
The callback() function is passed one or more parameters:
- the first parameter is executeCommand(), a function that upon calling will fire the original execute() method,
- then, all the parameters passed to original execute() call are passed.
Using those parameters it is possible to call the original command in the callback() (or skip it) and also do something before and/or after that call.
If callback is not set then the command will work the same both when track changes is on and off.
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
commandName : string
[ callback ] : Function
Returns
void
enableDefaultAttributesIntegration( commandName ) → void

Enables default attributes suggestions integration for given command.
Parameters
commandName : string
Name of the command to integrate.
Returns
void
fire( eventOrInfo, args ) → GetEventInfo<TEvent>[ 'return' ]
inherited

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.
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).
forceDefaultExecution( callback ) → unknown

Temporarily disable track changes to accept or discard a suggestion without intercepting original calls.
Parameters
callback : Function
Returns
unknown
forceDisabled( id ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#forceDisabled
Disables the plugin.
Plugin may be disabled by multiple features or algorithms (at once). When disabling a plugin, unique id should be passed (e.g. feature name). The same identifier should be used when enabling back the plugin. The plugin becomes enabled only after all features enabled it back.
Disabling and enabling a plugin:
```
plugin.isEnabled; // -> true
plugin.forceDisabled( 'MyFeature' );
plugin.isEnabled; // -> false
plugin.clearForceDisabled( 'MyFeature' );
plugin.isEnabled; // -> true
```
Copy code
Plugin disabled by multiple features:
```
plugin.forceDisabled( 'MyFeature' );
plugin.forceDisabled( 'OtherFeature' );
plugin.clearForceDisabled( 'MyFeature' );
plugin.isEnabled; // -> false
plugin.clearForceDisabled( 'OtherFeature' );
plugin.isEnabled; // -> true
```
Copy code
Multiple disabling with the same identifier is redundant:
```
plugin.forceDisabled( 'MyFeature' );
plugin.forceDisabled( 'MyFeature' );
plugin.clearForceDisabled( 'MyFeature' );
plugin.isEnabled; // -> true
```
Copy code
Note: some plugins or algorithms may have more complex logic when it comes to enabling or disabling certain plugins, so the plugin might be still disabled after clearForceDisabled was used.
Parameters
id : string
Unique identifier for disabling. Use the same id when enabling back the plugin.
Returns
void
getSuggestion( id ) → Suggestion

Returns suggestion for given id.
Parameters
id : string
Returns
Suggestion
getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<SuggestionJSON>

Parameters
options : object
Properties

[ options.skipNotAttached ] : boolean
options.toJSON : true
Returns
Array<SuggestionJSON>
getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<Suggestion> | Array<SuggestionJSON>

Parameters
options : object
Properties

[ options.skipNotAttached ] : boolean
options.toJSON : boolean
Returns
Array<Suggestion> | Array<SuggestionJSON>
getSuggestions( [ options ] = { [options.skipNotAttached], [options.toJSON] } ) → Array<Suggestion>

Parameters
[ options ] : object
Properties

[ options.skipNotAttached ] : boolean
[ options.toJSON ] : false
Returns
Array<Suggestion>
hasSuggestion( id ) → boolean

Checks if suggestion of given id exist.
Parameters
id : string
Returns
boolean
init() → void

Returns
void
listenTo( emitter, event, callback, [ options ] ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#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.
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
markAttributeChange( range, key, oldValue, newValue, attributes = { attributes.groupId, attributes.[key: string] } ) → Array<Suggestion>

Marks a single-range attribute suggestion on the given range.
Note: all nodes in the given range must have the same current value of key attribute.
Note: if a block attribute is marked, range should include only a single model element.
attributes is a required value and must include groupId: string property. The group id is used to group attribute suggestions together. All suggestions with the same groupId will be put into one suggestion chain. By default, all attribute suggestions created during the same batch have the same groupId.
It's possible that more than one suggestion will be created by this method if there are already suggestions with the same key but a different oldValue intersecting with the given range.
It is guaranteed that there will be no "conflicting" suggestions, that is, there will be no two intersecting suggestions for the same attribute key. If there is a conflicting suggestion, it will be partially or fully replaced by a new suggestion.
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
See Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
range : ModelRange
Range for which the attribute has changed.
key : string
Key of the attribute that changed.
oldValue : unknown
Previous value of the attribute.
newValue : unknown
New value of the attribute.
attributes : object
Suggestion attributes. Must include groupId.

Properties

attributes.groupId : string
attributes.[key: string] : any
Returns
Array<Suggestion>
markBlockFormat( elementOrRange, formatData, affectedElements, subType, attributes ) → null | Suggestion
module:track-changes/trackchangesediting~TrackChangesEditing#markBlockFormat
Marks a block format suggestion on the given range.
Block format suggestions are directly coupled with editor commands and represent a command execution on the given range or element.
This type of format suggestion is suitable for formatting (attribute) changes on block elements. Changes like resizing image, applying block quote or changing header type use this type of format suggestion.
Pass element if the suggestion should be marked exactly on that element. This is suitable if the command modifies exactly given element (for example, changes an attribute of that element). If such element is split, an additional suggestion is created for the new element:
```
	[<paragraph>Foobar]</paragraph>  -->  [<paragraph>Foo]</paragraph>[<paragraph>bar]</paragraph>
```
Copy code
Pass range for suggestions representing commands that can be executed on multiple blocks at once. This is suitable for commands which modifies all the block elements found in given range (those commands usually operate on selection ranges). This creates only one suggestion for the whole range and do not create additional suggestions if blocks in the range are split:
```
	[<paragraph>Foobar]</paragraph>  -->  [<paragraph>Foo</paragraph><paragraph>Bar]</paragraph>
```
Copy code
Example of marking block format suggestion on an element:
```
trackChangesPlugin.markBlockFormat( paragraphElement, {
		commandName: 'heading',
		commandParams: [ { value: 'heading1' } ],
		formatGroupId: 'blockName'
	} );
```
Copy code
Example of marking block format suggestion on a range:
```
plugin.markBlockFormat( selectionRange, {
		commandName: 'blockQuote',
		commandParams: [ { forceValue: true } ]
} );
```
Copy code
If you pass a range, it should start before the first element to change and end:
- for blocks (like paragraph, list item, heading, etc.): at the end of the last element to change,
- for objects (like image, table, media embed, etc.): after the last element to change.
```
[<paragraph>Foo</paragraph><paragraph>Bar]</paragraph><paragraph>Xyz</paragraph>
[<paragraph>Foo</paragraph><imageBlock src="foo.jpg"></imageBlock>]<paragraph>Xyz</paragraph>
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
When a format suggestion is accepted the command is executed based on parameters passed in formatData.
If a block format suggestion is marked inside the local user's insertion suggestion, the change is applied directly and no suggestion is created. Note that this does not support partial intersections with insertion suggestions (as opposed to inline format suggestions).
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
elementOrRange : ModelElement | ModelRange
Element or range on which the change happened.
formatData : SuggestionFormatData
Command parameters and additional suggestion parameters.
affectedElements : Array<ModelElement>
Elements (other than elementOrRange) that are also affected by the command execution. This parameter is used when the effect of the command execution is larger than elementOrRange. It is used when determining whether the change should be applied directly or if the suggestion should be created.

Defaults to []
subType : null | string
Suggestion subType to set. If not set (which is the default and recommended use) the sub type value is a string hash generated from formatData. This guarantees that all block format suggestions that perform the same changes have the same sub types (and can be properly handled).

Defaults to null
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null | Suggestion
markDeletion( range, subType, attributes ) → null | Suggestion
module:track-changes/trackchangesediting~TrackChangesEditing#markDeletion
Marks a single-range deletion suggestion on given range.
If the range to mark intersects with or contains insertion suggestions created by the local user, those suggestions may be removed in a part or in the whole together with their content.
```
trackChangesPlugin.markDeletion( deletedRange );
trackChangesPlugin.markDeletion( deletedRange, 'customDeletion' );
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
range : ModelRange
Range which should be marked as deletion suggestion.
subType : null | string
Suggestion subType to set. If not set, suggestion will be a generic insertion suggestion. Only suggestions with the same sub type will be joined.

Defaults to null
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null | Suggestion
Suggestion created or expanded as a result of execution of this method. Returns null if given range was collapsed or the deletion was in insertion (so no suggestion was created or expanded).
markInlineFormat( range, formatData, subType, attributes ) → null
module:track-changes/trackchangesediting~TrackChangesEditing#markInlineFormat
Marks an inline format suggestion on the given range.
This type of format suggestion is suitable for formatting (attribute) changes on inline elements and text. Changes like adding bold or setting a link use this type of format suggestion.
Inline format suggestions are directly coupled with editor commands and represent a command execution on given range.
```
trackChangesPlugin.markInlineFormat( formattedRange, {
		commandName: 'bold',
		commandParams: [ { forceValue: true } ]
} );

trackChangesPlugin.markInlineFormat( formattedRange, formatData, 'customSubType' );
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
When a format suggestion is accepted the command is executed based on parameters passed in formatData.
If an inline format suggestion is marked inside the local user's insertion suggestion, the change is applied directly and no suggestion is created. This supports partial intersections with insertion suggestions.
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
range : ModelRange
Range on which the change happened.
formatData : SuggestionFormatData
Command parameters.
subType : null | string
Suggestion subType to set. If not set (which is the default and recommended use) the sub type value is a string hash generated from formatData. This guarantees that all inline format suggestions that perform the same changes have the same sub type (and can be properly handled).

Defaults to null
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null
markInsertion( range, subType, attributes ) → null | Suggestion
module:track-changes/trackchangesediting~TrackChangesEditing#markInsertion
Marks a single-range insertion suggestion on the given range.
It is expected that given range is a range on just-created content and does not intersect with any other suggestion ranges.
```
trackChangesPlugin.markInsertion( insertionRange );
trackChangesPlugin.markInsertion( insertionRange, 'customInsertion' );
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
range : ModelRange
Range on content which got inserted.
subType : null | string
Suggestion subType to set. If not set, suggestion will be a generic insertion suggestion. Only suggestions with the same sub type will be joined.

Defaults to null
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null | Suggestion
Suggestion created or expanded as a result of execution of this method. Returns null if given range was collapsed (so no suggestion was created or expanded).
markMultiRangeBlockFormat( elementsOrRanges, formatData, affectedElements, subType, attributes ) → null | Suggestion

Marks a multi-range block format suggestion on given elements.
See TrackChangesEditing#markBlockFormat() to learn more about block format suggestions. Note that this method can be used only on elements (not on ranges).
This method is useful for creating a format suggestion on multiple elements which are not siblings, so one range cannot be used.
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
When a format suggestion is accepted the command is executed based on parameters passed in formatData.
If a block format suggestion is marked inside the local user's insertion suggestion, the change is applied directly and no suggestion is created. Note that this does not support partial intersections with insertion suggestions (as opposed to inline format suggestions).
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
elementsOrRanges : Array<ModelRange> | Array<ModelElement>
Elements or ranges on which the change happened.
formatData : SuggestionFormatData
Command parameters and additional suggestion parameters.
affectedElements : Array<ModelElement>
Elements (other than elementOrRange) that are also affected by the command execution. This parameter is used when the effect of the command execution is larger than elementOrRange. It is used when determining whether the change should be applied directly or if the suggestion should be created.

Defaults to []
subType : null | string
Suggestion subType to set. If not set (which is the default and recommended use) the sub type value is a string hash generated from formatData. This guarantees that all block format suggestions that perform the same changes have the same sub types (and can be properly handled).

Defaults to null
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null | Suggestion
markMultiRangeDeletion( ranges, subType, attributes ) → null | Suggestion
module:track-changes/trackchangesediting~TrackChangesEditing#markMultiRangeDeletion
Marks a multi-range deletion suggestion spanning over given ranges.
Each range of a multi-range deletion suggestion should contain exactly one element and should not be created on a text content.
If the ranges to mark contain or are contained in insertion suggestions created by the local user, those insertion suggestions may be removed together with their content.
```
trackChangesPlugin.markMultiRangeDeletion( deletedRanges );
trackChangesPlugin.markMultiRangeDeletion( deletedRanges, 'customDeletion' );
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
ranges : Array<ModelRange>
Ranges which should be marked as deletion suggestion.
subType : string
Suggestion subType to set. Only suggestions with the same sub type will be joined.

Defaults to 'multi'
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
null | Suggestion
Suggestion created or expanded as a result of execution of this method.
markMultiRangeInsertion( ranges, subType, attributes ) → Suggestion
module:track-changes/trackchangesediting~TrackChangesEditing#markMultiRangeInsertion
Marks a multi-range insertion suggestion spanning over given ranges.
It is expected that given ranges are ranges on just-created content and do not intersect with any other suggestion ranges.
Each range of a multi-range insertion suggestion should contain exactly one element and should not be created on a text content.
```
trackChangesPlugin.markMultiRangeInsertion( insertionRanges );
trackChangesPlugin.markMultiRangeInsertion( insertionRanges, 'customInsertion' );
```
Copy code
This method should be used in callback() in TrackChangesEditing#enableCommand to inform the track changes plugin about a suggestion that happened.
Always call this method inside model.change() or model.enqueueChange() block to ensure that all operations performed by this method are bound with one undo step.
If possible, the new suggestion will be joined with an existing suggestion (of the same type). This happens only if the suggestions are created by the same user and have similar attributes (i.e. passed attributes do not conflict with the existing suggestion).
See the Integrating track changes with custom features guide to learn more about enabling your feature in the suggestion mode.
Parameters
ranges : Array<ModelRange>
Ranges which got inserted.
subType : string
Suggestion subType to set. Only suggestions with the same subtype will be joined.

Defaults to 'multi'
attributes : Record<string, unknown>
Custom suggestion attributes.

Defaults to {}
Returns
Suggestion
Suggestion created or expanded as a result of execution of this method.
off( event, callback ) → void
inherited

Stops executing the callback on the given event. Shorthand for this.stopListening( this, event, callback ).
Parameters
event : string
The name of the event.
callback : Function
The function to stop being called.
Returns
void
on( event, callback, [ options ] ) → void
inherited

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).
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

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.
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
recordAttributeChanges( callback ) → void

Executes given callback and then finds all attribute and rename changes that have been made during that callback. For all these changes, creates proper attribute suggestions. Additionally cleans up existing, conflicting attribute suggestions if they intersect with the newly created suggestions.
Parameters
callback : () => void
Function to call and check for attribute and rename changes. Usually this executes an editor command.
Returns
void
registerBlockAttribute( attributeKey ) → void

Registers given attribute key for tracking as a block attribute (i.e. an attribute made on a block element).
Parameters
attributeKey : string
Returns
void
registerInlineAttribute( attributeKey ) → void

Registers given attribute key for tracking as an inline attribute (i.e. an attribute made on an inline element).
Parameters
attributeKey : string
Returns
void
set( values ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#set:OBJECT
Creates and sets the value of an observable properties of this object. Such a property becomes a part of the state and is observable.
It accepts a single object literal containing key/value pairs with properties to be set.
This method throws the observable-set-cannot-override error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that foo.set( 'bar', 1 ) may be slightly slower than foo.bar = 1.
In TypeScript, those properties should be declared in class using declare keyword. In example:
```
public declare myProp1: number;
public declare myProp2: string;

constructor() {
	this.set( {
		'myProp1: 2,
		'myProp2: 'foo'
	} );
}
```
Copy code
Parameters
values : object
An object with name=>value pairs.
Returns
void
set( name, value ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#set:KEY_VALUE
Creates and sets the value of an observable property of this object. Such a property becomes a part of the state and is observable.
This method throws the observable-set-cannot-override error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that foo.set( 'bar', 1 ) may be slightly slower than foo.bar = 1.
In TypeScript, those properties should be declared in class using declare keyword. In example:
```
public declare myProp: number;

constructor() {
	this.set( 'myProp', 2 );
}
```
Copy code
Type parameters
K
Parameters
name : K
The property's name.
value : TrackChangesEditing[ K ]
The property's value.
Returns
void
startTrackingSession( [ id ] ) → null | string

Starts a new tracking session, stopping all newly created suggestions from being joined with the previously existing ones, even if they meet the merging criteria. It returns an id that can be later used to continue the session by calling this method with said id as an argument.
Parameters
[ id ] : null | string
Returns
null | string
stopDelegating( [ event ], [ emitter ] ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#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.
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:track-changes/trackchangesediting~TrackChangesEditing#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.
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
unbind( unbindProperties ) → void
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#unbind
Removes the binding created with bind.
```
// Removes the binding for the 'a' property.
A.unbind( 'a' );

// Removes bindings for all properties.
A.unbind();
```
Copy code
Parameters
unbindProperties : Array<'off' | 'set' | 'bind' | 'unbind' | 'decorate' | 'stopListening' | 'on' | 'once' | 'listenTo' | 'fire' | 'delegate' | 'stopDelegating' | 'destroy' | 'init' | 'isEnabled' | 'editor' | 'forceDisabled' | 'clearForceDisabled' | 'afterInit' | 'adapter' | '_adapter' | 'getSuggestions' | 'getSuggestion' | 'activeMarkers' | 'descriptionFactory' | 'trackChangesCommand' | '_suggestionFactory' | '_isForcedDefaultExecutionBlock' | '_recordAttributeSuggestions' | 'acceptSuggestion' | 'discardSuggestion' | 'hasSuggestion' | 'addSuggestionData' | 'enableCommand' | 'forceDefaultExecution' | 'markInsertion' | 'markMultiRangeInsertion' | 'markInlineFormat' | 'markBlockFormat' | 'markMultiRangeBlockFormat' | 'markDeletion' | 'markMultiRangeDeletion' | 'markAttributeChange' | 'enableDefaultAttributesIntegration' | 'registerBlockAttribute' | 'registerInlineAttribute' | 'startTrackingSession' | '_getAttributeKey' | '_applyOperationsAsSuggestions' | '_splitMarkerName' | '_findSuggestions' | '_setSuggestionData' | '_isBlockAttribute' | '_isInlineAttribute' | 'recordAttributeChanges' | '_isRegisteredAttribute'>
Observable properties to be unbound. All the bindings will be released if no properties are provided.
Returns
void

Events

change:activeMarkers( eventInfo, name, value, oldValue )

Fired when the activeMarkers property changed value.
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
Name of the changed property (activeMarkers).
value : Array<string>
New value of the activeMarkers property with given key or null, if operation should remove property.
oldValue : Array<string>
Old value of the activeMarkers property with given key or null, if property was not set before.
change:isEnabled( eventInfo, name, value, oldValue )
inherited

Fired when the isEnabled property changed value.
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
Name of the changed property (isEnabled).
value : boolean
New value of the isEnabled property with given key or null, if operation should remove property.
oldValue : boolean
Old value of the isEnabled property with given key or null, if property was not set before.
change:{property}( eventInfo, name, value, oldValue )
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#event:change:{property}
Fired when a property changed value.
```
observable.set( 'prop', 1 );

observable.on<ObservableChangeEvent<number>>( 'change:prop', ( evt, propertyName, newValue, oldValue ) => {
	console.log( `${ propertyName } has changed from ${ oldValue } to ${ newValue }` );
} );

observable.prop = 2; // -> 'prop has changed from 1 to 2'
```
Copy code
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
The property name.
value : TValue
The new property value.
oldValue : TValue
The previous property value.
set:activeMarkers( eventInfo, name, value, oldValue )

Fired when the activeMarkers property is going to be set but is not set yet (before the change event is fired).
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
Name of the changed property (activeMarkers).
value : Array<string>
New value of the activeMarkers property with given key or null, if operation should remove property.
oldValue : Array<string>
Old value of the activeMarkers property with given key or null, if property was not set before.
set:isEnabled( eventInfo, name, value, oldValue )
inherited

Fired when the isEnabled property is going to be set but is not set yet (before the change event is fired).
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
Name of the changed property (isEnabled).
value : boolean
New value of the isEnabled property with given key or null, if operation should remove property.
oldValue : boolean
Old value of the isEnabled property with given key or null, if property was not set before.
set:{property}( eventInfo, name, value, oldValue )
inherited
module:track-changes/trackchangesediting~TrackChangesEditing#event:set:{property}
Fired when a property value is going to be set but is not set yet (before the change event is fired).
You can control the final value of the property by using the event's return property.
```
observable.set( 'prop', 1 );

observable.on<ObservableSetEvent<number>>( 'set:prop', ( evt, propertyName, newValue, oldValue ) => {
	console.log( `Value is going to be changed from ${ oldValue } to ${ newValue }` );
	console.log( `Current property value is ${ observable[ propertyName ] }` );

	// Let's override the value.
	evt.return = 3;
} );

observable.on<ObservableChangeEvent<number>>( 'change:prop', ( evt, propertyName, newValue, oldValue ) => {
	console.log( `Value has changed from ${ oldValue } to ${ newValue }` );
} );

observable.prop = 2; // -> 'Value is going to be changed from 1 to 2'
                     // -> 'Current property value is 1'
                     // -> 'Value has changed from 1 to 3'
```
Copy code
Note: The event is fired even when the new value is the same as the old value.
Parameters
eventInfo : EventInfo
An object containing information about the fired event.
name : string
The property name.
value : TValue
The new property value.
oldValue : TValue
The previous property value.

TrackChangesEditing

Properties

activeMarkers : Array<string> Eye iconobservable

adapter : null | TrackChangesAdapter

Parameters

descriptionFactory : SuggestionDescriptionFactory

editor : Editorreadonlyinherited

isEnabled : booleanreadonlyinherited Eye iconobservable

trackChangesCommand : TrackChangesCommand

Static properties

isContextPlugin : falsereadonlyinheritedstatic

pluginName : 'TrackChangesEditing'readonlystatic

requires : readonly tuplereadonlystatic

Methods

constructor( editor )

Parameters

acceptSuggestion( suggestion ) → void

Parameters

Returns

addSuggestionData( data ) → Suggestion

Parameters

Returns

afterInit() → void

Returns

bind( bindProperty1, bindProperty2 ) → ObservableDualBindChain<K1, TrackChangesEditing[ K1 ], K2, TrackChangesEditing[ K2 ]>inherited

Type parameters

Parameters

Returns

bind( bindProperties ) → ObservableMultiBindChaininherited

Parameters

Returns

bind( bindProperty ) → ObservableSingleBindChain<K, TrackChangesEditing[ K ]>inherited

Type parameters

Parameters

Returns

clearForceDisabled( id ) → voidinherited

Parameters

Returns

decorate( methodName ) → voidinherited

Parameters

Returns

delegate( events ) → EmitterMixinDelegateChaininherited

Parameters

Returns

destroy() → voidinherited

Returns

discardSuggestion( suggestion ) → void

Parameters

Returns

enableCommand( commandName, [ callback ] ) → void

Parameters

Returns

enableDefaultAttributesIntegration( commandName ) → void

Parameters

Returns

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

Type parameters

Parameters

Returns

forceDefaultExecution( callback ) → unknown

Parameters

Returns

forceDisabled( id ) → voidinherited

Parameters

Returns

getSuggestion( id ) → Suggestion

Parameters

Returns

getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<SuggestionJSON>

Parameters

Returns

getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<Suggestion> | Array<SuggestionJSON>

Parameters

Returns

getSuggestions( [ options ] = { [options.skipNotAttached], [options.toJSON] } ) → Array<Suggestion>

Parameters

Returns

hasSuggestion( id ) → boolean

Parameters

Returns

`activeMarkers : Array<string>`
observable

`adapter : null | TrackChangesAdapter`

`descriptionFactory : SuggestionDescriptionFactory`

`editor : Editor`
readonlyinherited

`isEnabled : boolean`
readonlyinheritedobservable

`trackChangesCommand : TrackChangesCommand`

`isContextPlugin : false`
readonlyinheritedstatic

`pluginName : 'TrackChangesEditing'`
readonlystatic

`requires : readonly tuple`
readonlystatic

`constructor( editor )`

`acceptSuggestion( suggestion ) → void`

`addSuggestionData( data ) → Suggestion`

`afterInit() → void`

`bind( bindProperty1, bindProperty2 ) → ObservableDualBindChain<K1, TrackChangesEditing[ K1 ], K2, TrackChangesEditing[ K2 ]>`
inherited

`bind( bindProperties ) → ObservableMultiBindChain`
inherited

`bind( bindProperty ) → ObservableSingleBindChain<K, TrackChangesEditing[ K ]>`
inherited

`clearForceDisabled( id ) → void`
inherited

`decorate( methodName ) → void`
inherited

`delegate( events ) → EmitterMixinDelegateChain`
inherited

`destroy() → void`
inherited

`discardSuggestion( suggestion ) → void`

`enableCommand( commandName, [ callback ] ) → void`

`enableDefaultAttributesIntegration( commandName ) → void`

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

`forceDefaultExecution( callback ) → unknown`

`forceDisabled( id ) → void`
inherited

`getSuggestion( id ) → Suggestion`

`getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<SuggestionJSON>`

`getSuggestions( options = { [options.skipNotAttached], options.toJSON } ) → Array<Suggestion> | Array<SuggestionJSON>`

`getSuggestions( [ options ] = { [options.skipNotAttached], [options.toJSON] } ) → Array<Suggestion>`

`hasSuggestion( id ) → boolean`

`init() → void`

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

`markAttributeChange( range, key, oldValue, newValue, attributes = { attributes.groupId, attributes.[key: string] } ) → Array<Suggestion>`

`markBlockFormat( elementOrRange, formatData, affectedElements, subType, attributes ) → null | Suggestion`

`markDeletion( range, subType, attributes ) → null | Suggestion`

`markInlineFormat( range, formatData, subType, attributes ) → null`

`markInsertion( range, subType, attributes ) → null | Suggestion`

`markMultiRangeBlockFormat( elementsOrRanges, formatData, affectedElements, subType, attributes ) → null | Suggestion`

`markMultiRangeDeletion( ranges, subType, attributes ) → null | Suggestion`

`markMultiRangeInsertion( ranges, subType, attributes ) → Suggestion`

`off( event, callback ) → void`
inherited

`on( event, callback, [ options ] ) → void`
inherited

`once( event, callback, [ options ] ) → void`
inherited

`recordAttributeChanges( callback ) → void`

`registerBlockAttribute( attributeKey ) → void`

`registerInlineAttribute( attributeKey ) → void`

`set( values ) → void`
inherited

`set( name, value ) → void`
inherited

`startTrackingSession( [ id ] ) → null | string`

`stopDelegating( [ event ], [ emitter ] ) → void`
inherited

`stopListening( [ emitter ], [ event ], [ callback ] ) → void`
inherited

`unbind( unbindProperties ) → void`
inherited