@ckeditor/ckeditor5-watchdog 41.4.2 → 42.0.0-alpha.0

package/dist/index.js

@@ -2,12 +2,15 @@
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-import { isElement, cloneDeepWith, throttle } from 'lodash-es';
+import { throttle, isElement, cloneDeepWith } from 'lodash-es';
 
 /**
  * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */ /**
+ * @module watchdog/watchdog
+ */ /* globals window */ // eslint-disable-next-line ckeditor5-rules/no-cross-package-imports
+/**
  * An abstract watchdog class that handles most of the error handling process and the state of the underlying component.
  *
  * See the {@glink features/watchdog Watchdog feature guide} to learn the rationale behind it and how to use it.
@@ -15,40 +18,96 @@ import { isElement, cloneDeepWith, throttle } from 'lodash-es';
  * @internal
  */ class Watchdog {
     /**
-     * Destroys the watchdog and releases the resources.
-     */ destroy() {
+	 * An array of crashes saved as an object with the following properties:
+	 *
+	 * * `message`: `String`,
+	 * * `stack`: `String`,
+	 * * `date`: `Number`,
+	 * * `filename`: `String | undefined`,
+	 * * `lineno`: `Number | undefined`,
+	 * * `colno`: `Number | undefined`,
+	 */ crashes = [];
+    /**
+	 * Specifies the state of the item watched by the watchdog. The state can be one of the following values:
+	 *
+	 * * `initializing` – Before the first initialization, and after crashes, before the item is ready.
+	 * * `ready` – A state when the user can interact with the item.
+	 * * `crashed` – A state when an error occurs. It quickly changes to `initializing` or `crashedPermanently`
+	 * depending on how many and how frequent errors have been caught recently.
+	 * * `crashedPermanently` – A state when the watchdog stops reacting to errors and keeps the item it is watching crashed,
+	 * * `destroyed` – A state when the item is manually destroyed by the user after calling `watchdog.destroy()`.
+	 */ state = 'initializing';
+    /**
+	 * @see module:watchdog/watchdog~WatchdogConfig
+	 */ _crashNumberLimit;
+    /**
+	 * Returns the result of the `Date.now()` call. It can be overridden in tests to mock time as some popular
+	 * approaches like `sinon.useFakeTimers()` do not work well with error handling.
+	 */ _now = Date.now;
+    /**
+	 * @see module:watchdog/watchdog~WatchdogConfig
+	 */ _minimumNonErrorTimePeriod;
+    /**
+	 * Checks if the event error comes from the underlying item and restarts the item.
+	 */ _boundErrorHandler;
+    /**
+	 * A dictionary of event emitter listeners.
+	 */ _listeners;
+    /**
+	 * @param {module:watchdog/watchdog~WatchdogConfig} config The watchdog plugin configuration.
+	 */ constructor(config){
+        this.crashes = [];
+        this._crashNumberLimit = typeof config.crashNumberLimit === 'number' ? config.crashNumberLimit : 3;
+        this._minimumNonErrorTimePeriod = typeof config.minimumNonErrorTimePeriod === 'number' ? config.minimumNonErrorTimePeriod : 5000;
+        this._boundErrorHandler = (evt)=>{
+            // `evt.error` is exposed by EventError while `evt.reason` is available in PromiseRejectionEvent.
+            const error = 'error' in evt ? evt.error : evt.reason;
+            // Note that `evt.reason` might be everything that is in the promise rejection.
+            // Similarly everything that is thrown lands in `evt.error`.
+            if (error instanceof Error) {
+                this._handleError(error, evt);
+            }
+        };
+        this._listeners = {};
+        if (!this._restart) {
+            throw new Error('The Watchdog class was split into the abstract `Watchdog` class and the `EditorWatchdog` class. ' + 'Please, use `EditorWatchdog` if you have used the `Watchdog` class previously.');
+        }
+    }
+    /**
+	 * Destroys the watchdog and releases the resources.
+	 */ destroy() {
         this._stopErrorHandling();
         this._listeners = {};
     }
     /**
-     * Starts listening to a specific event name by registering a callback that will be executed
-     * whenever an event with a given name fires.
-     *
-     * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
-     *
-     * @param eventName The event name.
-     * @param callback A callback which will be added to event listeners.
-     */ on(eventName, callback) {
+	 * Starts listening to a specific event name by registering a callback that will be executed
+	 * whenever an event with a given name fires.
+	 *
+	 * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+	 *
+	 * @param eventName The event name.
+	 * @param callback A callback which will be added to event listeners.
+	 */ on(eventName, callback) {
         if (!this._listeners[eventName]) {
             this._listeners[eventName] = [];
         }
         this._listeners[eventName].push(callback);
     }
     /**
-     * Stops listening to the specified event name by removing the callback from event listeners.
-     *
-     * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
-     *
-     * @param eventName The event name.
-     * @param callback A callback which will be removed from event listeners.
-     */ off(eventName, callback) {
+	 * Stops listening to the specified event name by removing the callback from event listeners.
+	 *
+	 * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+	 *
+	 * @param eventName The event name.
+	 * @param callback A callback which will be removed from event listeners.
+	 */ off(eventName, callback) {
         this._listeners[eventName] = this._listeners[eventName].filter((cb)=>cb !== callback);
     }
     /**
-     * Fires an event with a given event name and arguments.
-     *
-     * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
-     */ _fire(eventName, ...args) {
+	 * Fires an event with a given event name and arguments.
+	 *
+	 * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+	 */ _fire(eventName, ...args) {
         const callbacks = this._listeners[eventName] || [];
         for (const callback of callbacks){
             callback.apply(this, [
@@ -58,25 +117,25 @@ import { isElement, cloneDeepWith, throttle } from 'lodash-es';
         }
     }
     /**
-     * Starts error handling by attaching global error handlers.
-     */ _startErrorHandling() {
+	 * Starts error handling by attaching global error handlers.
+	 */ _startErrorHandling() {
         window.addEventListener('error', this._boundErrorHandler);
         window.addEventListener('unhandledrejection', this._boundErrorHandler);
     }
     /**
-     * Stops error handling by detaching global error handlers.
-     */ _stopErrorHandling() {
+	 * Stops error handling by detaching global error handlers.
+	 */ _stopErrorHandling() {
         window.removeEventListener('error', this._boundErrorHandler);
         window.removeEventListener('unhandledrejection', this._boundErrorHandler);
     }
     /**
-     * Checks if an error comes from the watched item and restarts it.
-     * It reacts to {@link module:utils/ckeditorerror~CKEditorError `CKEditorError` errors} only.
-     *
-     * @fires error
-     * @param error Error.
-     * @param evt An error event.
-     */ _handleError(error, evt) {
+	 * Checks if an error comes from the watched item and restarts it.
+	 * It reacts to {@link module:utils/ckeditorerror~CKEditorError `CKEditorError` errors} only.
+	 *
+	 * @fires error
+	 * @param error Error.
+	 * @param evt An error event.
+	 */ _handleError(error, evt) {
         // @if CK_DEBUG // const err = error as CKEditorError;
         // @if CK_DEBUG // if ( err.is && err.is( 'CKEditorError' ) && err.context === undefined ) {
         // @if CK_DEBUG // console.warn( 'The error is missing its context and Watchdog cannot restart the proper item.' );
@@ -107,18 +166,18 @@ import { isElement, cloneDeepWith, throttle } from 'lodash-es';
         }
     }
     /**
-     * Checks whether an error should be handled by the watchdog.
-     *
-     * @param error An error that was caught by the error handling process.
-     */ _shouldReactToError(error) {
+	 * Checks whether an error should be handled by the watchdog.
+	 *
+	 * @param error An error that was caught by the error handling process.
+	 */ _shouldReactToError(error) {
         return error.is && error.is('CKEditorError') && error.context !== undefined && // In some cases the watched item should not be restarted - e.g. during the item initialization.
         // That's why the `null` was introduced as a correct error context which does cause restarting.
         error.context !== null && // Do not react to errors if the watchdog is in states other than `ready`.
         this.state === 'ready' && this._isErrorComingFromThisItem(error);
     }
     /**
-     * Checks if the watchdog should restart the underlying item.
-     */ _shouldRestart() {
+	 * Checks if the watchdog should restart the underlying item.
+	 */ _shouldRestart() {
         if (this.crashes.length <= this._crashNumberLimit) {
             return true;
         }
@@ -127,50 +186,6 @@ import { isElement, cloneDeepWith, throttle } from 'lodash-es';
         const averageNonErrorTimePeriod = (lastErrorTime - firstMeaningfulErrorTime) / this._crashNumberLimit;
         return averageNonErrorTimePeriod > this._minimumNonErrorTimePeriod;
     }
-    /**
-     * @param {module:watchdog/watchdog~WatchdogConfig} config The watchdog plugin configuration.
-     */ constructor(config){
-        /**
-         * An array of crashes saved as an object with the following properties:
-         *
-         * * `message`: `String`,
-         * * `stack`: `String`,
-         * * `date`: `Number`,
-         * * `filename`: `String | undefined`,
-         * * `lineno`: `Number | undefined`,
-         * * `colno`: `Number | undefined`,
-         */ this.crashes = [];
-        /**
-         * Specifies the state of the item watched by the watchdog. The state can be one of the following values:
-         *
-         * * `initializing` &ndash; Before the first initialization, and after crashes, before the item is ready.
-         * * `ready` &ndash; A state when the user can interact with the item.
-         * * `crashed` &ndash; A state when an error occurs. It quickly changes to `initializing` or `crashedPermanently`
-         * depending on how many and how frequent errors have been caught recently.
-         * * `crashedPermanently` &ndash; A state when the watchdog stops reacting to errors and keeps the item it is watching crashed,
-         * * `destroyed` &ndash; A state when the item is manually destroyed by the user after calling `watchdog.destroy()`.
-         */ this.state = 'initializing';
-        /**
-         * Returns the result of the `Date.now()` call. It can be overridden in tests to mock time as some popular
-         * approaches like `sinon.useFakeTimers()` do not work well with error handling.
-         */ this._now = Date.now;
-        this.crashes = [];
-        this._crashNumberLimit = typeof config.crashNumberLimit === 'number' ? config.crashNumberLimit : 3;
-        this._minimumNonErrorTimePeriod = typeof config.minimumNonErrorTimePeriod === 'number' ? config.minimumNonErrorTimePeriod : 5000;
-        this._boundErrorHandler = (evt)=>{
-            // `evt.error` is exposed by EventError while `evt.reason` is available in PromiseRejectionEvent.
-            const error = 'error' in evt ? evt.error : evt.reason;
-            // Note that `evt.reason` might be everything that is in the promise rejection.
-            // Similarly everything that is thrown lands in `evt.error`.
-            if (error instanceof Error) {
-                this._handleError(error, evt);
-            }
-        };
-        this._listeners = {};
-        if (!this._restart) {
-            throw new Error('The Watchdog class was split into the abstract `Watchdog` class and the `EditorWatchdog` class. ' + 'Please, use `EditorWatchdog` if you have used the `Watchdog` class previously.');
-        }
-    }
 }
 
 /**
@@ -257,52 +272,108 @@ function isObject(structure) {
     return typeof structure === 'object' && structure !== null;
 }
 
-class EditorWatchdog extends Watchdog {
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */ /**
+ * @module watchdog/editorwatchdog
+ */ /* globals console */ // eslint-disable-next-line ckeditor5-rules/no-cross-package-imports
+/**
+ * A watchdog for CKEditor 5 editors.
+ *
+ * See the {@glink features/watchdog Watchdog feature guide} to learn the rationale behind it and
+ * how to use it.
+ */ class EditorWatchdog extends Watchdog {
+    /**
+	 * The current editor instance.
+	 */ _editor = null;
+    /**
+	 * A promise associated with the life cycle of the editor (creation or destruction processes).
+	 *
+	 * It is used to prevent the initialization of the editor if the previous instance has not been destroyed yet,
+	 * and conversely, to prevent the destruction of the editor if it has not been initialized.
+	 */ _lifecyclePromise = null;
+    /**
+	 * Throttled save method. The `save()` method is called the specified `saveInterval` after `throttledSave()` is called,
+	 * unless a new action happens in the meantime.
+	 */ _throttledSave;
+    /**
+	 * The latest saved editor data represented as a root name -> root data object.
+	 */ _data;
+    /**
+	 * The last document version.
+	 */ _lastDocumentVersion;
+    /**
+	 * The editor source element or data.
+	 */ _elementOrData;
+    /**
+	 * Specifies whether the editor was initialized using document data (`true`) or HTML elements (`false`).
+	 */ _initUsingData = true;
+    /**
+	 * The latest record of the editor editable elements. Used to restart the editor.
+	 */ _editables = {};
+    /**
+	 * The editor configuration.
+	 */ _config;
+    _excludedProps;
+    /**
+	 * @param Editor The editor class.
+	 * @param watchdogConfig The watchdog plugin configuration.
+	 */ constructor(Editor, watchdogConfig = {}){
+        super(watchdogConfig);
+        // this._editorClass = Editor;
+        this._throttledSave = throttle(this._save.bind(this), typeof watchdogConfig.saveInterval === 'number' ? watchdogConfig.saveInterval : 5000);
+        // Set default creator and destructor functions:
+        if (Editor) {
+            this._creator = (elementOrData, config)=>Editor.create(elementOrData, config);
+        }
+        this._destructor = (editor)=>editor.destroy();
+    }
     /**
-     * The current editor instance.
-     */ get editor() {
+	 * The current editor instance.
+	 */ get editor() {
         return this._editor;
     }
     /**
-     * @internal
-     */ get _item() {
+	 * @internal
+	 */ get _item() {
         return this._editor;
     }
     /**
-     * Sets the function that is responsible for the editor creation.
-     * It expects a function that should return a promise.
-     *
-     * ```ts
-     * watchdog.setCreator( ( element, config ) => ClassicEditor.create( element, config ) );
-     * ```
-     */ setCreator(creator) {
+	 * Sets the function that is responsible for the editor creation.
+	 * It expects a function that should return a promise.
+	 *
+	 * ```ts
+	 * watchdog.setCreator( ( element, config ) => ClassicEditor.create( element, config ) );
+	 * ```
+	 */ setCreator(creator) {
         this._creator = creator;
     }
     /**
-     * Sets the function that is responsible for the editor destruction.
-     * Overrides the default destruction function, which destroys only the editor instance.
-     * It expects a function that should return a promise or `undefined`.
-     *
-     * ```ts
-     * watchdog.setDestructor( editor => {
-     * 	// Do something before the editor is destroyed.
-     *
-     * 	return editor
-     * 		.destroy()
-     * 		.then( () => {
-     * 			// Do something after the editor is destroyed.
-     * 		} );
-     * } );
-     * ```
-     */ setDestructor(destructor) {
+	 * Sets the function that is responsible for the editor destruction.
+	 * Overrides the default destruction function, which destroys only the editor instance.
+	 * It expects a function that should return a promise or `undefined`.
+	 *
+	 * ```ts
+	 * watchdog.setDestructor( editor => {
+	 * 	// Do something before the editor is destroyed.
+	 *
+	 * 	return editor
+	 * 		.destroy()
+	 * 		.then( () => {
+	 * 			// Do something after the editor is destroyed.
+	 * 		} );
+	 * } );
+	 * ```
+	 */ setDestructor(destructor) {
         this._destructor = destructor;
     }
     /**
-     * Restarts the editor instance. This method is called whenever an editor error occurs. It fires the `restart` event and changes
-     * the state to `initializing`.
-     *
-     * @fires restart
-     */ _restart() {
+	 * Restarts the editor instance. This method is called whenever an editor error occurs. It fires the `restart` event and changes
+	 * the state to `initializing`.
+	 *
+	 * @fires restart
+	 */ _restart() {
         return Promise.resolve().then(()=>{
             this.state = 'initializing';
             this._fire('stateChange');
@@ -363,12 +434,12 @@ class EditorWatchdog extends Watchdog {
         });
     }
     /**
-     * Creates the editor instance and keeps it running, using the defined creator and destructor.
-     *
-     * @param elementOrData The editor source element or the editor data.
-     * @param config The editor configuration.
-     * @param context A context for the editor.
-     */ create(elementOrData = this._elementOrData, config = this._config, context) {
+	 * Creates the editor instance and keeps it running, using the defined creator and destructor.
+	 *
+	 * @param elementOrData The editor source element or the editor data.
+	 * @param config The editor configuration.
+	 * @param context A context for the editor.
+	 */ create(elementOrData = this._elementOrData, config = this._config, context) {
         this._lifecyclePromise = Promise.resolve(this._lifecyclePromise).then(()=>{
             super._startErrorHandling();
             this._elementOrData = elementOrData;
@@ -396,10 +467,10 @@ class EditorWatchdog extends Watchdog {
         return this._lifecyclePromise;
     }
     /**
-     * Destroys the watchdog and the current editor instance. It fires the callback
-     * registered in {@link #setDestructor `setDestructor()`} and uses it to destroy the editor instance.
-     * It also sets the state to `destroyed`.
-     */ destroy() {
+	 * Destroys the watchdog and the current editor instance. It fires the callback
+	 * registered in {@link #setDestructor `setDestructor()`} and uses it to destroy the editor instance.
+	 * It also sets the state to `destroyed`.
+	 */ destroy() {
         this._lifecyclePromise = Promise.resolve(this._lifecyclePromise).then(()=>{
             this.state = 'destroyed';
             this._fire('stateChange');
@@ -424,9 +495,9 @@ class EditorWatchdog extends Watchdog {
         });
     }
     /**
-     * Saves the editor data, so it can be restored after the crash even if the data cannot be fetched at
-     * the moment of the crash.
-     */ _save() {
+	 * Saves the editor data, so it can be restored after the crash even if the data cannot be fetched at
+	 * the moment of the crash.
+	 */ _save() {
         const version = this._editor.model.document.version;
         try {
             this._data = this._getData();
@@ -439,13 +510,13 @@ class EditorWatchdog extends Watchdog {
         }
     }
     /**
-     * @internal
-     */ _setExcludedProperties(props) {
+	 * @internal
+	 */ _setExcludedProperties(props) {
         this._excludedProps = props;
     }
     /**
-     * Gets all data that is required to reinitialize editor instance.
-     */ _getData() {
+	 * Gets all data that is required to reinitialize editor instance.
+	 */ _getData() {
         const editor = this._editor;
         const roots = editor.model.document.roots.filter((root)=>root.isAttached() && root.rootName != '$graveyard');
         const { plugins } = editor;
@@ -490,8 +561,8 @@ class EditorWatchdog extends Watchdog {
         return data;
     }
     /**
-     * For each attached model root, returns its HTML editable element (if available).
-     */ _getEditables() {
+	 * For each attached model root, returns its HTML editable element (if available).
+	 */ _getEditables() {
         const editables = {};
         for (const rootName of this.editor.model.document.getRootNames()){
             const editable = this.editor.ui.getEditableElement(rootName);
@@ -502,16 +573,16 @@ class EditorWatchdog extends Watchdog {
         return editables;
     }
     /**
-     * Traverses the error context and the current editor to find out whether these structures are connected
-     * to each other via properties.
-     *
-     * @internal
-     */ _isErrorComingFromThisItem(error) {
+	 * Traverses the error context and the current editor to find out whether these structures are connected
+	 * to each other via properties.
+	 *
+	 * @internal
+	 */ _isErrorComingFromThisItem(error) {
         return areConnectedThroughProperties(this._editor, error.context, this._excludedProps);
     }
     /**
-     * Clones the editor configuration.
-     */ _cloneEditorConfiguration(config) {
+	 * Clones the editor configuration.
+	 */ _cloneEditorConfiguration(config) {
         return cloneDeepWith(config, (value, key)=>{
             // Leave DOM references.
             if (isElement(value)) {
@@ -522,42 +593,20 @@ class EditorWatchdog extends Watchdog {
             }
         });
     }
-    /**
-     * @param Editor The editor class.
-     * @param watchdogConfig The watchdog plugin configuration.
-     */ constructor(Editor, watchdogConfig = {}){
-        super(watchdogConfig);
-        /**
-         * The current editor instance.
-         */ this._editor = null;
-        /**
-         * A promise associated with the life cycle of the editor (creation or destruction processes).
-         *
-         * It is used to prevent the initialization of the editor if the previous instance has not been destroyed yet,
-         * and conversely, to prevent the destruction of the editor if it has not been initialized.
-         */ this._lifecyclePromise = null;
-        /**
-         * Specifies whether the editor was initialized using document data (`true`) or HTML elements (`false`).
-         */ this._initUsingData = true;
-        /**
-         * The latest record of the editor editable elements. Used to restart the editor.
-         */ this._editables = {};
-        // this._editorClass = Editor;
-        this._throttledSave = throttle(this._save.bind(this), typeof watchdogConfig.saveInterval === 'number' ? watchdogConfig.saveInterval : 5000);
-        // Set default creator and destructor functions:
-        if (Editor) {
-            this._creator = (elementOrData, config)=>Editor.create(elementOrData, config);
-        }
-        this._destructor = (editor)=>editor.destroy();
-    }
 }
 /**
  * Internal plugin that is used to stop the default editor initialization and restoring the editor state
  * based on the `editor.config._watchdogInitialData` data.
  */ class EditorWatchdogInitPlugin {
+    editor;
+    _data;
+    constructor(editor){
+        this.editor = editor;
+        this._data = editor.config.get('_watchdogInitialData');
+    }
     /**
-     * @inheritDoc
-     */ init() {
+	 * @inheritDoc
+	 */ init() {
         // Stops the default editor initialization and use the saved data to restore the editor state.
         // Some of data could not be initialize as a config properties. It is important to keep the data
         // in the same form as it was before the restarting.
@@ -576,8 +625,8 @@ class EditorWatchdog extends Watchdog {
         });
     }
     /**
-     * Creates a model node (element or text) based on provided JSON.
-     */ _createNode(writer, jsonNode) {
+	 * Creates a model node (element or text) based on provided JSON.
+	 */ _createNode(writer, jsonNode) {
         if ('name' in jsonNode) {
             // If child has name property, it is an Element.
             const element = writer.createElement(jsonNode.name, jsonNode.attributes);
@@ -593,8 +642,8 @@ class EditorWatchdog extends Watchdog {
         }
     }
     /**
-     * Restores the editor by setting the document data, roots attributes and markers.
-     */ _restoreEditorData(writer) {
+	 * Restores the editor by setting the document data, roots attributes and markers.
+	 */ _restoreEditorData(writer) {
         const editor = this.editor;
         Object.entries(this._data.roots).forEach(([rootName, { content, attributes }])=>{
             const parsedNodes = JSON.parse(content);
@@ -622,8 +671,8 @@ class EditorWatchdog extends Watchdog {
         });
     }
     /**
-     * Restores the editor collaboration data - comment threads and suggestions.
-     */ _restoreCollaborationData() {
+	 * Restores the editor collaboration data - comment threads and suggestions.
+	 */ _restoreCollaborationData() {
         // `as any` to avoid linking from external private repo.
         const parsedCommentThreads = JSON.parse(this._data.commentThreads);
         const parsedSuggestions = JSON.parse(this._data.suggestions);
@@ -649,136 +698,193 @@ class EditorWatchdog extends Watchdog {
             }
         });
     }
-    constructor(editor){
-        this.editor = editor;
-        this._data = editor.config.get('_watchdogInitialData');
-    }
 }
 
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */ /**
+ * @module watchdog/contextwatchdog
+ */ /* globals console */ // eslint-disable-next-line ckeditor5-rules/no-cross-package-imports
 const mainQueueId = Symbol('MainQueueId');
-class ContextWatchdog extends Watchdog {
-    /**
-     * Sets the function that is responsible for the context creation.
-     * It expects a function that should return a promise (or `undefined`).
-     *
-     * ```ts
-     * watchdog.setCreator( config => Context.create( config ) );
-     * ```
-     */ setCreator(creator) {
+/**
+ * A watchdog for the {@link module:core/context~Context} class.
+ *
+ * See the {@glink features/watchdog Watchdog feature guide} to learn the rationale behind it and
+ * how to use it.
+ */ class ContextWatchdog extends Watchdog {
+    /**
+	 * A map of internal watchdogs for added items.
+	 */ _watchdogs = new Map();
+    /**
+	 * The watchdog configuration.
+	 */ _watchdogConfig;
+    /**
+	 * The current context instance.
+	 */ _context = null;
+    /**
+	 * Context properties (nodes/references) that are gathered during the initial context creation
+	 * and are used to distinguish the origin of an error.
+	 */ _contextProps = new Set();
+    /**
+	 * An action queue, which is used to handle async functions queuing.
+	 */ _actionQueues = new ActionQueues();
+    /**
+	 * The configuration for the {@link module:core/context~Context}.
+	 */ _contextConfig;
+    /**
+	 * The watched item.
+	 */ _item;
+    /**
+	 * The context watchdog class constructor.
+	 *
+	 * ```ts
+	 * const watchdog = new ContextWatchdog( Context );
+	 *
+	 * await watchdog.create( contextConfiguration );
+	 *
+	 * await watchdog.add( item );
+	 * ```
+	 *
+	 * See the {@glink features/watchdog Watchdog feature guide} to learn more how to use this feature.
+	 *
+	 * @param Context The {@link module:core/context~Context} class.
+	 * @param watchdogConfig The watchdog configuration.
+	 */ constructor(Context, watchdogConfig = {}){
+        super(watchdogConfig);
+        this._watchdogConfig = watchdogConfig;
+        // Default creator and destructor.
+        this._creator = (contextConfig)=>Context.create(contextConfig);
+        this._destructor = (context)=>context.destroy();
+        this._actionQueues.onEmpty(()=>{
+            if (this.state === 'initializing') {
+                this.state = 'ready';
+                this._fire('stateChange');
+            }
+        });
+    }
+    /**
+	 * Sets the function that is responsible for the context creation.
+	 * It expects a function that should return a promise (or `undefined`).
+	 *
+	 * ```ts
+	 * watchdog.setCreator( config => Context.create( config ) );
+	 * ```
+	 */ setCreator(creator) {
         this._creator = creator;
     }
     /**
-     * Sets the function that is responsible for the context destruction.
-     * Overrides the default destruction function, which destroys only the context instance.
-     * It expects a function that should return a promise (or `undefined`).
-     *
-     * ```ts
-     * watchdog.setDestructor( context => {
-     * 	// Do something before the context is destroyed.
-     *
-     * 	return context
-     * 		.destroy()
-     * 		.then( () => {
-     * 			// Do something after the context is destroyed.
-     * 		} );
-     * } );
-     * ```
-     */ setDestructor(destructor) {
+	 * Sets the function that is responsible for the context destruction.
+	 * Overrides the default destruction function, which destroys only the context instance.
+	 * It expects a function that should return a promise (or `undefined`).
+	 *
+	 * ```ts
+	 * watchdog.setDestructor( context => {
+	 * 	// Do something before the context is destroyed.
+	 *
+	 * 	return context
+	 * 		.destroy()
+	 * 		.then( () => {
+	 * 			// Do something after the context is destroyed.
+	 * 		} );
+	 * } );
+	 * ```
+	 */ setDestructor(destructor) {
         this._destructor = destructor;
     }
     /**
-     * The context instance. Keep in mind that this property might be changed when the context watchdog restarts,
-     * so do not keep this instance internally. Always operate on the `ContextWatchdog#context` property.
-     */ get context() {
+	 * The context instance. Keep in mind that this property might be changed when the context watchdog restarts,
+	 * so do not keep this instance internally. Always operate on the `ContextWatchdog#context` property.
+	 */ get context() {
         return this._context;
     }
     /**
-     * Initializes the context watchdog. Once it is created, the watchdog takes care about
-     * recreating the context and the provided items, and starts the error handling mechanism.
-     *
-     * ```ts
-     * await watchdog.create( {
-     * 	plugins: []
-     * } );
-     * ```
-     *
-     * @param contextConfig The context configuration. See {@link module:core/context~Context}.
-     */ create(contextConfig = {}) {
+	 * Initializes the context watchdog. Once it is created, the watchdog takes care about
+	 * recreating the context and the provided items, and starts the error handling mechanism.
+	 *
+	 * ```ts
+	 * await watchdog.create( {
+	 * 	plugins: []
+	 * } );
+	 * ```
+	 *
+	 * @param contextConfig The context configuration. See {@link module:core/context~Context}.
+	 */ create(contextConfig = {}) {
         return this._actionQueues.enqueue(mainQueueId, ()=>{
             this._contextConfig = contextConfig;
             return this._create();
         });
     }
     /**
-     * Returns an item instance with the given `itemId`.
-     *
-     * ```ts
-     * const editor1 = watchdog.getItem( 'editor1' );
-     * ```
-     *
-     * @param itemId The item ID.
-     * @returns The item instance or `undefined` if an item with a given ID has not been found.
-     */ getItem(itemId) {
+	 * Returns an item instance with the given `itemId`.
+	 *
+	 * ```ts
+	 * const editor1 = watchdog.getItem( 'editor1' );
+	 * ```
+	 *
+	 * @param itemId The item ID.
+	 * @returns The item instance or `undefined` if an item with a given ID has not been found.
+	 */ getItem(itemId) {
         const watchdog = this._getWatchdog(itemId);
         return watchdog._item;
     }
     /**
-     * Gets the state of the given item. See {@link #state} for a list of available states.
-     *
-     * ```ts
-     * const editor1State = watchdog.getItemState( 'editor1' );
-     * ```
-     *
-     * @param itemId Item ID.
-     * @returns The state of the item.
-     */ getItemState(itemId) {
+	 * Gets the state of the given item. See {@link #state} for a list of available states.
+	 *
+	 * ```ts
+	 * const editor1State = watchdog.getItemState( 'editor1' );
+	 * ```
+	 *
+	 * @param itemId Item ID.
+	 * @returns The state of the item.
+	 */ getItemState(itemId) {
         const watchdog = this._getWatchdog(itemId);
         return watchdog.state;
     }
     /**
-     * Adds items to the watchdog. Once created, instances of these items will be available using the {@link #getItem} method.
-     *
-     * Items can be passed together as an array of objects:
-     *
-     * ```ts
-     * await watchdog.add( [ {
-     * 	id: 'editor1',
-     * 	type: 'editor',
-     * 	sourceElementOrData: document.querySelector( '#editor' ),
-     * 	config: {
-     * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
-     * 		toolbar: [ 'bold', 'italic', 'alignment' ]
-     * 	},
-     * 	creator: ( element, config ) => ClassicEditor.create( element, config )
-     * } ] );
-     * ```
-     *
-     * Or one by one as objects:
-     *
-     * ```ts
-     * await watchdog.add( {
-     * 	id: 'editor1',
-     * 	type: 'editor',
-     * 	sourceElementOrData: document.querySelector( '#editor' ),
-     * 	config: {
-     * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
-     * 		toolbar: [ 'bold', 'italic', 'alignment' ]
-     * 	},
-     * 	creator: ( element, config ) => ClassicEditor.create( element, config )
-     * ] );
-     * ```
-     *
-     * Then an instance can be retrieved using the {@link #getItem} method:
-     *
-     * ```ts
-     * const editor1 = watchdog.getItem( 'editor1' );
-     * ```
-     *
-     * Note that this method can be called multiple times, but for performance reasons it is better
-     * to pass all items together.
-     *
-     * @param itemConfigurationOrItemConfigurations An item configuration object or an array of item configurations.
-     */ add(itemConfigurationOrItemConfigurations) {
+	 * Adds items to the watchdog. Once created, instances of these items will be available using the {@link #getItem} method.
+	 *
+	 * Items can be passed together as an array of objects:
+	 *
+	 * ```ts
+	 * await watchdog.add( [ {
+	 * 	id: 'editor1',
+	 * 	type: 'editor',
+	 * 	sourceElementOrData: document.querySelector( '#editor' ),
+	 * 	config: {
+	 * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
+	 * 		toolbar: [ 'bold', 'italic', 'alignment' ]
+	 * 	},
+	 * 	creator: ( element, config ) => ClassicEditor.create( element, config )
+	 * } ] );
+	 * ```
+	 *
+	 * Or one by one as objects:
+	 *
+	 * ```ts
+	 * await watchdog.add( {
+	 * 	id: 'editor1',
+	 * 	type: 'editor',
+	 * 	sourceElementOrData: document.querySelector( '#editor' ),
+	 * 	config: {
+	 * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
+	 * 		toolbar: [ 'bold', 'italic', 'alignment' ]
+	 * 	},
+	 * 	creator: ( element, config ) => ClassicEditor.create( element, config )
+	 * ] );
+	 * ```
+	 *
+	 * Then an instance can be retrieved using the {@link #getItem} method:
+	 *
+	 * ```ts
+	 * const editor1 = watchdog.getItem( 'editor1' );
+	 * ```
+	 *
+	 * Note that this method can be called multiple times, but for performance reasons it is better
+	 * to pass all items together.
+	 *
+	 * @param itemConfigurationOrItemConfigurations An item configuration object or an array of item configurations.
+	 */ add(itemConfigurationOrItemConfigurations) {
         const itemConfigurations = toArray(itemConfigurationOrItemConfigurations);
         return Promise.all(itemConfigurations.map((item)=>{
             return this._actionQueues.enqueue(item.id, ()=>{
@@ -830,20 +936,20 @@ class ContextWatchdog extends Watchdog {
         }));
     }
     /**
-     * Removes and destroys item(s) with given ID(s).
-     *
-     * ```ts
-     * await watchdog.remove( 'editor1' );
-     * ```
-     *
-     * Or
-     *
-     * ```ts
-     * await watchdog.remove( [ 'editor1', 'editor2' ] );
-     * ```
-     *
-     * @param itemIdOrItemIds Item ID or an array of item IDs.
-     */ remove(itemIdOrItemIds) {
+	 * Removes and destroys item(s) with given ID(s).
+	 *
+	 * ```ts
+	 * await watchdog.remove( 'editor1' );
+	 * ```
+	 *
+	 * Or
+	 *
+	 * ```ts
+	 * await watchdog.remove( [ 'editor1', 'editor2' ] );
+	 * ```
+	 *
+	 * @param itemIdOrItemIds Item ID or an array of item IDs.
+	 */ remove(itemIdOrItemIds) {
         const itemIds = toArray(itemIdOrItemIds);
         return Promise.all(itemIds.map((itemId)=>{
             return this._actionQueues.enqueue(itemId, ()=>{
@@ -854,13 +960,13 @@ class ContextWatchdog extends Watchdog {
         }));
     }
     /**
-     * Destroys the context watchdog and all added items.
-     * Once the context watchdog is destroyed, new items cannot be added.
-     *
-     * ```ts
-     * await watchdog.destroy();
-     * ```
-     */ destroy() {
+	 * Destroys the context watchdog and all added items.
+	 * Once the context watchdog is destroyed, new items cannot be added.
+	 *
+	 * ```ts
+	 * await watchdog.destroy();
+	 * ```
+	 */ destroy() {
         return this._actionQueues.enqueue(mainQueueId, ()=>{
             this.state = 'destroyed';
             this._fire('stateChange');
@@ -869,8 +975,8 @@ class ContextWatchdog extends Watchdog {
         });
     }
     /**
-     * Restarts the context watchdog.
-     */ _restart() {
+	 * Restarts the context watchdog.
+	 */ _restart() {
         return this._actionQueues.enqueue(mainQueueId, ()=>{
             this.state = 'initializing';
             this._fire('stateChange');
@@ -880,8 +986,8 @@ class ContextWatchdog extends Watchdog {
         });
     }
     /**
-     * Initializes the context watchdog.
-     */ _create() {
+	 * Initializes the context watchdog.
+	 */ _create() {
         return Promise.resolve().then(()=>{
             this._startErrorHandling();
             return this._creator(this._contextConfig);
@@ -895,8 +1001,8 @@ class ContextWatchdog extends Watchdog {
         });
     }
     /**
-     * Destroys the context instance and all added items.
-     */ _destroy() {
+	 * Destroys the context instance and all added items.
+	 */ _destroy() {
         return Promise.resolve().then(()=>{
             this._stopErrorHandling();
             const context = this._context;
@@ -907,10 +1013,10 @@ class ContextWatchdog extends Watchdog {
         });
     }
     /**
-     * Returns the watchdog for a given item ID.
-     *
-     * @param itemId Item ID.
-     */ _getWatchdog(itemId) {
+	 * Returns the watchdog for a given item ID.
+	 *
+	 * @param itemId Item ID.
+	 */ _getWatchdog(itemId) {
         const watchdog = this._watchdogs.get(itemId);
         if (!watchdog) {
             throw new Error(`Item with the given id was not registered: ${itemId}.`);
@@ -918,10 +1024,10 @@ class ContextWatchdog extends Watchdog {
         return watchdog;
     }
     /**
-     * Checks whether an error comes from the context instance and not from the item instances.
-     *
-     * @internal
-     */ _isErrorComingFromThisItem(error) {
+	 * Checks whether an error comes from the context instance and not from the item instances.
+	 *
+	 * @internal
+	 */ _isErrorComingFromThisItem(error) {
         for (const watchdog of this._watchdogs.values()){
             if (watchdog._isErrorComingFromThisItem(error)) {
                 return false;
@@ -929,64 +1035,26 @@ class ContextWatchdog extends Watchdog {
         }
         return areConnectedThroughProperties(this._context, error.context);
     }
-    /**
-     * The context watchdog class constructor.
-     *
-     * ```ts
-     * const watchdog = new ContextWatchdog( Context );
-     *
-     * await watchdog.create( contextConfiguration );
-     *
-     * await watchdog.add( item );
-     * ```
-     *
-     * See the {@glink features/watchdog Watchdog feature guide} to learn more how to use this feature.
-     *
-     * @param Context The {@link module:core/context~Context} class.
-     * @param watchdogConfig The watchdog configuration.
-     */ constructor(Context, watchdogConfig = {}){
-        super(watchdogConfig);
-        /**
-         * A map of internal watchdogs for added items.
-         */ this._watchdogs = new Map();
-        /**
-         * The current context instance.
-         */ this._context = null;
-        /**
-         * Context properties (nodes/references) that are gathered during the initial context creation
-         * and are used to distinguish the origin of an error.
-         */ this._contextProps = new Set();
-        /**
-         * An action queue, which is used to handle async functions queuing.
-         */ this._actionQueues = new ActionQueues();
-        this._watchdogConfig = watchdogConfig;
-        // Default creator and destructor.
-        this._creator = (contextConfig)=>Context.create(contextConfig);
-        this._destructor = (context)=>context.destroy();
-        this._actionQueues.onEmpty(()=>{
-            if (this.state === 'initializing') {
-                this.state = 'ready';
-                this._fire('stateChange');
-            }
-        });
-    }
 }
 /**
  * Manager of action queues that allows queuing async functions.
  */ class ActionQueues {
+    _onEmptyCallbacks = [];
+    _queues = new Map();
+    _activeActions = 0;
     /**
-     * Used to register callbacks that will be run when the queue becomes empty.
-     *
-     * @param onEmptyCallback A callback that will be run whenever the queue becomes empty.
-     */ onEmpty(onEmptyCallback) {
+	 * Used to register callbacks that will be run when the queue becomes empty.
+	 *
+	 * @param onEmptyCallback A callback that will be run whenever the queue becomes empty.
+	 */ onEmpty(onEmptyCallback) {
         this._onEmptyCallbacks.push(onEmptyCallback);
     }
     /**
-     * It adds asynchronous actions (functions) to the proper queue and runs them one by one.
-     *
-     * @param queueId The action queue ID.
-     * @param action A function that should be enqueued.
-     */ enqueue(queueId, action) {
+	 * It adds asynchronous actions (functions) to the proper queue and runs them one by one.
+	 *
+	 * @param queueId The action queue ID.
+	 * @param action A function that should be enqueued.
+	 */ enqueue(queueId, action) {
         const isMainAction = queueId === mainQueueId;
         this._activeActions++;
         if (!this._queues.get(queueId)) {
@@ -1010,11 +1078,6 @@ class ContextWatchdog extends Watchdog {
             }
         });
     }
-    constructor(){
-        this._onEmptyCallbacks = [];
-        this._queues = new Map();
-        this._activeActions = 0;
-    }
 }
 /**
  * Transforms any value to an array. If the provided value is already an array, it is returned unchanged.