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

package/src/model/rootelement.js

@@ -23,6 +23,12 @@ export default class RootElement extends Element {
          * @internal
          */
         this._isAttached = true;
+        /**
+         * Informs if the root element is loaded (default).
+         *
+         * @internal
+         */
+        this._isLoaded = true;
         this._document = document;
         this.rootName = rootName;
     }

package/src/model/schema.d.ts

@@ -1169,6 +1169,16 @@ export interface AttributeProperties {
      * Indicates that given text attribute should be copied to the next block when enter is pressed.
      */
     copyOnEnter?: boolean;
+    /**
+     * Indicates that given attribute should be preserved while replacing the element.
+     */
+    copyOnReplace?: boolean;
+    /**
+     * Indicates that given text attribute should be copied from an inline object to the next inserted inline content.
+     *
+     * @default true
+     */
+    copyFromObject?: boolean;
     [name: string]: unknown;
 }
 export type SchemaAttributeCheckCallback = (context: SchemaContext, attributeName: string) => unknown;

package/src/model/schema.js

@@ -677,6 +677,11 @@ export default class Schema extends ObservableMixin() {
      * @returns Nearest selection range or `null` if one cannot be found.
      */
     getNearestSelectionRange(position, direction = 'both') {
+        if (position.root.rootName == '$graveyard') {
+            // No valid selection range in the graveyard.
+            // This is important when getting the document selection default range.
+            return null;
+        }
         // Return collapsed range if provided position is valid.
         if (this.checkChild(position, '$text')) {
             return new Range(position);

package/src/model/utils/autoparagraphing.js

@@ -14,8 +14,7 @@
  */
 export function autoParagraphEmptyRoots(writer) {
     const { schema, document } = writer.model;
-    for (const rootName of document.getRootNames()) {
-        const root = document.getRoot(rootName);
+    for (const root of document.getRoots()) {
         if (root.isEmpty && !schema.checkChild(root, '$text')) {
             // If paragraph element is allowed in the root, create paragraph element.
             if (schema.checkChild(root, 'paragraph')) {

package/src/view/domconverter.d.ts

@@ -98,9 +98,9 @@ export default class DomConverter {
      */
     private readonly _rawContentElementMatcher;
     /**
-     * A set of encountered raw content DOM nodes. It is used for preventing left trimming of the following text node.
+     * Matcher for inline object view elements. This is an extension of a simple {@link #inlineObjectElements} array of element names.
      */
-    private readonly _encounteredRawContentDomNodes;
+    private readonly _inlineObjectElementMatcher;
     /**
      * Creates a DOM converter.
      *
@@ -269,9 +269,10 @@ export default class DomConverter {
      *
      * @param domElement Parent DOM element.
      * @param options See {@link module:engine/view/domconverter~DomConverter#domToView} options parameter.
+     * @param inlineNodes An array that will be populated with inline nodes. It's used internally for whitespace processing.
      * @returns View nodes.
      */
-    domChildrenToView(domElement: DomElement, options: Parameters<DomConverter['domToView']>[1]): IterableIterator<ViewNode>;
+    domChildrenToView(domElement: DomElement, options?: Parameters<DomConverter['domToView']>[1], inlineNodes?: Array<ViewNode>): IterableIterator<ViewNode>;
     /**
      * Converts DOM selection to view {@link module:engine/view/selection~Selection}.
      * Ranges which cannot be converted will be omitted.
@@ -391,6 +392,12 @@ export default class DomConverter {
      * Focuses DOM editable that is corresponding to provided {@link module:engine/view/editableelement~EditableElement}.
      */
     focus(viewEditable: EditableElement): void;
+    /**
+     * Remove DOM selection from blurred editable, so it won't interfere with clicking on dropdowns (especially on iOS).
+     *
+     * @internal
+     */
+    _clearDomSelection(): void;
     /**
      * Returns `true` when `node.nodeType` equals `Node.ELEMENT_NODE`.
      *
@@ -459,6 +466,17 @@ export default class DomConverter {
      * be treated as raw data.
      */
     registerRawContentMatcher(pattern: MatcherPattern): void;
+    /**
+     * Registers a {@link module:engine/view/matcher~MatcherPattern} for inline object view elements.
+     *
+     * This is affecting how {@link module:engine/view/domconverter~DomConverter#domToView} and
+     * {@link module:engine/view/domconverter~DomConverter#domChildrenToView} process DOM nodes.
+     *
+     * This is an extension of a simple {@link #inlineObjectElements} array of element names.
+     *
+     * @param pattern Pattern matching a view element which should be treated as an inline object.
+     */
+    registerInlineObjectMatcher(pattern: MatcherPattern): void;
     /**
      * Returns the block {@link module:engine/view/filler filler} node based on the current {@link #blockFillerMode} setting.
      */
@@ -471,6 +489,24 @@ export default class DomConverter {
      * @returns `true` if given position is at a correct place for selection boundary, `false` otherwise.
      */
     private _isDomSelectionPositionCorrect;
+    /**
+     * Internal generator for {@link #domToView}. Also used by {@link #domChildrenToView}.
+     * Separates DOM nodes conversion from whitespaces processing.
+     *
+     * @param domNode DOM node or document fragment to transform.
+     * @param inlineNodes An array of recently encountered inline nodes truncated to the block element boundaries.
+     * Used later to process whitespaces.
+     */
+    private _domToView;
+    /**
+     * Internal helper that walks the list of inline view nodes already generated from DOM nodes
+     * and handles whitespaces and NBSPs.
+     *
+     * @param domParent The DOM parent of the given inline nodes. This should be a document fragment or
+     * a block element to whitespace processing start cleaning.
+     * @param inlineNodes An array of recently encountered inline nodes truncated to the block element boundaries.
+     */
+    private _processDomInlineNodes;
     /**
      * Takes text data from a given {@link module:engine/view/text~Text#data} and processes it so
      * it is correctly displayed in the DOM.
@@ -496,36 +532,6 @@ export default class DomConverter {
      * @returns `true` if given `node` ends with space, `false` otherwise.
      */
     private _nodeEndsWithSpace;
-    /**
-     * Takes text data from native `Text` node and processes it to a correct {@link module:engine/view/text~Text view text node} data.
-     *
-     * Following changes are done:
-     *
-     * * multiple whitespaces are replaced to a single space,
-     * * space at the beginning of a text node is removed if it is the first text node in its container
-     * element or if the previous text node ends with a space character,
-     * * space at the end of the text node is removed if there are two spaces at the end of a node or if next node
-     * starts with a space or if it is the last text node in its container
-     * * nbsps are converted to spaces.
-     *
-     * @param node DOM text node to process.
-     * @returns Processed data.
-     */
-    private _processDataFromDomText;
-    /**
-     * Helper function which checks if a DOM text node, preceded by the given `prevNode` should
-     * be trimmed from the left side.
-     *
-     * @param prevNode Either DOM text or `<br>` or one of `#inlineObjectElements`.
-     */
-    private _checkShouldLeftTrimDomText;
-    /**
-     * Helper function which checks if a DOM text node, succeeded by the given `nextNode` should
-     * be trimmed from the right side.
-     *
-     * @param nextNode Either DOM text or `<br>` or one of `#inlineObjectElements`.
-     */
-    private _checkShouldRightTrimDomText;
     /**
      * Helper function. For given {@link module:engine/view/text~Text view text node}, it finds previous or next sibling
      * that is contained in the same container element. If there is no such sibling, `null` is returned.
@@ -536,29 +542,13 @@ export default class DomConverter {
      */
     private _getTouchingInlineViewNode;
     /**
-     * Helper function. For the given text node, it finds the closest touching node which is either
-     * a text, `<br>` or an {@link #inlineObjectElements inline object}.
-     *
-     * If no such node is found, `null` is returned.
-     *
-     * For instance, in the following DOM structure:
-     *
-     * ```html
-     * <p>foo<b>bar</b><br>bom</p>
-     * ```
-     *
-     * * `foo` doesn't have its previous touching inline node (`null` is returned),
-     * * `foo`'s next touching inline node is `bar`
-     * * `bar`'s next touching inline node is `<br>`
-     *
-     * This method returns text nodes and `<br>` elements because these types of nodes affect how
-     * spaces in the given text node need to be converted.
+     * Returns `true` if a DOM node belongs to {@link #blockElements}. `false` otherwise.
      */
-    private _getTouchingInlineDomNode;
+    private _isBlockDomElement;
     /**
-     * Returns `true` if a DOM node belongs to {@link #blockElements}. `false` otherwise.
+     * Returns `true` if a view node belongs to {@link #blockElements}. `false` otherwise.
      */
-    private _isBlockElement;
+    private _isBlockViewElement;
     /**
      * Returns `true` if a DOM node belongs to {@link #inlineObjectElements}. `false` otherwise.
      */