@ckeditor/ckeditor5-restricted-editing 47.2.0-alpha.7 → 47.3.0-alpha.0

package/src/index.js

@@ -11,6 +11,7 @@ export { RestrictedEditingModeUI } from './restrictededitingmodeui.js';
 export { RestrictedEditingExceptionCommand } from './restrictededitingexceptioncommand.js';
 export { RestrictedEditingModeNavigationCommand } from './restrictededitingmodenavigationcommand.js';
 export { RestrictedEditingExceptionBlockCommand } from './restrictededitingexceptionblockcommand.js';
+export { RestrictedEditingExceptionAutoCommand } from './restrictededitingexceptionautocommand.js';
 export { StandardEditingMode } from './standardeditingmode.js';
 export { StandardEditingModeEditing } from './standardeditingmodeediting.js';
 export { StandardEditingModeUI } from './standardeditingmodeui.js';

package/src/restrictededitingexceptionautocommand.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license Copyright (c) 2003-2025, 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/restrictededitingexceptionautocommand
+ */
+import { Command, type Editor } from 'ckeditor5/src/core.js';
+/**
+ * The command that toggles exceptions from the restricted editing on text or on blocks.
+ */
+export declare class RestrictedEditingExceptionAutoCommand extends Command {
+    /**
+     * A flag indicating whether the command is active.
+     *
+     * @readonly
+     */
+    value: boolean;
+    /**
+     * The inline exception command.
+     */
+    private readonly _inlineCommand;
+    /**
+     * The block exception command.
+     */
+    private readonly _blockCommand;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * @inheritDoc
+     */
+    execute(): void;
+}

package/src/restrictededitingexceptionautocommand.js

@@ -0,0 +1,73 @@
+/**
+ * @license Copyright (c) 2003-2025, 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/restrictededitingexceptionautocommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+import { count } from 'ckeditor5/src/utils.js';
+/**
+ * The command that toggles exceptions from the restricted editing on text or on blocks.
+ */
+export class RestrictedEditingExceptionAutoCommand extends Command {
+    /**
+     * The inline exception command.
+     */
+    _inlineCommand;
+    /**
+     * The block exception command.
+     */
+    _blockCommand;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor) {
+        super(editor);
+        this._inlineCommand = editor.commands.get('restrictedEditingException');
+        this._blockCommand = editor.commands.get('restrictedEditingExceptionBlock');
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        this.value = this._inlineCommand.value || this._blockCommand.value;
+        this.isEnabled = this._inlineCommand.isEnabled || this._blockCommand.isEnabled;
+    }
+    /**
+     * @inheritDoc
+     */
+    execute() {
+        const editor = this.editor;
+        // Selection is inside an inline exception.
+        if (this._inlineCommand.value) {
+            editor.execute('restrictedEditingException');
+        }
+        // Selection inside a block exception.
+        else if (this._blockCommand.value) {
+            editor.execute('restrictedEditingExceptionBlock');
+        }
+        // Selection allows only for inline exception.
+        else if (this._inlineCommand.isEnabled && !this._blockCommand.isEnabled) {
+            editor.execute('restrictedEditingException');
+        }
+        // Selection allows only for block exception.
+        else if (this._blockCommand.isEnabled && !this._inlineCommand.isEnabled) {
+            editor.execute('restrictedEditingExceptionBlock');
+        }
+        // Check selection to pick exception type.
+        else {
+            const schema = editor.model.schema;
+            const selection = editor.model.document.selection;
+            const selectedElement = selection.getSelectedElement();
+            if (selection.isCollapsed ||
+                selectedElement && schema.isObject(selectedElement) && schema.isBlock(selectedElement) ||
+                count(selection.getSelectedBlocks()) > 1) {
+                editor.execute('restrictedEditingExceptionBlock');
+            }
+            else {
+                editor.execute('restrictedEditingException');
+            }
+        }
+    }
+}

package/src/standardeditingmodeediting.js

