@ckeditor/ckeditor5-typing 40.0.0 → 40.2.0

package/src/inserttextcommand.js

@@ -1,80 +1,83 @@
-/**
- * @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 typing/inserttextcommand
- */
-import { Command } from '@ckeditor/ckeditor5-core';
-import ChangeBuffer from './utils/changebuffer';
-/**
- * The insert text command. Used by the {@link module:typing/input~Input input feature} to handle typing.
- */
-export default class InsertTextCommand extends Command {
-    /**
-     * Creates an instance of the command.
-     *
-     * @param undoStepSize The maximum number of atomic changes
-     * which can be contained in one batch in the command buffer.
-     */
-    constructor(editor, undoStepSize) {
-        super(editor);
-        this._buffer = new ChangeBuffer(editor.model, undoStepSize);
-        // Since this command may execute on different selectable than selection, it should be checked directly in execute block.
-        this._isEnabledBasedOnSelection = false;
-    }
-    /**
-     * The current change buffer.
-     */
-    get buffer() {
-        return this._buffer;
-    }
-    /**
-     * @inheritDoc
-     */
-    destroy() {
-        super.destroy();
-        this._buffer.destroy();
-    }
-    /**
-     * Executes the input command. It replaces the content within the given range with the given text.
-     * Replacing is a two step process, first the content within the range is removed and then the new text is inserted
-     * at the beginning of the range (which after the removal is a collapsed range).
-     *
-     * @fires execute
-     * @param options The command options.
-     */
-    execute(options = {}) {
-        const model = this.editor.model;
-        const doc = model.document;
-        const text = options.text || '';
-        const textInsertions = text.length;
-        let selection = doc.selection;
-        if (options.selection) {
-            selection = options.selection;
-        }
-        else if (options.range) {
-            selection = model.createSelection(options.range);
-        }
-        // Stop executing if selectable is in non-editable place.
-        if (!model.canEditAt(selection)) {
-            return;
-        }
-        const resultRange = options.resultRange;
-        model.enqueueChange(this._buffer.batch, writer => {
-            this._buffer.lock();
-            model.deleteContent(selection);
-            if (text) {
-                model.insertContent(writer.createText(text, doc.selection.getAttributes()), selection);
-            }
-            if (resultRange) {
-                writer.setSelection(resultRange);
-            }
-            else if (!selection.is('documentSelection')) {
-                writer.setSelection(selection);
-            }
-            this._buffer.unlock();
-            this._buffer.input(textInsertions);
-        });
-    }
-}
+/**
+ * @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 typing/inserttextcommand
+ */
+import { Command } from '@ckeditor/ckeditor5-core';
+import ChangeBuffer from './utils/changebuffer';
+/**
+ * The insert text command. Used by the {@link module:typing/input~Input input feature} to handle typing.
+ */
+export default class InsertTextCommand extends Command {
+    /**
+     * Creates an instance of the command.
+     *
+     * @param undoStepSize The maximum number of atomic changes
+     * which can be contained in one batch in the command buffer.
+     */
+    constructor(editor, undoStepSize) {
+        super(editor);
+        this._buffer = new ChangeBuffer(editor.model, undoStepSize);
+        // Since this command may execute on different selectable than selection, it should be checked directly in execute block.
+        this._isEnabledBasedOnSelection = false;
+    }
+    /**
+     * The current change buffer.
+     */
+    get buffer() {
+        return this._buffer;
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        super.destroy();
+        this._buffer.destroy();
+    }
+    /**
+     * Executes the input command. It replaces the content within the given range with the given text.
+     * Replacing is a two step process, first the content within the range is removed and then the new text is inserted
+     * at the beginning of the range (which after the removal is a collapsed range).
+     *
+     * @fires execute
+     * @param options The command options.
+     */
+    execute(options = {}) {
+        const model = this.editor.model;
+        const doc = model.document;
+        const text = options.text || '';
+        const textInsertions = text.length;
+        let selection = doc.selection;
+        if (options.selection) {
+            selection = options.selection;
+        }
+        else if (options.range) {
+            selection = model.createSelection(options.range);
+        }
+        // Stop executing if selectable is in non-editable place.
+        if (!model.canEditAt(selection)) {
+            return;
+        }
+        const resultRange = options.resultRange;
+        model.enqueueChange(this._buffer.batch, writer => {
+            this._buffer.lock();
+            // Store selection attributes before deleting old content to preserve formatting and link.
+            // This unifies the behavior between DocumentSelection and Selection provided as input option.
+            const selectionAttributes = Array.from(doc.selection.getAttributes());
+            model.deleteContent(selection);
+            if (text) {
+                model.insertContent(writer.createText(text, selectionAttributes), selection);
+            }
+            if (resultRange) {
+                writer.setSelection(resultRange);
+            }
+            else if (!selection.is('documentSelection')) {
+                writer.setSelection(selection);
+            }
+            this._buffer.unlock();
+            this._buffer.input(textInsertions);
+        });
+    }
+}

