@ckeditor/ckeditor5-undo 36.0.1 → 37.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-undo",
-  "version": "36.0.1",
+  "version": "37.0.0-alpha.0",
   "description": "Undo feature for CKEditor 5.",
   "keywords": [
     "ckeditor",
@@ -12,20 +12,20 @@
   ],
   "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-core": "^36.0.1",
-    "@ckeditor/ckeditor5-engine": "^36.0.1",
-    "@ckeditor/ckeditor5-ui": "^36.0.1"
+    "@ckeditor/ckeditor5-core": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-engine": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-ui": "^37.0.0-alpha.0"
   },
   "devDependencies": {
-    "@ckeditor/ckeditor5-basic-styles": "^36.0.1",
-    "@ckeditor/ckeditor5-clipboard": "^36.0.1",
-    "@ckeditor/ckeditor5-editor-classic": "^36.0.1",
-    "@ckeditor/ckeditor5-enter": "^36.0.1",
-    "@ckeditor/ckeditor5-heading": "^36.0.1",
-    "@ckeditor/ckeditor5-paragraph": "^36.0.1",
-    "@ckeditor/ckeditor5-typing": "^36.0.1",
-    "@ckeditor/ckeditor5-table": "^36.0.1",
-    "@ckeditor/ckeditor5-utils": "^36.0.1",
+    "@ckeditor/ckeditor5-basic-styles": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-clipboard": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-editor-classic": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-enter": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-heading": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-paragraph": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-typing": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-table": "^37.0.0-alpha.0",
+    "@ckeditor/ckeditor5-utils": "^37.0.0-alpha.0",
     "typescript": "^4.8.4",
     "webpack": "^5.58.1",
     "webpack-cli": "^4.9.0"
@@ -54,5 +54,6 @@
   "scripts": {
     "build": "tsc -p ./tsconfig.release.json",
     "postversion": "npm run build"
-  }
+  },
+  "types": "src/index.d.ts"
 }

package/src/basecommand.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @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 undo/basecommand
+ */
+import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { type Batch, type Operation, type Range } from '@ckeditor/ckeditor5-engine';
+/**
+ * Base class for the undo feature commands: {@link module:undo/undocommand~UndoCommand} and {@link module:undo/redocommand~RedoCommand}.
+ */
+export default abstract class BaseCommand extends Command {
+    /**
+     * Stack of items stored by the command. These are pairs of:
+     *
+     * * {@link module:engine/model/batch~Batch batch} saved by the command,
+     * * {@link module:engine/model/selection~Selection selection} state at the moment of saving the batch.
+     */
+    protected _stack: Array<{
+        batch: Batch;
+        selection: {
+            ranges: Array<Range>;
+            isBackward: boolean;
+        };
+    }>;
+    /**
+     * Stores all batches that were created by this command.
+     */
+    protected _createdBatches: WeakSet<Batch>;
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
+    /**
+     * @inheritDoc
+     */
+    refresh(): void;
+    /**
+     * Returns all batches created by this command.
+     */
+    get createdBatches(): WeakSet<Batch>;
+    /**
+     * Stores a batch in the command, together with the selection state of the {@link module:engine/model/document~Document document}
+     * created by the editor which this command is registered to.
+     *
+     * @param batch The batch to add.
+     */
+    addBatch(batch: Batch): void;
+    /**
+     * Removes all items from the stack.
+     */
+    clearStack(): void;
+    /**
+     * Restores the {@link module:engine/model/document~Document#selection document selection} state after a batch was undone.
+     *
+     * @param ranges Ranges to be restored.
+     * @param isBackward A flag describing whether the restored range was selected forward or backward.
+     * @param operations Operations which has been applied since selection has been stored.
+     */
+    protected _restoreSelection(ranges: Array<Range>, isBackward: boolean, operations: Array<Operation>): void;
+    /**
+     * Undoes a batch by reversing that batch, transforming reversed batch and finally applying it.
+     * This is a helper method for {@link #execute}.
+     *
+     * @param batchToUndo The batch to be undone.
+     * @param undoingBatch The batch that will contain undoing changes.
+     */
+    protected _undo(batchToUndo: Batch, undoingBatch: Batch): void;
+}

