@ckeditor/ckeditor5-widget 36.0.1 → 37.0.0-alpha.1

package/src/widgettoolbarrepository.js

@@ -17,23 +17,32 @@ import { isWidget } from './utils';
  *
  * The following example comes from the {@link module:image/imagetoolbar~ImageToolbar} plugin:
  *
- * 		class ImageToolbar extends Plugin {
- *			static get requires() {
- *				return [ WidgetToolbarRepository ];
- *			}
+ * ```ts
+ * class ImageToolbar extends Plugin {
+ * 	static get requires() {
+ * 		return [ WidgetToolbarRepository ];
+ * 	}
  *
- *			afterInit() {
- *				const editor = this.editor;
- *				const widgetToolbarRepository = editor.plugins.get( WidgetToolbarRepository );
+ * 	afterInit() {
+ * 		const editor = this.editor;
+ * 		const widgetToolbarRepository = editor.plugins.get( WidgetToolbarRepository );
  *
- *				widgetToolbarRepository.register( 'image', {
- *					items: editor.config.get( 'image.toolbar' ),
- *					getRelatedElement: getClosestSelectedImageWidget
- *				} );
- *			}
- *		}
+ * 		widgetToolbarRepository.register( 'image', {
+ * 			items: editor.config.get( 'image.toolbar' ),
+ * 			getRelatedElement: getClosestSelectedImageWidget
+ * 		} );
+ * 	}
+ * }
+ * ```
  */
 export default class WidgetToolbarRepository extends Plugin {
+    constructor() {
+        super(...arguments);
+        /**
+         * A map of toolbar definitions.
+         */
+        this._toolbarDefinitions = new Map();
+    }
     /**
      * @inheritDoc
      */
@@ -60,16 +69,6 @@ export default class WidgetToolbarRepository extends Plugin {
                 }
             }, { priority: 'high' });
         }
