@ckeditor/ckeditor5-core 48.0.0-alpha.7 → 48.0.0-alpha.9

package/dist/editor/editorconfig.d.ts

@@ -126,8 +126,9 @@ export interface EditorConfig extends EngineConfig {
      * plugins can read and/or modify it during initialization.
      *
      * **This property has been deprecated and will be removed in the future versions of CKEditor. Please use
-     * {@link module:core/editor/editorconfig~EditorConfig#root `root.initialData`} or
-     * {@link module:core/editor/editorconfig~EditorConfig#roots `roots.<rootName>.initialData`} instead.**
+     * {@link module:core/editor/editorconfig~EditorConfig#root `config.root.initialData`} instead.
+     * For the {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}, use
+     * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.initialData`}.**
      *
      * @deprecated
      */
@@ -571,8 +572,9 @@ export interface EditorConfig extends EngineConfig {
      * See the {@glink features/editor-placeholder "Editor placeholder"} guide for more information and live examples.
      *
      * **This property has been deprecated and will be removed in the future versions of CKEditor. Please use
-     * {@link module:core/editor/editorconfig~EditorConfig#root `root.placeholder`} or
-     * {@link module:core/editor/editorconfig~EditorConfig#roots `roots.<rootName>.placeholder`} instead.**
+     * {@link module:core/editor/editorconfig~EditorConfig#root `config.root.placeholder`} instead.
+     * For the {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}, use
+     * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.placeholder`}.**
      *
      * @deprecated
      */
@@ -856,14 +858,16 @@ export interface EditorConfig extends EngineConfig {
      */
     translations?: ArrayOrItem<Translations>;
     /**
-     * Label text for the `aria-label` attribute set on editor editing area. Used by assistive technologies
-     * to tell apart multiple editor instances (editing areas) on the page. If not set, a default
-     * "Rich Text Editor. Editing area [name of the area]" is used instead.
+     * Label which briefly describes the editing area. Used for the `aria-label` attribute set on the editor editing area,
+     * helping assistive technologies to tell apart multiple editor instances (editing areas) on the page. If not set,
+     * a default "Rich Text Editor. Editing area [name of the area]" is used instead.
+     *
+     * It can also be used by other features when referring to this editing area (e.g. AI features).
      *
      * ```ts
      * ClassicEditor
      * 	.create( document.querySelector( '#editor' ), {
-     * 		label: 'My editor'
+     * 		label: 'Article main content'
      * 	} )
      * 	.then( ... )
      * 	.catch( ... );
@@ -878,16 +882,16 @@ export interface EditorConfig extends EngineConfig {
      * 	{
      * 		header: document.querySelector( '#header' ),
      * 		content: document.querySelector( '#content' ),
-     * 		leftSide: document.querySelector( '#left-side' ),
-     * 		rightSide: document.querySelector( '#right-side' )
+     * 		sideQuote: document.querySelector( '#side-quote' ),
+     * 		relatedLinks: document.querySelector( '#related-links' )
      * 	},
      * 	// Config:
      * 	{
      * 		label: {
-     * 			header: 'Header label',
-     * 			content: 'Content label',
-     * 			leftSide: 'Left side label',
-     * 			rightSide: 'Right side label'
+     * 			header: 'Article header',
+     * 			content: 'Article main content',
+     * 			sideQuote: 'Side-quote',
+     * 			relatedLinks: 'Related links'
      * 		}
      * 	}
      * )
@@ -896,43 +900,192 @@ export interface EditorConfig extends EngineConfig {
      * ```
      *
      * **This property has been deprecated and will be removed in the future versions of CKEditor. Please use
-     * {@link module:core/editor/editorconfig~EditorConfig#root `root.label`} or
-     * {@link module:core/editor/editorconfig~EditorConfig#roots `roots.<rootName>.label`} instead.**
+     * {@link module:core/editor/editorconfig~EditorConfig#root `config.root.label`} instead.
+     * For the {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}, use
+     * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots.<rootName>.label`}.**
      *
      * @deprecated
      */
     label?: string | Record<string, string>;
     /**
-     * The root configuration options for the default `main` root.
+     * The root configuration for the default `main` root. Use this option to configure the initial data,
+     * placeholder, label, and source element for a single-root editor.
      *
-     * This option is an alias for `config.roots.main`.
-     */
-    root?: RootConfig;
-    /**
-     * The root configuration options grouped by the root name.
+     * This is the recommended way to configure a single-root editor:
      *
      * ```ts
+     * // Classic editor – uses `attachTo` for the source element.
      * ClassicEditor
      * 	.create( {
      * 		attachTo: document.querySelector( '#editor' ),
-     * 		roots: {
-     * 			main: {
-     * 				initialData: '<p>Hello world!</p>',
-     * 				placeholder: 'Type some text...',
-     * 				label: 'Main content'
-     * 			}
+     * 		root: {
+     * 			initialData: '<p>Hello world!</p>',
+     * 			placeholder: 'Type some text...'
      * 		}
-     * 	} );
+     * 	} )
+     * 	.then( ... )
+     * 	.catch( ... );
+     * ```
+     *
+     * ```ts
+     * // Inline editor – uses `root.element` for the source element.
+     * InlineEditor
+     * 	.create( {
+     * 		root: {
+     * 			element: document.querySelector( '#editor' ),
+     * 			initialData: '<p>Hello world!</p>',
+     * 			placeholder: 'Type some text...'
+     * 		}
+     * 	} )
+     * 	.then( ... )
+     * 	.catch( ... );
+     * ```
+     *
+     * ```ts
+     * // Balloon editor – uses `root.element` for the source element.
+     * BalloonEditor
+     * 	.create( {
+     * 		root: {
+     * 			element: document.querySelector( '#editor' ),
+     * 			placeholder: 'Type some text...'
+     * 		}
+     * 	} )
+     * 	.then( ... )
+     * 	.catch( ... );
+     * ```
+     *
+     * ```ts
+     * // Decoupled editor – uses `root.element` for the source element.
+     * // The toolbar and editable area must be manually added to the DOM.
+     * DecoupledEditor
+     * 	.create( {
+     * 		root: {
+     * 			element: document.querySelector( '#editor' ),
+     * 			initialData: '<p>Hello world!</p>'
+     * 		}
+     * 	} )
+     * 	.then( editor => {
+     * 		document.querySelector( '#toolbar' ).appendChild( editor.ui.view.toolbar.element );
+     * 	} )
+     * 	.catch( ... );
+     * ```
+     *
+     * Internally, this option is an alias for `config.roots.main`. If both `config.root` and `config.roots.main`
+     * are set, an error will be thrown.
+     *
+     * For the {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}, use the
+     * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots`} option instead to define
+     * configuration for each root individually.
+     */
+    root?: RootConfig;
+    /**
+     * The root configuration options grouped by the root name. This option is used primarily by the
+     * {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor} to define
+     * configuration for each root individually.
+     *
+     * For a typical single-root editor, use the simpler {@link module:core/editor/editorconfig~EditorConfig#root `config.root`}
+     * option instead.
+     *
+     * ```ts
+     * // Using existing DOM elements as source for each root.
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			element: document.querySelector( '#header' ),
+     * 			placeholder: 'Type header...',
+     * 			label: 'Article header'
+     * 		},
+     * 		content: {
+     * 			element: document.querySelector( '#content' ),
+     * 			placeholder: 'Type content...',
+     * 			label: 'Article main content'
+     * 		}
+     * 	}
+     * } )
+     * .then( editor => {
+     * 	document.querySelector( '#toolbar' ).appendChild( editor.ui.view.toolbar.element );
+     * } )
+     * .catch( ... );
+     * ```
+     *
+     * ```ts
+     * // Creating a detached editor with initial data for each root.
+     * MultiRootEditor.create( {
+     * 	roots: {
+     * 		header: {
+     * 			initialData: '<h2>Article title</h2>',
+     * 			placeholder: 'Type header...',
+     * 			label: 'Article header'
+     * 		},
+     * 		content: {
+     * 			initialData: '<p>Article body...</p>',
+     * 			placeholder: 'Type content...',
+     * 			label: 'Article main content'
+     * 		}
+     * 	}
+     * } )
+     * .then( editor => {
+     * 	document.querySelector( '#toolbar' ).appendChild( editor.ui.view.toolbar.element );
+     *
+     * 	for ( const rootName of editor.ui.getEditableElementsNames() ) {
+     * 		document.querySelector( '#editables' ).appendChild( editor.ui.view.getEditable( rootName ).element );
+     * 	}
+     * } )
+     * .catch( ... );
      * ```
      */
     roots?: Record<string, RootConfig>;
 }
 /**
- * Configuration for a an editor root. It is used in {@link module:core/editor/editorconfig~EditorConfig#root `EditorConfig#root`} and
+ * Configuration for an editor root. It is used in {@link module:core/editor/editorconfig~EditorConfig#root `EditorConfig#root`} and
  * {@link module:core/editor/editorconfig~EditorConfig#roots `EditorConfig#roots.<rootName>`}.
  *
- * **Note**: If your editor implementation uses only a single root, you can use `config.root` to set the root configuration instead of
- * `config.roots.main`.
+ * For a typical single-root editor (Classic, Inline, Balloon, Decoupled), use
+ * {@link module:core/editor/editorconfig~EditorConfig#root `config.root`} to set the root configuration.
+ * For the {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}, use
+ * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots`} to define configuration for each root.
+ *
+ * ```ts
+ * // Classic editor – the source element is set via `config.attachTo`.
+ * ClassicEditor.create( {
+ * 	attachTo: document.querySelector( '#editor' ),
+ * 	root: {
+ * 		initialData: '<p>Hello world!</p>',
+ * 		placeholder: 'Type some text...',
+ * 		label: 'Article main content'
+ * 	}
+ * } );
+ * ```
+ *
+ * ```ts
+ * // Inline editor – the source element is set via `root.element`.
+ * InlineEditor.create( {
+ * 	root: {
+ * 		element: document.querySelector( '#editor' ),
+ * 		initialData: '<p>Hello world!</p>',
+ * 		placeholder: 'Type some text...',
+ * 		label: 'Article main content'
+ * 	}
+ * } );
+ * ```
+ *
+ * ```ts
+ * // Multi-root editor – each root is configured separately via `config.roots`.
+ * MultiRootEditor.create( {
+ * 	roots: {
+ * 		header: {
+ * 			element: document.querySelector( '#header' ),
+ * 			placeholder: 'Type header...',
+ * 			label: 'Article header'
+ * 		},
+ * 		content: {
+ * 			element: document.querySelector( '#content' ),
+ * 			placeholder: 'Type content...',
+ * 			label: 'Article main content'
+ * 		}
+ * 	}
+ * } );
+ * ```
  */
 export interface RootConfig {
     /**
@@ -949,7 +1102,8 @@ export interface RootConfig {
      */
     element?: HTMLElement;
     /**
-     * The initial editor data to be used instead of the provided element's HTML content.
+     * The initial editor data to be used instead of the HTML content of the
+     * {@link module:core/editor/editorconfig~RootConfig#element source element}.
      *
      * ```ts
      * ClassicEditor
@@ -963,7 +1117,7 @@ export interface RootConfig {
      * 	.catch( ... );
      * ```
      *
-     * By default, the editor is initialized with the content of the element on which this editor is initialized.
+     * By default, the editor is initialized with the content of the source element on which this editor root is initialized.
      * This configuration option lets you override this behavior and pass different initial data.
      * It is especially useful if it is difficult for your integration to put the data inside the HTML element.
      *
@@ -995,13 +1149,6 @@ export interface RootConfig {
      * ```
      *
      * See also {@link module:core/editor/editor~Editor.create Editor.create()} documentation for the editor implementation which you use.
-     *
-     * **Note:** If initial data is passed to `Editor.create()` in the first parameter (instead of a DOM element), and,
-     * at the same time, root `initialData` is set, an error will be thrown as those two options exclude themselves.
-     *
-     * If `config.root.initialData` is not set when the editor is initialized, the data received in `Editor.create()` call
-     * will be used to set `config.roots.main.initialData`. As a result, `config.roots.main.initialData` is always set
-     * in the editor's config and plugins can read and/or modify it during initialization.
      */
     initialData?: string;
     /**
@@ -1069,16 +1216,20 @@ export interface RootConfig {
      */
     placeholder?: string;
     /**
-     * Label text for the `aria-label` attribute set on editor editing area. Used by assistive technologies
+     * Label which briefly describes this editing area.
+     *
+     * It is used for the `aria-label` attribute set on the editor editing area, helping assistive technologies
      * to tell apart multiple editor instances (editing areas) on the page. If not set, a default
      * "Rich Text Editor. Editing area [name of the area]" is used instead.
      *
+     * It can also be used by other features when referring to this editing area (e.g. AI features).
+     *
      * ```ts
      * ClassicEditor
      * 	.create( {
      * 		attachTo: document.querySelector( '#editor' ),
      * 		root: {
-     * 			label: 'My editor'
+     * 			label: 'Article main content'
      * 		}
      * 	} )
      * 	.then( ... )
@@ -1092,19 +1243,19 @@ export interface RootConfig {
      * 	roots: {
      * 		header: {
      * 			element: document.querySelector( '#header' ),
-     * 			label: 'Header label'
+     * 			label: 'Article header'
      * 		},
      * 		content: {
      * 			element: document.querySelector( '#content' ),
-     * 			label: 'Content label'
+     * 			label: 'Article main content'
      * 		},
-     * 		leftSide: {
-     * 			element: document.querySelector( '#left-side' ),
-     * 			label: 'Left side label'
+     * 		sideQuote: {
+     * 			element: document.querySelector( '#side-quote' ),
+     * 			label: 'Side-quote'
      * 		},
-     * 		rightSide: {
-     * 			element: document.querySelector( '#right-side' ),
-     * 			label: 'Right side label'
+     * 		relatedLinks: {
+     * 			element: document.querySelector( '#related-links' ),
+     * 			label: 'Related links'
      * 		}
      * 	}
      * } )
@@ -1114,22 +1265,6 @@ export interface RootConfig {
      */
     label?: string;
 }
-/**
- * The `config.initialData` option cannot be used together with `config.root.initialData` or
- * `config.roots.<rootName>.initialData` passed in the {@link module:core/editor/editor~Editor.create `Editor.create()`} configuration.
- *
- * @error editor-create-initial-data
- */
-/**
- * The `config.initialData` option cannot be used together with the `config.root.initialData` or `config.roots.main.initialData`.
- *
- * @error editor-create-roots-initial-data
- */
-/**
- * The `config.attachTo` option is available only for the {@link module:editor-classic/classiceditor~ClassicEditor}.
- *
- * @error editor-create-attachto-ignored
- */
 /**
  * The configuration of the editor language.
  *

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 { ObservableMixin, insertToPriorityArray, CKEditorError, EmitterMixin, Config, Locale, Collection, KeystrokeHandler, env, global, uid, decodeLicenseKey, toArray, crc32, releaseDate, logError, isFeatureBlockedByLicenseKey, setDataInElement, getDataFromElement } from '@ckeditor/ckeditor5-utils/dist/index.js';
+import { ObservableMixin, insertToPriorityArray, CKEditorError, EmitterMixin, Config, Locale, Collection, KeystrokeHandler, env, global, uid, decodeLicenseKey, toArray, crc32, releaseDate, logError, isFeatureBlockedByLicenseKey, setDataInElement, logWarning, getDataFromElement } from '@ckeditor/ckeditor5-utils/dist/index.js';
 import { get, set, isFunction, isElement as isElement$1 } from 'es-toolkit/compat';
 import { Model, StylesProcessor, DataController, EditingController, Conversion } from '@ckeditor/ckeditor5-engine/dist/index.js';
 import { EditorWatchdog, ContextWatchdog } from '@ckeditor/ckeditor5-watchdog/dist/index.js';
@@ -2896,10 +2896,40 @@ function isTextArea(sourceElement) {
     const mainRootConfig = config.get('root');
     const rootsConfig = config.get('roots') || Object.create(null);
     // Avoid mixing `config.root` and `config.roots.main`.
-    if (mainRootConfig && (!defaultRootName || defaultRootName in rootsConfig)) {
-        // Documented in core/editor/editorconfig.ts.
-        // eslint-disable-next-line ckeditor5-rules/ckeditor-error-message
-        throw new CKEditorError('editor-create-roots-initial-data');
+    if (mainRootConfig) {
+        if (!defaultRootName) {
+            /**
+			 * The {@link module:core/editor/editorconfig~EditorConfig#root `config.root`} option is designed
+			 * for single-root editors and cannot be used with the
+			 * {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}.
+			 *
+			 * To configure a multi-root editor, define each root individually using
+			 * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots`}:
+			 *
+			 * ```ts
+			 * MultiRootEditor.create( {
+			 * 	roots: {
+			 * 		header: { initialData: '<p>Header</p>' },
+			 * 		content: { initialData: '<p>Content</p>' }
+			 * 	}
+			 * } );
+			 * ```
+			 *
+			 * @error editor-create-multi-root-with-main
+			 */ throw new CKEditorError('editor-create-multi-root-with-main', null);
+        } else if (defaultRootName in rootsConfig) {
+            /**
+			 * Both {@link module:core/editor/editorconfig~EditorConfig#root `config.root`} and
+			 * `config.roots.main` are set, but they both configure the same default editing root,
+			 * which creates an ambiguity. Use one or the other:
+			 *
+			 * * {@link module:core/editor/editorconfig~EditorConfig#root `config.root`} for a single-root editor.
+			 * * {@link module:core/editor/editorconfig~EditorConfig#roots `config.roots`} when defining
+			 * multiple roots.
+			 *
+			 * @error editor-create-roots-with-main
+			 */ throw new CKEditorError('editor-create-roots-with-main', 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`.
@@ -2920,32 +2950,87 @@ function isTextArea(sourceElement) {
     for (const rootName of rootNames){
         const rootConfig = rootsConfig[rootName] || Object.create(null);
         const sourceElementOrDataForRoot = sourceElementIsPlainObject ? sourceElementsOrData[rootName] : sourceElementsOrData;
+        // Assign `sourceElement` to root config if it's an element.
+        if (!separateAttachTo && isElement(sourceElementOrDataForRoot)) {
+            if (rootConfig.element) {
+                /**
+				 * The root element is specified both as the first argument of the editor `create()` method
+				 * (e.g. {@link module:editor-inline/inlineeditor~InlineEditor.create `InlineEditor.create()`} or
+				 * {@link module:editor-multi-root/multirooteditor~MultiRootEditor.create `MultiRootEditor.create()`})
+				 * and in {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}
+				 * (or `config.roots.<rootName>.element` for the
+				 * {@link module:editor-multi-root/multirooteditor~MultiRootEditor multi-root editor}).
+				 *
+				 * Passing the element as the first argument is deprecated. Remove it and use
+				 * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}
+				 * (or `config.roots.<rootName>.element` for the multi-root editor) instead.
+				 *
+				 * @error editor-create-root-element-overspecified
+				 */ throw new CKEditorError('editor-create-root-element-overspecified', null);
+            }
+            rootConfig.element = sourceElementOrDataForRoot;
+        }
+        if (separateAttachTo && isElement(rootConfig.element)) {
+            /**
+			 * The {@link module:editor-classic/classiceditor~ClassicEditor} ignores
+			 * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`} because
+			 * the classic editor replaces the DOM element with its own UI rather than editing inline within it.
+			 * Use {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`}
+			 * to specify the DOM element the editor should replace.
+			 *
+			 * @error editor-create-root-element-not-supported
+			 */ logWarning('editor-create-root-element-not-supported');
+        }
         // No dedicated initial data for the root.
         if (rootConfig.initialData === undefined) {
             // No legacy initial data for the root, either.
             if (legacyInitialData[rootName] === undefined) {
                 // Use source element data or data itself as a string.
-                // Fall back to `rootConfig.element` or `config.attachTo` (for ClassicEditor) for data extraction.
+                // Fall back to legacy sourceElement, `rootConfig.element` or `config.attachTo` (for ClassicEditor) for data extraction.
                 rootConfig.initialData = getInitialData(sourceElementOrDataForRoot || rootConfig.element || separateAttachTo && config.get('attachTo') || '');
             } else if (sourceElementOrDataForRoot && !isElement(sourceElementOrDataForRoot)) {
-                // Documented in core/editor/editorconfig.ts.
-                // eslint-disable-next-line ckeditor5-rules/ckeditor-error-message
-                throw new CKEditorError('editor-create-initial-data', null);
+                /**
+				 * The initial data is specified both as the first argument of the editor `create()` method
+				 * (e.g. {@link module:editor-inline/inlineeditor~InlineEditor.create `InlineEditor.create()`} or
+				 * {@link module:editor-multi-root/multirooteditor~MultiRootEditor.create `MultiRootEditor.create()`})
+				 * and in the deprecated {@link module:core/editor/editorconfig~EditorConfig#initialData `config.initialData`}.
+				 *
+				 * Passing initial data as the first argument is deprecated. Remove it and use
+				 * {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}
+				 * (or `config.roots.<rootName>.initialData` for the multi-root editor) instead.
+				 *
+				 * @error editor-create-initial-data-overspecified
+				 */ throw new CKEditorError('editor-create-initial-data-overspecified', null);
             } else {
                 rootConfig.initialData = legacyInitialData[rootName];
             }
         } else if (sourceElementOrDataForRoot && !isElement(sourceElementOrDataForRoot)) {
-            // Documented in core/editor/editorconfig.ts.
-            // eslint-disable-next-line ckeditor5-rules/ckeditor-error-message
-            throw new CKEditorError('editor-create-initial-data', null);
+            /**
+			 * The initial data is specified both as the first argument of the editor `create()` method
+			 * (e.g. {@link module:editor-inline/inlineeditor~InlineEditor.create `InlineEditor.create()`} or
+			 * {@link module:editor-multi-root/multirooteditor~MultiRootEditor.create `MultiRootEditor.create()`})
+			 * and in {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}
+			 * (or `config.roots.<rootName>.initialData` for the multi-root editor).
+			 *
+			 * Passing initial data as the first argument is deprecated. Remove it and use
+			 * {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}
+			 * (or `config.roots.<rootName>.initialData` for the multi-root editor) instead.
+			 *
+			 * @error editor-create-root-initial-data-overspecified
+			 */ throw new CKEditorError('editor-create-root-initial-data-overspecified', null);
         } else if (legacyInitialData[rootName] !== undefined) {
-            // Documented in core/editor/editorconfig.ts.
-            // eslint-disable-next-line ckeditor5-rules/ckeditor-error-message
-            throw new CKEditorError('editor-create-roots-initial-data');
-        }
-        // Assign `sourceElement` to root config if it's an element.
-        if (!separateAttachTo && isElement(sourceElementOrDataForRoot)) {
-            rootConfig.element = sourceElementOrDataForRoot;
+            /**
+			 * The initial data is specified both in
+			 * {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}
+			 * (or `config.roots.<rootName>.initialData` for the multi-root editor) and in the deprecated
+			 * {@link module:core/editor/editorconfig~EditorConfig#initialData `config.initialData`}.
+			 *
+			 * The `config.initialData` option is deprecated. Remove it and use
+			 * {@link module:core/editor/editorconfig~RootConfig#initialData `config.root.initialData`}
+			 * (or `config.roots.<rootName>.initialData` for the multi-root editor) instead.
+			 *
+			 * @error editor-create-legacy-initial-data-overspecified
+			 */ throw new CKEditorError('editor-create-legacy-initial-data-overspecified', null);
         }
         // Handle legacy `config.placeholder` and `config.label` for the root.
         rootConfig.placeholder ??= getLegacyPlainConfigValue(config, 'placeholder', rootName);
@@ -2954,9 +3039,36 @@ function isTextArea(sourceElement) {
     }
     // The ClassicEditor has a special separate config option `attachTo`.
     // It is used as a source of editor data and attachment element, but not the root element.
-    if (separateAttachTo && config.get('attachTo') === undefined && isElement(sourceElementsOrData)) {
+    if (separateAttachTo && isElement(sourceElementsOrData)) {
+        if (config.get('attachTo')) {
+            /**
+			 * The element to attach the editor to is specified both as the first argument of
+			 * {@link module:editor-classic/classiceditor~ClassicEditor.create `ClassicEditor.create()`}
+			 * and in {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`}.
+			 *
+			 * Passing the element as the first argument is deprecated. Remove it and use
+			 * {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`} instead.
+			 *
+			 * @error editor-create-attachto-overspecified
+			 */ throw new CKEditorError('editor-create-attachto-overspecified', null);
+        }
         config.set('attachTo', sourceElementsOrData);
     }
+    // The `config.attachTo` is only supported by the ClassicEditor.
+    if (!separateAttachTo && config.get('attachTo')) {
+        /**
+		 * The {@link module:core/editor/editorconfig~EditorConfig#attachTo `config.attachTo`} option is only
+		 * available for the {@link module:editor-classic/classiceditor~ClassicEditor} because it replaces the
+		 * given DOM element with its own UI. Other editor types (e.g. inline, balloon, decoupled) render inside
+		 * the root element directly, so `config.attachTo` is not applicable.
+		 *
+		 * Remove the `attachTo` option from the editor configuration and use
+		 * {@link module:core/editor/editorconfig~RootConfig#element `config.root.element`}
+		 * (or `config.roots.<rootName>.element` for the multi-root editor) to specify the DOM element instead.
+		 *
+		 * @error editor-create-attachto-ignored
+		 */ throw new CKEditorError('editor-create-attachto-ignored', null);
+    }
     config.set('roots', rootsConfig);
 }
 /**