@ckeditor/ckeditor5-restricted-editing 47.6.1-alpha.1 → 48.0.0-alpha.0

package/src/restrictededitingexceptionblockcommand.js

@@ -1,203 +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 restricted-editing/restrictededitingexceptionblockcommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { first } from 'ckeditor5/src/utils.js';
-/**
- * The command that toggles exception blocks for the restricted editing.
- */
-export class RestrictedEditingExceptionBlockCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        this.value = this._getValue();
-        this.isEnabled = this._checkEnabled();
-    }
-    /**
-     * Wraps or unwraps the selected blocks with non-restricted area.
-     *
-     * @fires execute
-     * @param options Command options.
-     * @param options.forceValue If set, it will force the command behavior. If `true`, the command will apply a block exception,
-     * otherwise the command will remove the block exception. If not set, the command will act basing on its current value.
-     */
-    execute(options = {}) {
-        const model = this.editor.model;
-        const schema = model.schema;
-        const selection = model.document.selection;
-        const blocks = Array.from(selection.getSelectedBlocks());
-        const value = (options.forceValue === undefined) ? !this.value : options.forceValue;
-        model.change(writer => {
-            if (!value) {
-                const blocksToUnwrap = blocks.map(block => {
-                    // Find blocks directly nested inside an exception.
-                    return findExceptionContentBlock(block);
-                }).filter((exception) => !!exception);
-                this._removeException(writer, blocksToUnwrap);
-            }
-            else {
-                const blocksToWrap = blocks.filter(block => {
-                    // Already wrapped blocks needs to be considered while wrapping too
-                    // in order to reuse their wrapper elements.
-                    return findException(block) || checkCanBeWrapped(schema, block);
-                });
-                this._applyException(writer, blocksToWrap);
-            }
-        });
-    }
-    /**
-     * Checks the command's {@link #value}.
-     */
-    _getValue() {
-        const selection = this.editor.model.document.selection;
-        const firstBlock = first(selection.getSelectedBlocks());
-        return !!(firstBlock && findException(firstBlock));
-    }
-    /**
-     * Checks whether the command can be enabled in the current context.
-     *
-     * @returns Whether the command should be enabled.
-     */
-    _checkEnabled() {
-        if (this.value) {
-            return true;
-        }
-        const selection = this.editor.model.document.selection;
-        const schema = this.editor.model.schema;
-        const firstBlock = first(selection.getSelectedBlocks());
-        if (!firstBlock) {
-            return false;
-        }
-        return checkCanBeWrapped(schema, firstBlock);
-    }
-    /**
-     * Unwraps the exception from given blocks.
-     *
-     * If blocks which are supposed to be unwrapped are in the middle of an exception,
-     * start it or end it, then the exception will be split (if needed) and the blocks
-     * will be moved out of it, so other exception blocks remained wrapped.
-     */
-    _removeException(writer, blocks) {
-        // Unwrap all groups of block. Iterate in the reverse order to not break following ranges.
-        getRangesOfBlockGroups(writer, blocks).reverse().forEach(groupRange => {
-            if (groupRange.start.isAtStart && groupRange.end.isAtEnd) {
-                writer.unwrap(groupRange.start.parent);
-                return;
-            }
-            // The group of blocks are at the beginning of an exception so let's move them left (out of the exception).
-            if (groupRange.start.isAtStart) {
-                const positionBefore = writer.createPositionBefore(groupRange.start.parent);
-                writer.move(groupRange, positionBefore);
-                return;
-            }
-            // The blocks are in the middle of an exception so we need to split the exception after the last block
-            // so we move the items there.
-            if (!groupRange.end.isAtEnd) {
-                writer.split(groupRange.end);
-            }
-            // Now we are sure that groupRange.end.isAtEnd is true, so let's move the blocks right.
-            const positionAfter = writer.createPositionAfter(groupRange.end.parent);
-            writer.move(groupRange, positionAfter);
-        });
-    }
-    /**
-     * Applies the exception to given blocks.
-     */
-    _applyException(writer, blocks) {
-        const schema = this.editor.model.schema;
-        const exceptionsToMerge = [];
-        // Wrap all groups of block. Iterate in the reverse order to not break following ranges.
-        getRangesOfBlockGroups(writer, blocks).reverse().forEach(groupRange => {
-            let exception = findException(groupRange.start);
-            if (!exception) {
-                exception = writer.createElement('restrictedEditingException');
-                writer.wrap(groupRange, exception);
-            }
-            exceptionsToMerge.push(exception);
-        });
-        // Merge subsequent exception elements. Reverse the order again because this time we want to go through
-        // the exception elements in the source order (due to how merge works – it moves the right element's content
-        // to the first element and removes the right one. Since we may need to merge a couple of subsequent exception elements
-        // we want to keep the reference to the first (furthest left) one.
-        exceptionsToMerge.reverse();
-        // But first add any neighbouring block exceptions to the list.
-        if (exceptionsToMerge.length) {
-            const previousSibling = exceptionsToMerge.at(0).previousSibling;
-            const nextSibling = exceptionsToMerge.at(-1).nextSibling;
-            if (previousSibling?.is('element', 'restrictedEditingException')) {
-                exceptionsToMerge.unshift(previousSibling);
-            }
-            if (nextSibling?.is('element', 'restrictedEditingException')) {
-                exceptionsToMerge.push(nextSibling);
-            }
-        }
-        // Merge subsequent exceptions.
-        exceptionsToMerge.reduce((currentException, nextException) => {
-            if (currentException.nextSibling == nextException) {
-                writer.merge(writer.createPositionAfter(currentException));
-                return currentException;
-            }
-            return nextException;
-        });
-        // Remove inline exceptions from block exception.
-        schema.removeDisallowedAttributes(blocks, writer);
-    }
-}
-function findException(elementOrPosition) {
-    return elementOrPosition.findAncestor('restrictedEditingException', { includeSelf: true });
-}
-function findExceptionContentBlock(element) {
-    let node = element;
-    while (node.parent) {
-        if (node.parent.name == 'restrictedEditingException') {
-            return node;
-        }
-        node = node.parent;
-    }
-    return null;
-}
-/**
- * Returns a minimal array of ranges containing groups of subsequent blocks.
- *
- * content:         abcdefgh
- * blocks:          [ a, b, d, f, g, h ]
- * output ranges:   [ab]c[d]e[fgh]
- */
-function getRangesOfBlockGroups(writer, blocks) {
-    let startPosition;
-    let i = 0;
-    const ranges = [];
-    while (i < blocks.length) {
-        const block = blocks[i];
-        const nextBlock = blocks[i + 1];
-        if (!startPosition) {
-            startPosition = writer.createPositionBefore(block);
-        }
-        if (!nextBlock || block.nextSibling != nextBlock) {
-            ranges.push(writer.createRange(startPosition, writer.createPositionAfter(block)));
-            startPosition = null;
-        }
-        i++;
-    }
-    return ranges;
-}
-/**
- * Checks whether exception can wrap the block.
- */
-function checkCanBeWrapped(schema, block) {
-    const parentContext = schema.createContext(block.parent);
-    // Is block exception allowed in parent of block.
-    if (!schema.checkChild(parentContext, 'restrictedEditingException')) {
-        return false;
-    }
-    // Is block allowed inside block exception.
-    if (!schema.checkChild(parentContext.push('restrictedEditingException'), block)) {
-        return false;
-    }
-    return true;
-}

