@ckeditor/ckeditor5-engine 37.0.0-alpha.2 → 37.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-engine",
-  "version": "37.0.0-alpha.2",
+  "version": "37.0.0-rc.0",
   "description": "The editing engine of CKEditor 5 – the best browser-based rich text editor.",
   "keywords": [
     "wysiwyg",
@@ -23,36 +23,36 @@
   ],
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-utils": "^37.0.0-alpha.2",
+    "@ckeditor/ckeditor5-utils": "^37.0.0-rc.0",
     "lodash-es": "^4.17.15"
   },
   "devDependencies": {
-    "@ckeditor/ckeditor5-basic-styles": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-block-quote": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-clipboard": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-cloud-services": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-core": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-editor-classic": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-enter": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-essentials": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-heading": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-image": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-link": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-list": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-mention": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-paragraph": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-table": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-theme-lark": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-typing": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-ui": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-undo": "^37.0.0-alpha.2",
-    "@ckeditor/ckeditor5-widget": "^37.0.0-alpha.2",
+    "@ckeditor/ckeditor5-basic-styles": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-block-quote": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-clipboard": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-cloud-services": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-core": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-editor-classic": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-enter": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-essentials": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-heading": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-image": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-link": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-list": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-mention": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-paragraph": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-table": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-theme-lark": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-typing": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-ui": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-undo": "^37.0.0-rc.0",
+    "@ckeditor/ckeditor5-widget": "^37.0.0-rc.0",
     "typescript": "^4.8.4",
     "webpack": "^5.58.1",
     "webpack-cli": "^4.9.0"
   },
   "engines": {
-    "node": ">=14.0.0",
+    "node": ">=16.0.0",
     "npm": ">=5.7.1"
   },
   "author": "CKSource (http://cksource.com/)",

package/src/controller/datacontroller.d.ts

