@ckeditor/ckeditor5-typing 47.6.1 → 48.0.0-alpha.1

package/src/inserttextobserver.js

@@ -1,112 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module typing/inserttextobserver
- */
-import { env, EventInfo } from '@ckeditor/ckeditor5-utils';
-import { ViewDocumentDomEventData, Observer, FocusObserver } from '@ckeditor/ckeditor5-engine';
-// @if CK_DEBUG_TYPING // const { _buildLogMessage } = require( '@ckeditor/ckeditor5-engine/src/dev-utils/utils.js' );
-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'
-];
-const TYPING_INPUT_TYPES_ANDROID = [
-    ...TYPING_INPUT_TYPES,
-    'insertCompositionText'
-];
-/**
- * Text insertion observer introduces the {@link module:engine/view/document~ViewDocument#event:insertText} event.
- */
-export 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.
-     */
-    focusObserver;
-    /**
-     * @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.
-        const typingInputTypes = env.isAndroid ? TYPING_INPUT_TYPES_ANDROID : TYPING_INPUT_TYPES;
-        const viewDocument = view.document;
-        viewDocument.on('beforeinput', (evt, data) => {
-            if (!this.isEnabled) {
-                return;
-            }
-            const { data: text, targetRanges, inputType, domEvent, isComposing } = data;
-            if (!typingInputTypes.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 ViewDocumentDomEventData(view, domEvent, {
-                text,
-                selection: view.createSelection(targetRanges),
-                isComposing
-            }));
-            // Stop the beforeinput event if `delete` event was stopped.
-            // https://github.com/ckeditor/ckeditor5/issues/753
-            if (eventInfo.stop.called) {
-                evt.stop();
-            }
-        });
-        // 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 (!env.isAndroid) {
-            // Note: The priority must be lower than the CompositionObserver handler to call it after the renderer is unblocked.
-            // This is important for view to DOM position mapping.
-            // This causes the effect of first remove composed DOM and then reapply it after model modification.
-            viewDocument.on('compositionend', (evt, { data, domEvent }) => {
-                if (!this.isEnabled) {
-                    return;
-                }
-                // In case of aborted composition.
-                if (!data) {
-                    return;
-                }
-                // @if CK_DEBUG_TYPING // if ( ( window as any ).logCKETyping ) {
-                // @if CK_DEBUG_TYPING // 	console.log( ..._buildLogMessage( this, 'InsertTextObserver',
-                // @if CK_DEBUG_TYPING // 		`%cFire insertText event, %c${ JSON.stringify( data ) }`,
-                // @if CK_DEBUG_TYPING // 		'font-weight: bold',
-                // @if CK_DEBUG_TYPING // 		 'color: blue'
-                // @if CK_DEBUG_TYPING // 	) );
-                // @if CK_DEBUG_TYPING // }
-                // How do we know where to insert the composed text?
-                // 1. The SelectionObserver is blocked and the view is not updated with the composition changes.
-                // 2. The last moment before it's locked is the `compositionstart` event.
-                // 3. The `SelectionObserver` is listening for `compositionstart` event and immediately converts
-                //    the selection. Handle this at the low priority so after the rendering is blocked.
-                viewDocument.fire('insertText', new ViewDocumentDomEventData(view, domEvent, {
-                    text: data,
-                    isComposing: true
-                }));
-            }, { priority: 'low' });
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    observe() { }
-    /**
-     * @inheritDoc
-     */
-    stopObserving() { }
-}

package/src/texttransformation.js