package/src/restrictededitingexceptioncommand.js

@@ -1,61 +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 restricted-editing/restrictededitingexceptioncommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-/**
- * The command that toggles exceptions from the restricted editing on text.
- */
-export class RestrictedEditingExceptionCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const model = this.editor.model;
-        const doc = model.document;
-        this.value = !!doc.selection.getAttribute('restrictedEditingException');
-        this.isEnabled = model.schema.checkAttributeInSelection(doc.selection, 'restrictedEditingException');
-    }
-    /**
-     * @inheritDoc
-     */
-    execute(options = {}) {
-        const model = this.editor.model;
-        const document = model.document;
-        const selection = document.selection;
-        const valueToSet = (options.forceValue === undefined) ? !this.value : options.forceValue;
-        model.change(writer => {
-            const ranges = model.schema.getValidRanges(selection.getRanges(), 'restrictedEditingException');
-            if (selection.isCollapsed) {
-                if (valueToSet) {
-                    writer.setSelectionAttribute('restrictedEditingException', valueToSet);
-                }
-                else {
-                    const isSameException = (value) => {
-                        return value.item.getAttribute('restrictedEditingException') === this.value;
-                    };
-                    const focus = selection.focus;
-                    const exceptionStart = focus.getLastMatchingPosition(isSameException, { direction: 'backward' });
-                    const exceptionEnd = focus.getLastMatchingPosition(isSameException);
-                    writer.removeSelectionAttribute('restrictedEditingException');
-                    if (!(focus.isEqual(exceptionStart) || focus.isEqual(exceptionEnd))) {
-                        writer.removeAttribute('restrictedEditingException', writer.createRange(exceptionStart, exceptionEnd));
-                    }
-                }
-            }
-            else {
-                for (const range of ranges) {
-                    if (valueToSet) {
-                        writer.setAttribute('restrictedEditingException', valueToSet, range);
-                    }
-                    else {
-                        writer.removeAttribute('restrictedEditingException', range);
-                    }
-                }
-            }
-        });
-    }
-}

