@ckeditor/ckeditor5-undo 47.6.1 → 48.0.0-alpha.0

package/src/undo.js

@@ -1,127 +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 undo/undo
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import { UndoEditing } from './undoediting.js';
-import { UndoUI } from './undoui.js';
-/**
- * The undo feature.
- *
- * This is a "glue" plugin which loads the {@link module:undo/undoediting~UndoEditing undo editing feature}
- * and the {@link module:undo/undoui~UndoUI undo UI feature}.
- *
- * Below is an explanation of the undo mechanism working together with {@link module:engine/model/history~History History}:
- *
- * Whenever an {@link module:engine/model/operation/operation~Operation operation} is applied to the
- * {@link module:engine/model/document~ModelDocument document}, it is saved to `History` as is.
- * The {@link module:engine/model/batch~Batch batch} that owns that operation is also saved, in
- * {@link module:undo/undocommand~UndoCommand}, together with the selection that was present in the document before the
- * operation was applied. A batch is saved instead of the operation because changes are undone batch-by-batch, not operation-by-operation
- * and a batch is seen as one undo step.
- *
- * After changes happen to the document, the `History` and `UndoCommand` stack can be represented as follows:
- *
- * ```
- *    History                            Undo stack
- * ==============             ==================================
- * [operation A1]                      [  batch A  ]
- * [operation B1]                      [  batch B  ]
- * [operation B2]                      [  batch C  ]
- * [operation C1]
- * [operation C2]
- * [operation B3]
- * [operation C3]
- * ```
- *
- * Where operations starting with the same letter are from same batch.
- *
- * Undoing a batch means that a set of operations which will reverse the effects of that batch needs to be generated.
- * For example, if a batch added several letters, undoing the batch should remove them. It is important to apply undoing
- * operations in the reversed order, so if a batch has operation `X`, `Y`, `Z`, reversed operations `Zr`, `Yr` and `Xr`
- * need to be applied. Otherwise reversed operation `Xr` would operate on a wrong document state, because operation `X`
- * does not know that operations `Y` and `Z` happened.
- *
- * After operations from an undone batch got {@link module:engine/model/operation/operation~Operation#getReversed reversed},
- * one needs to make sure if they are ready to be applied. In the scenario above, operation `C3` is the last operation and `C3r`
- * bases on up-to-date document state, so it can be applied to the document.
- *
- * ```
- *      History                             Undo stack
- * =================             ==================================
- * [ operation A1  ]                      [  batch A  ]
- * [ operation B1  ]                      [  batch B  ]
- * [ operation B2  ]             [   processing undoing batch C   ]
- * [ operation C1  ]
- * [ operation C2  ]
- * [ operation B3  ]
- * [ operation C3  ]
- * [ operation C3r ]
- * ```
- *
- * Next is operation `C2`, reversed to `C2r`. `C2r` bases on `C2`, so it bases on the wrong document state. It needs to be
- * transformed by operations from history that happened after it, so it "knows" about them. Let us assume that `C2' = C2r * B3 * C3 * C3r`,
- * where `*` means "transformed by". Rest of operations from that batch are processed in the same fashion.
- *
- * ```
- *      History                             Undo stack                                      Redo stack
- * =================             ==================================             ==================================
- * [ operation A1  ]                      [  batch A  ]                                    [ batch Cr ]
- * [ operation B1  ]                      [  batch B  ]
- * [ operation B2  ]
- * [ operation C1  ]
- * [ operation C2  ]
- * [ operation B3  ]
- * [ operation C3  ]
- * [ operation C3r ]
- * [ operation C2' ]
- * [ operation C1' ]
- * ```
- *
- * Selective undo works on the same basis, however, instead of undoing the last batch in the undo stack, any batch can be undone.
- * The same algorithm applies: operations from a batch (i.e. `A1`) are reversed and then transformed by operations stored in history.
- *
- * Redo also is very similar to undo. It has its own stack that is filled with undoing (reversed batches). Operations from
- * the batch that is re-done are reversed-back, transformed in proper order and applied to the document.
- *
- * ```
- *      History                             Undo stack                                      Redo stack
- * =================             ==================================             ==================================
- * [ operation A1  ]                      [  batch A  ]
- * [ operation B1  ]                      [  batch B  ]
- * [ operation B2  ]                      [ batch Crr ]
- * [ operation C1  ]
- * [ operation C2  ]
- * [ operation B3  ]
- * [ operation C3  ]
- * [ operation C3r ]
- * [ operation C2' ]
- * [ operation C1' ]
- * [ operation C1'r]
- * [ operation C2'r]
- * [ operation C3rr]
- * ```
- */
-export class Undo extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get requires() {
-        return [UndoEditing, UndoUI];
-    }
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'Undo';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-}

