@ckeditor/ckeditor5-engine 38.2.0-alpha.0 → 39.0.0

package/README.md

@@ -4,7 +4,6 @@ CKEditor 5 editing engine
 [![npm version](https://badge.fury.io/js/%40ckeditor%2Fckeditor5-engine.svg)](https://www.npmjs.com/package/@ckeditor/ckeditor5-engine)
 [![Coverage Status](https://coveralls.io/repos/github/ckeditor/ckeditor5/badge.svg?branch=master)](https://coveralls.io/github/ckeditor/ckeditor5?branch=master)
 [![Build Status](https://travis-ci.com/ckeditor/ckeditor5.svg?branch=master)](https://app.travis-ci.com/github/ckeditor/ckeditor5)
-![Dependency Status](https://img.shields.io/librariesio/release/npm/@ckeditor/ckeditor5-engine)
 
 The CKEditor 5 editing engine implements a flexible MVC-based architecture for creating rich text editing features.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-engine",
-  "version": "38.2.0-alpha.0",
+  "version": "39.0.0",
   "description": "The editing engine of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -22,10 +22,9 @@
     "ckeditor5-dll"
   ],
   "main": "src/index.js",
-  "type": "module",
   "dependencies": {
-    "@ckeditor/ckeditor5-utils": "38.2.0-alpha.0",
-    "lodash-es": "^4.17.15"
+    "@ckeditor/ckeditor5-utils": "39.0.0",
+    "lodash-es": "4.17.21"
   },
   "engines": {
     "node": ">=16.0.0",

package/src/controller/editingcontroller.js

@@ -10,7 +10,7 @@ import RootEditableElement from '../view/rooteditableelement';
 import View from '../view/view';
 import Mapper from '../conversion/mapper';
 import DowncastDispatcher from '../conversion/downcastdispatcher';
-import { clearAttributes, convertCollapsedSelection, convertRangeSelection, insertAttributesAndChildren, insertText, remove } from '../conversion/downcasthelpers';
+import { cleanSelection, convertCollapsedSelection, convertRangeSelection, insertAttributesAndChildren, insertText, remove } from '../conversion/downcasthelpers';
 import { convertSelectionChange } from '../conversion/upcasthelpers';
 import { tryFixingRange } from '../model/utils/selection-post-fixer';
 // @if CK_DEBUG_ENGINE // const { dumpTrees, initDocumentDumping } = require( '../dev-utils/utils' );
@@ -67,7 +67,7 @@ export default class EditingController extends ObservableMixin() {
         this.downcastDispatcher.on('insert', insertAttributesAndChildren(), { priority: 'lowest' });
         this.downcastDispatcher.on('remove', remove(), { priority: 'low' });
         // Attach default model selection converters.
-        this.downcastDispatcher.on('selection', clearAttributes(), { priority: 'high' });
+        this.downcastDispatcher.on('cleanSelection', cleanSelection());
         this.downcastDispatcher.on('selection', convertRangeSelection(), { priority: 'low' });
         this.downcastDispatcher.on('selection', convertCollapsedSelection(), { priority: 'low' });
         // Binds {@link module:engine/view/document~Document#roots view roots collection} to

package/src/conversion/downcastdispatcher.d.ts

@@ -346,6 +346,9 @@ type EventMap<TItem = Item> = {
         attributeOldValue: unknown;
         attributeNewValue: unknown;
     };
+    cleanSelection: {
+        selection: Selection | DocumentSelection;
+    };
     selection: {
         selection: Selection | DocumentSelection;
     };
@@ -433,6 +436,18 @@ export type DowncastAttributeEvent<TItem = Item | Selection | DocumentSelection>
  * to be used by callback, passed in `DowncastDispatcher` constructor.
  */
 export type DowncastSelectionEvent = DowncastEvent<'selection'>;
+/**
+ * Fired at the beginning of selection conversion, before
+ * {@link module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:selection selection} events.
+ *
+ * Should be used to clean up the view state at the current selection position, before the selection is moved to another place.
+ *
+ * @eventName ~DowncastDispatcher#cleanSelection
+ * @param {module:engine/model/selection~Selection} selection Selection that is converted.
+ * @param {module:engine/conversion/downcastdispatcher~DowncastConversionApi} conversionApi Conversion interface
+ * to be used by callback, passed in `DowncastDispatcher` constructor.
+ */
+export type DowncastCleanSelectionEvent = DowncastEvent<'cleanSelection'>;
 /**
  * Fired when a new marker is added to the model. Also fired when a collapsed model selection that is inside a marker is converted.
  *

package/src/conversion/downcastdispatcher.js

@@ -198,38 +198,47 @@ export default class DowncastDispatcher extends EmitterMixin() {
      * @param writer View writer that should be used to modify the view document.
      */
     convertSelection(selection, markers, writer) {
-        const markersAtSelection = Array.from(markers.getMarkersAtPosition(selection.getFirstPosition()));
         const conversionApi = this._createConversionApi(writer);
+        // First perform a clean-up at the current position of the selection.
+        this.fire('cleanSelection', { selection }, conversionApi);
+        // Don't convert selection if it is in a model root that does not have a view root (for now this is only the graveyard root).
+        const modelRoot = selection.getFirstPosition().root;
+        if (!conversionApi.mapper.toViewElement(modelRoot)) {
+            return;
+        }
+        // Now, perform actual selection conversion.
+        const markersAtSelection = Array.from(markers.getMarkersAtPosition(selection.getFirstPosition()));
         this._addConsumablesForSelection(conversionApi.consumable, selection, markersAtSelection);
         this.fire('selection', { selection }, conversionApi);
         if (!selection.isCollapsed) {
             return;
         }
         for (const marker of markersAtSelection) {
-            const markerRange = marker.getRange();
-            if (!shouldMarkerChangeBeConverted(selection.getFirstPosition(), marker, conversionApi.mapper)) {
-                continue;
-            }
-            const data = {
-                item: selection,
-                markerName: marker.name,
-                markerRange
-            };
+            // Do not fire event if the marker has been consumed.
             if (conversionApi.consumable.test(selection, 'addMarker:' + marker.name)) {
+                const markerRange = marker.getRange();
+                if (!shouldMarkerChangeBeConverted(selection.getFirstPosition(), marker, conversionApi.mapper)) {
+                    continue;
+                }
+                const data = {
+                    item: selection,
+                    markerName: marker.name,
+                    markerRange
+                };
                 this.fire(`addMarker:${marker.name}`, data, conversionApi);
             }
         }
         for (const key of selection.getAttributeKeys()) {
-            const data = {
-                item: selection,
-                range: selection.getFirstRange(),
-                attributeKey: key,
-                attributeOldValue: null,
-                attributeNewValue: selection.getAttribute(key)
-            };
             // Do not fire event if the attribute has been consumed.
-            if (conversionApi.consumable.test(selection, 'attribute:' + data.attributeKey)) {
-                this.fire(`attribute:${data.attributeKey}:$text`, data, conversionApi);
+            if (conversionApi.consumable.test(selection, 'attribute:' + key)) {
+                const data = {
+                    item: selection,
+                    range: selection.getFirstRange(),
+                    attributeKey: key,
+                    attributeOldValue: null,
+                    attributeNewValue: selection.getAttribute(key)
+                };
+                this.fire(`attribute:${key}:$text`, data, conversionApi);
             }
         }
     }

package/src/conversion/downcasthelpers.d.ts

@@ -765,7 +765,7 @@ export default class DowncastHelpers extends ConversionHelpers<DowncastDispatche
      * ```ts
      * // Using a custom function which is the same as the default conversion:
      * editor.conversion.for( 'dataDowncast' ).markerToData( {
-     * 	model: 'comment'
+     * 	model: 'comment',
      * 	view: markerName => ( {
      * 		group: 'comment',
      * 		name: markerName.substr( 8 ) // Removes 'comment:' part.
@@ -774,7 +774,7 @@ export default class DowncastHelpers extends ConversionHelpers<DowncastDispatche
      *
      * // Using the converter priority:
      * editor.conversion.for( 'dataDowncast' ).markerToData( {
-     * 	model: 'comment'
+     * 	model: 'comment',
      * 	view: markerName => ( {
      * 		group: 'comment',
      * 		name: markerName.substr( 8 ) // Removes 'comment:' part.
@@ -880,7 +880,7 @@ export declare function convertRangeSelection(): (evt: EventInfo, data: {
  * converted, broken attributes might be merged again, or the position where the selection is may be wrapped
  * with different, appropriate attribute elements.
  *
- * See also {@link module:engine/conversion/downcasthelpers~clearAttributes} which does a clean-up
+ * See also {@link module:engine/conversion/downcasthelpers~cleanSelection} which does a clean-up
  * by merging attributes.
  *
  * @returns Selection converter.
@@ -889,7 +889,7 @@ export declare function convertCollapsedSelection(): (evt: EventInfo, data: {
     selection: ModelSelection | ModelDocumentSelection;
 }, conversionApi: DowncastConversionApi) => void;
 /**
- * Function factory that creates a converter which clears artifacts after the previous
+ * Function factory that creates a converter which cleans artifacts after the previous
  * {@link module:engine/model/selection~Selection model selection} conversion. It removes all empty
  * {@link module:engine/view/attributeelement~AttributeElement view attribute elements} and merges sibling attributes at all start and end
  * positions of all ranges.
@@ -908,7 +908,7 @@ export declare function convertCollapsedSelection(): (evt: EventInfo, data: {
  * This listener should be assigned before any converter for the new selection:
  *
  * ```ts
- * modelDispatcher.on( 'selection', clearAttributes() );
+ * modelDispatcher.on( 'cleanSelection', cleanSelection() );
  * ```
  *
  * See {@link module:engine/conversion/downcasthelpers~convertCollapsedSelection}
@@ -916,7 +916,7 @@ export declare function convertCollapsedSelection(): (evt: EventInfo, data: {
  *
  * @returns Selection converter.
  */
-export declare function clearAttributes(): (evt: EventInfo, data: unknown, conversionApi: DowncastConversionApi) => void;
+export declare function cleanSelection(): (evt: EventInfo, data: unknown, conversionApi: DowncastConversionApi) => void;
 /**
  * Function factory that creates a converter which converts the set/change/remove attribute changes from the model to the view.
  * It can also be used to convert selection attributes. In that case, an empty attribute element will be created and the

package/src/conversion/downcasthelpers.js

@@ -715,7 +715,7 @@ export default class DowncastHelpers extends ConversionHelpers {
      * ```ts
      * // Using a custom function which is the same as the default conversion:
      * editor.conversion.for( 'dataDowncast' ).markerToData( {
-     * 	model: 'comment'
+     * 	model: 'comment',
      * 	view: markerName => ( {
      * 		group: 'comment',
      * 		name: markerName.substr( 8 ) // Removes 'comment:' part.
@@ -724,7 +724,7 @@ export default class DowncastHelpers extends ConversionHelpers {
      *
      * // Using the converter priority:
      * editor.conversion.for( 'dataDowncast' ).markerToData( {
-     * 	model: 'comment'
+     * 	model: 'comment',
      * 	view: markerName => ( {
      * 		group: 'comment',
      * 		name: markerName.substr( 8 ) // Removes 'comment:' part.
@@ -876,7 +876,7 @@ export function convertRangeSelection() {
  * converted, broken attributes might be merged again, or the position where the selection is may be wrapped
  * with different, appropriate attribute elements.
  *
- * See also {@link module:engine/conversion/downcasthelpers~clearAttributes} which does a clean-up
+ * See also {@link module:engine/conversion/downcasthelpers~cleanSelection} which does a clean-up
  * by merging attributes.
  *
  * @returns Selection converter.
@@ -898,7 +898,7 @@ export function convertCollapsedSelection() {
     };
 }
 /**
- * Function factory that creates a converter which clears artifacts after the previous
+ * Function factory that creates a converter which cleans artifacts after the previous
  * {@link module:engine/model/selection~Selection model selection} conversion. It removes all empty
  * {@link module:engine/view/attributeelement~AttributeElement view attribute elements} and merges sibling attributes at all start and end
  * positions of all ranges.
@@ -917,7 +917,7 @@ export function convertCollapsedSelection() {
  * This listener should be assigned before any converter for the new selection:
  *
  * ```ts
- * modelDispatcher.on( 'selection', clearAttributes() );
+ * modelDispatcher.on( 'cleanSelection', cleanSelection() );
  * ```
  *
  * See {@link module:engine/conversion/downcasthelpers~convertCollapsedSelection}
@@ -925,7 +925,7 @@ export function convertCollapsedSelection() {
  *
  * @returns Selection converter.
  */
-export function clearAttributes() {
+export function cleanSelection() {
     return (evt, data, conversionApi) => {
         const viewWriter = conversionApi.writer;
         const viewSelection = viewWriter.document.selection;

package/src/dev-utils/view.js

@@ -820,7 +820,7 @@ class ViewStringify {
             else if (attribute === 'style') {
                 attributeValue = [...element.getStyleNames()]
                     .sort()
-                    .map(style => `${style}:${element.getStyle(style)}`)
+                    .map(style => `${style}:${element.getStyle(style).replace(/"/g, '"')}`)
                     .join(';');
             }
             else {

package/src/index.d.ts

@@ -89,6 +89,7 @@ export { default as ClickObserver } from './view/observer/clickobserver';
 export { default as DomEventObserver } from './view/observer/domeventobserver';
 export { default as MouseObserver } from './view/observer/mouseobserver';
 export { default as TabObserver } from './view/observer/tabobserver';
+export { default as FocusObserver } from './view/observer/focusobserver';
 export { default as DowncastWriter } from './view/downcastwriter';
 export { default as UpcastWriter } from './view/upcastwriter';
 export { default as Matcher, type MatcherPattern, type MatcherObjectPattern, type Match, type MatchResult } from './view/matcher';

package/src/index.js

@@ -63,6 +63,7 @@ export { default as ClickObserver } from './view/observer/clickobserver';
 export { default as DomEventObserver } from './view/observer/domeventobserver';
 export { default as MouseObserver } from './view/observer/mouseobserver';
 export { default as TabObserver } from './view/observer/tabobserver';
+export { default as FocusObserver } from './view/observer/focusobserver';
 export { default as DowncastWriter } from './view/downcastwriter';
 export { default as UpcastWriter } from './view/upcastwriter';
 export { default as Matcher } from './view/matcher';

package/src/model/differ.d.ts

@@ -9,6 +9,7 @@ import Position from './position';
 import Range from './range';
 import type { default as MarkerCollection, MarkerData } from './markercollection';
 import type Item from './item';
+import type RootElement from './rootelement';
 import type Operation from './operation/operation';
 /**
  * Calculates the difference between two model states.
@@ -191,6 +192,19 @@ export default class Differ {
      * @param item Item to refresh.
      */
     _refreshItem(item: Item): void;
+    /**
+     * Buffers all the data related to given root like it was all just added to the editor.
+     *
+     * Following changes are buffered:
+     *
+     * * root is attached,
+     * * all root content is inserted,
+     * * all root attributes are added,
+     * * all markers inside the root are added.
+     *
+     * @internal
+     */
+    _bufferRootLoad(root: RootElement): void;
     /**
      * Saves and handles an insert change.
      */

package/src/model/differ.js

@@ -94,6 +94,9 @@ export default class Differ {
         // Marking changes in them would cause a "double" changing then.
         //
         const operation = operationToBuffer;
+        // Note: an operation that happens inside a non-loaded root will be ignored. If the operation happens partially inside
+        // a non-loaded root, that part will be ignored (this may happen for move or marker operations).
+        //
         switch (operation.type) {
             case 'insert': {
                 if (this._isInInsertedElement(operation.position.parent)) {
@@ -179,12 +182,23 @@ export default class Differ {
             }
             case 'detachRoot':
             case 'addRoot': {
+                const root = operation.affectedSelectable;
+                if (!root._isLoaded) {
+                    return;
+                }
+                // Don't buffer if the root state does not change.
+                if (root.isAttached() == operation.isAdd) {
+                    return;
+                }
                 this._bufferRootStateChange(operation.rootName, operation.isAdd);
                 break;
             }
             case 'addRootAttribute':
             case 'removeRootAttribute':
             case 'changeRootAttribute': {
+                if (!operation.root._isLoaded) {
+                    return;
+                }
                 const rootName = operation.root.rootName;
                 this._bufferRootAttributeChange(rootName, operation.key, operation.oldValue, operation.newValue);
                 break;
@@ -201,20 +215,24 @@ export default class Differ {
      * @param newMarkerData Marker data after the change.
      */
     bufferMarkerChange(markerName, oldMarkerData, newMarkerData) {
-        const buffered = this._changedMarkers.get(markerName);
+        if (oldMarkerData.range && oldMarkerData.range.root.is('rootElement') && !oldMarkerData.range.root._isLoaded) {
+            oldMarkerData.range = null;
+        }
+        if (newMarkerData.range && newMarkerData.range.root.is('rootElement') && !newMarkerData.range.root._isLoaded) {
+            newMarkerData.range = null;
+        }
+        let buffered = this._changedMarkers.get(markerName);
         if (!buffered) {
-            this._changedMarkers.set(markerName, {
-                newMarkerData,
-                oldMarkerData
-            });
+            buffered = { newMarkerData, oldMarkerData };
+            this._changedMarkers.set(markerName, buffered);
         }
         else {
             buffered.newMarkerData = newMarkerData;
-            if (buffered.oldMarkerData.range == null && newMarkerData.range == null) {
-                // The marker is going to be removed (`newMarkerData.range == null`) but it did not exist before the first buffered change
-                // (`buffered.oldMarkerData.range == null`). In this case, do not keep the marker in buffer at all.
-                this._changedMarkers.delete(markerName);
-            }
+        }
+        if (buffered.oldMarkerData.range == null && newMarkerData.range == null) {
+            // The marker is going to be removed (`newMarkerData.range == null`) but it did not exist before the first buffered change
+            // (`buffered.oldMarkerData.range == null`). In this case, do not keep the marker in buffer at all.
+            this._changedMarkers.delete(markerName);
         }
     }
     /**
@@ -496,7 +514,7 @@ export default class Differ {
         }
         const diffItem = this._changedRoots.get(rootName);
         if (diffItem.state !== undefined) {
-            // Root `state` can only toggle between of the values ('attached' or 'detached') and no value. It cannot be any other way,
+            // Root `state` can only toggle between one of the values and no value. It cannot be any other way,
             // because if the root was originally attached it can only become detached. Then, if it is re-attached in the same batch of
             // changes, it gets back to "no change" (which means no value). Same if the root was originally detached.
             delete diffItem.state;
@@ -567,10 +585,45 @@ export default class Differ {
         // Clear cache after each buffered operation as it is no longer valid.
         this._cachedChanges = null;
     }
+    /**
+     * Buffers all the data related to given root like it was all just added to the editor.
+     *
+     * Following changes are buffered:
+     *
+     * * root is attached,
+     * * all root content is inserted,
+     * * all root attributes are added,
+     * * all markers inside the root are added.
+     *
+     * @internal
+     */
+    _bufferRootLoad(root) {
+        if (!root.isAttached()) {
+            return;
+        }
+        this._bufferRootStateChange(root.rootName, true);
+        this._markInsert(root, 0, root.maxOffset);
+        // Buffering root attribute changes makes sense and is actually needed, even though we buffer root state change above.
+        // Because the root state change is buffered, the root attributes changes are not returned by the differ.
+        // But, if the root attribute is removed in the same change block, or the root is detached, then the differ results would be wrong.
+        //
+        for (const key of root.getAttributeKeys()) {
+            this._bufferRootAttributeChange(root.rootName, key, null, root.getAttribute(key));
+        }
+        for (const marker of this._markerCollection) {
+            if (marker.getRange().root == root) {
+                const markerData = marker.getData();
+                this.bufferMarkerChange(marker.name, { ...markerData, range: null }, markerData);
+            }
+        }
+    }
     /**
      * Saves and handles an insert change.
      */
     _markInsert(parent, offset, howMany) {
+        if (parent.root.is('rootElement') && !parent.root._isLoaded) {
+            return;
+        }
         const changeItem = { type: 'insert', offset, howMany, count: this._changeCount++ };
         this._markChange(parent, changeItem);
     }
@@ -578,6 +631,9 @@ export default class Differ {
      * Saves and handles a remove change.
      */
     _markRemove(parent, offset, howMany) {
+        if (parent.root.is('rootElement') && !parent.root._isLoaded) {
+            return;
+        }
         const changeItem = { type: 'remove', offset, howMany, count: this._changeCount++ };
         this._markChange(parent, changeItem);
         this._removeAllNestedChanges(parent, offset, howMany);
@@ -586,6 +642,9 @@ export default class Differ {
      * Saves and handles an attribute change.
      */
     _markAttribute(item) {
+        if (item.root.is('rootElement') && !item.root._isLoaded) {
+            return;
+        }
         const changeItem = { type: 'attribute', offset: item.startOffset, howMany: item.offsetSize, count: this._changeCount++ };
         this._markChange(item.parent, changeItem);
     }

package/src/model/document.d.ts

@@ -125,9 +125,17 @@ export default class Document extends Document_base {
      * on the document data know which roots are still a part of the document and should be processed.
      *
      * @param includeDetached Specified whether detached roots should be returned as well.
-     * @returns Roots names.
      */
     getRootNames(includeDetached?: boolean): Array<string>;
+    /**
+     * Returns an array with all roots added to the document (except the {@link #graveyard graveyard root}).
+     *
+     * Detached roots **are not** returned by this method by default. This is to make sure that all features or algorithms that operate
+     * on the document data know which roots are still a part of the document and should be processed.
+     *
+     * @param includeDetached Specified whether detached roots should be returned as well.
+     */
+    getRoots(includeDetached?: boolean): Array<RootElement>;
     /**
      * Used to register a post-fixer callback. A post-fixer mechanism guarantees that the features
      * will operate on a correct model state.

package/src/model/document.js

@@ -179,12 +179,21 @@ export default class Document extends EmitterMixin() {
      * on the document data know which roots are still a part of the document and should be processed.
      *
      * @param includeDetached Specified whether detached roots should be returned as well.
-     * @returns Roots names.
      */
     getRootNames(includeDetached = false) {
+        return this.getRoots(includeDetached).map(root => root.rootName);
+    }
+    /**
+     * Returns an array with all roots added to the document (except the {@link #graveyard graveyard root}).
+     *
+     * Detached roots **are not** returned by this method by default. This is to make sure that all features or algorithms that operate
+     * on the document data know which roots are still a part of the document and should be processed.
+     *
+     * @param includeDetached Specified whether detached roots should be returned as well.
+     */
+    getRoots(includeDetached = false) {
         return Array.from(this.roots)
-            .filter(root => root.rootName != graveyardName && (includeDetached || root.isAttached()))
-            .map(root => root.rootName);
+            .filter(root => root != this.graveyard && (includeDetached || root.isAttached()) && root._isLoaded);
     }
     /**
      * Used to register a post-fixer callback. A post-fixer mechanism guarantees that the features
@@ -283,12 +292,8 @@ export default class Document extends EmitterMixin() {
      * @returns The default root for this document.
      */
     _getDefaultRoot() {
-        for (const root of this.roots) {
-            if (root !== this.graveyard) {
-                return root;
-            }
-        }
-        return this.graveyard;
+        const roots = this.getRoots();
+        return roots.length ? roots[0] : this.graveyard;
     }
     /**
      * Returns the default range for this selection. The default range is a collapsed range that starts and ends

package/src/model/documentselection.js

@@ -866,14 +866,19 @@ class LiveSelection extends Selection {
     _getSurroundingAttributes() {
         const position = this.getFirstPosition();
         const schema = this._model.schema;
+        if (position.root.rootName == '$graveyard') {
+            return null;
+        }
         let attrs = null;
         if (!this.isCollapsed) {
             // 1. If selection is a range...
             const range = this.getFirstRange();
             // ...look for a first character node in that range and take attributes from it.
             for (const value of range) {
-                // If the item is an object, we don't want to get attributes from its children.
+                // If the item is an object, we don't want to get attributes from its children...
                 if (value.item.is('element') && schema.isObject(value.item)) {
+                    // ...but collect attributes from inline object.
+                    attrs = getTextAttributes(value.item, schema);
                     break;
                 }
                 if (value.type == 'text') {
@@ -957,7 +962,8 @@ function getTextAttributes(node, schema) {
     const attributes = [];
     // Collect all attributes that can be applied to the text node.
     for (const [key, value] of node.getAttributes()) {
-        if (schema.checkAttribute('$text', key)) {
+        if (schema.checkAttribute('$text', key) &&
+            schema.getAttributeProperties(key).copyFromObject !== false) {
             attributes.push([key, value]);
         }
     }

package/src/model/model.d.ts

@@ -769,7 +769,6 @@ export default class Model extends Model_base {
     /**
      * Common part of {@link module:engine/model/model~Model#change} and {@link module:engine/model/model~Model#enqueueChange}
      * which calls callbacks and returns array of values returned by these callbacks.
-     *
      */
     private _runPendingChanges;
 }

package/src/model/model.js

@@ -792,7 +792,6 @@ export default class Model extends ObservableMixin() {
     /**
      * Common part of {@link module:engine/model/model~Model#change} and {@link module:engine/model/model~Model#enqueueChange}
      * which calls callbacks and returns array of values returned by these callbacks.
-     *
      */
     _runPendingChanges() {
         const ret = [];

package/src/model/operation/rootoperation.d.ts

@@ -54,10 +54,6 @@ export default class RootOperation extends Operation {
      * @inheritDoc
      */
     getReversed(): RootOperation;
-    /**
-     * @inheritDoc
-     */
-    _validate(): void;
     /**
      * @inheritDoc
      */

package/src/model/operation/rootoperation.js

@@ -6,7 +6,6 @@
  * @module engine/model/operation/rootoperation
  */
 import Operation from './operation';
-import { CKEditorError } from '@ckeditor/ckeditor5-utils';
 /**
  * Operation that creates (or attaches) or detaches a root element.
  */
@@ -59,29 +58,6 @@ export default class RootOperation extends Operation {
     getReversed() {
         return new RootOperation(this.rootName, this.elementName, !this.isAdd, this._document, this.baseVersion + 1);
     }
-    /**
-     * @inheritDoc
-     */
-    _validate() {
-        // Keep in mind that at this point the root will always exist as it was created in the `constructor()`, even for detach operation.
-        const root = this._document.getRoot(this.rootName);
-        if (root.isAttached() && this.isAdd) {
-            /**
-             * Trying to attach a root that is already attached.
-             *
-             * @error root-operation-root-attached
-             */
-            throw new CKEditorError('root-operation-root-attached', this);
-        }
-        else if (!root.isAttached() && !this.isAdd) {
-            /**
-             * Trying to detach a root that is already detached.
-             *
-             * @error root-operation-root-detached
-             */
-            throw new CKEditorError('root-operation-root-detached', this);
-        }
-    }
     /**
      * @inheritDoc
      */

package/src/model/operation/transform.js

@@ -1641,8 +1641,8 @@ setTransformation(RootAttributeOperation, RootAttributeOperation, (a, b, context
     return [a];
 });
 // -----------------------
-setTransformation(RootOperation, RootOperation, (a, b, context) => {
-    if (a.rootName === b.rootName && a.isAdd === b.isAdd && !context.bWasUndone) {
+setTransformation(RootOperation, RootOperation, (a, b) => {
+    if (a.rootName === b.rootName && a.isAdd === b.isAdd) {
         return [new NoOperation(0)];
     }
     return [a];

package/src/model/rootelement.d.ts

@@ -23,6 +23,12 @@ export default class RootElement extends Element {
      * @internal
      */
     _isAttached: boolean;
+    /**
+     * Informs if the root element is loaded (default).
+     *
+     * @internal
+     */
+    _isLoaded: boolean;
     /**
      * Creates root element.
      *