package/src/restrictededitingmode/converters.js

@@ -1,177 +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
- */
-import { Matcher } from 'ckeditor5/src/engine.js';
-import { getMarkerAtPosition } from './utils.js';
-const HIGHLIGHT_CLASS = 'restricted-editing-exception_selected';
-/**
- * Adds a visual highlight style to a restricted editing exception that the selection is anchored to.
- *
- * The highlight is turned on by adding the `.restricted-editing-exception_selected` class to the
- * exception in the view:
- *
- * * The class is removed before the conversion starts, as callbacks added with the `'highest'` priority
- * to {@link module:engine/conversion/downcastdispatcher~DowncastDispatcher} events.
- * * The class is added in the view post-fixer, after other changes in the model tree are converted to the view.
- *
- * This way, adding and removing the highlight does not interfere with conversion.
- *
- * @internal
- */
-export function setupExceptionHighlighting(editor) {
-    const view = editor.editing.view;
-    const model = editor.model;
-    const highlightedMarkers = new Set();
-    // Adding the class.
-    view.document.registerPostFixer((writer) => {
-        const modelSelection = model.document.selection;
-        const marker = getMarkerAtPosition(editor, modelSelection.anchor);
-        if (!marker) {
-            return false;
-        }
-        const modelWrapperElement = marker.getRange().getContainedElement();
-        if (modelWrapperElement && modelWrapperElement.is('element', 'restrictedEditingException')) {
-            const viewElement = editor.editing.mapper.toViewElement(modelWrapperElement);
-            writer.addClass(HIGHLIGHT_CLASS, viewElement);
-            highlightedMarkers.add(viewElement);
-        }
-        else {
-            for (const viewElement of editor.editing.mapper.markerNameToElements(marker.name)) {
-                writer.addClass(HIGHLIGHT_CLASS, viewElement);
-                highlightedMarkers.add(viewElement);
-            }
-        }
-        return false;
-    });
-    // Removing the class.
-    editor.conversion.for('editingDowncast').add(dispatcher => {
-        // Make sure the highlight is removed on every possible event, before conversion is started.
-        dispatcher.on('insert', removeHighlight, { priority: 'highest' });
-        dispatcher.on('remove', removeHighlight, { priority: 'highest' });
-        dispatcher.on('attribute', removeHighlight, { priority: 'highest' });
-        dispatcher.on('cleanSelection', removeHighlight);
-        function removeHighlight() {
-            view.change(writer => {
-                for (const item of highlightedMarkers.values()) {
-                    writer.removeClass(HIGHLIGHT_CLASS, item);
-                    highlightedMarkers.delete(item);
-                }
-            });
-        }
-    });
-}
-/**
- * A post-fixer that prevents removing a collapsed marker from the document.
- *
- * @internal
- */
-export function resurrectCollapsedMarkerPostFixer(editor) {
-    // This post-fixer shouldn't be necessary after https://github.com/ckeditor/ckeditor5/issues/5778.
-    return writer => {
-        let changeApplied = false;
-        for (const { name, data } of editor.model.document.differ.getChangedMarkers()) {
-            if (name.startsWith('restrictedEditingException') && data.newRange && data.newRange.root.rootName == '$graveyard') {
-                writer.updateMarker(name, {
-                    range: writer.createRange(writer.createPositionAt(data.oldRange.start))
-                });
-                changeApplied = true;
-            }
-        }
-        return changeApplied;
-    };
-}
-/**
- * A post-fixer that extends a marker when the user types on its boundaries.
- *
- * @internal
- */
-export function extendMarkerOnTypingPostFixer(editor) {
-    // This post-fixer shouldn't be necessary after https://github.com/ckeditor/ckeditor5/issues/5778.
-    return writer => {
-        let changeApplied = false;
-        const schema = editor.model.schema;
-        for (const change of editor.model.document.differ.getChanges()) {
-            if (change.type == 'insert' && schema.checkChild('$block', change.name)) {
-                changeApplied = _tryExtendMarkerStart(editor, change.position, change.length, writer) || changeApplied;
-                changeApplied = _tryExtendMarkedEnd(editor, change.position, change.length, writer) || changeApplied;
-            }
-        }
-        return changeApplied;
-    };
-}
-/**
- * A view highlight-to-marker conversion helper.
- *
- * @param config Conversion configuration.
- * @internal
- */
-export function upcastHighlightToMarker(config) {
-    return (dispatcher) => dispatcher.on('element', (evt, data, conversionApi) => {
-        const { writer } = conversionApi;
-        const matcher = new Matcher(config.view);
-        const matcherResult = matcher.match(data.viewItem);
-        // If there is no match, this callback should not do anything.
-        if (!matcherResult) {
-            return;
-        }
-        const match = matcherResult.match;
-        // Force consuming element's name (taken from upcast helpers elementToElement converter).
-        match.name = true;
-        if (!conversionApi.consumable.test(data.viewItem, match)) {
-            return;
-        }
-        let position = data.modelCursor;
-        let wrapperElement = null;
-        if (config.useWrapperElement) {
-            if (!conversionApi.schema.checkChild(position, 'restrictedEditingException')) {
-                return;
-            }
-            wrapperElement = writer.createElement('restrictedEditingException');
-            writer.insert(wrapperElement, position);
-            position = writer.createPositionAt(wrapperElement, 0);
-        }
-        const { modelRange: convertedChildrenRange } = conversionApi.convertChildren(data.viewItem, position);
-        conversionApi.consumable.consume(data.viewItem, match);
-        const markerName = config.model();
-        const fakeMarkerStart = writer.createElement('$marker', { 'data-name': markerName });
-        const fakeMarkerEnd = writer.createElement('$marker', { 'data-name': markerName });
-        if (wrapperElement) {
-            writer.insert(fakeMarkerStart, writer.createPositionBefore(wrapperElement));
-            writer.insert(fakeMarkerEnd, writer.createPositionAfter(wrapperElement));
-        }
-        else {
-            // Insert in reverse order to use converter content positions directly (without recalculating).
-            writer.insert(fakeMarkerEnd, convertedChildrenRange.end);
-            writer.insert(fakeMarkerStart, convertedChildrenRange.start);
-        }
-        data.modelRange = writer.createRange(writer.createPositionBefore(fakeMarkerStart), writer.createPositionAfter(fakeMarkerEnd));
-        data.modelCursor = data.modelRange.end;
-    });
-}
-/**
- * Extend marker if change detected on marker's start position.
- */
-function _tryExtendMarkerStart(editor, position, length, writer) {
-    const markerAtStart = getMarkerAtPosition(editor, position.getShiftedBy(length));
-    if (markerAtStart && markerAtStart.getStart().isEqual(position.getShiftedBy(length))) {
-        writer.updateMarker(markerAtStart, {
-            range: writer.createRange(markerAtStart.getStart().getShiftedBy(-length), markerAtStart.getEnd())
-        });
-        return true;
-    }
-    return false;
-}
-/**
- * Extend marker if change detected on marker's end position.
- */
-function _tryExtendMarkedEnd(editor, position, length, writer) {
-    const markerAtEnd = getMarkerAtPosition(editor, position);
-    if (markerAtEnd && markerAtEnd.getEnd().isEqual(position)) {
-        writer.updateMarker(markerAtEnd, {
-            range: writer.createRange(markerAtEnd.getStart(), markerAtEnd.getEnd().getShiftedBy(length))
-        });
-        return true;
-    }
-    return false;
-}