package/src/undocommand.js

@@ -1,44 +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 undo/undocommand
- */
-import { UndoRedoBaseCommand } from './basecommand.js';
-/**
- * The undo command stores {@link module:engine/model/batch~Batch batches} applied to the
- * {@link module:engine/model/document~ModelDocument document} and is able to undo a batch by reversing it and transforming by
- * batches from {@link module:engine/model/document~ModelDocument#history history} that happened after the reversed batch.
- *
- * The undo command also takes care of restoring the {@link module:engine/model/document~ModelDocument#selection document selection}.
- */
-export class UndoCommand extends UndoRedoBaseCommand {
-    /**
-     * Executes the command. This method reverts a {@link module:engine/model/batch~Batch batch} added to the command's stack, transforms
-     * and applies the reverted version on the {@link module:engine/model/document~ModelDocument document} and removes the batch from
-     * the stack. Then, it restores the {@link module:engine/model/document~ModelDocument#selection document selection}.
-     *
-     * @fires execute
-     * @fires revert
-     * @param batch A batch that should be undone. If not set, the last added batch will be undone.
-     */
-    execute(batch = null) {
-        // If batch is not given, set `batchIndex` to the last index in command stack.
-        const batchIndex = batch ? this._stack.findIndex(a => a.batch == batch) : this._stack.length - 1;
-        const item = this._stack.splice(batchIndex, 1)[0];
-        const undoingBatch = this.editor.model.createBatch({ isUndo: true });
-        // All changes have to be done in one `enqueueChange` callback so other listeners will not
-        // step between consecutive operations, or won't do changes to the document before selection is properly restored.
-        this.editor.model.enqueueChange(undoingBatch, () => {
-            this._undo(item.batch, undoingBatch);
-            const operations = this.editor.model.document.history.getOperations(item.batch.baseVersion);
-            this._restoreSelection(item.selection.ranges, item.selection.isBackward, operations);
-        });
-        // Firing `revert` event after the change block to make sure that it includes all changes from post-fixers
-        // and make sure that the selection is "stabilized" (the selection range is saved after undo is executed and then
-        // restored on redo, so it is important that the selection range is saved after post-fixers are done).
-        this.fire('revert', item.batch, undoingBatch);
-        this.refresh();
-    }
-}

package/src/undoediting.js

