@ckeditor/ckeditor5-engine 36.0.1 → 37.0.0-alpha.0

package/src/view/observer/keyobserver.js

@@ -11,14 +11,18 @@ import { getCode } from '@ckeditor/ckeditor5-utils';
  * Observer for events connected with pressing keyboard keys.
  *
  * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
- *
- * @extends module:engine/view/observer/domeventobserver~DomEventObserver
  */
 export default class KeyObserver extends DomEventObserver {
-    constructor(view) {
-        super(view);
+    constructor() {
+        super(...arguments);
+        /**
+         * @inheritDoc
+         */
         this.domEventType = ['keydown', 'keyup'];
     }
+    /**
+     * @inheritDoc
+     */
     onDomEvent(domEvt) {
         const data = {
             keyCode: domEvt.keyCode,
@@ -33,41 +37,3 @@ export default class KeyObserver extends DomEventObserver {
         this.fire(domEvt.type, domEvt, data);
     }
 }
-/**
- * Fired when a key has been pressed.
- *
- * Introduced by {@link module:engine/view/observer/keyobserver~KeyObserver}.
- *
- * Note that because {@link module:engine/view/observer/keyobserver~KeyObserver} is attached by the
- * {@link module:engine/view/view~View} this event is available by default.
- *
- * @see module:engine/view/observer/keyobserver~KeyObserver
- * @event module:engine/view/document~Document#event:keydown
- * @param {module:engine/view/observer/keyobserver~KeyEventData} keyEventData
- */
-/**
- * Fired when a key has been released.
- *
- * Introduced by {@link module:engine/view/observer/keyobserver~KeyObserver}.
- *
- * Note that because {@link module:engine/view/observer/keyobserver~KeyObserver} is attached by the
- * {@link module:engine/view/view~View} this event is available by default.
- *
- * @see module:engine/view/observer/keyobserver~KeyObserver
- * @event module:engine/view/document~Document#event:keyup
- * @param {module:engine/view/observer/keyobserver~KeyEventData} keyEventData
- */
-/**
- * The value of both events - {@link module:engine/view/document~Document#event:keydown} and
- * {@link module:engine/view/document~Document#event:keyup}.
- *
- * @class module:engine/view/observer/keyobserver~KeyEventData
- * @extends module:engine/view/observer/domeventdata~DomEventData
- * @implements module:utils/keyboard~KeystrokeInfo
- */
-/**
- * Code of the whole keystroke. See {@link module:utils/keyboard~getCode}.
- *
- * @readonly
- * @member {Number} module:engine/view/observer/keyobserver~KeyEventData#keystroke
- */

package/src/view/observer/mouseobserver.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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/observer/mouseobserver
+ */
+import DomEventObserver from './domeventobserver';
+import type DomEventData from './domeventdata';
+/**
+ * Mouse events observer.
+ *
+ * Note that this observer is not available by default. To make it available it needs to be added to
+ * {@link module:engine/view/view~View} by {@link module:engine/view/view~View#addObserver} method.
+ */
+export default class MouseObserver extends DomEventObserver<'mousedown' | 'mouseup' | 'mouseover' | 'mouseout'> {
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: readonly ["mousedown", "mouseup", "mouseover", "mouseout"];
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: MouseEvent): void;
+}
+/**
+ * Fired when the mouse button is pressed down on one of the editing roots of the editor.
+ *
+ * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
+ *
+ * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
+ * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:engine/view/observer/mouseobserver~MouseObserver
+ * @eventName mousedown
+ * @param data The event data.
+ */
+export type ViewDocumentMouseDownEvent = {
+    name: 'mousedown';
+    args: [data: DomEventData<MouseEvent>];
+};
+/**
+ * Fired when the mouse button is released over one of the editing roots of the editor.
+ *
+ * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
+ *
+ * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
+ * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:engine/view/observer/mouseobserver~MouseObserver
+ * @eventName mouseup
+ * @param  data The event data.
+ */
+export type ViewDocumentMouseUpEvent = {
+    name: 'mouseup';
+    args: [data: DomEventData<MouseEvent>];
+};
+/**
+ * Fired when the mouse is over one of the editing roots of the editor.
+ *
+ * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
+ *
+ * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
+ * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:engine/view/observer/mouseobserver~MouseObserver
+ * @eventName mouseup
+ * @param  data The event data.
+ */
+export type ViewDocumentMouseOverEvent = {
+    name: 'mouseover';
+    args: [data: DomEventData<MouseEvent>];
+};
+/**
+ * Fired when the mouse is moved out of the one of the editing roots of the editor.
+ *
+ * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
+ *
+ * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
+ * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:engine/view/observer/mouseobserver~MouseObserver
+ * @eventName mouseup
+ * @param  data The event data.
+ */
+export type ViewDocumentMouseOutEvent = {
+    name: 'mouseout';
+    args: [data: DomEventData<MouseEvent>];
+};

package/src/view/observer/mouseobserver.js

@@ -11,39 +11,19 @@ import DomEventObserver from './domeventobserver';
  *
  * Note that this observer is not available by default. To make it available it needs to be added to
  * {@link module:engine/view/view~View} by {@link module:engine/view/view~View#addObserver} method.
- *
- * @extends module:engine/view/observer/domeventobserver~DomEventObserver
  */
 export default class MouseObserver extends DomEventObserver {
-    constructor(view) {
-        super(view);
+    constructor() {
+        super(...arguments);
+        /**
+         * @inheritDoc
+         */
         this.domEventType = ['mousedown', 'mouseup', 'mouseover', 'mouseout'];
     }
+    /**
+     * @inheritDoc
+     */
     onDomEvent(domEvent) {
         this.fire(domEvent.type, domEvent);
     }
 }
-/**
- * Fired when the mouse button is pressed down on one of the editing roots of the editor.
- *
- * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
- *
- * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
- * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
- *
- * @see module:engine/view/observer/mouseobserver~MouseObserver
- * @event module:engine/view/document~Document#event:mousedown
- * @param {module:engine/view/observer/domeventdata~DomEventData} data The event data.
- */
-/**
- * Fired when the mouse button is released over one of the editing roots of the editor.
- *
- * Introduced by {@link module:engine/view/observer/mouseobserver~MouseObserver}.
- *
- * Note that this event is not available by default. To make it available, {@link module:engine/view/observer/mouseobserver~MouseObserver}
- * needs to be added to {@link module:engine/view/view~View} by the {@link module:engine/view/view~View#addObserver} method.
- *
- * @see module:engine/view/observer/mouseobserver~MouseObserver
- * @event module:engine/view/document~Document#event:mouseup
- * @param {module:engine/view/observer/domeventdata~DomEventData} data The event data.
- */

package/src/view/observer/mutationobserver.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @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/observer/mutationobserver
+ */
+import Observer from './observer';
+import type DomConverter from '../domconverter';
+import type Renderer from '../renderer';
+import type View from '../view';
+/**
+ * Mutation observer's role is to watch for any DOM changes inside the editor that weren't
+ * done by the editor's {@link module:engine/view/renderer~Renderer} itself and reverting these changes.
+ *
+ * It does this by observing all mutations in the DOM, marking related view elements as changed and calling
+ * {@link module:engine/view/renderer~Renderer#render}. Because all mutated nodes are marked as
+ * "to be rendered" and the {@link module:engine/view/renderer~Renderer#render `render()`} method is called,
+ * all changes are reverted in the DOM (the DOM is synced with the editor's view structure).
+ *
+ * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
+ */
+export default class MutationObserver extends Observer {
+    /**
+     * Reference to the {@link module:engine/view/view~View#domConverter}.
+     */
+    readonly domConverter: DomConverter;
+    /**
+     * Reference to the {@link module:engine/view/view~View#_renderer}.
+     */
+    readonly renderer: Renderer;
+    /**
+     * Native mutation observer config.
+     */
+    private readonly _config;
+    /**
+     * Observed DOM elements.
+     */
+    private readonly _domElements;
+    /**
+     * Native mutation observer.
+     */
+    private _mutationObserver;
+    /**
+     * @inheritDoc
+     */
+    constructor(view: View);
+    /**
+     * Synchronously handles mutations and empties the queue.
+     */
+    flush(): void;
+    /**
+     * @inheritDoc
+     */
+    observe(domElement: HTMLElement): void;
+    /**
+     * @inheritDoc
+     */
+    enable(): void;
+    /**
+     * @inheritDoc
+     */
+    disable(): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * Handles mutations. Mark view elements to sync and call render.
+     *
+     * @param domMutations Array of native mutations.
+     */
+    private _onMutations;
+    /**
+     * Checks if mutation was generated by the browser inserting bogus br on the end of the block element.
+     * Such mutations are generated while pressing space or performing native spellchecker correction
+     * on the end of the block element in Firefox browser.
+     *
+     * @param mutation Native mutation object.
+     */
+    private _isBogusBrMutation;
+}

package/src/view/observer/mutationobserver.js

@@ -19,48 +19,21 @@ import { isEqualWith } from 'lodash-es';
  * all changes are reverted in the DOM (the DOM is synced with the editor's view structure).
  *
  * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
- *
- * @extends module:engine/view/observer/observer~Observer
  */
 export default class MutationObserver extends Observer {
+    /**
+     * @inheritDoc
+     */
     constructor(view) {
         super(view);
-        /**
-         * Native mutation observer config.
-         *
-         * @private
-         * @member {Object}
-         */
         this._config = {
             childList: true,
             characterData: true,
             subtree: true
         };
-        /**
-         * Reference to the {@link module:engine/view/view~View#domConverter}.
-         *
-         * @member {module:engine/view/domconverter~DomConverter}
-         */
         this.domConverter = view.domConverter;
-        /**
-         * Reference to the {@link module:engine/view/view~View#_renderer}.
-         *
-         * @member {module:engine/view/renderer~Renderer}
-         */
         this.renderer = view._renderer;
-        /**
-         * Observed DOM elements.
-         *
-         * @private
-         * @member {Array.<HTMLElement>}
-         */
         this._domElements = [];
-        /**
-         * Native mutation observer.
-         *
-         * @private
-         * @member {MutationObserver}
-         */
         this._mutationObserver = new window.MutationObserver(this._onMutations.bind(this));
     }
     /**
@@ -104,8 +77,7 @@ export default class MutationObserver extends Observer {
     /**
      * Handles mutations. Mark view elements to sync and call render.
      *
-     * @private
-     * @param {Array.<Object>} domMutations Array of native mutations.
+     * @param domMutations Array of native mutations.
      */
     _onMutations(domMutations) {
         // As a result of this.flush() we can have an empty collection.
@@ -171,7 +143,7 @@ export default class MutationObserver extends Observer {
         }
         // In case only non-relevant mutations were recorded it skips the event and force render (#5600).
         if (hasMutations) {
-            // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.group( '%c[MutationObserver]%c Mutations detected',
             // @if CK_DEBUG_TYPING // 		'font-weight:bold;color:green', ''
             // @if CK_DEBUG_TYPING // 	);
@@ -179,7 +151,7 @@ export default class MutationObserver extends Observer {
             // At this point we have "dirty DOM" (changed) and de-synched view (which has not been changed).
             // In order to "reset DOM" we render the view again.
             this.view.forceRender();
-            // @if CK_DEBUG_TYPING // if ( window.logCKETyping ) {
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
             // @if CK_DEBUG_TYPING // 	console.groupEnd();
             // @if CK_DEBUG_TYPING // }
         }
@@ -189,9 +161,7 @@ export default class MutationObserver extends Observer {
      * Such mutations are generated while pressing space or performing native spellchecker correction
      * on the end of the block element in Firefox browser.
      *
-     * @private
-     * @param {Object} mutation Native mutation object.
-     * @returns {Boolean}
+     * @param mutation Native mutation object.
      */
     _isBogusBrMutation(mutation) {
         let addedNode = null;

package/src/view/observer/observer.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @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
+ */
+import type Document from '../document';
+import type View from '../view';
+declare const Observer_base: {
+    new (): import("@ckeditor/ckeditor5-utils").DomEmitter;
+    prototype: import("@ckeditor/ckeditor5-utils").DomEmitter;
+};
+/**
+ * Abstract base observer class. Observers are classes which listen to DOM events, do the preliminary
+ * processing and fire events on the {@link module:engine/view/document~Document} objects.
+ * Observers can also add features to the view, for instance by updating its status or marking elements
+ * which need a refresh on DOM events.
+ */
+export default abstract class Observer extends Observer_base {
+    /**
+     * An instance of the view controller.
+     */
+    readonly view: View;
+    /**
+     * A reference to the {@link module:engine/view/document~Document} object.
+     */
+    readonly document: Document;
+    /**
+     * The state of the observer. If it is disabled, no events will be fired.
+     */
+    private _isEnabled;
+    /**
+     * Creates an instance of the observer.
+     */
+    constructor(view: View);
+    /**
+     * The state of the observer. If it is disabled, no events will be fired.
+     */
+    get isEnabled(): boolean;
+    /**
+     * Enables the observer. This method is called when the observer is registered to the
+     * {@link module:engine/view/view~View} and after {@link module:engine/view/view~View#forceRender rendering}
+     * (all observers are {@link #disable disabled} before rendering).
+     *
+     * A typical use case for disabling observers is that mutation observers need to be disabled for the rendering.
+     * However, a child class may not need to be disabled, so it can implement an empty method.
+     *
+     * @see module:engine/view/observer/observer~Observer#disable
+     */
+    enable(): void;
+    /**
+     * Disables the observer. This method is called before
+     * {@link module:engine/view/view~View#forceRender rendering} to prevent firing events during rendering.
+     *
+     * @see module:engine/view/observer/observer~Observer#enable
+     */
+    disable(): void;
+    /**
+     * Disables and destroys the observer, among others removes event listeners created by the observer.
+     */
+    destroy(): void;
+    /**
+     * Checks whether a given DOM event should be ignored (should not be turned into a synthetic view document event).
+     *
+     * Currently, an event will be ignored only if its target or any of its ancestors has the `data-cke-ignore-events` attribute.
+     * This attribute can be used inside the structures generated by
+     * {@link module:engine/view/downcastwriter~DowncastWriter#createUIElement `DowncastWriter#createUIElement()`} to ignore events
+     * fired within a UI that should be excluded from CKEditor 5's realms.
+     *
+     * @param domTarget The DOM event target to check (usually an element, sometimes a text node and
+     * potentially sometimes a document, too).
+     * @returns Whether this event should be ignored by the observer.
+     */
+    checkShouldIgnoreEventFromTarget(domTarget: Node | null): boolean;
+    /**
+     * Starts observing the given root element.
+     *
+     * @param name The name of the root element.
+     */
+    abstract observe(domElement: HTMLElement, name: string): void;
+}
+/**
+ * The constructor of {@link ~Observer} subclass.
+ */
+export type ObserverConstructor = new (view: View) => Observer;
+export {};

package/src/view/observer/observer.js

@@ -11,38 +11,25 @@ import { DomEmitterMixin } from '@ckeditor/ckeditor5-utils';
  * processing and fire events on the {@link module:engine/view/document~Document} objects.
  * Observers can also add features to the view, for instance by updating its status or marking elements
  * which need a refresh on DOM events.
- *
- * @abstract
  */
 export default class Observer extends DomEmitterMixin() {
     /**
      * Creates an instance of the observer.
-     *
-     * @param {module:engine/view/view~View} view
      */
     constructor(view) {
         super();
         /**
-         * An instance of the view controller.
-         *
-         * @readonly
-         * @member {module:engine/view/view~View}
+         * The state of the observer. If it is disabled, no events will be fired.
          */
+        this._isEnabled = false;
         this.view = view;
-        /**
-         * A reference to the {@link module:engine/view/document~Document} object.
-         *
-         * @readonly
-         * @member {module:engine/view/document~Document}
-         */
         this.document = view.document;
-        /**
-         * The state of the observer. If it is disabled, no events will be fired.
-         *
-         * @readonly
-         * @member {Boolean}
-         */
-        this.isEnabled = false;
+    }
+    /**
+     * The state of the observer. If it is disabled, no events will be fired.
+     */
+    get isEnabled() {
+        return this._isEnabled;
     }
     /**
      * Enables the observer. This method is called when the observer is registered to the
@@ -55,7 +42,7 @@ export default class Observer extends DomEmitterMixin() {
      * @see module:engine/view/observer/observer~Observer#disable
      */
     enable() {
-        this.isEnabled = true;
+        this._isEnabled = true;
     }
     /**
      * Disables the observer. This method is called before
@@ -64,7 +51,7 @@ export default class Observer extends DomEmitterMixin() {
      * @see module:engine/view/observer/observer~Observer#enable
      */
     disable() {
-        this.isEnabled = false;
+        this._isEnabled = false;
     }
     /**
      * Disables and destroys the observer, among others removes event listeners created by the observer.
@@ -81,9 +68,9 @@ export default class Observer extends DomEmitterMixin() {
      * {@link module:engine/view/downcastwriter~DowncastWriter#createUIElement `DowncastWriter#createUIElement()`} to ignore events
      * fired within a UI that should be excluded from CKEditor 5's realms.
      *
-     * @param {Node} domTarget The DOM event target to check (usually an element, sometimes a text node and
+     * @param domTarget The DOM event target to check (usually an element, sometimes a text node and
      * potentially sometimes a document, too).
-     * @returns {Boolean} Whether this event should be ignored by the observer.
+     * @returns Whether this event should be ignored by the observer.
      */
     checkShouldIgnoreEventFromTarget(domTarget) {
         if (domTarget && domTarget.nodeType === 3) {

package/src/view/observer/selectionobserver.d.ts

@@ -0,0 +1,143 @@
+/**
+ * @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/observer/selectionobserver
+ */
+import Observer from './observer';
+import MutationObserver from './mutationobserver';
+import type View from '../view';
+import type DocumentSelection from '../documentselection';
+import type DomConverter from '../domconverter';
+import type Selection from '../selection';
+import FocusObserver from './focusobserver';
+type DomSelection = globalThis.Selection;
+/**
+ * Selection observer class observes selection changes in the document. If a selection changes on the document this
+ * observer checks if the DOM selection is different from the {@link module:engine/view/document~Document#selection view selection}.
+ * The selection observer fires {@link module:engine/view/document~Document#event:selectionChange} event only if
+ * a selection change was the only change in the document and the DOM selection is different from the view selection.
+ *
+ * This observer also manages the {@link module:engine/view/document~Document#isSelecting} property of the view document.
+ *
+ * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
+ */
+export default class SelectionObserver extends Observer {
+    /**
+     * Instance of the mutation observer. Selection observer calls
+     * {@link module:engine/view/observer/mutationobserver~MutationObserver#flush} to ensure that the mutations will be handled
+     * before the {@link module:engine/view/document~Document#event:selectionChange} event is fired.
+     */
+    readonly mutationObserver: MutationObserver;
+    /**
+     * Instance of the focus observer. Focus observer calls
+     * {@link module:engine/view/observer/focusobserver~FocusObserver#flush} to mark the latest focus change as complete.
+     */
+    readonly focusObserver: FocusObserver;
+    /**
+     * Reference to the view {@link module:engine/view/documentselection~DocumentSelection} object used to compare
+     * new selection with it.
+     */
+    readonly selection: DocumentSelection;
+    /**
+     * Reference to the {@link module:engine/view/view~View#domConverter}.
+     */
+    readonly domConverter: DomConverter;
+    /**
+     * A set of documents which have added `selectionchange` listener to avoid adding a listener twice to the same
+     * document.
+     */
+    private readonly _documents;
+    /**
+     * Fires debounced event `selectionChangeDone`. It uses `lodash#debounce` method to delay function call.
+     */
+    private readonly _fireSelectionChangeDoneDebounced;
+    /**
+     * When called, starts clearing the {@link #_loopbackCounter} counter in time intervals. When the number of selection
+     * changes exceeds a certain limit within the interval of time, the observer will not fire `selectionChange` but warn about
+     * possible infinite selection loop.
+     */
+    private readonly _clearInfiniteLoopInterval;
+    /**
+     * Unlocks the `isSelecting` state of the view document in case the selection observer did not record this fact
+     * correctly (for whatever reason). It is a safeguard (paranoid check), that returns document to the normal state
+     * after a certain period of time (debounced, postponed by each selectionchange event).
+     */
+    private readonly _documentIsSelectingInactivityTimeoutDebounced;
+    /**
+     * Private property to check if the code does not enter infinite loop.
+     */
+    private _loopbackCounter;
+    constructor(view: View);
+    /**
+     * @inheritDoc
+     */
+    observe(domElement: HTMLElement): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * Selection change listener. {@link module:engine/view/observer/mutationobserver~MutationObserver#flush Flush} mutations, check if
+     * a selection changes and fires {@link module:engine/view/document~Document#event:selectionChange} event on every change
+     * and {@link module:engine/view/document~Document#event:selectionChangeDone} when a selection stop changing.
+     *
+     * @param domEvent DOM event.
+     * @param domDocument DOM document.
+     */
+    private _handleSelectionChange;
+    /**
+     * Clears `SelectionObserver` internal properties connected with preventing infinite loop.
+     */
+    private _clearInfiniteLoop;
+}
+/**
+ * The value of {@link ~ViewDocumentSelectionChangeEvent} and {@link ~ViewDocumentSelectionChangeDoneEvent} events.
+ */
+export type ViewDocumentSelectionEventData = {
+    /**
+     * Old View selection which is {@link module:engine/view/document~Document#selection}.
+     */
+    oldSelection: DocumentSelection;
+    /**
+     * New View selection which is converted DOM selection.
+     */
+    newSelection: Selection;
+    /**
+     * Native DOM selection.
+     */
+    domSelection: DomSelection | null;
+};
+/**
+ * Fired when a selection has changed. This event is fired only when the selection change was the only change that happened
+ * in the document, and the old selection is different then the new selection.
+ *
+ * Introduced by {@link module:engine/view/observer/selectionobserver~SelectionObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/selectionobserver~SelectionObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/selectionobserver~SelectionObserver
+ * @eventName selectionChange
+ */
+export type ViewDocumentSelectionChangeEvent = {
+    name: 'selectionChange';
+    args: [ViewDocumentSelectionEventData];
+};
+/**
+ * Fired when selection stops changing.
+ *
+ * Introduced by {@link module:engine/view/observer/selectionobserver~SelectionObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/selectionobserver~SelectionObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/selectionobserver~SelectionObserver
+ * @eventName selectionChangeDone
+ */
+export type ViewDocumentSelectionChangeDoneEvent = {
+    name: 'selectionChangeDone';
+    args: [ViewDocumentSelectionEventData];
+};
+export {};