@ckeditor/ckeditor5-table 36.0.1 → 37.0.0-alpha.1

package/src/tablemouse/mouseeventsobserver.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @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 table/tablemouse/mouseeventsobserver
+ */
+import { DomEventObserver, type DomEventData } from 'ckeditor5/src/engine';
+/**
+ * The mouse selection event observer.
+ *
+ * It registers listeners for the following DOM events:
+ *
+ * - `'mousemove'`
+ * - `'mouseleave'`
+ *
+ * Note that this observer is disabled by default. To enable this observer, it needs to be added to
+ * {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * The observer is registered by the {@link module:table/tableselection~TableSelection} plugin.
+ */
+export default class MouseEventsObserver extends DomEventObserver<'mousemove' | 'mouseleave'> {
+    readonly domEventType: readonly ["mousemove", "mouseleave"];
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent: MouseEvent): void;
+}
+/**
+ * Fired when the mouse is moved over one of the editables.
+ *
+ * Introduced by {@link module:table/tablemouse/mouseeventsobserver~MouseEventsObserver}.
+ *
+ * Note that this event is not available by default. To make it available,
+ * {@link module:table/tablemouse/mouseeventsobserver~MouseEventsObserver} needs to be added
+ * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:table/tablemouse/mouseeventsobserver~MouseEventsObserver
+ * @eventName module:engine/view/document~Document#mousemove
+ * @param data Event data.
+ */
+export type ViewDocumentMouseMoveEvent = {
+    name: 'mousemove';
+    args: [data: DomEventData<MouseEvent>];
+};
+/**
+ * Fired when the mouse is moved out of one of the editables.
+ *
+ * Introduced by {@link module:table/tablemouse/mouseeventsobserver~MouseEventsObserver}.
+ *
+ * Note that this event is not available by default. To make it available,
+ * {@link module:table/tablemouse/mouseeventsobserver~MouseEventsObserver} needs to be added
+ * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
+ *
+ * @see module:table/tablemouse/mouseeventsobserver~MouseEventsObserver
+ * @eventName module:engine/view/document~Document#mouseleave
+ * @param data Event data.
+ */
+export type ViewDocumentMouseLeaveEvent = {
+    name: 'mouseleave';
+    args: [data: DomEventData<MouseEvent>];
+};

package/src/tablemouse/mouseeventsobserver.js

@@ -2,71 +2,34 @@
  * @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 table/tableselection/mouseeventsobserver
+ * @module table/tablemouse/mouseeventsobserver
  */
-
 import { DomEventObserver } from 'ckeditor5/src/engine';
-
 /**
  * The mouse selection event observer.
  *
  * It registers listeners for the following DOM events:
  *
  * - `'mousemove'`
- * - `'mouseup'`
  * - `'mouseleave'`
  *
  * Note that this observer is disabled by default. To enable this observer, it needs to be added to
  * {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
  *
  * The observer is registered by the {@link module:table/tableselection~TableSelection} plugin.
- *
- * @extends module:engine/view/observer/domeventobserver~DomEventObserver
  */
 export default class MouseEventsObserver extends DomEventObserver {
-	/**
-	 * @inheritDoc
-	 */
-	constructor( view ) {
-		super( view );
-
-		this.domEventType = [ 'mousemove', 'mouseleave' ];
-	}
-
-	/**
-	 * @inheritDoc
-	 */
-	onDomEvent( domEvent ) {
-		this.fire( domEvent.type, domEvent );
-	}
+    constructor() {
+        super(...arguments);
+        this.domEventType = [
+            'mousemove', 'mouseleave'
+        ];
+    }
+    /**
+     * @inheritDoc
+     */
+    onDomEvent(domEvent) {
+        this.fire(domEvent.type, domEvent);
+    }
 }
