Creates an instance of the plugin collection class. Allows loading and initializing plugins and their dependencies. Allows providing a list of already loaded plugins. These plugins will not be destroyed along with this collection.
OptionalavailablePlugins: Iterable<PluginConstructor<TContext>>Plugins (constructors) which the collection will be able to use
when module:core/plugincollection~PluginCollection#init is used with the plugin names (strings, instead of constructors).
Usually, the editor will pass its built-in plugins to the collection so they can later be
used in config.plugins or config.removePlugins by names.
OptionalcontextPlugins: Iterable<PluginEntry<TContext>>A list of already initialized plugins represented by a [ PluginConstructor, pluginInstance ] pair.
Iterable interface.
Returns [ PluginConstructor, pluginInstance ] pairs.
Delegates selected events to another module:utils/emittermixin~Emitter. For instance:
emitterA.delegate( 'eventX' ).to( emitterB );
emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
then eventX is delegated (fired by) emitterB and emitterC along with data:
emitterA.fire( 'eventX', data );
and eventY is delegated (fired by) emitterC along with data:
emitterA.fire( 'eventY', data );
Event names that will be delegated to another emitter.
Destroys all loaded plugins.
Fires an event, executing all callbacks registered for it.
The first parameter passed to callbacks is an module:utils/eventinfo~EventInfo object,
followed by the optional args provided in the fire() method call.
The type describing the event. See module:utils/emittermixin~BaseEvent.
The name of the event or EventInfo object if event is delegated.
Additional arguments to be passed to the callbacks.
By default the method returns undefined. However, the return value can be changed by listeners
through modification of the module:utils/eventinfo~EventInfo#return evt.return's property (the event info
is the first param of every callback).
Checks if a plugin is loaded.
// Check if the 'Clipboard' plugin was loaded.
if ( editor.plugins.has( 'ClipboardPipeline' ) ) {
// Now use the clipboard plugin instance:
const clipboard = editor.plugins.get( 'ClipboardPipeline' );
// ...
}
The plugin constructor or module:core/plugin~PluginStaticMembers#pluginName name.
Initializes a set of plugins and adds them to the collection.
An array of module:core/plugin~PluginInterface plugin constructors or module:core/plugin~PluginStaticMembers#pluginName plugin names.
OptionalpluginsToRemove: readonly (string | PluginConstructor<TContext>)[]Names of the plugins or plugin constructors
that should not be loaded (despite being specified in the plugins array).
OptionalpluginsSubstitutions: readonly PluginConstructor<TContext>[]An array of module:core/plugin~PluginInterface plugin constructors
that will be used to replace plugins of the same names that were passed in plugins or that are in their dependency tree.
A useful option for replacing built-in plugins while creating tests (for mocking their APIs). Plugins that will be replaced
must follow these rules:
A promise which gets resolved once all plugins are loaded and available in the collection.
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' );
An event callback can module:utils/eventinfo~EventInfo#stop stop the event and set the module:utils/eventinfo~EventInfo#return return value of the #fire method.
The type describing the event. See module:utils/emittermixin~BaseEvent.
The object that fires the event.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
Stops executing the callback on the given event.
Shorthand for #stopListening this.stopListening( this, event, callback ).
The name of the event.
The function to stop being called.
Registers a callback function to be executed when an event is fired.
Shorthand for #listenTo this.listenTo( this, event, callback, options ) (it makes the emitter
listen on itself).
The type descibing the event. See module:utils/emittermixin~BaseEvent.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
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.
The type descibing the event. See module:utils/emittermixin~BaseEvent.
The name of the event.
The function to be called on event.
Optionaloptions: GetCallbackOptions<TEvent>Additional options.
Stops delegating events. It can be used at different levels:
Optionalevent: stringThe name of the event to stop delegating. If omitted, stops it all delegations.
Optionalemitter: Emitter(requires event) The object to stop delegating a particular event to.
If omitted, stops delegation of event to all emitters.
Stops listening for events. It can be used at different levels:
Optionalemitter: EmitterThe object to stop listening to. If omitted, stops it for all objects.
Optionalevent: string(Requires the emitter) The name of the event to stop listening to. If omitted, stops it
for all events from emitter.
Optionalcallback: Function(Requires the event) The function to be removed from the call list for the given
event.
Manages a list of CKEditor plugins, including loading, resolving dependencies and initialization.