package/src/inserttextobserver.d.ts

@@ -1,59 +1,59 @@
-/**
- * @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 { DomEventData, Observer, FocusObserver, type View, type ViewDocumentSelection, type ViewRange, type ViewSelection } from '@ckeditor/ckeditor5-engine';
-/**
- * Text insertion observer introduces the {@link module:engine/view/document~Document#event:insertText} event.
- */
-export default class InsertTextObserver extends Observer {
-    /**
-     * Instance of the focus observer. Insert text observer calls
-     * {@link module:engine/view/observer/focusobserver~FocusObserver#flush} to mark the latest focus change as complete.
-     */
-    readonly focusObserver: FocusObserver;
-    /**
-     * @inheritDoc
-     */
-    constructor(view: View);
-    /**
-     * @inheritDoc
-     */
-    observe(): void;
-    /**
-     * @inheritDoc
-     */
-    stopObserving(): void;
-}
-/**
- * Event fired when the user types text, for instance presses <kbd>A</kbd> or <kbd>?</kbd> in the
- * editing view document.
- *
- * **Note**: This event will **not** fire for keystrokes such as <kbd>Delete</kbd> or <kbd>Enter</kbd>.
- * They have dedicated events, see {@link module:engine/view/document~Document#event:delete} and
- * {@link module:engine/view/document~Document#event:enter} to learn more.
- *
- * **Note**: This event is fired by the {@link module:typing/inserttextobserver~InsertTextObserver input feature}.
- *
- * @eventName module:engine/view/document~Document#insertText
- * @param data The event data.
- */
-export type ViewDocumentInsertTextEvent = {
-    name: 'insertText';
-    args: [data: InsertTextEventData];
-};
-export interface InsertTextEventData extends DomEventData {
-    /**
-     *  The text to be inserted.
-     */
-    text: string;
-    /**
-     * The selection into which the text should be inserted.
-     * If not specified, the insertion should occur at the current view selection.
-     */
-    selection: ViewSelection | ViewDocumentSelection;
-    /**
-     * The range that view selection should be set to after insertion.
-     */
-    resultRange?: ViewRange;
-}
+/**
+ * @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 { DomEventData, Observer, FocusObserver, type View, type ViewDocumentSelection, type ViewRange, type ViewSelection } from '@ckeditor/ckeditor5-engine';
+/**
+ * Text insertion observer introduces the {@link module:engine/view/document~Document#event:insertText} event.
+ */
+export default class InsertTextObserver extends Observer {
+    /**
+     * Instance of the focus observer. Insert text observer calls
+     * {@link module:engine/view/observer/focusobserver~FocusObserver#flush} to mark the latest focus change as complete.
+     */
+    readonly focusObserver: FocusObserver;
+    /**
+     * @inheritDoc
+     */
+    constructor(view: View);
+    /**
+     * @inheritDoc
+     */
+    observe(): void;
+    /**
+     * @inheritDoc
+     */
+    stopObserving(): void;
+}
+/**
+ * Event fired when the user types text, for instance presses <kbd>A</kbd> or <kbd>?</kbd> in the
+ * editing view document.
+ *
+ * **Note**: This event will **not** fire for keystrokes such as <kbd>Delete</kbd> or <kbd>Enter</kbd>.
+ * They have dedicated events, see {@link module:engine/view/document~Document#event:delete} and
+ * {@link module:engine/view/document~Document#event:enter} to learn more.
+ *
+ * **Note**: This event is fired by the {@link module:typing/inserttextobserver~InsertTextObserver input feature}.
+ *
+ * @eventName module:engine/view/document~Document#insertText
+ * @param data The event data.
+ */
+export type ViewDocumentInsertTextEvent = {
+    name: 'insertText';
+    args: [data: InsertTextEventData];
+};
+export interface InsertTextEventData extends DomEventData {
+    /**
+     *  The text to be inserted.
+     */
+    text: string;
+    /**
+     * The selection into which the text should be inserted.
+     * If not specified, the insertion should occur at the current view selection.
+     */
+    selection: ViewSelection | ViewDocumentSelection;
+    /**
+     * The range that view selection should be set to after insertion.
+     */
+    resultRange?: ViewRange;
+}