-
-/**
- * Fired when the mouse is moved over one of the editables.
- *
- * Introduced by {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver}.
- *
- * Note that this event is not available by default. To make it available,
- * {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver} needs to be added
- * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
- *
- * @see module:table/tableselection/mouseeventsobserver~MouseEventsObserver
- * @event module:engine/view/document~Document#event:mousemove
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */
-
-/**
- * Fired when the mouse is moved out of one of the editables.
- *
- * Introduced by {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver}.
- *
- * Note that this event is not available by default. To make it available,
- * {@link module:table/tableselection/mouseeventsobserver~MouseEventsObserver} needs to be added
- * to {@link module:engine/view/view~View} using the {@link module:engine/view/view~View#addObserver} method.
- *
- * @see module:table/tableselection/mouseeventsobserver~MouseEventsObserver
- * @event module:engine/view/document~Document#event:mouseleave
- * @param {module:engine/view/observer/domeventdata~DomEventData} data Event data.
- */

package/src/tablemouse.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @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 table/tablemouse
+ */
+import { Plugin, type PluginDependencies } from 'ckeditor5/src/core';
+/**
+ * This plugin enables a table cells' selection with the mouse.
+ * It is loaded automatically by the {@link module:table/table~Table} plugin.
+ */
+export default class TableMouse extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): 'TableMouse';
+    /**
+     * @inheritDoc
+     */
+    static get requires(): PluginDependencies;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * Enables making cells selection by <kbd>Shift</kbd>+click. Creates a selection from the cell which previously held
+     * the selection to the cell which was clicked. It can be the same cell, in which case it selects a single cell.
+     */
+    private _enableShiftClickSelection;
+    /**
+     * Enables making cells selection by dragging.
+     *
+     * The selection is made only on mousemove. Mouse tracking is started on mousedown.
+     * However, the cells selection is enabled only after the mouse cursor left the anchor cell.
+     * Thanks to that normal text selection within one cell works just fine. However, you can still select
+     * just one cell by leaving the anchor cell and moving back to it.
+     */
+    private _enableMouseDragSelection;
+    /**
+     * Returns the model table cell element based on the target element of the passed DOM event.
+     *
+     * @returns Returns the table cell or `undefined`.
+     */
+    private _getModelTableCellFromDomEvent;
+}

package/src/tablemouse.js

@@ -2,219 +2,171 @@
  * @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 table/tablemouse
  */
-
 import { Plugin } from 'ckeditor5/src/core';
-
 import TableSelection from './tableselection';
 import MouseEventsObserver from './tablemouse/mouseeventsobserver';
 import TableUtils from './tableutils';
