@ckeditor/ckeditor5-utils 40.0.0 → 40.2.0

package/src/dom/remove.d.ts

@@ -1,13 +1,13 @@
-/**
- * @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 utils/dom/remove
- */
-/**
- * Removes given node from parent.
- *
- * @param node Node to remove.
- */
-export default function remove(node: Node): void;
+/**
+ * @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 utils/dom/remove
+ */
+/**
+ * Removes given node from parent.
+ *
+ * @param node Node to remove.
+ */
+export default function remove(node: Node): void;

package/src/dom/remove.js

@@ -1,18 +1,18 @@
-/**
- * @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 utils/dom/remove
- */
-/**
- * Removes given node from parent.
- *
- * @param node Node to remove.
- */
-export default function remove(node) {
-    const parent = node.parentNode;
-    if (parent) {
-        parent.removeChild(node);
-    }
-}
+/**
+ * @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 utils/dom/remove
+ */
+/**
+ * Removes given node from parent.
+ *
+ * @param node Node to remove.
+ */
+export default function remove(node) {
+    const parent = node.parentNode;
+    if (parent) {
+        parent.removeChild(node);
+    }
+}

package/src/dom/resizeobserver.d.ts

@@ -1,74 +1,74 @@
-/**
- * @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 helper class which instances allow performing custom actions when native DOM elements are resized.
- *
- * ```ts
- * const editableElement = editor.editing.view.getDomRoot();
- *
- * const observer = new ResizeObserver( editableElement, entry => {
- * 	console.log( 'The editable element has been resized in DOM.' );
- * 	console.log( entry.target ); // -> editableElement
- * 	console.log( entry.contentRect.width ); // -> e.g. '423px'
- * } );
- * ```
- *
- * It uses the [native DOM resize observer](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
- * under the hood.
- */
-export default class ResizeObserver {
-    /**
-     * The element observed by this observer.
-     */
-    private readonly _element;
-    /**
-     * The callback executed each time {@link #_element} is resized.
-     */
-    private readonly _callback;
-    /**
-     * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
-     */
-    private static _observerInstance;
-    /**
-     * A mapping of native DOM elements and their callbacks shared across all
-     * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
-     */
-    private static _elementCallbacks;
-    /**
-     * Creates an instance of the `ResizeObserver` class.
-     *
-     * @param element A DOM element that is to be observed for resizing. Note that
-     * the element must be visible (i.e. not detached from DOM) for the observer to work.
-     * @param callback A function called when the observed element was resized. It passes
-     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
-     * object with information about the resize event.
-     */
-    constructor(element: Element, callback: (entry: ResizeObserverEntry) => void);
-    /**
-     * The element observed by this observer.
-     */
-    get element(): Element;
-    /**
-     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
-     */
-    destroy(): void;
-    /**
-     * Registers a new resize callback for the DOM element.
-     */
-    private static _addElementCallback;
-    /**
-     * Removes a resize callback from the DOM element. If no callbacks are left
-     * for the element, it removes the element from the native observer.
-     */
-    private static _deleteElementCallback;
-    /**
-     * Returns are registered resize callbacks for the DOM element.
-     */
-    private static _getElementCallbacks;
-    /**
-     * Creates the single native observer shared across all `ResizeObserver` instances.
-     */
-    private static _createObserver;
-}
+/**
+ * @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 helper class which instances allow performing custom actions when native DOM elements are resized.
+ *
+ * ```ts
+ * const editableElement = editor.editing.view.getDomRoot();
+ *
+ * const observer = new ResizeObserver( editableElement, entry => {
+ * 	console.log( 'The editable element has been resized in DOM.' );
+ * 	console.log( entry.target ); // -> editableElement
+ * 	console.log( entry.contentRect.width ); // -> e.g. '423px'
+ * } );
+ * ```
+ *
+ * It uses the [native DOM resize observer](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
+ * under the hood.
+ */
+export default class ResizeObserver {
+    /**
+     * The element observed by this observer.
+     */
+    private readonly _element;
+    /**
+     * The callback executed each time {@link #_element} is resized.
+     */
+    private readonly _callback;
+    /**
+     * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+     */
+    private static _observerInstance;
+    /**
+     * A mapping of native DOM elements and their callbacks shared across all
+     * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+     */
+    private static _elementCallbacks;
+    /**
+     * Creates an instance of the `ResizeObserver` class.
+     *
+     * @param element A DOM element that is to be observed for resizing. Note that
+     * the element must be visible (i.e. not detached from DOM) for the observer to work.
+     * @param callback A function called when the observed element was resized. It passes
+     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
+     * object with information about the resize event.
+     */
+    constructor(element: Element, callback: (entry: ResizeObserverEntry) => void);
+    /**
+     * The element observed by this observer.
+     */
+    get element(): Element;
+    /**
+     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
+     */
+    destroy(): void;
+    /**
+     * Registers a new resize callback for the DOM element.
+     */
+    private static _addElementCallback;
+    /**
+     * Removes a resize callback from the DOM element. If no callbacks are left
+     * for the element, it removes the element from the native observer.
+     */
+    private static _deleteElementCallback;
+    /**
+     * Returns are registered resize callbacks for the DOM element.
+     */
+    private static _getElementCallbacks;
+    /**
+     * Creates the single native observer shared across all `ResizeObserver` instances.
+     */
+    private static _createObserver;
+}

