@ckeditor/ckeditor5-engine 0.0.0-internal-20241017.0

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

@@ -0,0 +1,94 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/focusobserver
+ */
+import DomEventObserver from './domeventobserver.js';
+import type DomEventData from './domeventdata.js';
+import type View from '../view.js';
+/**
+ * {@link module:engine/view/document~Document#event:focus Focus}
+ * and {@link module:engine/view/document~Document#event:blur blur} events observer.
+ * Focus observer handle also {@link module:engine/view/rooteditableelement~RootEditableElement#isFocused isFocused} property of the
+ * {@link module:engine/view/rooteditableelement~RootEditableElement root elements}.
+ *
+ * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
+ */
+export default class FocusObserver extends DomEventObserver<'focus' | 'blur'> {
+    /**
+     * Identifier of the timeout currently used by focus listener to delay rendering execution.
+     */
+    private _renderTimeoutId;
+    /**
+     * Set to `true` if the document is in the process of setting the focus.
+     *
+     * The flag is used to indicate that setting the focus is in progress.
+     */
+    private _isFocusChanging;
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: readonly ["focus", "blur"];
+    /**
+     * @inheritDoc
+     */
+    constructor(view: View);
+    /**
+     * Finishes setting the document focus state.
+     */
+    flush(): void;
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: FocusEvent): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * The `focus` event handler.
+     */
+    private _handleFocus;
+    /**
+     * The `blur` event handler.
+     */
+    private _handleBlur;
+    /**
+     * Clears timeout.
+     */
+    private _clearTimeout;
+}
+/**
+ * Fired when one of the editables gets focus.
+ *
+ * Introduced by {@link module:engine/view/observer/focusobserver~FocusObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/focusobserver~FocusObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/focusobserver~FocusObserver
+ * @eventName module:engine/view/document~Document#focus
+ * @param data Event data.
+ */
+export type ViewDocumentFocusEvent = {
+    name: 'focus';
+    args: [data: DomEventData<FocusEvent>];
+};
+/**
+ * Fired when one of the editables loses focus.
+ *
+ * Introduced by {@link module:engine/view/observer/focusobserver~FocusObserver}.
+ *
+ * Note that because {@link module:engine/view/observer/focusobserver~FocusObserver} is attached by the
+ * {@link module:engine/view/view~View} this event is available by default.
+ *
+ * @see module:engine/view/observer/focusobserver~FocusObserver
+ * @eventName module:engine/view/document~Document#blur
+ * @param data Event data.
+ */
+export type ViewDocumentBlurEvent = {
+    name: 'blur';
+    args: [data: DomEventData<FocusEvent>];
+};

package/src/view/observer/focusobserver.js