-        /**
-         * A map of toolbar definitions.
-         *
-         * @protected
-         * @member {Map.<String,module:widget/widgettoolbarrepository~WidgetRepositoryToolbarDefinition>} #_toolbarDefinitions
-         */
-        this._toolbarDefinitions = new Map();
-        /**
-         * @private
-         */
         this._balloon = this.editor.plugins.get('ContextualBalloon');
         this.on('change:isEnabled', () => {
             this._updateToolbarsVisibility();
@@ -96,29 +95,28 @@ export default class WidgetToolbarRepository extends Plugin {
      * Note: This method should be called in the {@link module:core/plugin~PluginInterface#afterInit `Plugin#afterInit()`}
      * callback (or later) to make sure that the given toolbar items were already registered by other plugins.
      *
-     * @param {String} toolbarId An id for the toolbar. Used to
-     * @param {Object} options
-     * @param {String} [options.ariaLabel] Label used by assistive technologies to describe this toolbar element.
-     * @param {Array.<String>} options.items Array of toolbar items.
-     * @param {Function} options.getRelatedElement Callback which returns an element the toolbar should be attached to.
-     * @param {String} [options.balloonClassName='ck-toolbar-container'] CSS class for the widget balloon.
+     * @param toolbarId An id for the toolbar. Used to
+     * @param options.ariaLabel Label used by assistive technologies to describe this toolbar element.
+     * @param options.items Array of toolbar items.
+     * @param options.getRelatedElement Callback which returns an element the toolbar should be attached to.
+     * @param options.balloonClassName CSS class for the widget balloon.
      */
     register(toolbarId, { ariaLabel, items, getRelatedElement, balloonClassName = 'ck-toolbar-container' }) {
         // Trying to register a toolbar without any item.
         if (!items.length) {
             /**
-             * When {@link #register registering} a new widget toolbar, you need to provide a non-empty array with
-             * the items that will be inserted into the toolbar.
+             * When {@link module:widget/widgettoolbarrepository~WidgetToolbarRepository#register registering} a new widget toolbar, you
+             * need to provide a non-empty array with the items that will be inserted into the toolbar.
              *
              * If you see this error when integrating the editor, you likely forgot to configure one of the widget toolbars.
              *
              * See for instance:
              *
-             * * {@link module:table/table~TableConfig#contentToolbar `config.table.contentToolbar`}
-             * * {@link module:image/image~ImageConfig#toolbar `config.image.toolbar`}
+             * * {@link module:table/tableconfig~TableConfig#contentToolbar `config.table.contentToolbar`}
+             * * {@link module:image/imageconfig~ImageConfig#toolbar `config.image.toolbar`}
              *
              * @error widget-toolbar-no-items
-             * @param {String} toolbarId The id of the toolbar that has not been configured correctly.
+             * @param toolbarId The id of the toolbar that has not been configured correctly.
              */
             logWarning('widget-toolbar-no-items', { toolbarId });
             return;
@@ -160,8 +158,6 @@ export default class WidgetToolbarRepository extends Plugin {
     }
     /**
      * Iterates over stored toolbars and makes them visible or hidden.
-     *
-     * @private
      */
     _updateToolbarsVisibility() {
         let maxRelatedElementDepth = 0;
@@ -198,9 +194,6 @@ export default class WidgetToolbarRepository extends Plugin {
     }
     /**
      * Hides the given toolbar.
-     *
-     * @private
-     * @param {module:widget/widgettoolbarrepository~WidgetRepositoryToolbarDefinition} toolbarDefinition
      */
     _hideToolbar(toolbarDefinition) {
         this._balloon.remove(toolbarDefinition.view);
@@ -211,11 +204,7 @@ export default class WidgetToolbarRepository extends Plugin {
      * Otherwise, repositions the toolbar's balloon when toolbar's view is the most top view in balloon stack.
      *
      * It might happen here that the toolbar's view is under another view. Then do nothing as the other toolbar view
-     * should be still visible after the {@link module:core/editor/editorui~EditorUI#event:update}.
-     *
-     * @private
-     * @param {module:widget/widgettoolbarrepository~WidgetRepositoryToolbarDefinition} toolbarDefinition
-     * @param {module:engine/view/element~Element} relatedElement
+     * should be still visible after the {@link module:ui/editorui/editorui~EditorUI#event:update}.
      */
     _showToolbar(toolbarDefinition, relatedElement) {
         if (this._isToolbarVisible(toolbarDefinition)) {
@@ -245,19 +234,9 @@ export default class WidgetToolbarRepository extends Plugin {
             });
         }
     }
-    /**
-     * @private
-     * @param {Object} toolbar
-     * @returns {Boolean}
-     */
     _isToolbarVisible(toolbar) {
         return this._balloon.visibleView === toolbar.view;
     }
-    /**
-     * @private
-     * @param {Object} toolbar
-     * @returns {Boolean}
-     */
     _isToolbarInBalloon(toolbar) {
         return this._balloon.hasView(toolbar.view);
     }

package/src/widgettypearound/utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { DocumentSelection, DomConverter, Element, Schema, Selection, ViewElement } from '@ckeditor/ckeditor5-engine';
+/**
+ * The name of the type around model selection attribute responsible for
+ * displaying a fake caret next to a selected widget.
+ */
+export declare const TYPE_AROUND_SELECTION_ATTRIBUTE = "widget-type-around";
+/**
+ * Checks if an element is a widget that qualifies to get the widget type around UI.
+ */
+export declare function isTypeAroundWidget(viewElement: ViewElement | undefined, modelElement: Element, schema: Schema): boolean;
+/**
+ * For the passed HTML element, this helper finds the closest widget type around button ancestor.
+ */
+export declare function getClosestTypeAroundDomButton(domElement: HTMLElement): HTMLElement | null;
+/**
+ * For the passed widget type around button element, this helper determines at which position
+ * the paragraph would be inserted into the content if, for instance, the button was
+ * clicked by the user.
+ *
+ * @returns The position of the button.
+ */
+export declare function getTypeAroundButtonPosition(domElement: HTMLElement): 'before' | 'after';
+/**
+ * For the passed HTML element, this helper returns the closest view widget ancestor.
+ */
+export declare function getClosestWidgetViewElement(domElement: HTMLElement, domConverter: DomConverter): ViewElement;
+/**
+ * For the passed selection instance, it returns the position of the fake caret displayed next to a widget.
+ *
+ * **Note**: If the fake caret is not currently displayed, `null` is returned.
+ *
+ * @returns The position of the fake caret or `null` when none is present.
+ */
+export declare function getTypeAroundFakeCaretPosition(selection: Selection | DocumentSelection): 'before' | 'after' | null;

package/src/widgettypearound/utils.js

@@ -13,20 +13,12 @@ import { isWidget } from '../utils';
 export const TYPE_AROUND_SELECTION_ATTRIBUTE = 'widget-type-around';
 /**
  * Checks if an element is a widget that qualifies to get the widget type around UI.
- *
- * @param {module:engine/view/element~Element} viewElement
- * @param {module:engine/model/element~Element} modelElement
- * @param {module:engine/model/schema~Schema} schema
- * @returns {Boolean}
  */
 export function isTypeAroundWidget(viewElement, modelElement, schema) {
     return !!viewElement && isWidget(viewElement) && !schema.isInline(modelElement);
 }
 /**
  * For the passed HTML element, this helper finds the closest widget type around button ancestor.
- *
- * @param {HTMLElement} domElement
- * @returns {HTMLElement|null}
  */
 export function getClosestTypeAroundDomButton(domElement) {
     return domElement.closest('.ck-widget__type-around__button');
@@ -36,18 +28,13 @@ export function getClosestTypeAroundDomButton(domElement) {
  * the paragraph would be inserted into the content if, for instance, the button was
  * clicked by the user.
  *
- * @param {HTMLElement} domElement
- * @returns {'before'|'after'} The position of the button.
+ * @returns The position of the button.
  */
 export function getTypeAroundButtonPosition(domElement) {
     return domElement.classList.contains('ck-widget__type-around__button_before') ? 'before' : 'after';
 }
 /**
  * For the passed HTML element, this helper returns the closest view widget ancestor.
- *
- * @param {HTMLElement} domElement
- * @param {module:engine/view/domconverter~DomConverter} domConverter
- * @returns {module:engine/view/element~Element}
  */
 export function getClosestWidgetViewElement(domElement, domConverter) {
     const widgetDomElement = domElement.closest('.ck-widget');
@@ -58,8 +45,7 @@ export function getClosestWidgetViewElement(domElement, domConverter) {
  *
  * **Note**: If the fake caret is not currently displayed, `null` is returned.
  *
- * @param {module:engine/model/selection~Selection|module:engine/model/documentselection~DocumentSelection} selection
- * @returns {'before'|'after'|null} The position of the fake caret or `null` when none is present.
+ * @returns The position of the fake caret or `null` when none is present.
  */
 export function getTypeAroundFakeCaretPosition(selection) {
     return selection.getAttribute(TYPE_AROUND_SELECTION_ATTRIBUTE);

package/src/widgettypearound/widgettypearound.d.ts

@@ -0,0 +1,227 @@
+/**
+ * @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 widget/widgettypearound/widgettypearound
+ */
+import { Plugin, type PluginDependencies } from '@ckeditor/ckeditor5-core';
+import '../../theme/widgettypearound.css';
+/**
+ * A plugin that allows users to type around widgets where normally it is impossible to place the caret due
+ * to limitations of web browsers. These "tight spots" occur, for instance, before (or after) a widget being
+ * the first (or last) child of its parent or between two block widgets.
+ *
+ * This plugin extends the {@link module:widget/widget~Widget `Widget`} plugin and injects the user interface
+ * with two buttons into each widget instance in the editor. Each of the buttons can be clicked by the
+ * user if the widget is next to the "tight spot". Once clicked, a paragraph is created with the selection anchored
+ * in it so that users can type (or insert content, paste, etc.) straight away.
+ */
+export default class WidgetTypeAround extends Plugin {
+    /**
+     * A reference to the model widget element that has the fake caret active
+     * on either side of it. It is later used to remove CSS classes associated with the fake caret
+     * when the widget no longer needs it.
+     */
+    private _currentFakeCaretModelElement;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): 'WidgetTypeAround';
+    /**
+     * @inheritDoc
+     */
+    static get requires(): PluginDependencies;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * Inserts a new paragraph next to a widget element with the selection anchored in it.
+     *
+     * **Note**: This method is heavily user-oriented and will both focus the editing view and scroll
+     * the viewport to the selection in the inserted paragraph.
+     *
+     * @param widgetModelElement The model widget element next to which a paragraph is inserted.
+     * @param position The position where the paragraph is inserted. Either `'before'` or `'after'` the widget.
+     */
+    private _insertParagraph;
+    /**
+     * A wrapper for the {@link module:utils/emittermixin~Emitter#listenTo} method that executes the callbacks only
+     * when the plugin {@link #isEnabled is enabled}.
+     *
+     * @param emitter The object that fires the event.
+     * @param event The name of the event.
+     * @param callback The function to be called on event.
+     * @param options Additional options.
+     * @param options.priority The priority of this event callback. The higher the priority value the sooner
+     * the callback will be fired. Events having the same priority are called in the order they were added.
+     */
+    private _listenToIfEnabled;
+    /**
+     * Similar to {@link #_insertParagraph}, this method inserts a paragraph except that it
+     * does not expect a position. Instead, it performs the insertion next to a selected widget
+     * according to the `widget-type-around` model selection attribute value (fake caret position).
+     *
+     * Because this method requires the `widget-type-around` attribute to be set,
+     * the insertion can only happen when the widget's fake caret is active (e.g. activated
+     * using the keyboard).
+     *
+     * @returns Returns `true` when the paragraph was inserted (the attribute was present) and `false` otherwise.
+     */
+    private _insertParagraphAccordingToFakeCaretPosition;
+    /**
+     * Creates a listener in the editing conversion pipeline that injects the widget type around
+     * UI into every single widget instance created in the editor.
+     *
+     * The UI is delivered as a {@link module:engine/view/uielement~UIElement}
+     * wrapper which renders DOM buttons that users can use to insert paragraphs.
+     */
+    private _enableTypeAroundUIInjection;
+    /**
+     * Brings support for the fake caret that appears when either:
+     *
+     * * the selection moves to a widget from a position next to it using arrow keys,
+     * * the arrow key is pressed when the widget is already selected.
+     *
+     * The fake caret lets the user know that they can start typing or just press
+     * <kbd>Enter</kbd> to insert a paragraph at the position next to a widget as suggested by the fake caret.
+     *
+     * The fake caret disappears when the user changes the selection or the editor
+     * gets blurred.
+     *
+     * The whole idea is as follows:
+     *
+     * 1. A user does one of the 2 scenarios described at the beginning.
+     * 2. The "keydown" listener is executed and the decision is made whether to show or hide the fake caret.
+     * 3. If it should show up, the `widget-type-around` model selection attribute is set indicating
+     *    on which side of the widget it should appear.
+     * 4. The selection dispatcher reacts to the selection attribute and sets CSS classes responsible for the
+     *    fake caret on the view widget.
+     * 5. If the fake caret should disappear, the selection attribute is removed and the dispatcher
+     *    does the CSS class clean-up in the view.
+     * 6. Additionally, `change:range` and `FocusTracker#isFocused` listeners also remove the selection
+     *    attribute (the former also removes widget CSS classes).
+     */
+    private _enableTypeAroundFakeCaretActivationUsingKeyboardArrows;
+    /**
+     * A listener executed on each "keydown" in the view document, a part of
+     * {@link #_enableTypeAroundFakeCaretActivationUsingKeyboardArrows}.
+     *
+     * It decides whether the arrow keypress should activate the fake caret or not (also whether it should
+     * be deactivated).
+     *
+     * The fake caret activation is done by setting the `widget-type-around` model selection attribute
+     * in this listener, and stopping and preventing the event that would normally be handled by the widget
+     * plugin that is responsible for the regular keyboard navigation near/across all widgets (that
+     * includes inline widgets, which are ignored by the widget type around plugin).
+     */
+    private _handleArrowKeyPress;
+    /**
+     * Handles the keyboard navigation on "keydown" when a widget is currently selected and activates or deactivates
+     * the fake caret for that widget, depending on the current value of the `widget-type-around` model
+     * selection attribute and the direction of the pressed arrow key.
+     *
+     * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+     * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+     * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+     * process the event any further. Returns `false` otherwise.
+     */
+    private _handleArrowKeyPressOnSelectedWidget;
+    /**
+     * Handles the keyboard navigation on "keydown" when **no** widget is selected but the selection is **directly** next
+     * to one and upon the fake caret should become active for this widget upon arrow keypress
+     * (AKA entering/selecting the widget).
+     *
+     * **Note**: This code mirrors the implementation from the widget plugin but also adds the selection attribute.
+     * Unfortunately, there is no safe way to let the widget plugin do the selection part first and then just set the
+     * selection attribute here in the widget type around plugin. This is why this code must duplicate some from the widget plugin.
+     *
+     * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+     * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+     * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+     * process the event any further. Returns `false` otherwise.
+     */
+    private _handleArrowKeyPressWhenSelectionNextToAWidget;
+    /**
+     * Handles the keyboard navigation on "keydown" when a widget is currently selected (together with some other content)
+     * and the widget is the first or last element in the selection. It activates or deactivates the fake caret for that widget.
+     *
+     * @param isForward `true` when the pressed arrow key was responsible for the forward model selection movement
+     * as in {@link module:utils/keyboard~isForwardArrowKeyCode}.
+     * @returns Returns `true` when the keypress was handled and no other keydown listener of the editor should
+     * process the event any further. Returns `false` otherwise.
+     */
+    private _handleArrowKeyPressWhenNonCollapsedSelection;
+    /**
+     * Registers a `mousedown` listener for the view document which intercepts events
+     * coming from the widget type around UI, which happens when a user clicks one of the buttons
+     * that insert a paragraph next to a widget.
+     */
+    private _enableInsertingParagraphsOnButtonClick;
+    /**
+     * Creates the <kbd>Enter</kbd> key listener on the view document that allows the user to insert a paragraph
+     * near the widget when either:
+     *
+     * * The fake caret was first activated using the arrow keys,
+     * * The entire widget is selected in the model.
+     *
+     * In the first case, the new paragraph is inserted according to the `widget-type-around` selection
+     * attribute (see {@link #_handleArrowKeyPress}).
+     *
+     * In the second case, the new paragraph is inserted based on whether a soft (<kbd>Shift</kbd>+<kbd>Enter</kbd>) keystroke
+     * was pressed or not.
+     */
+    private _enableInsertingParagraphsOnEnterKeypress;
+    /**
+     * Similar to the {@link #_enableInsertingParagraphsOnEnterKeypress}, it allows the user
+     * to insert a paragraph next to a widget when the fake caret was activated using arrow
+     * keys but it responds to typing instead of <kbd>Enter</kbd>.
+     *
+     * Listener enabled by this method will insert a new paragraph according to the `widget-type-around`
+     * model selection attribute as the user simply starts typing, which creates the impression that the fake caret
+     * behaves like a real one rendered by the browser (AKA your text appears where the caret was).
+     *
+     * **Note**: At the moment this listener creates 2 undo steps: one for the `insertParagraph` command
+     * and another one for actual typing. It is not a disaster but this may need to be fixed
+     * sooner or later.
+     */
+    private _enableInsertingParagraphsOnTypingKeystroke;
+    /**
+     * It creates a "delete" event listener on the view document to handle cases when the <kbd>Delete</kbd> or <kbd>Backspace</kbd>
+     * is pressed and the fake caret is currently active.
+     *
+     * The fake caret should create an illusion of a real browser caret so that when it appears before or after
+     * a widget, pressing <kbd>Delete</kbd> or <kbd>Backspace</kbd> should remove a widget or delete the content
+     * before or after a widget (depending on the content surrounding the widget).
+     */
+    private _enableDeleteIntegration;
+    /**
+     * Attaches the {@link module:engine/model/model~Model#event:insertContent} event listener that, for instance, allows the user to paste
+     * content near a widget when the fake caret is first activated using the arrow keys.
+     *
+     * The content is inserted according to the `widget-type-around` selection attribute (see {@link #_handleArrowKeyPress}).
+     */
+    private _enableInsertContentIntegration;
+    /**
+     * Attaches the {@link module:engine/model/model~Model#event:insertObject} event listener that modifies the
+     * `options.findOptimalPosition`parameter to position of fake caret in relation to selected element
+     * to reflect user's intent of desired insertion position.
+     *
+     * The object is inserted according to the `widget-type-around` selection attribute (see {@link #_handleArrowKeyPress}).
+     */
+    private _enableInsertObjectIntegration;
+    /**
+     * Attaches the {@link module:engine/model/model~Model#event:deleteContent} event listener to block the event when the fake
+     * caret is active.
+     *
+     * This is required for cases that trigger {@link module:engine/model/model~Model#deleteContent `model.deleteContent()`}
+     * before calling {@link module:engine/model/model~Model#insertContent `model.insertContent()`} like, for instance,
+     * plain text pasting.
+     */
+    private _enableDeleteContentIntegration;
+}