package/src/basecommand.js

@@ -9,11 +9,11 @@ import { Command } from '@ckeditor/ckeditor5-core';
 import { transformSets } from '@ckeditor/ckeditor5-engine';
 /**
  * Base class for the undo feature commands: {@link module:undo/undocommand~UndoCommand} and {@link module:undo/redocommand~RedoCommand}.
- *
- * @protected
- * @extends module:core/command~Command
  */
 export default class BaseCommand extends Command {
+    /**
+     * @inheritDoc
+     */
     constructor(editor) {
         super(editor);
         /**
@@ -21,16 +21,10 @@ export default class BaseCommand extends Command {
          *
          * * {@link module:engine/model/batch~Batch batch} saved by the command,
          * * {@link module:engine/model/selection~Selection selection} state at the moment of saving the batch.
-         *
-         * @protected
-         * @member {Array} #_stack
          */
         this._stack = [];
         /**
          * Stores all batches that were created by this command.
-         *
-         * @protected
-         * @member {WeakSet.<module:engine/model/batch~Batch>} #_createdBatches
          */
         this._createdBatches = new WeakSet();
         // Refresh state, so the command is inactive right after initialization.
@@ -63,11 +57,17 @@ export default class BaseCommand extends Command {
     refresh() {
         this.isEnabled = this._stack.length > 0;
     }
+    /**
+     * Returns all batches created by this command.
+     */
+    get createdBatches() {
+        return this._createdBatches;
+    }
     /**
      * Stores a batch in the command, together with the selection state of the {@link module:engine/model/document~Document document}
      * created by the editor which this command is registered to.
      *
-     * @param {module:engine/model/batch~Batch} batch The batch to add.
+     * @param batch The batch to add.
      */
     addBatch(batch) {
         const docSelection = this.editor.model.document.selection;
@@ -88,11 +88,9 @@ export default class BaseCommand extends Command {
     /**
      * Restores the {@link module:engine/model/document~Document#selection document selection} state after a batch was undone.
      *
-     * @protected
-     * @param {Array.<module:engine/model/range~Range>} ranges Ranges to be restored.
-     * @param {Boolean} isBackward A flag describing whether the restored range was selected forward or backward.
-     * @param {Array.<module:engine/model/operation/operation~Operation>} operations Operations which has been applied
-     * since selection has been stored.
+     * @param ranges Ranges to be restored.
+     * @param isBackward A flag describing whether the restored range was selected forward or backward.
+     * @param operations Operations which has been applied since selection has been stored.
      */
     _restoreSelection(ranges, isBackward, operations) {
         const model = this.editor.model;
@@ -131,9 +129,8 @@ export default class BaseCommand extends Command {
      * Undoes a batch by reversing that batch, transforming reversed batch and finally applying it.
      * This is a helper method for {@link #execute}.
      *
-     * @protected
-     * @param {module:engine/model/batch~Batch} batchToUndo The batch to be undone.
-     * @param {module:engine/model/batch~Batch} undoingBatch The batch that will contain undoing changes.
+     * @param batchToUndo The batch to be undone.
+     * @param undoingBatch The batch that will contain undoing changes.
      */
     _undo(batchToUndo, undoingBatch) {
         const model = this.editor.model;
@@ -164,10 +161,11 @@ export default class BaseCommand extends Command {
         }
     }
 }
-// Normalizes list of ranges by joining intersecting or "touching" ranges.
-//
-// @param {Array.<module:engine/model/range~Range>} ranges
-//
+/**
+ * Normalizes list of ranges by joining intersecting or "touching" ranges.
+ *
+ * @param ranges Ranges to be normalized.
+ */
 function normalizeRanges(ranges) {
     ranges.sort((a, b) => a.start.isBefore(b.start) ? -1 : 1);
     for (let i = 1; i < ranges.length; i++) {

package/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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 undo
+ */
+export { default as Undo } from './undo';
+export { default as UndoEditing } from './undoediting';
+export { default as UndoUi } from './undoui';
+export type { default as UndoCommand } from './undocommand';

package/src/redocommand.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 undo/redocommand
+ */
+import BaseCommand from './basecommand';
+/**
+ * The redo command stores {@link module:engine/model/batch~Batch batches} that were used to undo a batch by
+ * {@link module:undo/undocommand~UndoCommand}. It is able to redo a previously undone batch by reversing the undoing
+ * batches created by `UndoCommand`. The reversed batch is transformed by all the batches from
+ * {@link module:engine/model/document~Document#history history} that happened after the reversed undo batch.
+ *
+ * The redo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
+ */
+export default class RedoCommand extends BaseCommand {
+    /**
+     * Executes the command. This method reverts the last {@link module:engine/model/batch~Batch batch} added to
+     * the command's stack, applies the reverted and transformed version on the
+     * {@link module:engine/model/document~Document document} and removes the batch from the stack.
+     * Then, it restores the {@link module:engine/model/document~Document#selection document selection}.
+     *
+     * @fires execute
+     */
+    execute(): void;
+}
+declare module '@ckeditor/ckeditor5-core' {
+    interface CommandsMap {
+        redo: RedoCommand;
+    }
+}

package/src/redocommand.js

@@ -13,8 +13,6 @@ import BaseCommand from './basecommand';
  * {@link module:engine/model/document~Document#history history} that happened after the reversed undo batch.
  *
  * The redo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
- *
- * @extends module:undo/basecommand~BaseCommand
  */
 export default class RedoCommand extends BaseCommand {
     /**

package/src/undo.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @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 undo/undo
+ */
+import { Plugin, type PluginDependencies } from '@ckeditor/ckeditor5-core';
+/**
+ * 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~Document 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 default class Undo extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): PluginDependencies;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): 'Undo';
+}
+declare module '@ckeditor/ckeditor5-core' {
+    interface PluginsMap {
+        [Undo.pluginName]: Undo;
+    }
+}

package/src/undo.js

@@ -25,15 +25,17 @@ import UndoUI from './undoui';
  *
  * 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]
+ * ```
+ *    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.
  *
@@ -47,33 +49,37 @@ import UndoUI from './undoui';
  * 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 ]
+ * ```
+ *      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' ]
+ * ```
+ *      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.
@@ -81,23 +87,23 @@ import UndoUI from './undoui';
  * 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]
- *
- * @extends module:core/plugin~Plugin
+ * ```
+ *      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 default class Undo extends Plugin {
     /**

package/src/undocommand.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @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 undo/undocommand
+ */
+import BaseCommand from './basecommand';
+import type { Batch } from '@ckeditor/ckeditor5-engine';
+/**
+ * The undo command stores {@link module:engine/model/batch~Batch batches} applied to the
+ * {@link module:engine/model/document~Document document} and is able to undo a batch by reversing it and transforming by
+ * batches from {@link module:engine/model/document~Document#history history} that happened after the reversed batch.
+ *
+ * The undo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
+ */
+export default class UndoCommand extends BaseCommand {
+    /**
+     * 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~Document document} and removes the batch from the stack.
+     * Then, it restores the {@link module:engine/model/document~Document#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?: Batch | null): void;
+}
+/**
+ * Fired when execution of the command reverts some batch.
+ *
+ * @eventName revert
+ */
+export type UndoCommandRevertEvent = {
+    name: 'revert';
+    args: [batch: Batch, undoingBatch: Batch];
+};
+declare module '@ckeditor/ckeditor5-core' {
+    interface CommandsMap {
+        undo: UndoCommand;
+    }
+}

package/src/undocommand.js

@@ -12,8 +12,6 @@ import BaseCommand from './basecommand';
  * batches from {@link module:engine/model/document~Document#history history} that happened after the reversed batch.
  *
  * The undo command also takes care of restoring the {@link module:engine/model/document~Document#selection document selection}.
- *
- * @extends module:undo/basecommand~BaseCommand
  */
 export default class UndoCommand extends BaseCommand {
     /**
@@ -23,7 +21,7 @@ export default class UndoCommand extends BaseCommand {
      *
      * @fires execute
      * @fires revert
-     * @param {module:engine/model/batch~Batch} [batch] A batch that should be undone. If not set, the last added batch will be undone.
+     * @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.

package/src/undoediting.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @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 undo/undoediting
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * The undo engine feature.
+ *
+ * It introduces the `'undo'` and `'redo'` commands to the editor.
+ */
+export default 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}.
+     */
+    private _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}.
+     */
+    private _redoCommand;
+    /**
+     * Keeps track of which batches were registered in undo.
+     */
+    private _batchRegistry;
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): 'UndoEditing';
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}
+declare module '@ckeditor/ckeditor5-core' {
+    interface PluginsMap {
+        [UndoEditing.pluginName]: UndoEditing;
+    }
+}

package/src/undoediting.js

@@ -12,43 +12,21 @@ import RedoCommand from './redocommand';
  * The undo engine feature.
  *
  * It introduces the `'undo'` and `'redo'` commands to the editor.
- *
- * @extends module:core/plugin~Plugin
  */
 export default class UndoEditing extends Plugin {
+    constructor() {
+        super(...arguments);
+        /**
+         * Keeps track of which batches were registered in undo.
+         */
+        this._batchRegistry = new WeakSet();
+    }
     /**
      * @inheritDoc
      */
     static get pluginName() {
         return 'UndoEditing';
     }
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        /**
-         * The command that manages the undo {@link module:engine/model/batch~Batch batches} stack (history).
-         * Created and registered during the {@link #init feature initialization}.
-         *
-         * @private
-         * @member {module:undo/undocommand~UndoCommand} #_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}.
-         *
-         * @private
-         * @member {module:undo/undocommand~UndoCommand} #_redoCommand
-         */
-        /**
-         * Keeps track of which batches were registered in undo.
-         *
-         * @private
-         * @member {WeakSet.<module:engine/model/batch~Batch>}
-         */
-        this._batchRegistry = new WeakSet();
-    }
     /**
      * @inheritDoc
      */
@@ -71,8 +49,8 @@ export default class UndoEditing extends Plugin {
                 return;
             }
             const batch = operation.batch;
-            const isRedoBatch = this._redoCommand._createdBatches.has(batch);
-            const isUndoBatch = this._undoCommand._createdBatches.has(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) {

package/src/undoui.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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 undo/undoui
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+/**
+ * The undo UI feature. It introduces the `'undo'` and `'redo'` buttons to the editor.
+ */
+export default class UndoUI extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): 'UndoUI';
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * 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.
+     */
+    private _addButton;
+}
+declare module '@ckeditor/ckeditor5-core' {
+    interface PluginsMap {
+        [UndoUI.pluginName]: UndoUI;
+    }
+}

package/src/undoui.js

@@ -11,8 +11,6 @@ import undoIcon from '../theme/icons/undo.svg';
 import redoIcon from '../theme/icons/redo.svg';
 /**
  * The undo UI feature. It introduces the `'undo'` and `'redo'` buttons to the editor.
- *
- * @extends module:core/plugin~Plugin
  */
 export default class UndoUI extends Plugin {
     /**
@@ -36,11 +34,10 @@ export default class UndoUI extends Plugin {
     /**
      * Creates a button for the specified command.
      *
-     * @private
-     * @param {String} name Command name.
-     * @param {String} label Button label.
-     * @param {String} keystroke Command keystroke.
-     * @param {String} Icon Source of the icon.
+     * @param name Command name.
+     * @param label Button label.
+     * @param keystroke Command keystroke.
+     * @param Icon Source of the icon.
      */
     _addButton(name, label, keystroke, Icon) {
         const editor = this.editor;