@@ -9,6 +9,7 @@ import { Plugin } from 'ckeditor5/src/core.js';
 import { Matcher } from 'ckeditor5/src/engine.js';
 import { RestrictedEditingExceptionCommand } from './restrictededitingexceptioncommand.js';
 import { RestrictedEditingExceptionBlockCommand } from './restrictededitingexceptionblockcommand.js';
+import { RestrictedEditingExceptionAutoCommand } from './restrictededitingexceptionautocommand.js';
 /**
  * The standard editing mode editing feature.
  *
@@ -158,6 +159,7 @@ export class StandardEditingModeEditing extends Plugin {
         });
         editor.commands.add('restrictedEditingException', new RestrictedEditingExceptionCommand(editor));
         editor.commands.add('restrictedEditingExceptionBlock', new RestrictedEditingExceptionBlockCommand(editor));
+        editor.commands.add('restrictedEditingExceptionAuto', new RestrictedEditingExceptionAutoCommand(editor));
         editor.editing.view.change(writer => {
             for (const root of editor.editing.view.document.roots) {
                 writer.addClass('ck-restricted-editing_mode_standard', root);

package/src/standardeditingmodeui.js

@@ -32,6 +32,7 @@ export class StandardEditingModeUI extends Plugin {
     init() {
         const editor = this.editor;
         const componentFactory = editor.ui.componentFactory;
+        // Dropdown button with inline/block buttons.
         componentFactory.add('restrictedEditingException:dropdown', locale => {
             const dropdownView = createDropdown(locale);
             const t = locale.t;
@@ -70,28 +71,40 @@ export class StandardEditingModeUI extends Plugin {
             });
             return dropdownView;
         });
+        // Inline exception button.
         componentFactory.add('restrictedEditingException:inline', () => {
             const button = this._createButton('restrictedEditingException', ButtonView);
             button.set({
-                tooltip: true,
-                isToggleable: true
+                tooltip: true
             });
             return button;
         });
+        // Block exception button.
         componentFactory.add('restrictedEditingException:block', () => {
             const button = this._createButton('restrictedEditingExceptionBlock', ButtonView);
             button.set({
-                tooltip: true,
-                isToggleable: true
+                tooltip: true
             });
             return button;
         });
+        // Menu bar inline/block buttons.
         componentFactory.add('menuBar:restrictedEditingException:inline', () => {
             return this._createButton('restrictedEditingException', MenuBarMenuListItemButtonView);
         });
         componentFactory.add('menuBar:restrictedEditingException:block', () => {
             return this._createButton('restrictedEditingExceptionBlock', MenuBarMenuListItemButtonView);
         });
+        // Auto button - triggers inline or block exception command.
+        componentFactory.add('restrictedEditingException:auto', () => {
+            const button = this._createButton('restrictedEditingExceptionAuto', ButtonView);
+            button.set({
+                tooltip: true
+            });
+            return button;
+        });
+        componentFactory.add('menuBar:restrictedEditingException:auto', () => {
+            return this._createButton('restrictedEditingExceptionAuto', MenuBarMenuListItemButtonView);
+        });
         // Aliases for backward compatibility.
         componentFactory.add('restrictedEditingException', () => {
             return componentFactory.create('restrictedEditingException:inline');
@@ -110,8 +123,14 @@ export class StandardEditingModeUI extends Plugin {
         const view = new ButtonClass(locale);
         const t = locale.t;
         view.icon = IconContentUnlock;
+        view.isToggleable = true;
         view.bind('isOn', 'isEnabled').to(command, 'value', 'isEnabled');
-        if (commandName == 'restrictedEditingExceptionBlock') {
+        if (commandName == 'restrictedEditingExceptionAuto') {
+            view.bind('label').to(command, 'value', value => {
+                return value ? t('Disable editing') : t('Enable editing');
+            });
+        }
+        else if (commandName == 'restrictedEditingExceptionBlock') {
             view.bind('label').to(command, 'value', value => {
                 return value ? t('Disable block editing') : t('Enable block editing');
             });