@@ -0,0 +1,116 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/focusobserver
+ */
+/* globals setTimeout, clearTimeout */
+import DomEventObserver from './domeventobserver.js';
+/**
+ * {@link module:engine/view/document~Document#event:focus Focus}
+ * and {@link module:engine/view/document~Document#event:blur blur} events observer.
+ * Focus observer handle also {@link module:engine/view/rooteditableelement~RootEditableElement#isFocused isFocused} property of the
+ * {@link module:engine/view/rooteditableelement~RootEditableElement root elements}.
+ *
+ * Note that this observer is attached by the {@link module:engine/view/view~View} and is available by default.
+ */
+export default class FocusObserver extends DomEventObserver {
+    /**
+     * @inheritDoc
+     */
+    constructor(view) {
+        super(view);
+        /**
+         * Identifier of the timeout currently used by focus listener to delay rendering execution.
+         */
+        this._renderTimeoutId = null;
+        /**
+         * Set to `true` if the document is in the process of setting the focus.
+         *
+         * The flag is used to indicate that setting the focus is in progress.
+         */
+        this._isFocusChanging = false;
+        /**
+         * @inheritDoc
+         */
+        this.domEventType = ['focus', 'blur'];
+        this.useCapture = true;
+        const document = this.document;
+        document.on('focus', () => this._handleFocus());
+        document.on('blur', (evt, data) => this._handleBlur(data));
+        // Focus the editor in cases where browser dispatches `beforeinput` event to a not-focused editable element.
+        // This is flushed by the beforeinput listener in the `InsertTextObserver`.
+        // Note that focus is set only if the document is not focused yet.
+        // See https://github.com/ckeditor/ckeditor5/issues/14702.
+        document.on('beforeinput', () => {
+            if (!document.isFocused) {
+                this._handleFocus();
+            }
+        }, { priority: 'highest' });
+    }
+    /**
+     * Finishes setting the document focus state.
+     */
+    flush() {
+        if (this._isFocusChanging) {
+            this._isFocusChanging = false;
+            this.document.isFocused = true;
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent) {
+        this.fire(domEvent.type, domEvent);
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        this._clearTimeout();
+        super.destroy();
+    }
+    /**
+     * The `focus` event handler.
+     */
+    _handleFocus() {
+        this._clearTimeout();
+        this._isFocusChanging = true;
+        // Unfortunately native `selectionchange` event is fired asynchronously.
+        // We need to wait until `SelectionObserver` handle the event and then render. Otherwise rendering will
+        // overwrite new DOM selection with selection from the view.
+        // See https://github.com/ckeditor/ckeditor5-engine/issues/795 for more details.
+        // Long timeout is needed to solve #676 and https://github.com/ckeditor/ckeditor5-engine/issues/1157 issues.
+        //
+        // Using `view.change()` instead of `view.forceRender()` to prevent double rendering
+        // in a situation where `selectionchange` already caused selection change.
+        this._renderTimeoutId = setTimeout(() => {
+            this._renderTimeoutId = null;
+            this.flush();
+            this.view.change(() => { });
+        }, 50);
+    }
+    /**
+     * The `blur` event handler.
+     */
+    _handleBlur(data) {
+        const selectedEditable = this.document.selection.editableElement;
+        if (selectedEditable === null || selectedEditable === data.target) {
+            this.document.isFocused = false;
+            this._isFocusChanging = false;
+            // Re-render the document to update view elements
+            // (changing document.isFocused already marked view as changed since last rendering).
+            this.view.change(() => { });
+        }
+    }
+    /**
+     * Clears timeout.
+     */
+    _clearTimeout() {
+        if (this._renderTimeoutId) {
+            clearTimeout(this._renderTimeoutId);
+            this._renderTimeoutId = null;
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/inputobserver
+ */
+import DomEventObserver from './domeventobserver.js';
+import type DomEventData from './domeventdata.js';
+import type ViewRange from '../range.js';
+import DataTransfer from '../datatransfer.js';
+/**
+ * Observer for events connected with data input.
+ *
+ * **Note**: This observer is attached by {@link module:engine/view/view~View} and available by default in all
+ * editor instances.
+ */
+export default class InputObserver extends DomEventObserver<'beforeinput'> {
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: "beforeinput";
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: InputEvent): void;
+}
+/**
+ * Fired before the web browser inputs, deletes, or formats some data.
+ *
+ * This event is introduced by {@link module:engine/view/observer/inputobserver~InputObserver} and available
+ * by default in all editor instances (attached by {@link module:engine/view/view~View}).
+ *
+ * @see module:engine/view/observer/inputobserver~InputObserver
+ * @eventName module:engine/view/document~Document#beforeinput
+ * @param data Event data containing detailed information about the event.
+ */
+export type ViewDocumentInputEvent = {
+    name: 'beforeinput';
+    args: [data: InputEventData];
+};
+/**
+ * The value of the {@link ~ViewDocumentInputEvent} event.
+ */
+export interface InputEventData extends DomEventData<InputEvent> {
+    /**
+     * The type of the input event (e.g. "insertText" or "deleteWordBackward"). Corresponds to native `InputEvent#inputType`.
+     */
+    readonly inputType: string;
+    /**
+     * A unified text data passed along with the input event. Depending on:
+     *
+     * * the web browser and input events implementation (for instance [Level 1](https://www.w3.org/TR/input-events-1/) or
+     * [Level 2](https://www.w3.org/TR/input-events-2/)),
+     * * {@link module:engine/view/observer/inputobserver~InputEventData#inputType input type}
+     *
+     * text data is sometimes passed in the `data` and sometimes in the `dataTransfer` property.
+     *
+     * * If `InputEvent#data` was set, this property reflects its value.
+     * * If `InputEvent#data` is unavailable, this property contains the `'text/plain'` data from
+     * {@link module:engine/view/observer/inputobserver~InputEventData#dataTransfer}.
+     * * If the event ({@link module:engine/view/observer/inputobserver~InputEventData#inputType input type})
+     * provides no data whatsoever, this property is `null`.
+     */
+    readonly data: string | null;
+    /**
+     * The data transfer instance of the input event. Corresponds to native `InputEvent#dataTransfer`.
+     *
+     * The value is `null` when no `dataTransfer` was passed along with the input event.
+     */
+    readonly dataTransfer: DataTransfer;
+    /**
+     * A flag indicating that the `beforeinput` event was fired during composition.
+     *
+     * Corresponds to the
+     * {@link module:engine/view/document~Document#event:compositionstart},
+     * {@link module:engine/view/document~Document#event:compositionupdate},
+     * and {@link module:engine/view/document~Document#event:compositionend } trio.
+     */
+    readonly isComposing: boolean;
+    /**
+     * Editing {@link module:engine/view/range~Range view ranges} corresponding to DOM ranges provided by the web browser
+     * (as returned by `InputEvent#getTargetRanges()`).
+     */
+    readonly targetRanges: Array<ViewRange>;
+}

package/src/view/observer/inputobserver.js

@@ -0,0 +1,166 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/inputobserver
+ */
+import DomEventObserver from './domeventobserver.js';
+import DataTransfer from '../datatransfer.js';
+import { env } from '@ckeditor/ckeditor5-utils';
+// @if CK_DEBUG_TYPING // const { _debouncedLine } = require( '../../dev-utils/utils.js' );
+/**
+ * Observer for events connected with data input.
+ *
+ * **Note**: This observer is attached by {@link module:engine/view/view~View} and available by default in all
+ * editor instances.
+ */
+export default class InputObserver extends DomEventObserver {
+    constructor() {
+        super(...arguments);
+        /**
+         * @inheritDoc
+         */
+        this.domEventType = 'beforeinput';
+    }
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent) {
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	_debouncedLine();
+        // @if CK_DEBUG_TYPING // 	console.group( `%c[InputObserver]%c ${ domEvent.type }: ${ domEvent.inputType }`,
+        // @if CK_DEBUG_TYPING // 		'color: green', 'color: default'
+        // @if CK_DEBUG_TYPING // 	);
+        // @if CK_DEBUG_TYPING // }
+        const domTargetRanges = domEvent.getTargetRanges();
+        const view = this.view;
+        const viewDocument = view.document;
+        let dataTransfer = null;
+        let data = null;
+        let targetRanges = [];
+        if (domEvent.dataTransfer) {
+            dataTransfer = new DataTransfer(domEvent.dataTransfer);
+        }
+        if (domEvent.data !== null) {
+            data = domEvent.data;
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( `%c[InputObserver]%c event data: %c${ JSON.stringify( data ) }`,
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', 'color: blue;'
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+        }
+        else if (dataTransfer) {
+            data = dataTransfer.getData('text/plain');
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( `%c[InputObserver]%c event data transfer: %c${ JSON.stringify( data ) }`,
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', 'color: blue;'
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+        }
+        // If the editor selection is fake (an object is selected), the DOM range does not make sense because it is anchored
+        // in the fake selection container.
+        if (viewDocument.selection.isFake) {
+            // Future-proof: in case of multi-range fake selections being possible.
+            targetRanges = Array.from(viewDocument.selection.getRanges());
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using fake selection:',
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges,
+            // @if CK_DEBUG_TYPING // 		viewDocument.selection.isFake ? 'fake view selection' : 'fake DOM parent'
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+        }
+        else if (domTargetRanges.length) {
+            targetRanges = domTargetRanges.map(domRange => {
+                // Sometimes browser provides range that starts before editable node.
+                // We try to fall back to collapsed range at the valid end position.
+                // See https://github.com/ckeditor/ckeditor5/issues/14411.
+                // See https://github.com/ckeditor/ckeditor5/issues/14050.
+                const viewStart = view.domConverter.domPositionToView(domRange.startContainer, domRange.startOffset);
+                const viewEnd = view.domConverter.domPositionToView(domRange.endContainer, domRange.endOffset);
+                if (viewStart) {
+                    return view.createRange(viewStart, viewEnd);
+                }
+                else if (viewEnd) {
+                    return view.createRange(viewEnd);
+                }
+            }).filter((range) => !!range);
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using target ranges:',
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+        }
+        // For Android devices we use a fallback to the current DOM selection, Android modifies it according
+        // to the expected target ranges of input event.
+        else if (env.isAndroid) {
+            const domSelection = domEvent.target.ownerDocument.defaultView.getSelection();
+            targetRanges = Array.from(view.domConverter.domSelectionToView(domSelection).getRanges());
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.info( '%c[InputObserver]%c using selection ranges:',
+            // @if CK_DEBUG_TYPING // 		'color: green; font-weight: bold', 'font-weight: bold', targetRanges
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+        }
+        // Android sometimes fires insertCompositionText with a new-line character at the end of the data
+        // instead of firing insertParagraph beforeInput event.
+        // Fire the correct type of beforeInput event and ignore the replaced fragment of text because
+        // it wants to replace "test" with "test\n".
+        // https://github.com/ckeditor/ckeditor5/issues/12368.
+        if (env.isAndroid && domEvent.inputType == 'insertCompositionText' && data && data.endsWith('\n')) {
+            this.fire(domEvent.type, domEvent, {
+                inputType: 'insertParagraph',
+                targetRanges: [view.createRange(targetRanges[0].end)]
+            });
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.groupEnd();
+            // @if CK_DEBUG_TYPING // }
+            return;
+        }
+        // Normalize the insertText data that includes new-line characters.
+        // https://github.com/ckeditor/ckeditor5/issues/2045.
+        if (domEvent.inputType == 'insertText' && data && data.includes('\n')) {
+            // There might be a single new-line or double for new paragraph, but we translate
+            // it to paragraphs as it is our default action for enter handling.
+            const parts = data.split(/\n{1,2}/g);
+            let partTargetRanges = targetRanges;
+            for (let i = 0; i < parts.length; i++) {
+                const dataPart = parts[i];
+                if (dataPart != '') {
+                    this.fire(domEvent.type, domEvent, {
+                        data: dataPart,
+                        dataTransfer,
+                        targetRanges: partTargetRanges,
+                        inputType: domEvent.inputType,
+                        isComposing: domEvent.isComposing
+                    });
+                    // Use the result view selection so following events will be added one after another.
+                    partTargetRanges = [viewDocument.selection.getFirstRange()];
+                }
+                if (i + 1 < parts.length) {
+                    this.fire(domEvent.type, domEvent, {
+                        inputType: 'insertParagraph',
+                        targetRanges: partTargetRanges
+                    });
+                    // Use the result view selection so following events will be added one after another.
+                    partTargetRanges = [viewDocument.selection.getFirstRange()];
+                }
+            }
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.groupEnd();
+            // @if CK_DEBUG_TYPING // }
+            return;
+        }
+        // Fire the normalized beforeInput event.
+        this.fire(domEvent.type, domEvent, {
+            data,
+            dataTransfer,
+            targetRanges,
+            inputType: domEvent.inputType,
+            isComposing: domEvent.isComposing
+        });
+        // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+        // @if CK_DEBUG_TYPING // 	console.groupEnd();
+        // @if CK_DEBUG_TYPING // }
+    }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/keyobserver
+ */
+import DomEventObserver from './domeventobserver.js';
+import type DomEventData from './domeventdata.js';
+import { type KeystrokeInfo } 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.
+ */
+export default class KeyObserver extends DomEventObserver<'keydown' | 'keyup', KeystrokeInfo & {
+    keystroke: number;
+}> {
+    /**
+     * @inheritDoc
+     */
+    readonly domEventType: readonly ["keydown", "keyup"];
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvt: KeyboardEvent): void;
+}
+/**
+ * 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
+ * @eventName module:engine/view/document~Document#keydown
+ */
+export type ViewDocumentKeyDownEvent = {
+    name: 'keydown';
+    args: [data: 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
+ * @eventName module:engine/view/document~Document#keyup
+ */
+export type ViewDocumentKeyUpEvent = {
+    name: 'keyup';
+    args: [data: KeyEventData];
+};
+/**
+ * The value of both events - {@link ~ViewDocumentKeyDownEvent} and {@link ~ViewDocumentKeyUpEvent}.
+ */
+export interface KeyEventData extends DomEventData<KeyboardEvent>, KeystrokeInfo {
+    /**
+     * Code of the whole keystroke. See {@link module:utils/keyboard~getCode}.
+     */
+    keystroke: number;
+}

package/src/view/observer/keyobserver.js

@@ -0,0 +1,39 @@
+/**
+ * @license Copyright (c) 2003-2024, 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/keyobserver
+ */
+import DomEventObserver from './domeventobserver.js';
+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.
+ */
+export default class KeyObserver extends DomEventObserver {
+    constructor() {
+        super(...arguments);
+        /**
+         * @inheritDoc
+         */
+        this.domEventType = ['keydown', 'keyup'];
+    }
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvt) {
+        const data = {
+            keyCode: domEvt.keyCode,
+            altKey: domEvt.altKey,
+            ctrlKey: domEvt.ctrlKey,
+            shiftKey: domEvt.shiftKey,
+            metaKey: domEvt.metaKey,
+            get keystroke() {
+                return getCode(this);
+            }
+        };
+        this.fire(domEvt.type, domEvt, data);
+    }
+}

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

@@ -0,0 +1,89 @@
+/**
+ * @license Copyright (c) 2003-2024, 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.js';
+import type DomEventData from './domeventdata.js';
+/**
+ * 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 module:engine/view/document~Document#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 module:engine/view/document~Document#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 module:engine/view/document~Document#mouseover
+ * @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 module:engine/view/document~Document#mouseout
+ * @param  data The event data.
+ */
+export type ViewDocumentMouseOutEvent = {
+    name: 'mouseout';
+    args: [data: DomEventData<MouseEvent>];
+};