@ckeditor/ckeditor5-engine 40.0.0 → 40.2.0

package/src/view/containerelement.d.ts

@@ -1,49 +1,49 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/view/containerelement
- */
-import Element, { type ElementAttributes } from './element';
-import type Document from './document';
-import type Node from './node';
-/**
- * Containers are elements which define document structure. They define boundaries for
- * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
- *
- * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
- *
- * The container element should be your default choice when writing a converter, unless:
- *
- * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
- * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
- * * this is a root element,
- * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
- *
- * To create a new container element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
- * method.
- */
-export default class ContainerElement extends Element {
-    /**
-     * Creates a container element.
-     *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
-     * @see module:engine/view/element~Element
-     * @internal
-     * @param document The document instance to which this element belongs.
-     * @param name Node name.
-     * @param attrs Collection of attributes.
-     * @param children A list of nodes to be inserted into created element.
-     */
-    constructor(document: Document, name: string, attrs?: ElementAttributes, children?: Node | Iterable<Node>);
-}
-/**
- * Returns block {@link module:engine/view/filler filler} offset or `null` if block filler is not needed.
- *
- * @returns Block filler offset or `null` if block filler is not needed.
- */
-export declare function getFillerOffset(this: ContainerElement): number | null;
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/containerelement
+ */
+import Element, { type ElementAttributes } from './element';
+import type Document from './document';
+import type Node from './node';
+/**
+ * Containers are elements which define document structure. They define boundaries for
+ * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
+ *
+ * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
+ * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ *
+ * The container element should be your default choice when writing a converter, unless:
+ *
+ * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
+ * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
+ * * this is a root element,
+ * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
+ *
+ * To create a new container element instance use the
+ * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
+ * method.
+ */
+export default class ContainerElement extends Element {
+    /**
+     * Creates a container element.
+     *
+     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
+     * @see module:engine/view/element~Element
+     * @internal
+     * @param document The document instance to which this element belongs.
+     * @param name Node name.
+     * @param attrs Collection of attributes.
+     * @param children A list of nodes to be inserted into created element.
+     */
+    constructor(document: Document, name: string, attrs?: ElementAttributes, children?: Node | Iterable<Node>);
+}
+/**
+ * Returns block {@link module:engine/view/filler filler} offset or `null` if block filler is not needed.
+ *
+ * @returns Block filler offset or `null` if block filler is not needed.
+ */
+export declare function getFillerOffset(this: ContainerElement): number | null;

package/src/view/containerelement.js