package/src/inserttextobserver.js

@@ -1,108 +1,108 @@
-/**
- * @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 typing/inserttextobserver
- */
-import { env, EventInfo } from '@ckeditor/ckeditor5-utils';
-import { DomEventData, Observer, FocusObserver } from '@ckeditor/ckeditor5-engine';
-const TYPING_INPUT_TYPES = [
-    // For collapsed range:
-    //	- This one is a regular typing (all browsers, all systems).
-    //	- This one is used by Chrome when typing accented letter – 2nd step when the user selects the accent (Mac).
-    // For non-collapsed range:
-    //	- This one is used by Chrome when typing accented letter – when the selection box first appears (Mac).
-    //	- This one is used by Safari when accepting spell check suggestions from the context menu (Mac).
-    'insertText',
-    // This one is used by Safari when typing accented letter (Mac).
-    // This one is used by Safari when accepting spell check suggestions from the autocorrection pop-up (Mac).
-    'insertReplacementText'
-];
-/**
- * Text insertion observer introduces the {@link module:engine/view/document~Document#event:insertText} event.
- */
-export default class InsertTextObserver extends Observer {
-    /**
-     * @inheritDoc
-     */
-    constructor(view) {
-        super(view);
-        this.focusObserver = view.getObserver(FocusObserver);
-        // On Android composition events should immediately be applied to the model. Rendering is not disabled.
-        // On non-Android the model is updated only on composition end.
-        // On Android we can't rely on composition start/end to update model.
-        if (env.isAndroid) {
-            TYPING_INPUT_TYPES.push('insertCompositionText');
-        }
-        const viewDocument = view.document;
-        viewDocument.on('beforeinput', (evt, data) => {
-            if (!this.isEnabled) {
-                return;
-            }
-            const { data: text, targetRanges, inputType, domEvent } = data;
-            if (!TYPING_INPUT_TYPES.includes(inputType)) {
-                return;
-            }
-            // Mark the latest focus change as complete (we are typing in editable after the focus
-            // so the selection is in the focused element).
-            this.focusObserver.flush();
-            const eventInfo = new EventInfo(viewDocument, 'insertText');
-            viewDocument.fire(eventInfo, new DomEventData(view, domEvent, {
-                text,
-                selection: view.createSelection(targetRanges)
-            }));
-            // Stop the beforeinput event if `delete` event was stopped.
-            // https://github.com/ckeditor/ckeditor5/issues/753
-            if (eventInfo.stop.called) {
-                evt.stop();
-            }
-        });
-        // Note: The priority must be lower than the CompositionObserver handler to call it after the renderer is unblocked.
-        viewDocument.on('compositionend', (evt, { data, domEvent }) => {
-            // On Android composition events are immediately applied to the model.
-            // On non-Android the model is updated only on composition end.
-            // On Android we can't rely on composition start/end to update model.
-            if (!this.isEnabled || env.isAndroid) {
-                return;
-            }
-            // In case of aborted composition.
-            if (!data) {
-                return;
-            }
-            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-            // @if CK_DEBUG_TYPING // 	console.log( `%c[InsertTextObserver]%c Fire insertText event, text: ${ JSON.stringify( data ) }`,
-            // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green;', ''
-            // @if CK_DEBUG_TYPING // 	);
-            // @if CK_DEBUG_TYPING // }
-            // How do we know where to insert the composed text?
-            // The selection observer is blocked and the view is not updated with the composition changes.
-            // There were three options:
-            //   - Store the selection on `compositionstart` and use it now. This wouldn't work in RTC
-            //     where the view would change and the stored selection might get incorrect.
-            //     We'd need to fallback to the current view selection anyway.
-            //   - Use the current view selection. This is a bit weird and non-intuitive because
-            //     this isn't necessarily the selection on which the user started composing.
-            //     We cannot even know whether it's still collapsed (there might be some weird
-            //     editor feature that changed it in unpredictable ways for us). But it's by far
-            //     the simplest solution and should be stable (the selection is definitely correct)
-            //     and probably mostly predictable (features usually don't modify the selection
-            //     unless called explicitly by the user).
-            //   - Try to follow it from the `beforeinput` events. This would be really complex as each
-            //     `beforeinput` would come with just the range it's changing and we'd need to calculate that.
-            // We decided to go with the 2nd option for its simplicity and stability.
-            viewDocument.fire('insertText', new DomEventData(view, domEvent, {
-                text: data,
-                selection: viewDocument.selection
-            }));
-        }, { priority: 'lowest' });
-    }
-    /**
-     * @inheritDoc
-     */
-    observe() { }
-    /**
-     * @inheritDoc
-     */
-    stopObserving() { }
-}
+/**
+ * @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 typing/inserttextobserver
+ */
+import { env, EventInfo } from '@ckeditor/ckeditor5-utils';
+import { DomEventData, Observer, FocusObserver } from '@ckeditor/ckeditor5-engine';
+const TYPING_INPUT_TYPES = [
+    // For collapsed range:
+    //	- This one is a regular typing (all browsers, all systems).
+    //	- This one is used by Chrome when typing accented letter – 2nd step when the user selects the accent (Mac).
+    // For non-collapsed range:
+    //	- This one is used by Chrome when typing accented letter – when the selection box first appears (Mac).
+    //	- This one is used by Safari when accepting spell check suggestions from the context menu (Mac).
+    'insertText',
+    // This one is used by Safari when typing accented letter (Mac).
+    // This one is used by Safari when accepting spell check suggestions from the autocorrection pop-up (Mac).
+    'insertReplacementText'
+];
+/**
+ * Text insertion observer introduces the {@link module:engine/view/document~Document#event:insertText} event.
+ */
+export default class InsertTextObserver extends Observer {
+    /**
+     * @inheritDoc
+     */
+    constructor(view) {
+        super(view);
+        this.focusObserver = view.getObserver(FocusObserver);
+        // On Android composition events should immediately be applied to the model. Rendering is not disabled.
+        // On non-Android the model is updated only on composition end.
+        // On Android we can't rely on composition start/end to update model.
+        if (env.isAndroid) {
+            TYPING_INPUT_TYPES.push('insertCompositionText');
+        }
+        const viewDocument = view.document;
+        viewDocument.on('beforeinput', (evt, data) => {
+            if (!this.isEnabled) {
+                return;
+            }
+            const { data: text, targetRanges, inputType, domEvent } = data;
+            if (!TYPING_INPUT_TYPES.includes(inputType)) {
+                return;
+            }
+            // Mark the latest focus change as complete (we are typing in editable after the focus
+            // so the selection is in the focused element).
+            this.focusObserver.flush();
+            const eventInfo = new EventInfo(viewDocument, 'insertText');
+            viewDocument.fire(eventInfo, new DomEventData(view, domEvent, {
+                text,
+                selection: view.createSelection(targetRanges)
+            }));
+            // Stop the beforeinput event if `delete` event was stopped.
+            // https://github.com/ckeditor/ckeditor5/issues/753
+            if (eventInfo.stop.called) {
+                evt.stop();
+            }
+        });
+        // Note: The priority must be lower than the CompositionObserver handler to call it after the renderer is unblocked.
+        viewDocument.on('compositionend', (evt, { data, domEvent }) => {
+            // On Android composition events are immediately applied to the model.
+            // On non-Android the model is updated only on composition end.
+            // On Android we can't rely on composition start/end to update model.
+            if (!this.isEnabled || env.isAndroid) {
+                return;
+            }
+            // In case of aborted composition.
+            if (!data) {
+                return;
+            }
+            // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
+            // @if CK_DEBUG_TYPING // 	console.log( `%c[InsertTextObserver]%c Fire insertText event, text: ${ JSON.stringify( data ) }`,
+            // @if CK_DEBUG_TYPING // 		'font-weight: bold; color: green;', ''
+            // @if CK_DEBUG_TYPING // 	);
+            // @if CK_DEBUG_TYPING // }
+            // How do we know where to insert the composed text?
+            // The selection observer is blocked and the view is not updated with the composition changes.
+            // There were three options:
+            //   - Store the selection on `compositionstart` and use it now. This wouldn't work in RTC
+            //     where the view would change and the stored selection might get incorrect.
+            //     We'd need to fallback to the current view selection anyway.
+            //   - Use the current view selection. This is a bit weird and non-intuitive because
+            //     this isn't necessarily the selection on which the user started composing.
+            //     We cannot even know whether it's still collapsed (there might be some weird
+            //     editor feature that changed it in unpredictable ways for us). But it's by far
+            //     the simplest solution and should be stable (the selection is definitely correct)
+            //     and probably mostly predictable (features usually don't modify the selection
+            //     unless called explicitly by the user).
+            //   - Try to follow it from the `beforeinput` events. This would be really complex as each
+            //     `beforeinput` would come with just the range it's changing and we'd need to calculate that.
+            // We decided to go with the 2nd option for its simplicity and stability.
+            viewDocument.fire('insertText', new DomEventData(view, domEvent, {
+                text: data,
+                selection: viewDocument.selection
+            }));
+        }, { priority: 'lowest' });
+    }
+    /**
+     * @inheritDoc
+     */
+    observe() { }
+    /**
+     * @inheritDoc
+     */
+    stopObserving() { }
+}

package/src/texttransformation.d.ts

@@ -1,33 +1,33 @@
-/**
- * @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 typing/texttransformation
- */
-import { Plugin, type Editor } from '@ckeditor/ckeditor5-core';
-/**
- * The text transformation plugin.
- */
-export default class TextTransformation extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires(): readonly ["Delete", "Input"];
-    /**
-     * @inheritDoc
-     */
-    static get pluginName(): "TextTransformation";
-    /**
-     * @inheritDoc
-     */
-    constructor(editor: Editor);
-    /**
-     * @inheritDoc
-     */
-    init(): void;
-    /**
-     * Create new TextWatcher listening to the editor for typing and selection events.
-     */
-    private _enableTransformationWatchers;
-}
+/**
+ * @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 typing/texttransformation
+ */
+import { Plugin, type Editor } from '@ckeditor/ckeditor5-core';
+/**
+ * The text transformation plugin.
+ */
+export default class TextTransformation extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly ["Delete", "Input"];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "TextTransformation";
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * Create new TextWatcher listening to the editor for typing and selection events.
+     */
+    private _enableTransformationWatchers;
+}