package/src/dom/resizeobserver.js

@@ -1,126 +1,126 @@
-/**
- * @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 utils/dom/resizeobserver
- */
-import global from './global';
-/**
- * A helper class which instances allow performing custom actions when native DOM elements are resized.
- *
- * ```ts
- * const editableElement = editor.editing.view.getDomRoot();
- *
- * const observer = new ResizeObserver( editableElement, entry => {
- * 	console.log( 'The editable element has been resized in DOM.' );
- * 	console.log( entry.target ); // -> editableElement
- * 	console.log( entry.contentRect.width ); // -> e.g. '423px'
- * } );
- * ```
- *
- * It uses the [native DOM resize observer](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
- * under the hood.
- */
-export default class ResizeObserver {
-    /**
-     * Creates an instance of the `ResizeObserver` class.
-     *
-     * @param element A DOM element that is to be observed for resizing. Note that
-     * the element must be visible (i.e. not detached from DOM) for the observer to work.
-     * @param callback A function called when the observed element was resized. It passes
-     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
-     * object with information about the resize event.
-     */
-    constructor(element, callback) {
-        // **Note**: For the maximum performance, this class ensures only a single instance of the native
-        // observer is used no matter how many instances of this class were created.
-        if (!ResizeObserver._observerInstance) {
-            ResizeObserver._createObserver();
-        }
-        this._element = element;
-        this._callback = callback;
-        ResizeObserver._addElementCallback(element, callback);
-        ResizeObserver._observerInstance.observe(element);
-    }
-    /**
-     * The element observed by this observer.
-     */
-    get element() {
-        return this._element;
-    }
-    /**
-     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
-     */
-    destroy() {
-        ResizeObserver._deleteElementCallback(this._element, this._callback);
-    }
-    /**
-     * Registers a new resize callback for the DOM element.
-     */
-    static _addElementCallback(element, callback) {
-        if (!ResizeObserver._elementCallbacks) {
-            ResizeObserver._elementCallbacks = new Map();
-        }
-        let callbacks = ResizeObserver._elementCallbacks.get(element);
-        if (!callbacks) {
-            callbacks = new Set();
-            ResizeObserver._elementCallbacks.set(element, callbacks);
-        }
-        callbacks.add(callback);
-    }
-    /**
-     * Removes a resize callback from the DOM element. If no callbacks are left
-     * for the element, it removes the element from the native observer.
-     */
-    static _deleteElementCallback(element, callback) {
-        const callbacks = ResizeObserver._getElementCallbacks(element);
-        // Remove the element callback. Check if exist first in case someone
-        // called destroy() twice.
-        if (callbacks) {
-            callbacks.delete(callback);
-            // If no callbacks left for the element, also remove the element.
-            if (!callbacks.size) {
-                ResizeObserver._elementCallbacks.delete(element);
-                ResizeObserver._observerInstance.unobserve(element);
-            }
-        }
-        if (ResizeObserver._elementCallbacks && !ResizeObserver._elementCallbacks.size) {
-            ResizeObserver._observerInstance = null;
-            ResizeObserver._elementCallbacks = null;
-        }
-    }
-    /**
-     * Returns are registered resize callbacks for the DOM element.
-     */
-    static _getElementCallbacks(element) {
-        if (!ResizeObserver._elementCallbacks) {
-            return null;
-        }
-        return ResizeObserver._elementCallbacks.get(element);
-    }
-    /**
-     * Creates the single native observer shared across all `ResizeObserver` instances.
-     */
-    static _createObserver() {
-        ResizeObserver._observerInstance = new global.window.ResizeObserver(entries => {
-            for (const entry of entries) {
-                const callbacks = ResizeObserver._getElementCallbacks(entry.target);
-                if (callbacks) {
-                    for (const callback of callbacks) {
-                        callback(entry);
-                    }
-                }
-            }
-        });
-    }
-}
-/**
- * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
- */
-ResizeObserver._observerInstance = null;
-/**
- * A mapping of native DOM elements and their callbacks shared across all
- * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
- */
-ResizeObserver._elementCallbacks = 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 utils/dom/resizeobserver
+ */
+import global from './global';
+/**
+ * A helper class which instances allow performing custom actions when native DOM elements are resized.
+ *
+ * ```ts
+ * const editableElement = editor.editing.view.getDomRoot();
+ *
+ * const observer = new ResizeObserver( editableElement, entry => {
+ * 	console.log( 'The editable element has been resized in DOM.' );
+ * 	console.log( entry.target ); // -> editableElement
+ * 	console.log( entry.contentRect.width ); // -> e.g. '423px'
+ * } );
+ * ```
+ *
+ * It uses the [native DOM resize observer](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
+ * under the hood.
+ */
+export default class ResizeObserver {
+    /**
+     * Creates an instance of the `ResizeObserver` class.
+     *
+     * @param element A DOM element that is to be observed for resizing. Note that
+     * the element must be visible (i.e. not detached from DOM) for the observer to work.
+     * @param callback A function called when the observed element was resized. It passes
+     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
+     * object with information about the resize event.
+     */
+    constructor(element, callback) {
+        // **Note**: For the maximum performance, this class ensures only a single instance of the native
+        // observer is used no matter how many instances of this class were created.
+        if (!ResizeObserver._observerInstance) {
+            ResizeObserver._createObserver();
+        }
+        this._element = element;
+        this._callback = callback;
+        ResizeObserver._addElementCallback(element, callback);
+        ResizeObserver._observerInstance.observe(element);
+    }
+    /**
+     * The element observed by this observer.
+     */
+    get element() {
+        return this._element;
+    }
+    /**
+     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
+     */
+    destroy() {
+        ResizeObserver._deleteElementCallback(this._element, this._callback);
+    }
+    /**
+     * Registers a new resize callback for the DOM element.
+     */
+    static _addElementCallback(element, callback) {
+        if (!ResizeObserver._elementCallbacks) {
+            ResizeObserver._elementCallbacks = new Map();
+        }
+        let callbacks = ResizeObserver._elementCallbacks.get(element);
+        if (!callbacks) {
+            callbacks = new Set();
+            ResizeObserver._elementCallbacks.set(element, callbacks);
+        }
+        callbacks.add(callback);
+    }
+    /**
+     * Removes a resize callback from the DOM element. If no callbacks are left
+     * for the element, it removes the element from the native observer.
+     */
+    static _deleteElementCallback(element, callback) {
+        const callbacks = ResizeObserver._getElementCallbacks(element);
+        // Remove the element callback. Check if exist first in case someone
+        // called destroy() twice.
+        if (callbacks) {
+            callbacks.delete(callback);
+            // If no callbacks left for the element, also remove the element.
+            if (!callbacks.size) {
+                ResizeObserver._elementCallbacks.delete(element);
+                ResizeObserver._observerInstance.unobserve(element);
+            }
+        }
+        if (ResizeObserver._elementCallbacks && !ResizeObserver._elementCallbacks.size) {
+            ResizeObserver._observerInstance = null;
+            ResizeObserver._elementCallbacks = null;
+        }
+    }
+    /**
+     * Returns are registered resize callbacks for the DOM element.
+     */
+    static _getElementCallbacks(element) {
+        if (!ResizeObserver._elementCallbacks) {
+            return null;
+        }
+        return ResizeObserver._elementCallbacks.get(element);
+    }
+    /**
+     * Creates the single native observer shared across all `ResizeObserver` instances.
+     */
+    static _createObserver() {
+        ResizeObserver._observerInstance = new global.window.ResizeObserver(entries => {
+            for (const entry of entries) {
+                const callbacks = ResizeObserver._getElementCallbacks(entry.target);
+                if (callbacks) {
+                    for (const callback of callbacks) {
+                        callback(entry);
+                    }
+                }
+            }
+        });
+    }
+}
+/**
+ * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+ */
+ResizeObserver._observerInstance = null;
+/**
+ * A mapping of native DOM elements and their callbacks shared across all
+ * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+ */
+ResizeObserver._elementCallbacks = null;