-
 /**
  * This plugin enables a table cells' selection with the mouse.
  * It is loaded automatically by the {@link module:table/table~Table} plugin.
- *
- * @extends module:core/plugin~Plugin
  */
 export default class TableMouse extends Plugin {
-	/**
-	 * @inheritDoc
-	 */
-	static get pluginName() {
-		return 'TableMouse';
-	}
-
-	/**
-	 * @inheritDoc
-	 */
-	static get requires() {
-		return [ TableSelection, TableUtils ];
-	}
-
-	/**
-	 * @inheritDoc
-	 */
-	init() {
-		const editor = this.editor;
-
-		// Currently the MouseObserver only handles `mousedown` and `mouseup` events.
-		// TODO move to the engine?
-		editor.editing.view.addObserver( MouseEventsObserver );
-
-		this._enableShiftClickSelection();
-		this._enableMouseDragSelection();
-	}
-
-	/**
-	 * Enables making cells selection by <kbd>Shift</kbd>+click. Creates a selection from the cell which previously held
-	 * the selection to the cell which was clicked. It can be the same cell, in which case it selects a single cell.
-	 *
-	 * @private
-	 */
-	_enableShiftClickSelection() {
-		const editor = this.editor;
-		const tableUtils = editor.plugins.get( TableUtils );
-		let blockSelectionChange = false;
-
-		const tableSelection = editor.plugins.get( TableSelection );
-
-		this.listenTo( editor.editing.view.document, 'mousedown', ( evt, domEventData ) => {
-			const selection = editor.model.document.selection;
-
-			if ( !this.isEnabled || !tableSelection.isEnabled ) {
-				return;
-			}
-
-			if ( !domEventData.domEvent.shiftKey ) {
-				return;
-			}
-
-			const anchorCell = tableSelection.getAnchorCell() || tableUtils.getTableCellsContainingSelection( selection )[ 0 ];
-
-			if ( !anchorCell ) {
-				return;
-			}
-
-			const targetCell = this._getModelTableCellFromDomEvent( domEventData );
-
-			if ( targetCell && haveSameTableParent( anchorCell, targetCell ) ) {
-				blockSelectionChange = true;
-				tableSelection.setCellSelection( anchorCell, targetCell );
-
-				domEventData.preventDefault();
-			}
-		} );
-
-		this.listenTo( editor.editing.view.document, 'mouseup', () => {
-			blockSelectionChange = false;
-		} );
-
-		// We need to ignore a `selectionChange` event that is fired after we render our new table cells selection.
-		// When downcasting table cells selection to the view, we put the view selection in the last selected cell
-		// in a place that may not be natively a "correct" location. This is – we put it directly in the `<td>` element.
-		// All browsers fire the native `selectionchange` event.
-		// However, all browsers except Safari return the selection in the exact place where we put it
-		// (even though it's visually normalized). Safari returns `<td><p>^foo` that makes our selection observer
-		// fire our `selectionChange` event (because the view selection that we set in the first step differs from the DOM selection).
-		// Since `selectionChange` is fired, we automatically update the model selection that moves it that paragraph.
-		// This breaks our dear cells selection.
-		//
-		// Theoretically this issue concerns only Safari that is the only browser that do normalize the selection.
-		// However, to avoid code branching and to have a good coverage for this event blocker, I enabled it for all browsers.
-		//
-		// Note: I'm keeping the `blockSelectionChange` state separately for shift+click and mouse drag (exact same logic)
-		// so I don't have to try to analyze whether they don't overlap in some weird cases. Probably they don't.
-		// But I have other things to do, like writing this comment.
-		this.listenTo( editor.editing.view.document, 'selectionChange', evt => {
-			if ( blockSelectionChange ) {
-				// @if CK_DEBUG // console.log( 'Blocked selectionChange to avoid breaking table cells selection.' );
-
-				evt.stop();
-			}
-		}, { priority: 'highest' } );
-	}
-
-	/**
-	 * Enables making cells selection by dragging.
-	 *
-	 * The selection is made only on mousemove. Mouse tracking is started on mousedown.
-	 * However, the cells selection is enabled only after the mouse cursor left the anchor cell.
-	 * Thanks to that normal text selection within one cell works just fine. However, you can still select
-	 * just one cell by leaving the anchor cell and moving back to it.
-	 *
-	 * @private
-	 */
-	_enableMouseDragSelection() {
-		const editor = this.editor;
-		let anchorCell, targetCell;
-		let beganCellSelection = false;
-		let blockSelectionChange = false;
-
-		const tableSelection = editor.plugins.get( TableSelection );
-
-		this.listenTo( editor.editing.view.document, 'mousedown', ( evt, domEventData ) => {
-			if ( !this.isEnabled || !tableSelection.isEnabled ) {
-				return;
-			}
-
-			// Make sure to not conflict with the shift+click listener and any other possible handler.
-			if ( domEventData.domEvent.shiftKey || domEventData.domEvent.ctrlKey || domEventData.domEvent.altKey ) {
-				return;
-			}
-
-			anchorCell = this._getModelTableCellFromDomEvent( domEventData );
-		} );
-
-		this.listenTo( editor.editing.view.document, 'mousemove', ( evt, domEventData ) => {
-			if ( !domEventData.domEvent.buttons ) {
-				return;
-			}
-
-			if ( !anchorCell ) {
-				return;
-			}
-
-			const newTargetCell = this._getModelTableCellFromDomEvent( domEventData );
-
-			if ( newTargetCell && haveSameTableParent( anchorCell, newTargetCell ) ) {
-				targetCell = newTargetCell;
-
-				// Switch to the cell selection mode after the mouse cursor left the anchor cell.
-				// Switch off only on mouseup (makes selecting a single cell possible).
-				if ( !beganCellSelection && targetCell != anchorCell ) {
-					beganCellSelection = true;
-				}
-			}
-
-			// Yep, not making a cell selection yet. See method docs.
-			if ( !beganCellSelection ) {
-				return;
-			}
-
-			blockSelectionChange = true;
-			tableSelection.setCellSelection( anchorCell, targetCell );
-
-			domEventData.preventDefault();
-		} );
-
-		this.listenTo( editor.editing.view.document, 'mouseup', () => {
-			beganCellSelection = false;
-			blockSelectionChange = false;
-			anchorCell = null;
-			targetCell = null;
-		} );
-
-		// See the explanation in `_enableShiftClickSelection()`.
-		this.listenTo( editor.editing.view.document, 'selectionChange', evt => {
-			if ( blockSelectionChange ) {
-				// @if CK_DEBUG // console.log( 'Blocked selectionChange to avoid breaking table cells selection.' );
-
-				evt.stop();
-			}
-		}, { priority: 'highest' } );
-	}
-
-	/**
-	 * Returns the model table cell element based on the target element of the passed DOM event.
-	 *
-	 * @private
-	 * @param {module:engine/view/observer/domeventdata~DomEventData} domEventData
-	 * @returns {module:engine/model/element~Element|undefined} Returns the table cell or `undefined`.
-	 */
-	_getModelTableCellFromDomEvent( domEventData ) {
-		// Note: Work with positions (not element mapping) because the target element can be an attribute or other non-mapped element.
-		const viewTargetElement = domEventData.target;
-		const viewPosition = this.editor.editing.view.createPositionAt( viewTargetElement, 0 );
-		const modelPosition = this.editor.editing.mapper.toModelPosition( viewPosition );
-		const modelElement = modelPosition.parent;
-
-		return modelElement.findAncestor( 'tableCell', { includeSelf: true } );
-	}
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'TableMouse';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [TableSelection, TableUtils];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        // Currently the MouseObserver only handles `mousedown` and `mouseup` events.
+        // TODO move to the engine?
+        editor.editing.view.addObserver(MouseEventsObserver);
+        this._enableShiftClickSelection();
+        this._enableMouseDragSelection();
+    }
+    /**
+     * Enables making cells selection by <kbd>Shift</kbd>+click. Creates a selection from the cell which previously held
+     * the selection to the cell which was clicked. It can be the same cell, in which case it selects a single cell.
+     */
+    _enableShiftClickSelection() {
+        const editor = this.editor;
+        const tableUtils = editor.plugins.get(TableUtils);
+        let blockSelectionChange = false;
+        const tableSelection = editor.plugins.get(TableSelection);
+        this.listenTo(editor.editing.view.document, 'mousedown', (evt, domEventData) => {
+            const selection = editor.model.document.selection;
+            if (!this.isEnabled || !tableSelection.isEnabled) {
+                return;
+            }
+            if (!domEventData.domEvent.shiftKey) {
+                return;
+            }
+            const anchorCell = tableSelection.getAnchorCell() || tableUtils.getTableCellsContainingSelection(selection)[0];
+            if (!anchorCell) {
+                return;
+            }
+            const targetCell = this._getModelTableCellFromDomEvent(domEventData);
+            if (targetCell && haveSameTableParent(anchorCell, targetCell)) {
+                blockSelectionChange = true;
+                tableSelection.setCellSelection(anchorCell, targetCell);
+                domEventData.preventDefault();
+            }
+        });
+        this.listenTo(editor.editing.view.document, 'mouseup', () => {
+            blockSelectionChange = false;
+        });
+        // We need to ignore a `selectionChange` event that is fired after we render our new table cells selection.
+        // When downcasting table cells selection to the view, we put the view selection in the last selected cell
+        // in a place that may not be natively a "correct" location. This is – we put it directly in the `<td>` element.
+        // All browsers fire the native `selectionchange` event.
+        // However, all browsers except Safari return the selection in the exact place where we put it
+        // (even though it's visually normalized). Safari returns `<td><p>^foo` that makes our selection observer
+        // fire our `selectionChange` event (because the view selection that we set in the first step differs from the DOM selection).
+        // Since `selectionChange` is fired, we automatically update the model selection that moves it that paragraph.
+        // This breaks our dear cells selection.
+        //
+        // Theoretically this issue concerns only Safari that is the only browser that do normalize the selection.
+        // However, to avoid code branching and to have a good coverage for this event blocker, I enabled it for all browsers.
+        //
+        // Note: I'm keeping the `blockSelectionChange` state separately for shift+click and mouse drag (exact same logic)
+        // so I don't have to try to analyze whether they don't overlap in some weird cases. Probably they don't.
+        // But I have other things to do, like writing this comment.
+        this.listenTo(editor.editing.view.document, 'selectionChange', evt => {
+            if (blockSelectionChange) {
+                // @if CK_DEBUG // console.log( 'Blocked selectionChange to avoid breaking table cells selection.' );
+                evt.stop();
+            }
+        }, { priority: 'highest' });
+    }
+    /**
+     * Enables making cells selection by dragging.
+     *
+     * The selection is made only on mousemove. Mouse tracking is started on mousedown.
+     * However, the cells selection is enabled only after the mouse cursor left the anchor cell.
+     * Thanks to that normal text selection within one cell works just fine. However, you can still select
+     * just one cell by leaving the anchor cell and moving back to it.
+     */
+    _enableMouseDragSelection() {
+        const editor = this.editor;
+        let anchorCell, targetCell;
+        let beganCellSelection = false;
+        let blockSelectionChange = false;
+        const tableSelection = editor.plugins.get(TableSelection);
+        this.listenTo(editor.editing.view.document, 'mousedown', (evt, domEventData) => {
+            if (!this.isEnabled || !tableSelection.isEnabled) {
+                return;
+            }
+            // Make sure to not conflict with the shift+click listener and any other possible handler.
+            if (domEventData.domEvent.shiftKey || domEventData.domEvent.ctrlKey || domEventData.domEvent.altKey) {
+                return;
+            }
+            anchorCell = this._getModelTableCellFromDomEvent(domEventData);
+        });
+        this.listenTo(editor.editing.view.document, 'mousemove', (evt, domEventData) => {
+            if (!domEventData.domEvent.buttons) {
+                return;
+            }
+            if (!anchorCell) {
+                return;
+            }
+            const newTargetCell = this._getModelTableCellFromDomEvent(domEventData);
+            if (newTargetCell && haveSameTableParent(anchorCell, newTargetCell)) {
+                targetCell = newTargetCell;
+                // Switch to the cell selection mode after the mouse cursor left the anchor cell.
+                // Switch off only on mouseup (makes selecting a single cell possible).
+                if (!beganCellSelection && targetCell != anchorCell) {
+                    beganCellSelection = true;
+                }
+            }
+            // Yep, not making a cell selection yet. See method docs.
+            if (!beganCellSelection) {
+                return;
+            }
+            blockSelectionChange = true;
+            tableSelection.setCellSelection(anchorCell, targetCell);
+            domEventData.preventDefault();
+        });
+        this.listenTo(editor.editing.view.document, 'mouseup', () => {
+            beganCellSelection = false;
+            blockSelectionChange = false;
+            anchorCell = null;
+            targetCell = null;
+        });
+        // See the explanation in `_enableShiftClickSelection()`.
+        this.listenTo(editor.editing.view.document, 'selectionChange', evt => {
+            if (blockSelectionChange) {
+                // @if CK_DEBUG // console.log( 'Blocked selectionChange to avoid breaking table cells selection.' );
+                evt.stop();
+            }
+        }, { priority: 'highest' });
+    }
+    /**
+     * Returns the model table cell element based on the target element of the passed DOM event.
+     *
+     * @returns Returns the table cell or `undefined`.
+     */
+    _getModelTableCellFromDomEvent(domEventData) {
+        // Note: Work with positions (not element mapping) because the target element can be an attribute or other non-mapped element.
+        const viewTargetElement = domEventData.target;
+        const viewPosition = this.editor.editing.view.createPositionAt(viewTargetElement, 0);
+        const modelPosition = this.editor.editing.mapper.toModelPosition(viewPosition);
+        const modelElement = modelPosition.parent;
+        return modelElement.findAncestor('tableCell', { includeSelf: true });
+    }
 }