@@ -1,80 +1,80 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/view/containerelement
- */
-import Element from './element';
-/**
- * Containers are elements which define document structure. They define boundaries for
- * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
- *
- * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
- * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
- * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
- *
- * The container element should be your default choice when writing a converter, unless:
- *
- * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
- * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
- * * this is a root element,
- * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
- *
- * To create a new container element instance use the
- * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
- * method.
- */
-export default class ContainerElement extends Element {
-    /**
-     * Creates a container element.
-     *
-     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
-     * @see module:engine/view/element~Element
-     * @internal
-     * @param document The document instance to which this element belongs.
-     * @param name Node name.
-     * @param attrs Collection of attributes.
-     * @param children A list of nodes to be inserted into created element.
-     */
-    constructor(document, name, attrs, children) {
-        super(document, name, attrs, children);
-        this.getFillerOffset = getFillerOffset;
-    }
-}
-// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
-// Proper overload would interfere with that.
-ContainerElement.prototype.is = function (type, name) {
-    if (!name) {
-        return type === 'containerElement' || type === 'view:containerElement' ||
-            // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
-            type === 'element' || type === 'view:element' ||
-            type === 'node' || type === 'view:node';
-    }
-    else {
-        return name === this.name && (type === 'containerElement' || type === 'view:containerElement' ||
-            // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
-            type === 'element' || type === 'view:element');
-    }
-};
-/**
- * Returns block {@link module:engine/view/filler filler} offset or `null` if block filler is not needed.
- *
- * @returns Block filler offset or `null` if block filler is not needed.
- */
-export function getFillerOffset() {
-    const children = [...this.getChildren()];
-    const lastChild = children[this.childCount - 1];
-    // Block filler is required after a `<br>` if it's the last element in its container. See #1422.
-    if (lastChild && lastChild.is('element', 'br')) {
-        return this.childCount;
-    }
-    for (const child of children) {
-        // If there's any non-UI element – don't render the bogus.
-        if (!child.is('uiElement')) {
-            return null;
-        }
-    }
-    // If there are only UI elements – render the bogus at the end of the element.
-    return this.childCount;
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/containerelement
+ */
+import Element from './element';
+/**
+ * Containers are elements which define document structure. They define boundaries for
+ * {@link module:engine/view/attributeelement~AttributeElement attributes}. They are mostly used for block elements like `<p>` or `<div>`.
+ *
+ * Editing engine does not define a fixed HTML DTD. This is why a feature developer needs to choose between various
+ * types (container element, {@link module:engine/view/attributeelement~AttributeElement attribute element},
+ * {@link module:engine/view/emptyelement~EmptyElement empty element}, etc) when developing a feature.
+ *
+ * The container element should be your default choice when writing a converter, unless:
+ *
+ * * this element represents a model text attribute (then use {@link module:engine/view/attributeelement~AttributeElement}),
+ * * this is an empty element like `<img>` (then use {@link module:engine/view/emptyelement~EmptyElement}),
+ * * this is a root element,
+ * * this is a nested editable element (then use  {@link module:engine/view/editableelement~EditableElement}).
+ *
+ * To create a new container element instance use the
+ * {@link module:engine/view/downcastwriter~DowncastWriter#createContainerElement `DowncastWriter#createContainerElement()`}
+ * method.
+ */
+export default class ContainerElement extends Element {
+    /**
+     * Creates a container element.
+     *
+     * @see module:engine/view/downcastwriter~DowncastWriter#createContainerElement
+     * @see module:engine/view/element~Element
+     * @internal
+     * @param document The document instance to which this element belongs.
+     * @param name Node name.
+     * @param attrs Collection of attributes.
+     * @param children A list of nodes to be inserted into created element.
+     */
+    constructor(document, name, attrs, children) {
+        super(document, name, attrs, children);
+        this.getFillerOffset = getFillerOffset;
+    }
+}
+// The magic of type inference using `is` method is centralized in `TypeCheckable` class.
+// Proper overload would interfere with that.
+ContainerElement.prototype.is = function (type, name) {
+    if (!name) {
+        return type === 'containerElement' || type === 'view:containerElement' ||
+            // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
+            type === 'element' || type === 'view:element' ||
+            type === 'node' || type === 'view:node';
+    }
+    else {
+        return name === this.name && (type === 'containerElement' || type === 'view:containerElement' ||
+            // From super.is(). This is highly utilised method and cannot call super. See ckeditor/ckeditor5#6529.
+            type === 'element' || type === 'view:element');
+    }
+};
+/**
+ * Returns block {@link module:engine/view/filler filler} offset or `null` if block filler is not needed.
+ *
+ * @returns Block filler offset or `null` if block filler is not needed.
+ */
+export function getFillerOffset() {
+    const children = [...this.getChildren()];
+    const lastChild = children[this.childCount - 1];
+    // Block filler is required after a `<br>` if it's the last element in its container. See #1422.
+    if (lastChild && lastChild.is('element', 'br')) {
+        return this.childCount;
+    }
+    for (const child of children) {
+        // If there's any non-UI element – don't render the bogus.
+        if (!child.is('uiElement')) {
+            return null;
+        }
+    }
+    // If there are only UI elements – render the bogus at the end of the element.
+    return this.childCount;
+}

package/src/view/datatransfer.d.ts

@@ -1,79 +1,79 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * @module engine/view/datatransfer
- */
-type DomDataTransfer = globalThis.DataTransfer;
-/**
- * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
- */
-export default class DataTransfer {
-    /**
-     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
-     */
-    private _files;
-    /**
-     * The native DataTransfer object.
-     */
-    private _native;
-    /**
-     * @param nativeDataTransfer The native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
-     * @param options.cacheFiles Whether `files` list should be initialized in the constructor.
-     */
-    constructor(nativeDataTransfer: DomDataTransfer, options?: {
-        cacheFiles?: boolean;
-    });
-    /**
-     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
-     */
-    get files(): Array<File>;
-    /**
-     * Returns an array of available native content types.
-     */
-    get types(): ReadonlyArray<string>;
-    /**
-     * Gets the data from the data transfer by its MIME type.
-     *
-     * ```ts
-     * dataTransfer.getData( 'text/plain' );
-     * ```
-     *
-     * @param type The MIME type. E.g. `text/html` or `text/plain`.
-     */
-    getData(type: string): string;
-    /**
-     * Sets the data in the data transfer.
-     *
-     * @param type The MIME type. E.g. `text/html` or `text/plain`.
-     */
-    setData(type: string, data: string): void;
-    /**
-     * The effect that is allowed for a drag operation.
-     */
-    set effectAllowed(value: EffectAllowed);
-    get effectAllowed(): EffectAllowed;
-    /**
-     * The actual drop effect.
-     */
-    set dropEffect(value: DropEffect);
-    get dropEffect(): DropEffect;
-    /**
-     * Set a preview image of the dragged content.
-     */
-    setDragImage(image: Element, x: number, y: number): void;
-    /**
-     * Whether the dragging operation was canceled.
-     */
-    get isCanceled(): boolean;
-}
-/**
- * The effect that is allowed for a drag operation.
- */
-export type EffectAllowed = DomDataTransfer['effectAllowed'];
-/**
- * The actual drop effect.
- */
-export type DropEffect = DomDataTransfer['dropEffect'];
-export {};
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module engine/view/datatransfer
+ */
+type DomDataTransfer = globalThis.DataTransfer;
+/**
+ * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
+ */
+export default class DataTransfer {
+    /**
+     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
+     */
+    private _files;
+    /**
+     * The native DataTransfer object.
+     */
+    private _native;
+    /**
+     * @param nativeDataTransfer The native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
+     * @param options.cacheFiles Whether `files` list should be initialized in the constructor.
+     */
+    constructor(nativeDataTransfer: DomDataTransfer, options?: {
+        cacheFiles?: boolean;
+    });
+    /**
+     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
+     */
+    get files(): Array<File>;
+    /**
+     * Returns an array of available native content types.
+     */
+    get types(): ReadonlyArray<string>;
+    /**
+     * Gets the data from the data transfer by its MIME type.
+     *
+     * ```ts
+     * dataTransfer.getData( 'text/plain' );
+     * ```
+     *
+     * @param type The MIME type. E.g. `text/html` or `text/plain`.
+     */
+    getData(type: string): string;
+    /**
+     * Sets the data in the data transfer.
+     *
+     * @param type The MIME type. E.g. `text/html` or `text/plain`.
+     */
+    setData(type: string, data: string): void;
+    /**
+     * The effect that is allowed for a drag operation.
+     */
+    set effectAllowed(value: EffectAllowed);
+    get effectAllowed(): EffectAllowed;
+    /**
+     * The actual drop effect.
+     */
+    set dropEffect(value: DropEffect);
+    get dropEffect(): DropEffect;
+    /**
+     * Set a preview image of the dragged content.
+     */
+    setDragImage(image: Element, x: number, y: number): void;
+    /**
+     * Whether the dragging operation was canceled.
+     */
+    get isCanceled(): boolean;
+}
+/**
+ * The effect that is allowed for a drag operation.
+ */
+export type EffectAllowed = DomDataTransfer['effectAllowed'];
+/**
+ * The actual drop effect.
+ */
+export type DropEffect = DomDataTransfer['dropEffect'];
+export {};

package/src/view/datatransfer.js

@@ -1,98 +1,98 @@
-/**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
- */
-/**
- * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
- */
-export default class DataTransfer {
-    /**
-     * @param nativeDataTransfer The native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
-     * @param options.cacheFiles Whether `files` list should be initialized in the constructor.
-     */
-    constructor(nativeDataTransfer, options = {}) {
-        // We should store references to the File instances in case someone would like to process this files
-        // outside the event handler. Files are stored only for `drop` and `paste` events because they are not usable
-        // in other events and are generating a huge delay on Firefox while dragging.
-        // See https://github.com/ckeditor/ckeditor5/issues/13366.
-        this._files = options.cacheFiles ? getFiles(nativeDataTransfer) : null;
-        this._native = nativeDataTransfer;
-    }
-    /**
-     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
-     */
-    get files() {
-        if (!this._files) {
-            this._files = getFiles(this._native);
-        }
-        return this._files;
-    }
-    /**
-     * Returns an array of available native content types.
-     */
-    get types() {
-        return this._native.types;
-    }
-    /**
-     * Gets the data from the data transfer by its MIME type.
-     *
-     * ```ts
-     * dataTransfer.getData( 'text/plain' );
-     * ```
-     *
-     * @param type The MIME type. E.g. `text/html` or `text/plain`.
-     */
-    getData(type) {
-        return this._native.getData(type);
-    }
-    /**
-     * Sets the data in the data transfer.
-     *
-     * @param type The MIME type. E.g. `text/html` or `text/plain`.
-     */
-    setData(type, data) {
-        this._native.setData(type, data);
-    }
-    /**
-     * The effect that is allowed for a drag operation.
-     */
-    set effectAllowed(value) {
-        this._native.effectAllowed = value;
-    }
-    get effectAllowed() {
-        return this._native.effectAllowed;
-    }
-    /**
-     * The actual drop effect.
-     */
-    set dropEffect(value) {
-        this._native.dropEffect = value;
-    }
-    get dropEffect() {
-        return this._native.dropEffect;
-    }
-    /**
-     * Set a preview image of the dragged content.
-     */
-    setDragImage(image, x, y) {
-        this._native.setDragImage(image, x, y);
-    }
-    /**
-     * Whether the dragging operation was canceled.
-     */
-    get isCanceled() {
-        return this._native.dropEffect == 'none' || !!this._native.mozUserCancelled;
-    }
-}
-function getFiles(nativeDataTransfer) {
-    // DataTransfer.files and items are array-like and might not have an iterable interface.
-    const files = Array.from(nativeDataTransfer.files || []);
-    const items = Array.from(nativeDataTransfer.items || []);
-    if (files.length) {
-        return files;
-    }
-    // Chrome has empty DataTransfer.files, but allows getting files through the items interface.
-    return items
-        .filter(item => item.kind === 'file')
-        .map(item => item.getAsFile());
-}
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * A facade over the native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
+ */
+export default class DataTransfer {
+    /**
+     * @param nativeDataTransfer The native [`DataTransfer`](https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer) object.
+     * @param options.cacheFiles Whether `files` list should be initialized in the constructor.
+     */
+    constructor(nativeDataTransfer, options = {}) {
+        // We should store references to the File instances in case someone would like to process this files
+        // outside the event handler. Files are stored only for `drop` and `paste` events because they are not usable
+        // in other events and are generating a huge delay on Firefox while dragging.
+        // See https://github.com/ckeditor/ckeditor5/issues/13366.
+        this._files = options.cacheFiles ? getFiles(nativeDataTransfer) : null;
+        this._native = nativeDataTransfer;
+    }
+    /**
+     * The array of files created from the native `DataTransfer#files` or `DataTransfer#items`.
+     */
+    get files() {
+        if (!this._files) {
+            this._files = getFiles(this._native);
+        }
+        return this._files;
+    }
+    /**
+     * Returns an array of available native content types.
+     */
+    get types() {
+        return this._native.types;
+    }
+    /**
+     * Gets the data from the data transfer by its MIME type.
+     *
+     * ```ts
+     * dataTransfer.getData( 'text/plain' );
+     * ```
+     *
+     * @param type The MIME type. E.g. `text/html` or `text/plain`.
+     */
+    getData(type) {
+        return this._native.getData(type);
+    }
+    /**
+     * Sets the data in the data transfer.
+     *
+     * @param type The MIME type. E.g. `text/html` or `text/plain`.
+     */
+    setData(type, data) {
+        this._native.setData(type, data);
+    }
+    /**
+     * The effect that is allowed for a drag operation.
+     */
+    set effectAllowed(value) {
+        this._native.effectAllowed = value;
+    }
+    get effectAllowed() {
+        return this._native.effectAllowed;
+    }
+    /**
+     * The actual drop effect.
+     */
+    set dropEffect(value) {
+        this._native.dropEffect = value;
+    }
+    get dropEffect() {
+        return this._native.dropEffect;
+    }
+    /**
+     * Set a preview image of the dragged content.
+     */
+    setDragImage(image, x, y) {
+        this._native.setDragImage(image, x, y);
+    }
+    /**
+     * Whether the dragging operation was canceled.
+     */
+    get isCanceled() {
+        return this._native.dropEffect == 'none' || !!this._native.mozUserCancelled;
+    }
+}
+function getFiles(nativeDataTransfer) {
+    // DataTransfer.files and items are array-like and might not have an iterable interface.
+    const files = Array.from(nativeDataTransfer.files || []);
+    const items = Array.from(nativeDataTransfer.items || []);
+    if (files.length) {
+        return files;
+    }
+    // Chrome has empty DataTransfer.files, but allows getting files through the items interface.
+    return items
+        .filter(item => item.kind === 'file')
+        .map(item => item.getAsFile());
+}