@ckeditor/ckeditor5-ui 36.0.0 → 37.0.0-alpha.0

package/src/editorui/bodycollection.js

@@ -24,24 +24,16 @@ import { createElement } from '@ckeditor/ckeditor5-utils';
  * If you create multiple body collections, this class will create a special wrapper element in the DOM to limit the number of
  * elements created directly in the body and remove it when the last body collection will be
  * {@link ~BodyCollection#detachFromDom detached}.
- *
- * @extends module:ui/viewcollection~ViewCollection
  */
 export default class BodyCollection extends ViewCollection {
     /**
      * Creates a new instance of the {@link module:ui/editorui/bodycollection~BodyCollection}.
      *
-     * @param {module:utils/locale~Locale} locale The {@link module:core/editor/editor~Editor editor's locale} instance.
-     * @param {Iterable.<module:ui/view~View>} [initialItems] The initial items of the collection.
+     * @param locale The {@link module:core/editor/editor~Editor editor's locale} instance.
+     * @param initialItems The initial items of the collection.
      */
     constructor(locale, initialItems = []) {
         super(initialItems);
-        /**
-         * The {@link module:core/editor/editor~Editor#locale editor's locale} instance.
-         * See the view {@link module:ui/view~View#locale locale} property.
-         *
-         * @member {module:utils/locale~Locale}
-         */
         this.locale = locale;
     }
     /**
@@ -49,12 +41,6 @@ export default class BodyCollection extends ViewCollection {
      * the body collection.
      */
     attachToDom() {
-        /**
-         * The element holding elements of the body region.
-         *
-         * @protected
-         * @member {HTMLElement} #_bodyCollectionContainer
-         */
         this._bodyCollectionContainer = new Template({
             tag: 'div',
             attributes: {

package/src/editorui/boxed/boxededitoruiview.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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 ui/editorui/boxed/boxededitoruiview
+ */
+import EditorUIView from '../editoruiview';
+import type ViewCollection from '../../viewcollection';
+import type { Locale } from '@ckeditor/ckeditor5-utils';
+/**
+ * The boxed editor UI view class. This class represents an editor interface
+ * consisting of a toolbar and an editable area, enclosed within a box.
+ */
+export default abstract class BoxedEditorUIView extends EditorUIView {
+    /**
+     * Collection of the child views located in the top (`.ck-editor__top`)
+     * area of the UI.
+     */
+    readonly top: ViewCollection;
+    /**
+     * Collection of the child views located in the main (`.ck-editor__main`)
+     * area of the UI.
+     */
+    readonly main: ViewCollection;
+    /**
+     * Voice label of the UI.
+     */
+    private readonly _voiceLabelView;
+    /**
+     * Creates an instance of the boxed editor UI view class.
+     *
+     * @param locale The locale instance..
+     */
+    constructor(locale: Locale);
+    /**
+     * Creates a voice label view instance.
+     */
+    private _createVoiceLabel;
+}

package/src/editorui/boxed/boxededitoruiview.js

@@ -10,40 +10,17 @@ import LabelView from '../../label/labelview';
 /**
  * The boxed editor UI view class. This class represents an editor interface
  * consisting of a toolbar and an editable area, enclosed within a box.
- *
- * @extends module:ui/editorui/editoruiview~EditorUIView
  */
 export default class BoxedEditorUIView extends EditorUIView {
     /**
      * Creates an instance of the boxed editor UI view class.
      *
-     * @param {module:utils/locale~Locale} locale The locale instance..
+     * @param locale The locale instance..
      */
     constructor(locale) {
         super(locale);
-        /**
-         * Collection of the child views located in the top (`.ck-editor__top`)
-         * area of the UI.
-         *
-         * @readonly
-         * @member {module:ui/viewcollection~ViewCollection}
-         */
         this.top = this.createCollection();
-        /**
-         * Collection of the child views located in the main (`.ck-editor__main`)
-         * area of the UI.
-         *
-         * @readonly
-         * @member {module:ui/viewcollection~ViewCollection}
-         */
         this.main = this.createCollection();
-        /**
-         * Voice label of the UI.
-         *
-         * @protected
-         * @readonly
-         * @member {module:ui/view~View} #_voiceLabelView
-         */
         this._voiceLabelView = this._createVoiceLabel();
         this.setTemplate({
             tag: 'div',
@@ -89,9 +66,6 @@ export default class BoxedEditorUIView extends EditorUIView {
     }
     /**
      * Creates a voice label view instance.
-     *
-     * @private
-     * @returns {module:ui/label/labelview~LabelView}
      */
     _createVoiceLabel() {
         const t = this.t;

package/src/editorui/editorui.d.ts

@@ -0,0 +1,264 @@
+/**
+ * @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 core/editor/editorui
+ */
+import ComponentFactory from '../componentfactory';
+import TooltipManager from '../tooltipmanager';
+import type EditorUIView from './editoruiview';
+import type ToolbarView from '../toolbar/toolbarview';
+import { FocusTracker } from '@ckeditor/ckeditor5-utils';
+import type { Editor } from '@ckeditor/ckeditor5-core';
+import '../uiconfig';
+declare const EditorUI_base: {
+    new (): import("@ckeditor/ckeditor5-utils").Observable;
+    prototype: import("@ckeditor/ckeditor5-utils").Observable;
+};
+/**
+ * A class providing the minimal interface that is required to successfully bootstrap any editor UI.
+ */
+export default abstract class EditorUI extends EditorUI_base {
+    /**
+     * The editor that the UI belongs to.
+     */
+    readonly editor: Editor;
+    /**
+     * An instance of the {@link module:ui/componentfactory~ComponentFactory}, a registry used by plugins
+     * to register factories of specific UI components.
+     */
+    readonly componentFactory: ComponentFactory;
+    /**
+     * Stores the information about the editor UI focus and propagates it so various plugins and components
+     * are unified as a focus group.
+     */
+    readonly focusTracker: FocusTracker;
+    /**
+     * Manages the tooltips displayed on mouseover and focus across the UI.
+     */
+    readonly tooltipManager: TooltipManager;
+    /**
+     * Indicates the UI is ready. Set `true` after {@link #event:ready} event is fired.
+     *
+     * @readonly
+     * @default false
+     */
+    isReady: boolean;
+    abstract get view(): EditorUIView;
+    /**
+     * Stores viewport offsets from every direction.
+     *
+     * Viewport offset can be used to constrain balloons or other UI elements into an element smaller than the viewport.
+     * This can be useful if there are any other absolutely positioned elements that may interfere with editor UI.
+     *
+     * Example `editor.ui.viewportOffset` returns:
+     *
+     * ```js
+     * {
+     * 	top: 50,
+     * 	right: 50,
+     * 	bottom: 50,
+     * 	left: 50
+     * }
+     * ```
+     *
+     * This property can be overriden after editor already being initialized:
+     *
+     * ```js
+     * editor.ui.viewportOffset = {
+     * 	top: 100,
+     * 	right: 0,
+     * 	bottom: 0,
+     * 	left: 0
+     * };
+     * ```
+     *
+     * @observable
+     */
+    viewportOffset: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    /**
+     * Stores all editable elements used by the editor instance.
+     */
+    private _editableElementsMap;
+    /**
+     * All available & focusable toolbars.
+     */
+    private _focusableToolbarDefinitions;
+    /**
+     * Creates an instance of the editor UI class.
+     *
+     * @param editor The editor instance.
+     */
+    constructor(editor: Editor);
+    /**
+     * The main (outermost) DOM element of the editor UI.
+     *
+     * For example, in {@link module:editor-classic/classiceditor~ClassicEditor} it is a `<div>` which
+     * wraps the editable element and the toolbar. In {@link module:editor-inline/inlineeditor~InlineEditor}
+     * it is the editable element itself (as there is no other wrapper). However, in
+     * {@link module:editor-decoupled/decouplededitor~DecoupledEditor} it is set to `null` because this editor does not
+     * come with a single "main" HTML element (its editable element and toolbar are separate).
+     *
+     * This property can be understood as a shorthand for retrieving the element that a specific editor integration
+     * considers to be its main DOM element.
+     */
+    get element(): HTMLElement | null;
+    /**
+     * Fires the {@link module:core/editor/editorui~EditorUI#event:update `update`} event.
+     *
+     * This method should be called when the editor UI (e.g. positions of its balloons) needs to be updated due to
+     * some environmental change which CKEditor 5 is not aware of (e.g. resize of a container in which it is used).
+     */
+    update(): void;
+    /**
+     * Destroys the UI.
+     */
+    destroy(): void;
+    /**
+     * Stores the native DOM editable element used by the editor under a unique name.
+     *
+     * Also, registers the element in the editor to maintain the accessibility of the UI. When the user is editing text in a focusable
+     * editable area, they can use the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke to navigate over editor toolbars. See {@link #addToolbar}.
+     *
+     * @param rootName The unique name of the editable element.
+     * @param domElement The native DOM editable element.
+     */
+    setEditableElement(rootName: string, domElement: HTMLElement): void;
+    /**
+     * Returns the editable editor element with the given name or null if editable does not exist.
+     *
+     * @param rootName The editable name.
+     */
+    getEditableElement(rootName?: string): HTMLElement | undefined;
+    /**
+     * Returns array of names of all editor editable elements.
+     */
+    getEditableElementsNames(): IterableIterator<string>;
+    /**
+     * Adds a toolbar to the editor UI. Used primarily to maintain the accessibility of the UI.
+     *
+     * Focusable toolbars can be accessed (focused) by users by pressing the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
+     * Successive keystroke presses navigate over available toolbars.
+     *
+     * @param toolbarView A instance of the toolbar to be registered.
+     */
+    addToolbar(toolbarView: ToolbarView, options?: FocusableToolbarOptions): void;
+    /**
+     * Stores all editable elements used by the editor instance.
+     *
+     * @deprecated
+     */
+    protected get _editableElements(): unknown;
+    /**
+     * Returns viewport offsets object:
+     *
+     * ```js
+     * {
+     * 	top: Number,
+     * 	right: Number,
+     * 	bottom: Number,
+     * 	left: Number
+     * }
+     * ```
+     *
+     * Only top property is currently supported.
+     */
+    private _readViewportOffsetFromConfig;
+    /**
+     * Starts listening for <kbd>Alt</kbd> + <kbd>F10</kbd> and <kbd>Esc</kbd> keystrokes in the context of focusable
+     * {@link #setEditableElement editable elements} and {@link #addToolbar toolbars}
+     * to allow users navigate across the UI.
+     */
+    private _initFocusTracking;
+    /**
+     * Returns definitions of toolbars that could potentially be focused, sorted by their importance for the user.
+     *
+     * Focusable toolbars candidates are either:
+     * * already visible,
+     * * have `beforeFocus()` set in their {@link module:core/editor/editorui~FocusableToolbarDefinition definition} that suggests that
+     * they might show up when called. Keep in mind that determining whether a toolbar will show up (and become focusable) is impossible
+     * at this stage because it depends on its implementation, that in turn depends on the editing context (selection).
+     *
+     * **Note**: Contextual toolbars take precedence over regular toolbars.
+     */
+    private _getFocusableCandidateToolbarDefinitions;
+    /**
+     * Returns a definition of the toolbar that is currently visible and focused (one of its children has focus).
+     *
+     * `null` is returned when no toolbar is currently focused.
+     */
+    private _getCurrentFocusedToolbarDefinition;
+    /**
+     * Focuses a focusable toolbar candidate using its definition.
+     *
+     * @param candidateToolbarDefinition A definition of the toolbar to focus.
+     * @returns `true` when the toolbar candidate was focused. `false` otherwise.
+     */
+    private _focusFocusableCandidateToolbar;
+}
+/**
+ * Fired when the editor UI is ready.
+ *
+ * Fired before {@link module:engine/controller/datacontroller~DataController#event:ready}.
+ *
+ * @eventName ready
+ */
+export type EditorUIReadyEvent = {
+    name: 'ready';
+    args: [];
+};
+/**
+ * Fired whenever the UI (all related components) should be refreshed.
+ *
+ * **Note:**: The event is fired after each {@link module:engine/view/document~Document#event:layoutChanged}.
+ * It can also be fired manually via the {@link module:core/editor/editorui~EditorUI#update} method.
+ *
+ * @eventName update
+ */
+export type EditorUIUpdateEvent = {
+    name: 'update';
+    args: [];
+};
+/**
+ * A definition of a focusable toolbar. Used by {@link module:core/editor/editorui~EditorUI#addToolbar}.
+ */
+export interface FocusableToolbarDefinition {
+    /**
+     * An instance of a focusable toolbar view.
+     */
+    toolbarView: ToolbarView;
+    /**
+     * Options of a focusable toolbar view:
+     *
+     * * `isContextual`: Marks the higher priority toolbar. For example when there are 2 visible toolbars,
+     * it allows to distinguish which toolbar should be focused first after the `alt+f10` keystroke
+     * * `beforeFocus`: A callback executed before the `ToolbarView` gains focus upon the `Alt+F10` keystroke.
+     * * `afterBlur`: A callback executed after `ToolbarView` loses focus upon `Esc` keystroke but before
+     * the focus goes back to the `origin`.
+     */
+    options: FocusableToolbarOptions;
+}
+export interface FocusableToolbarOptions {
+    /**
+     * Set `true` if the toolbar is attached to the content of the editor. Such toolbar takes
+     * a precedence over other toolbars when a user pressed <kbd>Alt</kbd> + <kbd>F10</kbd>.
+     */
+    isContextual?: boolean;
+    /**
+     * Specify a callback executed before the toolbar instance DOM element gains focus
+     * upon the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
+     */
+    beforeFocus?: () => void;
+    /**
+     * Specify a callback executed after the toolbar instance DOM element loses focus upon
+     * <kbd>Esc</kbd> keystroke but before the focus goes back to the {@link #setEditableElement editable element}.
+     */
+    afterBlur?: () => void;
+}
+export {};

package/src/editorui/editorui.js

@@ -9,106 +9,41 @@
 import ComponentFactory from '../componentfactory';
 import TooltipManager from '../tooltipmanager';
 import { ObservableMixin, isVisible, FocusTracker } from '@ckeditor/ckeditor5-utils';
+import '../uiconfig';
 /**
  * A class providing the minimal interface that is required to successfully bootstrap any editor UI.
- *
- * @mixes module:utils/emittermixin~EmitterMixin
  */
 export default class EditorUI extends ObservableMixin() {
     /**
      * Creates an instance of the editor UI class.
      *
-     * @param {module:core/editor/editor~Editor} editor The editor instance.
+     * @param editor The editor instance.
      */
     constructor(editor) {
         super();
-        /**
-         * The editor that the UI belongs to.
-         *
-         * @readonly
-         * @member {module:core/editor/editor~Editor} #editor
-         */
-        this.editor = editor;
-        /**
-         * An instance of the {@link module:ui/componentfactory~ComponentFactory}, a registry used by plugins
-         * to register factories of specific UI components.
-         *
-         * @readonly
-         * @member {module:ui/componentfactory~ComponentFactory} #componentFactory
-         */
-        this.componentFactory = new ComponentFactory(editor);
-        /**
-         * Stores the information about the editor UI focus and propagates it so various plugins and components
-         * are unified as a focus group.
-         *
-         * @readonly
-         * @member {module:utils/focustracker~FocusTracker} #focusTracker
-         */
-        this.focusTracker = new FocusTracker();
-        /**
-         * Manages the tooltips displayed on mouseover and focus across the UI.
-         *
-         * @readonly
-         * @member {module:ui/tooltipmanager~TooltipManager}
-         */
-        this.tooltipManager = new TooltipManager(editor);
-        /**
-         * Stores viewport offsets from every direction.
-         *
-         * Viewport offset can be used to constrain balloons or other UI elements into an element smaller than the viewport.
-         * This can be useful if there are any other absolutely positioned elements that may interfere with editor UI.
-         *
-         * Example `editor.ui.viewportOffset` returns:
-         *
-         * ```js
-         * {
-         * 	top: 50,
-         * 	right: 50,
-         * 	bottom: 50,
-         * 	left: 50
-         * }
-         * ```
-         *
-         * This property can be overriden after editor already being initialized:
-         *
-         * ```js
-         * editor.ui.viewportOffset = {
-         * 	top: 100,
-         * 	right: 0,
-         * 	bottom: 0,
-         * 	left: 0
-         * };
-         * ```
-         *
-         * @observable
-         * @member {Object} #viewportOffset
-         */
-        this.set('viewportOffset', this._readViewportOffsetFromConfig());
         /**
          * Indicates the UI is ready. Set `true` after {@link #event:ready} event is fired.
          *
          * @readonly
          * @default false
-         * @member {Boolean} #isReady
          */
         this.isReady = false;
-        this.once('ready', () => {
-            this.isReady = true;
-        });
         /**
          * Stores all editable elements used by the editor instance.
-         *
-         * @private
-         * @member {Map.<String,HTMLElement>}
          */
         this._editableElementsMap = new Map();
         /**
          * All available & focusable toolbars.
-         *
-         * @private
-         * @type {Array.<module:core/editor/editorui~FocusableToolbarDefinition>}
          */
         this._focusableToolbarDefinitions = [];
+        this.editor = editor;
+        this.componentFactory = new ComponentFactory(editor);
+        this.focusTracker = new FocusTracker();
+        this.tooltipManager = new TooltipManager(editor);
+        this.set('viewportOffset', this._readViewportOffsetFromConfig());
+        this.once('ready', () => {
+            this.isReady = true;
+        });
         // Informs UI components that should be refreshed after layout change.
         this.listenTo(editor.editing.view.document, 'layoutChanged', () => this.update());
         this._initFocusTracking();
@@ -124,9 +59,6 @@ export default class EditorUI extends ObservableMixin() {
      *
      * This property can be understood as a shorthand for retrieving the element that a specific editor integration
      * considers to be its main DOM element.
-     *
-     * @readonly
-     * @member {HTMLElement|null} #element
      */
     get element() {
         return null;
@@ -160,8 +92,8 @@ export default class EditorUI extends ObservableMixin() {
      * Also, registers the element in the editor to maintain the accessibility of the UI. When the user is editing text in a focusable
      * editable area, they can use the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke to navigate over editor toolbars. See {@link #addToolbar}.
      *
-     * @param {String} rootName The unique name of the editable element.
-     * @param {HTMLElement} domElement The native DOM editable element.
+     * @param rootName The unique name of the editable element.
+     * @param domElement The native DOM editable element.
      */
     setEditableElement(rootName, domElement) {
         this._editableElementsMap.set(rootName, domElement);
@@ -194,16 +126,13 @@ export default class EditorUI extends ObservableMixin() {
     /**
      * Returns the editable editor element with the given name or null if editable does not exist.
      *
-     * @param {String} [rootName=main] The editable name.
-     * @returns {HTMLElement|undefined}
+     * @param rootName The editable name.
      */
     getEditableElement(rootName = 'main') {
         return this._editableElementsMap.get(rootName);
     }
     /**
      * Returns array of names of all editor editable elements.
-     *
-     * @returns {Iterable.<String>}
      */
     getEditableElementsNames() {
         return this._editableElementsMap.keys();
@@ -214,14 +143,7 @@ export default class EditorUI extends ObservableMixin() {
      * Focusable toolbars can be accessed (focused) by users by pressing the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
      * Successive keystroke presses navigate over available toolbars.
      *
-     * @param {module:ui/toolbar/toolbarview~ToolbarView} toolbarView A instance of the toolbar to be registered.
-     * @param {Object} [options]
-     * @param {Boolean} [options.isContextual] Set `true` if the toolbar is attached to the content of the editor. Such toolbar takes
-     * a precedence over other toolbars when a user pressed <kbd>Alt</kbd> + <kbd>F10</kbd>.
-     * @param {Function} [options.beforeFocus] Specify a callback executed before the toolbar instance DOM element gains focus
-     * upon the <kbd>Alt</kbd> + <kbd>F10</kbd> keystroke.
-     * @param {Function} [options.afterBlur] Specify a callback executed after the toolbar instance DOM element loses focus upon
-     * <kbd>Esc</kbd> keystroke but before the focus goes back to the {@link #setEditableElement editable element}.
+     * @param toolbarView A instance of the toolbar to be registered.
      */
     addToolbar(toolbarView, options = {}) {
         if (toolbarView.isRendered) {
@@ -239,9 +161,7 @@ export default class EditorUI extends ObservableMixin() {
     /**
      * Stores all editable elements used by the editor instance.
      *
-     * @protected
      * @deprecated
-     * @member {Map.<String,HTMLElement>}
      */
     get _editableElements() {
         /**
@@ -250,7 +170,7 @@ export default class EditorUI extends ObservableMixin() {
          * {@link #getEditableElement `getEditableElement()`} methods instead.
          *
          * @error editor-ui-deprecated-editable-elements
-         * @param {module:core/editor/editorui~EditorUI} editorUI Editor UI instance the deprecated property belongs to.
+         * @param editorUI Editor UI instance the deprecated property belongs to.
          */
         console.warn('editor-ui-deprecated-editable-elements: ' +
             'The EditorUI#_editableElements property has been deprecated and will be removed in the near future.', { editorUI: this });
@@ -269,9 +189,6 @@ export default class EditorUI extends ObservableMixin() {
      * ```
      *
      * Only top property is currently supported.
-     *
-     * @private
-     * @return {Object}
      */
     _readViewportOffsetFromConfig() {
         const editor = this.editor;
@@ -302,8 +219,6 @@ export default class EditorUI extends ObservableMixin() {
      * Starts listening for <kbd>Alt</kbd> + <kbd>F10</kbd> and <kbd>Esc</kbd> keystrokes in the context of focusable
      * {@link #setEditableElement editable elements} and {@link #addToolbar toolbars}
      * to allow users navigate across the UI.
-     *
-     * @private
      */
     _initFocusTracking() {
         const editor = this.editor;
@@ -385,9 +300,6 @@ export default class EditorUI extends ObservableMixin() {
      * at this stage because it depends on its implementation, that in turn depends on the editing context (selection).
      *
      * **Note**: Contextual toolbars take precedence over regular toolbars.
-     *
-     * @private
-     * @returns {Array.<module:core/editor/editorui~FocusableToolbarDefinition>}
      */
     _getFocusableCandidateToolbarDefinitions() {
         const definitions = [];
@@ -406,9 +318,6 @@ export default class EditorUI extends ObservableMixin() {
      * Returns a definition of the toolbar that is currently visible and focused (one of its children has focus).
      *
      * `null` is returned when no toolbar is currently focused.
-     *
-     * @private
-     * @returns {module:core/editor/editorui~FocusableToolbarDefinition|null}
      */
     _getCurrentFocusedToolbarDefinition() {
         for (const definition of this._focusableToolbarDefinitions) {
@@ -421,9 +330,8 @@ export default class EditorUI extends ObservableMixin() {
     /**
      * Focuses a focusable toolbar candidate using its definition.
      *
-     * @private
-     * @param {module:core/editor/editorui~FocusableToolbarDefinition} candidateToolbarDefinition A definition of the toolbar to focus.
-     * @returns {Boolean} `true` when the toolbar candidate was focused. `false` otherwise.
+     * @param candidateToolbarDefinition A definition of the toolbar to focus.
+     * @returns `true` when the toolbar candidate was focused. `false` otherwise.
      */
     _focusFocusableCandidateToolbar(candidateToolbarDefinition) {
         const { toolbarView, options: { beforeFocus } } = candidateToolbarDefinition;
@@ -439,28 +347,13 @@ export default class EditorUI extends ObservableMixin() {
     }
 }
 /**
- * An instance of a focusable toolbar view.
- *
- * @member {module:ui/toolbar/toolbarview~ToolbarView} #toolbarView
- */
-/**
- * Options of a focusable toolbar view:
+ * Returns a number (weight) for a toolbar definition. Visible toolbars have a higher priority and so do
+ * contextual toolbars (displayed in the context of a content, for instance, an image toolbar).
  *
- * * `isContextual`: Marks the higher priority toolbar. For example when there are 2 visible toolbars,
- * it allows to distinguish which toolbar should be focused first after the `alt+f10` keystroke
- * * `beforeFocus`: A callback executed before the `ToolbarView` gains focus upon the `Alt+F10` keystroke.
- * * `afterBlur`: A callback executed after `ToolbarView` loses focus upon `Esc` keystroke but before the focus goes back to the `origin`.
+ * A standard invisible toolbar is the heaviest. A visible contextual toolbar is the lightest.
  *
- * @member {Object} #options
+ * @param toolbarDef A toolbar definition to be weighted.
  */
-// Returns a number (weight) for a toolbar definition. Visible toolbars have a higher priority and so do
-// contextual toolbars (displayed in the context of a content, for instance, an image toolbar).
-//
-// A standard invisible toolbar is the heaviest. A visible contextual toolbar is the lightest.
-//
-// @private
-// @param {module:core/editor/editorui~FocusableToolbarDefinition} toolbarDef A toolbar definition to be weighted.
-// @returns {Number}
 function getToolbarDefinitionWeight(toolbarDef) {
     const { toolbarView, options } = toolbarDef;
     let weight = 10;