@@ -1,237 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module typing/texttransformation
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import { TextWatcher } from './textwatcher.js';
-import { escapeRegExp } from 'es-toolkit/compat';
-// All named transformations.
-const TRANSFORMATIONS = {
-    // Common symbols:
-    copyright: { from: '(c)', to: '©' },
-    registeredTrademark: { from: '(r)', to: '®' },
-    trademark: { from: '(tm)', to: '™' },
-    // Mathematical:
-    oneHalf: { from: /(^|[^/a-z0-9])(1\/2)([^/a-z0-9])$/i, to: [null, '½', null] },
-    oneThird: { from: /(^|[^/a-z0-9])(1\/3)([^/a-z0-9])$/i, to: [null, '⅓', null] },
-    twoThirds: { from: /(^|[^/a-z0-9])(2\/3)([^/a-z0-9])$/i, to: [null, '⅔', null] },
-    oneForth: { from: /(^|[^/a-z0-9])(1\/4)([^/a-z0-9])$/i, to: [null, '¼', null] },
-    threeQuarters: { from: /(^|[^/a-z0-9])(3\/4)([^/a-z0-9])$/i, to: [null, '¾', null] },
-    lessThanOrEqual: { from: '<=', to: '≤' },
-    greaterThanOrEqual: { from: '>=', to: '≥' },
-    notEqual: { from: '!=', to: '≠' },
-    arrowLeft: { from: '<-', to: '←' },
-    arrowRight: { from: '->', to: '→' },
-    // Typography:
-    horizontalEllipsis: { from: '...', to: '…' },
-    enDash: { from: /(^| )(--)( )$/, to: [null, '–', null] },
-    emDash: { from: /(^| )(---)( )$/, to: [null, '—', null] },
-    // Quotations:
-    // English, US
-    quotesPrimary: { from: buildQuotesRegExp('"'), to: [null, '“', null, '”'] },
-    quotesSecondary: { from: buildQuotesRegExp('\''), to: [null, '‘', null, '’'] },
-    // English, UK
-    quotesPrimaryEnGb: { from: buildQuotesRegExp('\''), to: [null, '‘', null, '’'] },
-    quotesSecondaryEnGb: { from: buildQuotesRegExp('"'), to: [null, '“', null, '”'] },
-    // Polish
-    quotesPrimaryPl: { from: buildQuotesRegExp('"'), to: [null, '„', null, '”'] },
-    quotesSecondaryPl: { from: buildQuotesRegExp('\''), to: [null, '‚', null, '’'] }
-};
-// Transformation groups.
-const TRANSFORMATION_GROUPS = {
-    symbols: ['copyright', 'registeredTrademark', 'trademark'],
-    mathematical: [
-        'oneHalf', 'oneThird', 'twoThirds', 'oneForth', 'threeQuarters',
-        'lessThanOrEqual', 'greaterThanOrEqual', 'notEqual',
-        'arrowLeft', 'arrowRight'
-    ],
-    typography: ['horizontalEllipsis', 'enDash', 'emDash'],
-    quotes: ['quotesPrimary', 'quotesSecondary']
-};
-// A set of default transformations provided by the feature.
-const DEFAULT_TRANSFORMATIONS = [
-    'symbols',
-    'mathematical',
-    'typography',
-    'quotes'
-];
-/**
- * The text transformation plugin.
- */
-export class TextTransformation extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return ['Delete', 'Input'];
-    }
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'TextTransformation';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        editor.config.define('typing', {
-            transformations: {
-                include: DEFAULT_TRANSFORMATIONS
-            }
-        });
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const model = this.editor.model;
-        const modelSelection = model.document.selection;
-        modelSelection.on('change:range', () => {
-            // Disable plugin when selection is inside a code block or inline code.
-            const anchor = modelSelection.anchor;
-            const isInCodeBlock = !!anchor && anchor.parent.is('element', 'codeBlock');
-            const isInInlineCode = modelSelection.hasAttribute('code');
-            this.isEnabled = !(isInCodeBlock || isInInlineCode);
-        });
-        this._enableTransformationWatchers();
-    }
-    /**
-     * Create new TextWatcher listening to the editor for typing and selection events.
-     */
-    _enableTransformationWatchers() {
-        const editor = this.editor;
-        const model = editor.model;
-        const deletePlugin = editor.plugins.get('Delete');
-        const normalizedTransformations = normalizeTransformations(editor.config.get('typing.transformations'));
-        const testCallback = (text) => {
-            for (const normalizedTransformation of normalizedTransformations) {
-                const from = normalizedTransformation.from;
-                const match = from.test(text);
-                if (match) {
-                    return { normalizedTransformation };
-                }
-            }
-        };
-        const watcher = new TextWatcher(editor.model, testCallback);
-        watcher.on('matched:data', (evt, data) => {
-            if (!data.batch.isTyping) {
-                return;
-            }
-            const { from, to } = data.normalizedTransformation;
-            const matches = from.exec(data.text);
-            const replaces = to(matches.slice(1));
-            const matchedRange = data.range;
-            let changeIndex = matches.index;
-            model.enqueueChange(writer => {
-                for (let i = 1; i < matches.length; i++) {
-                    const match = matches[i];
-                    const replaceWith = replaces[i - 1];
-                    if (replaceWith == null) {
-                        changeIndex += match.length;
-                        continue;
-                    }
-                    const replacePosition = matchedRange.start.getShiftedBy(changeIndex);
-                    const replaceRange = model.createRange(replacePosition, replacePosition.getShiftedBy(match.length));
-                    const attributes = getTextAttributesAfterPosition(replacePosition);
-                    model.insertContent(writer.createText(replaceWith, attributes), replaceRange);
-                    changeIndex += replaceWith.length;
-                }
-                model.enqueueChange(() => {
-                    deletePlugin.requestUndoOnBackspace();
-                });
-            });
-        });
-        watcher.bind('isEnabled').to(this);
-    }
-}
-/**
- * Normalizes the configuration `from` parameter value.
- * The normalized value for the `from` parameter is a RegExp instance. If the passed `from` is already a RegExp instance,
- * it is returned unchanged.
- */
-function normalizeFrom(from) {
-    if (typeof from == 'string') {
-        return new RegExp(`(${escapeRegExp(from)})$`);
-    }
-    // `from` is already a regular expression.
-    return from;
-}
-/**
- * Normalizes the configuration `to` parameter value.
- * The normalized value for the `to` parameter is a function that takes an array and returns an array. See more in the
- * configuration description. If the passed `to` is already a function, it is returned unchanged.
- */
-function normalizeTo(to) {
-    if (typeof to == 'string') {
-        return () => [to];
-    }
-    else if (to instanceof Array) {
-        return () => to;
-    }
-    // `to` is already a function.
-    return to;
-}
-/**
- * For given `position` returns attributes for the text that is after that position.
- * The text can be in the same text node as the position (`foo[]bar`) or in the next text node (`foo[]<$text bold="true">bar</$text>`).
- */
-function getTextAttributesAfterPosition(position) {
-    const textNode = position.textNode ? position.textNode : position.nodeAfter;
-    return textNode.getAttributes();
-}
-/**
- * Returns a RegExp pattern string that detects a sentence inside a quote.
- *
- * @param quoteCharacter The character to create a pattern for.
- */
-function buildQuotesRegExp(quoteCharacter) {
-    return new RegExp(`(^|\\s)(${quoteCharacter})([^${quoteCharacter}]*)(${quoteCharacter})$`);
-}
-/**
- * Reads text transformation config and returns normalized array of transformations objects.
- */
-function normalizeTransformations(config) {
-    const extra = config.extra || [];
-    const remove = config.remove || [];
-    const isNotRemoved = (transformation) => !remove.includes(transformation);
-    const configured = config.include.concat(extra).filter(isNotRemoved);
-    return expandGroupsAndRemoveDuplicates(configured)
-        .filter(isNotRemoved) // Filter out 'remove' transformations as they might be set in group.
-        .map(transformation => (typeof transformation == 'string' && TRANSFORMATIONS[transformation] ? TRANSFORMATIONS[transformation] : transformation))
-        // Filter out transformations set as string that has not been found.
-        .filter((transformation) => typeof transformation === 'object')
-        .map(transformation => ({
-        from: normalizeFrom(transformation.from),
-        to: normalizeTo(transformation.to)
-    }));
-}
-/**
- * Reads definitions and expands named groups if needed to transformation names.
- * This method also removes duplicated named transformations if any.
- */
-function expandGroupsAndRemoveDuplicates(definitions) {
-    // Set is using to make sure that transformation names are not duplicated.
-    const definedTransformations = new Set();
-    for (const transformationOrGroup of definitions) {
-        if (typeof transformationOrGroup == 'string' && TRANSFORMATION_GROUPS[transformationOrGroup]) {
-            for (const transformation of TRANSFORMATION_GROUPS[transformationOrGroup]) {
-                definedTransformations.add(transformation);
-            }
-        }
-        else {
-            definedTransformations.add(transformationOrGroup);
-        }
-    }
-    return Array.from(definedTransformations);
-}