package/src/restrictededitingmode/utils.js

@@ -1,69 +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 restricted-editing/restrictededitingmode/utils
- */
-/**
- * Returns a single "restricted-editing-exception" marker at a given position. Contrary to
- * {@link module:engine/model/markercollection~MarkerCollection#getMarkersAtPosition}, it returnd a marker also when the postion is
- * equal to one of the marker's start or end positions.
- *
- * @internal
- */
-export function getMarkerAtPosition(editor, position) {
-    for (const marker of editor.model.markers) {
-        const markerRange = getExceptionRange(marker, editor.model);
-        if (isPositionInRangeBoundaries(markerRange, position)) {
-            if (marker.name.startsWith('restrictedEditingException:')) {
-                return marker;
-            }
-        }
-    }
-}
-/**
- * Checks if the position is fully contained in the range. Positions equal to range start or end are considered "in".
- *
- * @internal
- */
-export function isPositionInRangeBoundaries(range, position) {
-    return (range.containsPosition(position) ||
-        range.end.isEqual(position) ||
-        range.start.isEqual(position));
-}
-/**
- * Checks if the selection is fully contained in the marker. Positions on marker boundaries are considered "in".
- *
- * ```xml
- * <marker>[]foo</marker> -> true
- * <marker>f[oo]</marker> -> true
- * <marker>f[oo</marker> ba]r -> false
- * <marker>foo</marker> []bar -> false
- * ```
- *
- * @internal
- */
-export function isSelectionInMarker(selection, model, marker) {
-    if (!marker) {
-        return false;
-    }
-    const markerRange = getExceptionRange(marker, model);
-    if (selection.isCollapsed) {
-        return isPositionInRangeBoundaries(markerRange, selection.focus);
-    }
-    return markerRange.containsRange(selection.getFirstRange(), true);
-}
-/**
- * Returns the marker range asjusted to the inside of exception wrapper element if needed.
- *
- * @internal
- */
-export function getExceptionRange(marker, model) {
-    const markerRange = marker.getRange();
-    const wrapperElement = markerRange.getContainedElement();
-    if (wrapperElement && wrapperElement.is('element', 'restrictedEditingException')) {
-        return model.createRangeIn(wrapperElement);
-    }
-    return markerRange;
-}

package/src/restrictededitingmode.js

@@ -1,39 +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 restricted-editing/restrictededitingmode
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { RestrictedEditingModeEditing } from './restrictededitingmodeediting.js';
-import { RestrictedEditingModeUI } from './restrictededitingmodeui.js';
-import '../theme/restrictedediting.css';
-/**
- * The restricted editing mode plugin.
- *
- * This is a "glue" plugin which loads the following plugins:
- *
- * * The {@link module:restricted-editing/restrictededitingmodeediting~RestrictedEditingModeEditing restricted mode editing feature}.
- * * The {@link module:restricted-editing/restrictededitingmodeui~RestrictedEditingModeUI restricted mode UI feature}.
- */
-export class RestrictedEditingMode extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'RestrictedEditingMode';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [RestrictedEditingModeEditing, RestrictedEditingModeUI];
-    }
-}