-
-function haveSameTableParent( cellA, cellB ) {
-	return cellA.parent.parent == cellB.parent.parent;
+function haveSameTableParent(cellA, cellB) {
+    return cellA.parent.parent == cellB.parent.parent;
 }

package/src/tableproperties/commands/tablealignmentcommand.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 table/tableproperties/commands/tablealignmentcommand
+ */
+import type { Editor } from 'ckeditor5/src/core';
+import TablePropertyCommand from './tablepropertycommand';
+/**
+ * The table alignment command.
+ *
+ * The command is registered by the {@link module:table/tableproperties/tablepropertiesediting~TablePropertiesEditing} as
+ * the `'tableAlignment'` editor command.
+ *
+ * To change the alignment of the selected table, execute the command:
+ *
+ * ```ts
+ * editor.execute( 'tableAlignment', {
+ *   value: 'right'
+ * } );
+ * ```
+ */
+export default class TableAlignmentCommand extends TablePropertyCommand {
+    /**
+     * Creates a new `TableAlignmentCommand` instance.
+     *
+     * @param editor An editor in which this command will be used.
+     * @param defaultValue The default value for the "alignment" attribute.
+     */
+    constructor(editor: Editor, defaultValue: string);
+}

package/src/tableproperties/commands/tablealignmentcommand.js

@@ -2,13 +2,7 @@
  * @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 table/tableproperties/commands/tablealignmentcommand
- */
-
 import TablePropertyCommand from './tablepropertycommand';
-
 /**
  * The table alignment command.
  *
@@ -17,20 +11,20 @@ import TablePropertyCommand from './tablepropertycommand';
  *
  * To change the alignment of the selected table, execute the command:
  *
- *		editor.execute( 'tableAlignment', {
- *			value: 'right'
- *		} );
- *
- * @extends module:table/tableproperties/commands/tablepropertycommand~TablePropertyCommand
+ * ```ts
+ * editor.execute( 'tableAlignment', {
+ *   value: 'right'
+ * } );
+ * ```
  */
 export default class TableAlignmentCommand extends TablePropertyCommand {
-	/**
-	 * Creates a new `TableAlignmentCommand` instance.
-	 *
-	 * @param {module:core/editor/editor~Editor} editor An editor in which this command will be used.
-	 * @param {String} defaultValue The default value for the "alignment" attribute.
-	 */
-	constructor( editor, defaultValue ) {
-		super( editor, 'tableAlignment', defaultValue );
-	}
+    /**
+     * Creates a new `TableAlignmentCommand` instance.
+     *
+     * @param editor An editor in which this command will be used.
+     * @param defaultValue The default value for the "alignment" attribute.
+     */
+    constructor(editor, defaultValue) {
+        super(editor, 'tableAlignment', defaultValue);
+    }
 }