@@ -1,109 +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 undo/undoediting
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import { UndoCommand } from './undocommand.js';
-import { RedoCommand } from './redocommand.js';
-/**
- * The undo engine feature.
- *
- * It introduces the `'undo'` and `'redo'` commands to the editor.
- */
-export class UndoEditing extends Plugin {
-    /**
-     * The command that manages the undo {@link module:engine/model/batch~Batch batches} stack (history).
-     * Created and registered during the {@link #init feature initialization}.
-     */
-    _undoCommand;
-    /**
-     * The command that manages the redo {@link module:engine/model/batch~Batch batches} stack (history).
-     * Created and registered during the {@link #init feature initialization}.
-     */
-    _redoCommand;
-    /**
-     * Keeps track of which batches were registered in undo.
-     */
-    _batchRegistry = new WeakSet();
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'UndoEditing';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const t = editor.t;
-        // Create commands.
-        this._undoCommand = new UndoCommand(editor);
-        this._redoCommand = new RedoCommand(editor);
-        // Register command to the editor.
-        editor.commands.add('undo', this._undoCommand);
-        editor.commands.add('redo', this._redoCommand);
-        this.listenTo(editor.model, 'applyOperation', (evt, args) => {
-            const operation = args[0];
-            // Do not register batch if the operation is not a document operation.
-            // This prevents from creating empty undo steps, where all operations where non-document operations.
-            // Non-document operations creates and alters content in detached tree fragments (for example, document fragments).
-            // Most of time this is preparing data before it is inserted into actual tree (for example during copy & paste).
-            // Such operations should not be reversed.
-            if (!operation.isDocumentOperation) {
-                return;
-            }
-            const batch = operation.batch;
-            const isRedoBatch = this._redoCommand.createdBatches.has(batch);
-            const isUndoBatch = this._undoCommand.createdBatches.has(batch);
-            const wasProcessed = this._batchRegistry.has(batch);
-            // Skip the batch if it was already processed.
-            if (wasProcessed) {
-                return;
-            }
-            // Add the batch to the registry so it will not be processed again.
-            this._batchRegistry.add(batch);
-            if (!batch.isUndoable) {
-                return;
-            }
-            if (isRedoBatch) {
-                // If this batch comes from `redoCommand`, add it to the `undoCommand` stack.
-                this._undoCommand.addBatch(batch);
-            }
-            else if (!isUndoBatch) {
-                // If the batch comes neither  from `redoCommand` nor from `undoCommand` then it is a new, regular batch.
-                // Add the batch to the `undoCommand` stack and clear the `redoCommand` stack.
-                this._undoCommand.addBatch(batch);
-                this._redoCommand.clearStack();
-            }
-        }, { priority: 'highest' });
-        this.listenTo(this._undoCommand, 'revert', (evt, undoneBatch, undoingBatch) => {
-            this._redoCommand.addBatch(undoingBatch);
-        });
-        editor.keystrokes.set('CTRL+Z', 'undo');
-        editor.keystrokes.set('CTRL+Y', 'redo');
-        editor.keystrokes.set('CTRL+SHIFT+Z', 'redo');
-        // Add the information about the keystrokes to the accessibility database.
-        editor.accessibility.addKeystrokeInfos({
-            keystrokes: [
-                {
-                    label: t('Undo'),
-                    keystroke: 'CTRL+Z'
-                },
-                {
-                    label: t('Redo'),
-                    keystroke: [['CTRL+Y'], ['CTRL+SHIFT+Z']]
-                }
-            ]
-        });
-    }
-}

package/src/undoui.js

@@ -1,80 +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 undo/undoui
- */
-import { Plugin } from '@ckeditor/ckeditor5-core';
-import { ButtonView, MenuBarMenuListItemButtonView } from '@ckeditor/ckeditor5-ui';
-import { IconUndo, IconRedo } from '@ckeditor/ckeditor5-icons';
-/**
- * The undo UI feature. It introduces the `'undo'` and `'redo'` buttons to the editor.
- */
-export class UndoUI extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'UndoUI';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const locale = editor.locale;
-        const t = editor.t;
-        const localizedUndoIcon = locale.uiLanguageDirection == 'ltr' ? IconUndo : IconRedo;
-        const localizedRedoIcon = locale.uiLanguageDirection == 'ltr' ? IconRedo : IconUndo;
-        this._addButtonsToFactory('undo', t('Undo'), 'CTRL+Z', localizedUndoIcon);
-        this._addButtonsToFactory('redo', t('Redo'), 'CTRL+Y', localizedRedoIcon);
-    }
-    /**
-     * Creates a button for the specified command.
-     *
-     * @param name Command name.
-     * @param label Button label.
-     * @param keystroke Command keystroke.
-     * @param Icon Source of the icon.
-     */
-    _addButtonsToFactory(name, label, keystroke, Icon) {
-        const editor = this.editor;
-        editor.ui.componentFactory.add(name, () => {
-            const buttonView = this._createButton(ButtonView, name, label, keystroke, Icon);
-            buttonView.set({
-                tooltip: true
-            });
-            return buttonView;
-        });
-        editor.ui.componentFactory.add('menuBar:' + name, () => {
-            return this._createButton(MenuBarMenuListItemButtonView, name, label, keystroke, Icon);
-        });
-    }
-    /**
-     * TODO
-     */
-    _createButton(ButtonClass, name, label, keystroke, Icon) {
-        const editor = this.editor;
-        const locale = editor.locale;
-        const command = editor.commands.get(name);
-        const view = new ButtonClass(locale);
-        view.set({
-            label,
-            icon: Icon,
-            keystroke
-        });
-        view.bind('isEnabled').to(command, 'isEnabled');
-        this.listenTo(view, 'execute', () => {
-            editor.execute(name);
-            editor.editing.view.focus();
-        });
-        return view;
-    }
-}