@ckeditor/ckeditor5-watchdog 47.6.1 → 48.0.0-alpha.0

package/LICENSE.md

@@ -18,7 +18,7 @@ Where not otherwise indicated, all CKEditor 5 content is authored by CKSour
 
 The following libraries are included in CKEditor 5 under the [MIT license](https://opensource.org/licenses/MIT):
 
-* es-toolkit - Copyright (c) 2024 Viva Republica, Inc.
+* es-toolkit - Copyright (c) 2024 Viva Republica, Inc and Copyright OpenJS Foundation and other contributors.
 
 Trademarks
 ----------

package/ckeditor5-metadata.json

@@ -5,7 +5,7 @@
 			"className": "EditorWatchdog",
 			"description": "A utility that detects if an editor crashed, destroys it, and automatically creates a new instance of that editor with the content of the previous editor.",
 			"docs": "features/watchdog.html",
-			"path": "src/editorwatchdog.js"
+			"path": "src/editorwatchdog.ts"
 		}
 	]
 }

package/{src → dist}/contextwatchdog.d.ts

@@ -152,12 +152,12 @@ export declare class ContextWatchdog<TContext extends Context = Context> extends
      * await watchdog.add( [ {
      * 	id: 'editor1',
      * 	type: 'editor',
-     * 	sourceElementOrData: document.querySelector( '#editor' ),
      * 	config: {
+     * 		attachTo: document.querySelector( '#editor' ),
      * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
      * 		toolbar: [ 'bold', 'italic', 'alignment' ]
      * 	},
-     * 	creator: ( element, config ) => ClassicEditor.create( element, config )
+     * 	creator: config => ClassicEditor.create( config )
      * } ] );
      * ```
      *
@@ -167,13 +167,13 @@ export declare class ContextWatchdog<TContext extends Context = Context> extends
      * await watchdog.add( {
      * 	id: 'editor1',
      * 	type: 'editor',
-     * 	sourceElementOrData: document.querySelector( '#editor' ),
      * 	config: {
+     * 		attachTo: document.querySelector( '#editor' ),
      * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
      * 		toolbar: [ 'bold', 'italic', 'alignment' ]
      * 	},
-     * 	creator: ( element, config ) => ClassicEditor.create( element, config )
-     * ] );
+     * 	creator: config => ClassicEditor.create( config )
+     * } );
      * ```
      *
      * Then an instance can be retrieved using the {@link #getItem} method:
@@ -312,8 +312,8 @@ export interface ContextWatchdogItemConfiguration {
      */
     type: 'editor';
     /**
-     * A function that initializes the item (the editor). The function takes editor initialization arguments
-     * and should return a promise. For example: `( el, config ) => ClassicEditor.create( el, config )`.
+     * A function that initializes the item (the editor). The function takes the editor configuration
+     * and should return a promise. For example: `config => ClassicEditor.create( config )`.
      */
     creator: EditorWatchdogCreatorFunction;
     /**
@@ -324,8 +324,13 @@ export interface ContextWatchdogItemConfiguration {
     /**
      * The source element or data that will be passed
      * as the first argument to the `Editor.create()` method.
+     *
+     * When not provided, the watchdog will use config-based creator mode, passing only the {@link #config}
+     * to the editor creator.
+     *
+     * @deprecated
      */
-    sourceElementOrData: string | HTMLElement;
+    sourceElementOrData?: string | HTMLElement;
     /**
      * An editor configuration.
      */

package/{src → dist}/editorwatchdog.d.ts

@@ -41,9 +41,19 @@ export declare class EditorWatchdog<TEditor extends Editor = Editor> extends Wat
      */
     private _elementOrData?;
     /**
-     * Specifies whether the editor was initialized using document data (`true`) or HTML elements (`false`).
+     * Stores the original DOM element for single-root editors.
      */
-    private _initUsingData;
+    private _editorAttachTo;
+    /**
+     * Specifies whether the editor is a single-root editor (e.g. ClassicEditor) or a multi-root editor (e.g. MultiRootEditor).
+     */
+    private _isSingleRootEditor;
+    /**
+     * Specifies whether the editor was created using config-based creator mode (without a source element or data as the first argument).
+     *
+     * @internal
+     */
+    _isUsingConfigBasedCreator: boolean;
     /**
      * The latest record of the editor editable elements. Used to restart the editor.
      */
@@ -84,6 +94,14 @@ export declare class EditorWatchdog<TEditor extends Editor = Editor> extends Wat
      * Sets the function that is responsible for the editor creation.
      * It expects a function that should return a promise.
      *
+     * For config-based editor creation:
+     *
+     * ```ts
+     * watchdog.setCreator( config => ClassicEditor.create( config ) );
+     * ```
+     *
+     * For legacy editor creation (with element or data as the first argument):
+     *
      * ```ts
      * watchdog.setCreator( ( element, config ) => ClassicEditor.create( element, config ) );
      * ```
@@ -117,11 +135,21 @@ export declare class EditorWatchdog<TEditor extends Editor = Editor> extends Wat
     /**
      * Creates the editor instance and keeps it running, using the defined creator and destructor.
      *
+     * @param config The editor configuration.
+     * @param context A context for the editor.
+     */
+    create(config: EditorConfig, context?: Context): Promise<unknown>;
+    /**
+     * Creates the editor instance and keeps it running, using the defined creator and destructor.
+     *
+     * **Note**: This method signature is deprecated and will be removed in the future release.
+     *
+     * @deprecated
      * @param elementOrData The editor source element or the editor data.
      * @param config The editor configuration.
      * @param context A context for the editor.
      */
-    create(elementOrData?: HTMLElement | string | Record<string, string> | Record<string, HTMLElement>, config?: EditorConfig, context?: Context): Promise<unknown>;
+    create(elementOrData: HTMLElement | string | Record<string, string> | Record<string, HTMLElement>, config: EditorConfig, context?: Context): Promise<unknown>;
     /**
      * 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.
@@ -153,6 +181,11 @@ export declare class EditorWatchdog<TEditor extends Editor = Editor> extends Wat
      * @internal
      */
     _isErrorComingFromThisItem(error: CKEditorError): boolean;
+    /**
+     * Detects whether the `create()` call was made in config-based creator mode
+     * (i.e., the first argument is a config object rather than a source element or data).
+     */
+    private _detectConfigBasedCreator;
     /**
      * Clones the editor configuration.
      */
@@ -188,4 +221,4 @@ export type EditorWatchdogRestartEvent = {
     args: [];
     return: undefined;
 };
-export type EditorWatchdogCreatorFunction<TEditor = Editor> = (elementOrData: HTMLElement | string | Record<string, string> | Record<string, HTMLElement>, config: EditorConfig) => Promise<TEditor>;
+export type EditorWatchdogCreatorFunction<TEditor = Editor> = ((config: EditorConfig) => Promise<TEditor>) | ((elementOrData: HTMLElement | string | Record<string, string> | Record<string, HTMLElement> | undefined, config: EditorConfig) => Promise<TEditor>);

package/dist/index.css

@@ -2,3 +2,6 @@
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
+
+
+/*# sourceMappingURL=index.css.map */

package/dist/index.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.css"],"names":[],"mappings":";;;;;;AAEA,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC","file":"index.css.map","sourcesContent":["\n\n/*# sourceMappingURL=index.css.map */"]}

package/dist/index.js

@@ -2,7 +2,7 @@
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
  */
-import { throttle, isElement, cloneDeepWith, isPlainObject } from 'es-toolkit/compat';
+import { isElement as isElement$2, throttle, cloneDeepWith, isPlainObject as isPlainObject$1 } from 'es-toolkit/compat';
 
 /**
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -274,6 +274,82 @@ function isObject(structure) {
     return typeof structure === 'object' && structure !== null;
 }
 
+// Note: This file is a copy of core/editor/utils/normalizerootsconfig with some adjustments.
+// The main difference is that it does not use the `Config` class from `@ckeditor/ckeditor5-utils` and instead works
+// with a plain `EditorConfig` object. It also does not throw `CKEditorError` but a generic `Error` with a specific message.
+// It resolves root configuration for the editor, but does not care about real data in initialData as the watchdog does not need it.
+// It just needs to ensure that initialData is defined for all roots, so the editor features can work with it without additional checks.
+// Note that this helper modifies the provided config object.
+/**
+ * Normalizes the editor roots configuration. It ensures that all root configurations are defined in `config.roots`
+ * and that they have `initialData` defined.
+ *
+ * It normalizes a single-root configuration (where `config.root` is used) to a multi-root configuration
+ * (where all roots are defined in `config.roots`). This is considered a standard configuration format,
+ * so the editor features can always expect roots to be defined in `config.roots`.
+ *
+ * It also handles legacy configuration options, such as `config.initialData`, `config.placeholder`, and `config.label`.
+ *
+ * @internal
+ */ function normalizeRootsConfig(sourceElementsOrData, config, defaultRootName) {
+    const mainRootConfig = config.root;
+    const rootsConfig = config.roots || Object.create(null);
+    // Move `config.root` to `config.roots.main`.
+    // This makes access to root configuration more consistent as all roots will be defined in `config.roots`.
+    if (defaultRootName && !rootsConfig[defaultRootName]) {
+        rootsConfig[defaultRootName] = mainRootConfig || Object.create(null);
+    }
+    const sourceElementIsPlainObject = isPlainObject(sourceElementsOrData);
+    // Collect legacy configuration values for `initialData`, `placeholder`, and `label` from the config.
+    const legacyInitialData = getLegacyInitialData(config, sourceElementIsPlainObject, defaultRootName);
+    // Collect root names. This includes root names from the source element (if it's an object),
+    // from `config.roots`, and from legacy config. This ensures that all roots are processed in the next step.
+    const rootNames = Array.from(new Set([
+        ...sourceElementIsPlainObject ? Object.keys(sourceElementsOrData) : [],
+        ...Object.keys(rootsConfig),
+        ...Object.keys(legacyInitialData)
+    ]));
+    // Ensure that all roots have `initialData` defined. If not, try to get it from the source element or data.
+    for (const rootName of rootNames){
+        const rootConfig = rootsConfig[rootName] || Object.create(null);
+        // Watchdog does not need HTML, it uses dedicated plugin for restoring the model.
+        // As watchdog uses only DOM element or map of DOM elements for sourceElementsOrData,
+        // it can not use string as initial data, so it can be safely set to an empty string.
+        rootConfig.initialData = '';
+        // Handle legacy `config.placeholder` and `config.label` for the root.
+        rootConfig.placeholder ??= getLegacyPlainConfigValue(config, 'placeholder', rootName);
+        rootConfig.label ??= getLegacyPlainConfigValue(config, 'label', rootName);
+        rootsConfig[rootName] = rootConfig;
+    }
+    config.roots = rootsConfig;
+}
+/**
+ * Type guard to check if the provided value is a plain object.
+ */ function isPlainObject(sourceElementsOrData) {
+    return !!sourceElementsOrData && typeof sourceElementsOrData == 'object' && !Array.isArray(sourceElementsOrData) && !isElement$1(sourceElementsOrData);
+}
+/**
+ * Retrieve legacy configuration value for `initialData` from the config.
+ * Normalize single-root config so returned value is always an object with root names as keys.
+ */ function getLegacyInitialData(config, sourceElementIsObject, defaultRootName) {
+    return sourceElementIsObject || !defaultRootName ? config.initialData || Object.create(null) : {
+        [defaultRootName]: config.initialData
+    };
+}
+/**
+ * Retrieve legacy configuration value for `placeholder` or `label` from the config for a specific root.
+ */ function getLegacyPlainConfigValue(config, key, rootName) {
+    const legacyValue = config[key];
+    if (legacyValue) {
+        return typeof legacyValue == 'string' ? legacyValue : legacyValue[rootName];
+    }
+}
+/**
+ * An alias for `isElement` from `es-toolkit/compat` with additional type guard.
+ */ function isElement$1(value) {
+    return isElement$2(value);
+}
+
 /**
  * A watchdog for CKEditor 5 editors.
  *
@@ -303,8 +379,16 @@ function isObject(structure) {
 	 * The editor source element or data.
 	 */ _elementOrData;
     /**
-	 * Specifies whether the editor was initialized using document data (`true`) or HTML elements (`false`).
-	 */ _initUsingData = true;
+	 * Stores the original DOM element for single-root editors.
+	 */ _editorAttachTo = null;
+    /**
+	 * Specifies whether the editor is a single-root editor (e.g. ClassicEditor) or a multi-root editor (e.g. MultiRootEditor).
+	 */ _isSingleRootEditor = true;
+    /**
+	 * Specifies whether the editor was created using config-based creator mode (without a source element or data as the first argument).
+	 *
+	 * @internal
+	 */ _isUsingConfigBasedCreator = false;
     /**
 	 * The latest record of the editor editable elements. Used to restart the editor.
 	 */ _editables = {};
@@ -321,7 +405,14 @@ function isObject(structure) {
         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._creator = (elementOrDataOrConfig, config)=>{
+                if (config === undefined) {
+                    // Config-based mode: first argument is the config.
+                    return Editor.create(elementOrDataOrConfig);
+                }
+                // Legacy mode: first argument is element/data, second is config.
+                return Editor.create(elementOrDataOrConfig, config);
+            };
         }
         this._destructor = (editor)=>editor.destroy();
     }
@@ -339,6 +430,14 @@ function isObject(structure) {
 	 * Sets the function that is responsible for the editor creation.
 	 * It expects a function that should return a promise.
 	 *
+	 * For config-based editor creation:
+	 *
+	 * ```ts
+	 * watchdog.setCreator( config => ClassicEditor.create( config ) );
+	 * ```
+	 *
+	 * For legacy editor creation (with element or data as the first argument):
+	 *
 	 * ```ts
 	 * watchdog.setCreator( ( element, config ) => ClassicEditor.create( element, config ) );
 	 * ```
@@ -379,80 +478,98 @@ function isObject(structure) {
         }).then(()=>{
             // Pre-process some data from the original editor config.
             // Our goal here is to make sure that the restarted editor will be reinitialized with correct set of roots.
-            // We are not interested in any data set in config or in `.create()` first parameter. It will be replaced anyway.
+            // We are not interested in any data set in config. It will be replaced anyway.
             // But we need to set them correctly to make sure that proper roots are created.
             //
-            // Since a different set of roots will be created, `lazyRoots` and `rootsAttributes` properties must be managed too.
-            // Keys are root names, values are ''. Used when the editor was initialized by setting the first parameter to document data.
-            const existingRoots = {};
-            // Keeps lazy roots. They may be different when compared to initial config if some of the roots were loaded.
-            const lazyRoots = [];
-            // Roots attributes from the old config. Will be referred when setting new attributes.
-            const oldRootsAttributes = this._config.rootsAttributes || {};
-            // New attributes to be set. Is filled only for roots that still exist in the document.
-            const rootsAttributes = {};
-            // Traverse through the roots saved when the editor crashed and set up the discussed values.
-            for (const [rootName, rootData] of Object.entries(this._data.roots)){
-                if (rootData.isLoaded) {
-                    existingRoots[rootName] = '';
-                    rootsAttributes[rootName] = oldRootsAttributes[rootName] || {};
-                } else {
-                    lazyRoots.push(rootName);
-                }
+            // Since a different set of roots will be created, lazy-roots and roots-attributes must be managed too.
+            if (this._isUsingConfigBasedCreator) {
+                // In config-based creator mode, normalize using an empty source to ensure `config.root` is moved
+                // to `config.roots.main` and other legacy config properties are handled.
+                normalizeRootsConfig(this._isSingleRootEditor ? '' : {}, this._config, this._isSingleRootEditor ? 'main' : false);
+            } else {
+                // Normalize the roots configuration based on the editor source element or data and the editor configuration.
+                normalizeRootsConfig(this._isSingleRootEditor ? this._editorAttachTo || '' : this._editables, this._config, this._isSingleRootEditor ? 'main' : false);
             }
             const updatedConfig = {
                 ...this._config,
                 extraPlugins: this._config.extraPlugins || [],
-                lazyRoots,
-                rootsAttributes,
                 _watchdogInitialData: this._data
             };
-            // Delete `initialData` as it is not needed. Data will be set by the watchdog based on `_watchdogInitialData`.
-            // First parameter of the editor `.create()` will be used to set up initial roots.
-            delete updatedConfig.initialData;
+            // Add content loading plugin to the editor configuration.
+            // This plugin will be responsible for loading the editor data into the editor after it is restarted.
             updatedConfig.extraPlugins.push(EditorWatchdogInitPlugin);
-            if (this._initUsingData) {
-                return this.create(existingRoots, updatedConfig, updatedConfig.context);
-            } else {
-                // Set correct editables to make sure that proper roots are created and linked with DOM elements.
-                // No need to set initial data, as it would be discarded anyway.
-                //
-                // If one element was initially set in `elementOrData`, then use that original element to restart the editor.
-                // This is for compatibility purposes with single-root editor types.
-                if (isElement(this._elementOrData)) {
-                    return this.create(this._elementOrData, updatedConfig, updatedConfig.context);
+            // Collect existing roots configuration and update it. This will ensure that the same set of roots
+            // will be created after the restart, and they will have correct lazy loading and attributes configuration.
+            const updatedRootsConfig = {};
+            for (const [rootName, rootData] of Object.entries(this._data.roots)){
+                const rootConfig = updatedConfig.roots[rootName] || Object.create(null);
+                // Delete `initialData` as it is not needed. Data will be set by the watchdog based on `_watchdogInitialData`.
+                rootConfig.initialData = '';
+                if (rootData.isLoaded) {
+                    rootConfig.lazyLoad = false;
                 } else {
-                    return this.create(this._editables, updatedConfig, updatedConfig.context);
+                    delete rootConfig.modelAttributes;
                 }
+                updatedRootsConfig[rootName] = rootConfig;
             }
+            updatedConfig.roots = updatedRootsConfig;
+            // Delete `initialData` as it is not needed. Data will be set by the watchdog based on `_watchdogInitialData`.
+            delete updatedConfig.initialData;
+            // Also alias for main root should not provide initial data.
+            // In fact, it should not provide any data as it is only an alias for the root defined in `config.roots`
+            // and it is the `config.roots` that should be used to set up the initial data for the main root.
+            // This would cause a crash while normalizing conflict when left as is.
+            delete updatedConfig.root;
+            if (this._isUsingConfigBasedCreator) {
+                return this.create(updatedConfig, updatedConfig.context);
+            }
+            const elementOrData = this._isSingleRootEditor ? this._editorAttachTo || '' : this._editables;
+            return this.create(elementOrData, updatedConfig, updatedConfig.context);
         }).then(()=>{
             this._fire('restart');
         });
     }
-    /**
-	 * 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) {
+    create(elementOrDataOrConfig = this._isUsingConfigBasedCreator ? this._config : this._elementOrData, configOrContext = this._isUsingConfigBasedCreator ? undefined : this._config, context) {
+        // Detect config-based creator mode: first argument is a config object (not an element, string, or record of strings/elements).
+        // The detection is skipped during restart (when `_elementOrData` or `_config` is already set).
+        const isUsingConfigBasedCreator = this._detectConfigBasedCreator(elementOrDataOrConfig, configOrContext);
+        const elementOrData = isUsingConfigBasedCreator ? undefined : elementOrDataOrConfig;
+        const config = isUsingConfigBasedCreator ? elementOrDataOrConfig : configOrContext;
+        const resolvedContext = isUsingConfigBasedCreator ? configOrContext : context;
         this._lifecyclePromise = Promise.resolve(this._lifecyclePromise).then(()=>{
             super._startErrorHandling();
+            this._isUsingConfigBasedCreator = isUsingConfigBasedCreator;
             this._elementOrData = elementOrData;
-            // Use document data in the first parameter of the editor `.create()` call only if it was used like this originally.
-            // Use document data if a string or object with strings was passed.
-            this._initUsingData = typeof elementOrData == 'string' || Object.keys(elementOrData).length > 0 && typeof Object.values(elementOrData)[0] == 'string';
             // Clone configuration because it might be shared within multiple watchdog instances. Otherwise,
             // when an error occurs in one of these editors, the watchdog will restart all of them.
-            this._config = this._cloneEditorConfiguration(config) || {};
-            this._config.context = context;
+            this._config = this._cloneEditorConfiguration(config || {});
+            this._config.context = resolvedContext;
+            // Store the original DOM element for single-root editors. We can't use editable elements as ClassicEditor
+            // expects the attachment element.
+            if (isUsingConfigBasedCreator) {
+                // In config-based creator mode, element references are already in the config
+                // (`config.attachTo` or `config.roots.*.element`), so there's no need to store them separately.
+                this._editorAttachTo = null;
+                // Detect single-root vs multi-root from config. The config might use `config.root` (alias),
+                // `config.roots`, `config.attachTo`, or legacy `config.initialData`.
+                const rootsCount = this._config.roots ? Object.keys(this._config.roots).length : 0;
+                const legacyInitialData = this._config.initialData;
+                const isMultiRootFromLegacy = legacyInitialData && typeof legacyInitialData === 'object';
+                this._isSingleRootEditor = !isMultiRootFromLegacy && rootsCount <= 1;
+            } else {
+                this._editorAttachTo = isElement(elementOrData) ? elementOrData : null;
+                this._isSingleRootEditor = isElement(elementOrData) || typeof elementOrData == 'string';
+            }
+            if (isUsingConfigBasedCreator) {
+                return this._creator(this._config);
+            }
             return this._creator(elementOrData, this._config);
         }).then((editor)=>{
             this._editor = editor;
             editor.model.document.on('change:data', this._throttledSave);
             this._lastDocumentVersion = editor.model.document.version;
             this._data = this._getData();
-            if (!this._initUsingData) {
+            if (!this._editorAttachTo) {
                 this._editables = this._getEditables();
             }
             this.state = 'ready';
@@ -497,7 +614,7 @@ function isObject(structure) {
         const version = this._editor.model.document.version;
         try {
             this._data = this._getData();
-            if (!this._initUsingData) {
+            if (!this._editorAttachTo) {
                 this._editables = this._getEditables();
             }
             this._lastDocumentVersion = version;
@@ -576,6 +693,28 @@ function isObject(structure) {
 	 */ _isErrorComingFromThisItem(error) {
         return areConnectedThroughProperties(this._editor, error.context, this._excludedProps);
     }
+    /**
+	 * Detects whether the `create()` call was made in config-based creator mode
+	 * (i.e., the first argument is a config object rather than a source element or data).
+	 */ _detectConfigBasedCreator(elementOrDataOrConfig, configOrContext) {
+        // A string or DOM element is clearly the legacy signature.
+        if (typeof elementOrDataOrConfig === 'string' || isElement(elementOrDataOrConfig)) {
+            return false;
+        }
+        // If the second argument is a plain object with keys, it's a config → legacy signature.
+        if (configOrContext && typeof configOrContext === 'object' && !('destroy' in configOrContext) && Object.keys(configOrContext).length > 0) {
+            return false;
+        }
+        // If the first argument is an object where all values are strings or elements, it's multi-root legacy.
+        if (elementOrDataOrConfig && typeof elementOrDataOrConfig === 'object') {
+            const values = Object.values(elementOrDataOrConfig);
+            if (values.length > 0 && values.every((v)=>typeof v === 'string' || isElement(v))) {
+                return false;
+            }
+        }
+        // Otherwise, it's config-based.
+        return true;
+    }
     /**
 	 * Clones the editor configuration.
 	 */ _cloneEditorConfiguration(config) {
@@ -705,6 +844,11 @@ function isObject(structure) {
         }
     }
 }
+/**
+ * An alias for `isElement` from `es-toolkit/compat` with additional type guard.
+ */ function isElement(value) {
+    return isElement$2(value);
+}
 
 const mainQueueId = Symbol('MainQueueId');
 /**
@@ -850,12 +994,12 @@ const mainQueueId = Symbol('MainQueueId');
 	 * await watchdog.add( [ {
 	 * 	id: 'editor1',
 	 * 	type: 'editor',
-	 * 	sourceElementOrData: document.querySelector( '#editor' ),
 	 * 	config: {
+	 * 		attachTo: document.querySelector( '#editor' ),
 	 * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
 	 * 		toolbar: [ 'bold', 'italic', 'alignment' ]
 	 * 	},
-	 * 	creator: ( element, config ) => ClassicEditor.create( element, config )
+	 * 	creator: config => ClassicEditor.create( config )
 	 * } ] );
 	 * ```
 	 *
@@ -865,13 +1009,13 @@ const mainQueueId = Symbol('MainQueueId');
 	 * await watchdog.add( {
 	 * 	id: 'editor1',
 	 * 	type: 'editor',
-	 * 	sourceElementOrData: document.querySelector( '#editor' ),
 	 * 	config: {
+	 * 		attachTo: document.querySelector( '#editor' ),
 	 * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
 	 * 		toolbar: [ 'bold', 'italic', 'alignment' ]
 	 * 	},
-	 * 	creator: ( element, config ) => ClassicEditor.create( element, config )
-	 * ] );
+	 * 	creator: config => ClassicEditor.create( config )
+	 * } );
 	 * ```
 	 *
 	 * Then an instance can be retrieved using the {@link #getItem} method:
@@ -928,7 +1072,10 @@ const mainQueueId = Symbol('MainQueueId');
                                 watchdog.on('restart', rethrowRestartEventOnce);
                             }));
                     });
-                    return watchdog.create(item.sourceElementOrData, item.config, this._context);
+                    if (item.sourceElementOrData !== undefined) {
+                        return watchdog.create(item.sourceElementOrData, item.config, this._context);
+                    }
+                    return watchdog.create(item.config, this._context);
                 } else {
                     throw new Error(`Not supported item type: '${item.type}'.`);
                 }
@@ -996,6 +1143,9 @@ const mainQueueId = Symbol('MainQueueId');
             this._contextProps = getSubNodes(this._context);
             return Promise.all(Array.from(this._watchdogs.values()).map((watchdog)=>{
                 watchdog._setExcludedProperties(this._contextProps);
+                if (watchdog._isUsingConfigBasedCreator) {
+                    return watchdog.create(undefined, this._context);
+                }
                 return watchdog.create(undefined, undefined, this._context);
             }));
         });
@@ -1552,7 +1702,7 @@ const mainQueueId = Symbol('MainQueueId');
     if (typeof value.toJSON == 'function') {
         const jsonData = value.toJSON();
         // Make sure that toJSON returns plain object, otherwise it could be just a clone with circular references.
-        if (isPlainObject(jsonData) || Array.isArray(jsonData) || [
+        if (isPlainObject$1(jsonData) || Array.isArray(jsonData) || [
             'string',
             'number',
             'boolean'