package/src/textwatcher.js

@@ -1,123 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module typing/textwatcher
- */
-import { ObservableMixin } from '@ckeditor/ckeditor5-utils';
-import { getLastTextLine } from './utils/getlasttextline.js';
-/**
- * The text watcher feature.
- *
- * Fires the {@link module:typing/textwatcher~TextWatcher#event:matched:data `matched:data`},
- * {@link module:typing/textwatcher~TextWatcher#event:matched:selection `matched:selection`} and
- * {@link module:typing/textwatcher~TextWatcher#event:unmatched `unmatched`} events on typing or selection changes.
- */
-export class TextWatcher extends /* #__PURE__ */ ObservableMixin() {
-    /**
-     * The editor's model.
-     */
-    model;
-    /**
-     * The function used to match the text.
-     *
-     * The test callback can return 3 values:
-     *
-     * * `false` if there is no match,
-     * * `true` if there is a match,
-     * * an object if there is a match and we want to pass some additional information to the {@link #event:matched:data} event.
-     */
-    testCallback;
-    /**
-     * Whether there is a match currently.
-     */
-    _hasMatch;
-    /**
-     * Creates a text watcher instance.
-     *
-     * @param testCallback See {@link module:typing/textwatcher~TextWatcher#testCallback}.
-     */
-    constructor(model, testCallback) {
-        super();
-        this.model = model;
-        this.testCallback = testCallback;
-        this._hasMatch = false;
-        this.set('isEnabled', true);
-        // Toggle text watching on isEnabled state change.
-        this.on('change:isEnabled', () => {
-            if (this.isEnabled) {
-                this._startListening();
-            }
-            else {
-                this.stopListening(model.document.selection);
-                this.stopListening(model.document);
-            }
-        });
-        this._startListening();
-    }
-    /**
-     * Flag indicating whether there is a match currently.
-     */
-    get hasMatch() {
-        return this._hasMatch;
-    }
-    /**
-     * Starts listening to the editor for typing and selection events.
-     */
-    _startListening() {
-        const model = this.model;
-        const document = model.document;
-        this.listenTo(document.selection, 'change:range', (evt, { directChange }) => {
-            // Indirect changes (i.e. when the user types or external changes are applied) are handled in the document's change event.
-            if (!directChange) {
-                return;
-            }
-            // Act only on collapsed selection.
-            if (!document.selection.isCollapsed) {
-                if (this.hasMatch) {
-                    this.fire('unmatched');
-                    this._hasMatch = false;
-                }
-                return;
-            }
-            this._evaluateTextBeforeSelection('selection');
-        });
-        this.listenTo(document, 'change:data', (evt, batch) => {
-            if (batch.isUndo || !batch.isLocal) {
-                return;
-            }
-            this._evaluateTextBeforeSelection('data', { batch });
-        });
-    }
-    /**
-     * Checks the editor content for matched text.
-     *
-     * @fires matched:data
-     * @fires matched:selection
-     * @fires unmatched
-     *
-     * @param suffix A suffix used for generating the event name.
-     * @param data Data object for event.
-     */
-    _evaluateTextBeforeSelection(suffix, data = {}) {
-        const model = this.model;
-        const document = model.document;
-        const selection = document.selection;
-        const rangeBeforeSelection = model.createRange(model.createPositionAt(selection.focus.parent, 0), selection.focus);
-        const { text, range } = getLastTextLine(rangeBeforeSelection, model);
-        const testResult = this.testCallback(text);
-        if (!testResult && this.hasMatch) {
-            this.fire('unmatched');
-        }
-        this._hasMatch = !!testResult;
-        if (testResult) {
-            const eventData = Object.assign(data, { text, range });
-            // If the test callback returns an object with additional data, assign the data as well.
-            if (typeof testResult == 'object') {
-                Object.assign(eventData, testResult);
-            }
-            this.fire(`matched:${suffix}`, eventData);
-        }
-    }
-}