@@ -90,6 +90,9 @@ export default class DataController extends DataController_base {
      * Returns the model's data converted by downcast dispatchers attached to {@link #downcastDispatcher} and
      * formatted by the {@link #processor data processor}.
      *
+     * A warning is logged when you try to retrieve data for a detached root, as most probably this is a mistake. A detached root should
+     * be treated like it is removed, and you should not save its data. Note, that the detached root data is always an empty string.
+     *
      * @fires get
      * @param options Additional configuration for the retrieved data. `DataController` provides two optional
      * properties: `rootName` and `trim`. Other properties of this object are specified by various editor features.

package/src/controller/datacontroller.js

@@ -17,6 +17,7 @@ import ViewDowncastWriter from '../view/downcastwriter';
 import ModelRange from '../model/range';
 import { autoParagraphEmptyRoots } from '../model/utils/autoparagraphing';
 import HtmlDataProcessor from '../dataprocessor/htmldataprocessor';
+import { logWarning } from '@ckeditor/ckeditor5-utils/src/ckeditorerror';
 /**
  * Controller for the data pipeline. The data pipeline controls how data is retrieved from the document
  * and set inside it. Hence, the controller features two methods which allow to {@link ~DataController#get get}
@@ -87,6 +88,9 @@ export default class DataController extends EmitterMixin() {
      * Returns the model's data converted by downcast dispatchers attached to {@link #downcastDispatcher} and
      * formatted by the {@link #processor data processor}.
      *
+     * A warning is logged when you try to retrieve data for a detached root, as most probably this is a mistake. A detached root should
+     * be treated like it is removed, and you should not save its data. Note, that the detached root data is always an empty string.
+     *
      * @fires get
      * @param options Additional configuration for the retrieved data. `DataController` provides two optional
      * properties: `rootName` and `trim`. Other properties of this object are specified by various editor features.
@@ -116,6 +120,17 @@ export default class DataController extends EmitterMixin() {
             throw new CKEditorError('datacontroller-get-non-existent-root', this);
         }
         const root = this.model.document.getRoot(rootName);
+        if (!root.isAttached()) {
+            /**
+             * Retrieving document data for a detached root.
+             *
+             * This usually indicates an error as a detached root should be considered "removed" and should not be included in the
+             * document data.
+             *
+             * @error datacontroller-get-detached-root
+             */
+            logWarning('datacontroller-get-detached-root', this);
+        }
         if (trim === 'empty' && !this.model.hasContent(root, { ignoreWhitespaces: true })) {
             return '';
         }
@@ -387,7 +402,7 @@ export default class DataController extends EmitterMixin() {
      */
     _checkIfRootsExists(rootNames) {
         for (const rootName of rootNames) {
-            if (!this.model.document.getRootNames().includes(rootName)) {
+            if (!this.model.document.getRoot(rootName)) {
                 return false;
             }
         }

package/src/index.d.ts

@@ -24,8 +24,10 @@ export { default as MergeOperation } from './model/operation/mergeoperation';
 export { default as SplitOperation } from './model/operation/splitoperation';
 export { default as MarkerOperation } from './model/operation/markeroperation';
 export { default as OperationFactory } from './model/operation/operationfactory';
-export type { default as AttributeOperation } from './model/operation/attributeoperation';
-export type { default as RenameOperation } from './model/operation/renameoperation';
+export { default as AttributeOperation } from './model/operation/attributeoperation';
+export { default as RenameOperation } from './model/operation/renameoperation';
+export { default as RootAttributeOperation } from './model/operation/rootattributeoperation';
+export { default as RootOperation } from './model/operation/rootoperation';
 export { transformSets } from './model/operation/transform';
 export { default as DocumentSelection, type DocumentSelectionChangeRangeEvent } from './model/documentselection';
 export { default as Range } from './model/range';

package/src/index.js

@@ -18,6 +18,10 @@ export { default as MergeOperation } from './model/operation/mergeoperation';
 export { default as SplitOperation } from './model/operation/splitoperation';
 export { default as MarkerOperation } from './model/operation/markeroperation';
 export { default as OperationFactory } from './model/operation/operationfactory';
+export { default as AttributeOperation } from './model/operation/attributeoperation';
+export { default as RenameOperation } from './model/operation/renameoperation';
+export { default as RootAttributeOperation } from './model/operation/rootattributeoperation';
+export { default as RootOperation } from './model/operation/rootoperation';
 export { transformSets } from './model/operation/transform';
 // Model.
 export { default as DocumentSelection } from './model/documentselection';

package/src/model/differ.d.ts

@@ -45,6 +45,12 @@ export default class Differ {
      * - `newMarkerData`.
      */
     private readonly _changedMarkers;
+    /**
+     * A map that stores all roots that have been changed.
+     *
+     * The keys are the names of the roots while value represents the changes.
+     */
+    private readonly _changedRoots;
     /**
      * Stores the number of changes that were processed. Used to order the changes chronologically. It is important
      * when changes are sorted.
@@ -83,9 +89,6 @@ export default class Differ {
     /**
      * Buffers the given operation. An operation has to be buffered before it is executed.
      *
-     * Operation type is checked and it is checked which nodes it will affect. These nodes are then stored in `Differ`
-     * in the state before the operation is executed.
-     *
      * @param operationToBuffer An operation to buffer.
      */
     bufferOperation(operationToBuffer: Operation): void;
@@ -132,6 +135,7 @@ export default class Differ {
      *
      * * model structure changes,
      * * attribute changes,
+     * * a root is added or detached,
      * * changes of markers which were defined as `affectsData`,
      * * changes of markers' `affectsData` property.
      */
@@ -157,6 +161,12 @@ export default class Differ {
     getChanges(options?: {
         includeChangesInGraveyard?: boolean;
     }): Array<DiffItem>;
+    /**
+     * Returns all roots that have changed (either were attached, or detached, or their attributes changed).
+     *
+     * @returns Diff between the old and the new roots state.
+     */
+    getChangedRoots(): Array<DiffItemRoot>;
     /**
      * Returns a set of model items that were marked to get refreshed.
      */
@@ -165,6 +175,14 @@ export default class Differ {
      * Resets `Differ`. Removes all buffered changes.
      */
     reset(): void;
+    /**
+     * Buffers the root state change after the root was attached or detached
+     */
+    private _bufferRootStateChange;
+    /**
+     * Buffers a root attribute change.
+     */
+    private _bufferRootAttributeChange;
     /**
      * Marks the given `item` in differ to be "refreshed". It means that the item will be marked as removed and inserted
      * in the differ changes set, so it will be effectively re-converted when the differ changes are handled by a dispatcher.
@@ -253,7 +271,7 @@ export default class Differ {
  */
 export type DiffItem = DiffItemInsert | DiffItemRemove | DiffItemAttribute;
 /**
- * The single diff item for inserted nodes.
+ * A single diff item for inserted nodes.
  */
 export interface DiffItemInsert {
     /**
@@ -273,12 +291,12 @@ export interface DiffItemInsert {
      */
     position: Position;
     /**
-     * The length of an inserted text node. For elements it is always 1 as each inserted element is counted as a one.
+     * The length of an inserted text node. For elements, it is always 1 as each inserted element is counted as a one.
      */
     length: number;
 }
 /**
- * The single diff item for removed nodes.
+ * A single diff item for removed nodes.
  */
 export interface DiffItemRemove {
     /**
@@ -298,12 +316,12 @@ export interface DiffItemRemove {
      */
     position: Position;
     /**
-     * The length of a removed text node. For elements it is always 1 as each removed element is counted as a one.
+     * The length of a removed text node. For elements, it is always 1, as each removed element is counted as a one.
      */
     length: number;
 }
 /**
- * The single diff item for attribute change.
+ * A single diff item for attribute change.
  */
 export interface DiffItemAttribute {
     /**
@@ -327,3 +345,29 @@ export interface DiffItemAttribute {
      */
     range: Range;
 }
+/**
+ * A single diff item for a changed root.
+ */
+export interface DiffItemRoot {
+    /**
+     * Name of the changed root.
+     */
+    name: string;
+    /**
+     * Set accordingly if the root got attached or detached. Otherwise, not set.
+     */
+    state?: 'attached' | 'detached';
+    /**
+     * Keeps all attribute changes that happened on the root.
+     *
+     * The keys are keys of the changed attributes. The values are objects containing the attribute value before the change
+     * (`oldValue`) and after the change (`newValue`).
+     *
+     * Note, that if the root state changed (`state` is set), then `attributes` property will not be set. All attributes should be
+     * handled together with the root being attached or detached.
+     */
+    attributes?: Record<string, {
+        oldValue: unknown;
+        newValue: unknown;
+    }>;
+}

package/src/model/differ.js

@@ -44,6 +44,12 @@ export default class Differ {
          * - `newMarkerData`.
          */
         this._changedMarkers = new Map();
+        /**
+         * A map that stores all roots that have been changed.
+         *
+         * The keys are the names of the roots while value represents the changes.
+         */
+        this._changedRoots = new Map();
         /**
          * Stores the number of changes that were processed. Used to order the changes chronologically. It is important
          * when changes are sorted.
@@ -75,14 +81,11 @@ export default class Differ {
      * Informs whether there are any changes buffered in `Differ`.
      */
     get isEmpty() {
-        return this._changesInElement.size == 0 && this._changedMarkers.size == 0;
+        return this._changesInElement.size == 0 && this._changedMarkers.size == 0 && this._changedRoots.size == 0;
     }
     /**
      * Buffers the given operation. An operation has to be buffered before it is executed.
      *
-     * Operation type is checked and it is checked which nodes it will affect. These nodes are then stored in `Differ`
-     * in the state before the operation is executed.
-     *
      * @param operationToBuffer An operation to buffer.
      */
     bufferOperation(operationToBuffer) {
@@ -174,6 +177,18 @@ export default class Differ {
                 }
                 break;
             }
+            case 'detachRoot':
+            case 'addRoot': {
+                this._bufferRootStateChange(operation.rootName, operation.isAdd);
+                break;
+            }
+            case 'addRootAttribute':
+            case 'removeRootAttribute':
+            case 'changeRootAttribute': {
+                const rootName = operation.root.rootName;
+                this._bufferRootAttributeChange(rootName, operation.key, operation.oldValue, operation.newValue);
+                break;
+            }
         }
         // Clear cache after each buffered operation as it is no longer valid.
         this._cachedChanges = null;
@@ -249,6 +264,7 @@ export default class Differ {
      *
      * * model structure changes,
      * * attribute changes,
+     * * a root is added or detached,
      * * changes of markers which were defined as `affectsData`,
      * * changes of markers' `affectsData` property.
      */
@@ -256,6 +272,9 @@ export default class Differ {
         if (this._changesInElement.size > 0) {
             return true;
         }
+        if (this._changedRoots.size > 0) {
+            return true;
+        }
         for (const { newMarkerData, oldMarkerData } of this._changedMarkers.values()) {
             if (newMarkerData.affectsData !== oldMarkerData.affectsData) {
                 return true;
@@ -429,6 +448,27 @@ export default class Differ {
             return this._cachedChanges.slice();
         }
     }
+    /**
+     * Returns all roots that have changed (either were attached, or detached, or their attributes changed).
+     *
+     * @returns Diff between the old and the new roots state.
+     */
+    getChangedRoots() {
+        return Array.from(this._changedRoots.values()).map(diffItem => {
+            const entry = { ...diffItem };
+            if (entry.state !== undefined) {
+                // The root was attached or detached -- do not return its attributes changes.
+                // If the root was attached, it should be handled as a whole, together with its attributes, the same way as model nodes.
+                // If the root was detached, its attributes should be discarded anyway.
+                //
+                // Keep in mind that filtering must happen on this stage (when retrieving changes). If filtering happens on-the-fly as
+                // the attributes change, it may lead to incorrect situation, e.g.: detach root, change attribute, re-attach root.
+                // In this case, attribute change cannot be filtered. After the root is re-attached, the attribute change must be kept.
+                delete entry.attributes;
+            }
+            return entry;
+        });
+    }
     /**
      * Returns a set of model items that were marked to get refreshed.
      */
@@ -442,9 +482,69 @@ export default class Differ {
         this._changesInElement.clear();
         this._elementSnapshots.clear();
         this._changedMarkers.clear();
+        this._changedRoots.clear();
         this._refreshedItems = new Set();
         this._cachedChanges = null;
     }
+    /**
+     * Buffers the root state change after the root was attached or detached
+     */
+    _bufferRootStateChange(rootName, isAttached) {
+        if (!this._changedRoots.has(rootName)) {
+            this._changedRoots.set(rootName, { name: rootName, state: isAttached ? 'attached' : 'detached' });
+            return;
+        }
+        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,
+            // 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;
+            if (diffItem.attributes === undefined) {
+                // If there is no `state` change and no `attributes` change, remove the entry.
+                this._changedRoots.delete(rootName);
+            }
+        }
+        else {
+            diffItem.state = isAttached ? 'attached' : 'detached';
+        }
+    }
+    /**
+     * Buffers a root attribute change.
+     */
+    _bufferRootAttributeChange(rootName, key, oldValue, newValue) {
+        const diffItem = this._changedRoots.get(rootName) || { name: rootName };
+        const attrs = diffItem.attributes || {};
+        if (attrs[key]) {
+            // If this attribute or metadata was already changed earlier and is changed again, check to what value it is changed.
+            const attrEntry = attrs[key];
+            if (newValue === attrEntry.oldValue) {
+                // If it was changed back to the old value, remove the entry.
+                delete attrs[key];
+            }
+            else {
+                // If it was changed to a different value, update the entry.
+                attrEntry.newValue = newValue;
+            }
+        }
+        else {
+            // If this attribute or metadata was not set earlier, add an entry.
+            attrs[key] = { oldValue, newValue };
+        }
+        if (Object.entries(attrs).length === 0) {
+            // If attributes or metadata changes set became empty, remove it from the diff item.
+            delete diffItem.attributes;
+            if (diffItem.state === undefined) {
+                // If there is no `state` change and no `attributes` change, remove the entry.
+                this._changedRoots.delete(rootName);
+            }
+        }
+        else {
+            // Make sure that, if a new object in the structure was created, it gets set.
+            diffItem.attributes = attrs;
+            this._changedRoots.set(rootName, diffItem);
+        }
+    }
     /**
      * Marks the given `item` in differ to be "refreshed". It means that the item will be marked as removed and inserted
      * in the differ changes set, so it will be effectively re-converted when the differ changes are handled by a dispatcher.

package/src/model/document.d.ts

@@ -48,8 +48,8 @@ export default class Document extends Document_base {
      */
     readonly selection: DocumentSelection;
     /**
-     * A list of roots that are owned and managed by this document. Use {@link #createRoot} and
-     * {@link #getRoot} to manipulate it.
+     * A list of roots that are owned and managed by this document. Use {@link #createRoot}, {@link #getRoot} and
+     * {@link #getRootNames} to manipulate it.
      */
     readonly roots: Collection<RootElement>;
     /**
@@ -61,7 +61,7 @@ export default class Document extends Document_base {
      */
     private readonly _postFixers;
     /**
-     * A boolean indicates whether the selection has changed until
+     * A flag that indicates whether the selection has changed since last change block.
      */
     private _hasSelectionChangedFromTheLastChangeBlock;
     /**
@@ -87,8 +87,11 @@ export default class Document extends Document_base {
     /**
      * Creates a new root.
      *
+     * **Note:** do not use this method after the editor has been initialized! If you want to dynamically add a root, use
+     * {@link module:engine/model/writer~Writer#addRoot `model.Writer#addRoot`} instead.
+     *
      * @param elementName The element name. Defaults to `'$root'` which also has some basic schema defined
-     * (`$block`s are allowed inside the `$root`). Make sure to define a proper schema if you use a different name.
+     * (e.g. `$block` elements are allowed inside the `$root`). Make sure to define a proper schema if you use a different name.
      * @param rootName A unique root name.
      * @returns The created root.
      */
@@ -100,16 +103,23 @@ export default class Document extends Document_base {
     /**
      * Returns a root by its name.
      *
-     * @param name A unique root name.
+     * Detached roots are returned by this method. This is to be able to operate on the detached root (for example, to be able to create
+     * a position inside such a root for undo feature purposes).
+     *
+     * @param name The root name of the root to return.
      * @returns The root registered under a given name or `null` when there is no root with the given name.
      */
     getRoot(name?: string): RootElement | null;
     /**
-     * Returns an array with names of all roots (without the {@link #graveyard}) added to the document.
+     * Returns an array with names of 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.
      * @returns Roots names.
      */
-    getRootNames(): Array<string>;
+    getRootNames(includeDetached?: boolean): Array<string>;
     /**
      * 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

@@ -79,6 +79,33 @@ export default class Document extends EmitterMixin() {
                 });
             }
         });
+        // This is a solution for a problem that may occur during real-time editing. If one client detached a root and another added
+        // something there at the same moment, the OT does not solve this problem currently. In such situation, the added elements would
+        // stay in the detached root.
+        //
+        // This is incorrect, a detached root should be empty and all elements from it should be removed. To solve this, the post-fixer will
+        // remove any element that is left in a detached root.
+        //
+        // Similarly, markers that are created at the beginning or at the end of the detached root will not be removed as well.
+        //
+        // The drawback of this solution over the OT solution is that the elements removed by the post-fixer will never be brought back.
+        // If the root detachment gets undone (and the root is brought back), the removed elements will not be there.
+        this.registerPostFixer(writer => {
+            let result = false;
+            for (const root of this.roots) {
+                if (!root.isAttached() && !root.isEmpty) {
+                    writer.remove(writer.createRangeIn(root));
+                    result = true;
+                }
+            }
+            for (const marker of this.model.markers) {
+                if (!marker.getRange().root.isAttached()) {
+                    writer.removeMarker(marker);
+                    result = true;
+                }
+            }
+            return result;
+        });
     }
     /**
      * The document version. Every applied operation increases the version number. It is used to
@@ -104,8 +131,11 @@ export default class Document extends EmitterMixin() {
     /**
      * Creates a new root.
      *
+     * **Note:** do not use this method after the editor has been initialized! If you want to dynamically add a root, use
+     * {@link module:engine/model/writer~Writer#addRoot `model.Writer#addRoot`} instead.
+     *
      * @param elementName The element name. Defaults to `'$root'` which also has some basic schema defined
-     * (`$block`s are allowed inside the `$root`). Make sure to define a proper schema if you use a different name.
+     * (e.g. `$block` elements are allowed inside the `$root`). Make sure to define a proper schema if you use a different name.
      * @param rootName A unique root name.
      * @returns The created root.
      */
@@ -132,19 +162,28 @@ export default class Document extends EmitterMixin() {
     /**
      * Returns a root by its name.
      *
-     * @param name A unique root name.
+     * Detached roots are returned by this method. This is to be able to operate on the detached root (for example, to be able to create
+     * a position inside such a root for undo feature purposes).
+     *
+     * @param name The root name of the root to return.
      * @returns The root registered under a given name or `null` when there is no root with the given name.
      */
     getRoot(name = 'main') {
         return this.roots.get(name);
     }
     /**
-     * Returns an array with names of all roots (without the {@link #graveyard}) added to the document.
+     * Returns an array with names of 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.
      * @returns Roots names.
      */
-    getRootNames() {
-        return Array.from(this.roots, root => root.rootName).filter(name => name != graveyardName);
+    getRootNames(includeDetached = false) {
+        return Array.from(this.roots)
+            .filter(root => root.rootName != graveyardName && (includeDetached || root.isAttached()))
+            .map(root => root.rootName);
     }
     /**
      * Used to register a post-fixer callback. A post-fixer mechanism guarantees that the features

package/src/model/documentfragment.d.ts

@@ -82,6 +82,10 @@ export default class DocumentFragment extends TypeCheckable implements Iterable<
      * Artificial owner of `DocumentFragment`. Returns `null`. Added for compatibility reasons.
      */
     get document(): null;
+    /**
+     * Returns `false` as `DocumentFragment` by definition is not attached to a document. Added for compatibility reasons.
+     */
+    isAttached(): false;
     /**
      * Returns empty array. Added for compatibility reasons.
      */

package/src/model/documentfragment.js

@@ -100,6 +100,12 @@ export default class DocumentFragment extends TypeCheckable {
     get document() {
         return null;
     }
+    /**
+     * Returns `false` as `DocumentFragment` by definition is not attached to a document. Added for compatibility reasons.
+     */
+    isAttached() {
+        return false;
+    }
     /**
      * Returns empty array. Added for compatibility reasons.
      */

package/src/model/node.d.ts

@@ -66,15 +66,15 @@ export default abstract class Node extends TypeCheckable {
      */
     get document(): Document | null;
     /**
-     * Index of this node in it's parent or `null` if the node has no parent.
+     * Index of this node in its parent or `null` if the node has no parent.
      *
      * Accessing this property throws an error if this node's parent element does not contain it.
      * This means that model tree got broken.
      */
     get index(): number | null;
     /**
-     * Offset at which this node starts in it's parent. It is equal to the sum of {@link #offsetSize offsetSize}
-     * of all it's previous siblings. Equals to `null` if node has no parent.
+     * Offset at which this node starts in its parent. It is equal to the sum of {@link #offsetSize offsetSize}
+     * of all its previous siblings. Equals to `null` if node has no parent.
      *
      * Accessing this property throws an error if this node's parent element does not contain it.
      * This means that model tree got broken.
@@ -107,7 +107,7 @@ export default abstract class Node extends TypeCheckable {
      */
     get root(): Node | DocumentFragment;
     /**
-     * Returns true if the node is in a tree rooted in the document (is a descendant of one of its roots).
+     * Returns `true` if the node is inside a document root that is attached to the document.
      */
     isAttached(): boolean;
     /**