package/src/dom/scroll.d.ts

@@ -1,73 +1,73 @@
-/**
- * @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
- */
-type IfTrue<T> = T extends true ? true : never;
-/**
- * Makes any page `HTMLElement` or `Range` (`target`) visible inside the browser viewport.
- * This helper will scroll all `target` ancestors and the web browser viewport to reveal the target to
- * the user. If the `target` is already visible, nothing will happen.
- *
- * @param options Additional configuration of the scrolling behavior.
- * @param options.target A target, which supposed to become visible to the user.
- * @param options.viewportOffset An offset from the edge of the viewport (in pixels)
- * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
- * by keeping the `target` some distance from the edge of the viewport and thus making it easier to
- * read or edit by the user.
- * @param options.ancestorOffset An offset from the boundary of scrollable ancestors (if any)
- * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
- * by keeping the `target` some distance from the edge of the ancestors and thus making it easier to
- * read or edit by the user.
- * @param options.alignToTop When set `true`, the helper will make sure the `target` is scrolled up
- * to the top boundary of the viewport and/or scrollable ancestors if scrolled up. When not set
- * (default), the `target` will be revealed by scrolling as little as possible. This option will
- * not affect `targets` that must be scrolled down because they will appear at the top of the boundary
- * anyway.
- *
- * ```
- *                                             scrollViewportToShowTarget() with            scrollViewportToShowTarget() with
- *          Initial state                        alignToTop unset (default)                        alignToTop = true
- *
- * ┌────────────────────────────────┬─┐       ┌────────────────────────────────┬─┐        ┌────────────────────────────────┬─┐
- * │                                │▲│       │                                │▲│        │   [ Target to be revealed ]    │▲│
- * │                                │ │       │                                │ │        │                                │ │
- * │                                │█│       │                                │ │        │                                │ │
- * │                                │█│       │                                │ │        │                                │ │
- * │                                │ │       │                                │█│        │                                │ │
- * │                                │ │       │                                │█│        │                                │█│
- * │                                │ │       │                                │ │        │                                │█│
- * │                                │▼│       │   [ Target to be revealed ]    │▼│        │                                │▼│
- * └────────────────────────────────┴─┘       └────────────────────────────────┴─┘        └────────────────────────────────┴─┘
- *
- *
- *     [ Target to be revealed ]
- *```
- *
- * @param options.forceScroll When set `true`, the `target` will be aligned to the top of the viewport
- * and scrollable ancestors whether it is already visible or not. This option will only work when `alignToTop`
- * is `true`
- */
-export declare function scrollViewportToShowTarget<T extends boolean, U extends IfTrue<T>>({ target, viewportOffset, ancestorOffset, alignToTop, forceScroll }: {
-    readonly target: HTMLElement | Range;
-    readonly viewportOffset?: number | {
-        top: number;
-        bottom: number;
-        left: number;
-        right: number;
-    };
-    readonly ancestorOffset?: number;
-    readonly alignToTop?: T;
-    readonly forceScroll?: U;
-}): void;
-/**
- * Makes any page `HTMLElement` or `Range` (target) visible within its scrollable ancestors,
- * e.g. if they have `overflow: scroll` CSS style.
- *
- * @param target A target, which supposed to become visible to the user.
- * @param ancestorOffset An offset between the target and the boundary of scrollable ancestors
- * to be maintained while scrolling.
- * @param limiterElement The outermost ancestor that should be scrolled. If specified, it can prevent
- * scrolling the whole page.
- */
-export declare function scrollAncestorsToShowTarget(target: HTMLElement | Range, ancestorOffset?: number, limiterElement?: HTMLElement): void;
-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
+ */
+type IfTrue<T> = T extends true ? true : never;
+/**
+ * Makes any page `HTMLElement` or `Range` (`target`) visible inside the browser viewport.
+ * This helper will scroll all `target` ancestors and the web browser viewport to reveal the target to
+ * the user. If the `target` is already visible, nothing will happen.
+ *
+ * @param options Additional configuration of the scrolling behavior.
+ * @param options.target A target, which supposed to become visible to the user.
+ * @param options.viewportOffset An offset from the edge of the viewport (in pixels)
+ * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
+ * by keeping the `target` some distance from the edge of the viewport and thus making it easier to
+ * read or edit by the user.
+ * @param options.ancestorOffset An offset from the boundary of scrollable ancestors (if any)
+ * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
+ * by keeping the `target` some distance from the edge of the ancestors and thus making it easier to
+ * read or edit by the user.
+ * @param options.alignToTop When set `true`, the helper will make sure the `target` is scrolled up
+ * to the top boundary of the viewport and/or scrollable ancestors if scrolled up. When not set
+ * (default), the `target` will be revealed by scrolling as little as possible. This option will
+ * not affect `targets` that must be scrolled down because they will appear at the top of the boundary
+ * anyway.
+ *
+ * ```
+ *                                             scrollViewportToShowTarget() with            scrollViewportToShowTarget() with
+ *          Initial state                        alignToTop unset (default)                        alignToTop = true
+ *
+ * ┌────────────────────────────────┬─┐       ┌────────────────────────────────┬─┐        ┌────────────────────────────────┬─┐
+ * │                                │▲│       │                                │▲│        │   [ Target to be revealed ]    │▲│
+ * │                                │ │       │                                │ │        │                                │ │
+ * │                                │█│       │                                │ │        │                                │ │
+ * │                                │█│       │                                │ │        │                                │ │
+ * │                                │ │       │                                │█│        │                                │ │
+ * │                                │ │       │                                │█│        │                                │█│
+ * │                                │ │       │                                │ │        │                                │█│
+ * │                                │▼│       │   [ Target to be revealed ]    │▼│        │                                │▼│
+ * └────────────────────────────────┴─┘       └────────────────────────────────┴─┘        └────────────────────────────────┴─┘
+ *
+ *
+ *     [ Target to be revealed ]
+ *```
+ *
+ * @param options.forceScroll When set `true`, the `target` will be aligned to the top of the viewport
+ * and scrollable ancestors whether it is already visible or not. This option will only work when `alignToTop`
+ * is `true`
+ */
+export declare function scrollViewportToShowTarget<T extends boolean, U extends IfTrue<T>>({ target, viewportOffset, ancestorOffset, alignToTop, forceScroll }: {
+    readonly target: HTMLElement | Range;
+    readonly viewportOffset?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    readonly ancestorOffset?: number;
+    readonly alignToTop?: T;
+    readonly forceScroll?: U;
+}): void;
+/**
+ * Makes any page `HTMLElement` or `Range` (target) visible within its scrollable ancestors,
+ * e.g. if they have `overflow: scroll` CSS style.
+ *
+ * @param target A target, which supposed to become visible to the user.
+ * @param ancestorOffset An offset between the target and the boundary of scrollable ancestors
+ * to be maintained while scrolling.
+ * @param limiterElement The outermost ancestor that should be scrolled. If specified, it can prevent
+ * scrolling the whole page.
+ */
+export declare function scrollAncestorsToShowTarget(target: HTMLElement | Range, ancestorOffset?: number, limiterElement?: HTMLElement): void;
+export {};