handsontable 17.1.0 → 18.0.0-rc2

package/editors/baseEditor/baseEditor.mjs

@@ -1,5 +1,21 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 import { stringify } from '../../helpers/mixed.mjs';
 import { throwWithCause } from '../../helpers/errors.mjs';
+import { warn } from '../../helpers/console.mjs';
 import { mixin } from '../../helpers/object.mjs';
 import hooksRefRegisterer from '../../mixins/hooksRefRegisterer.mjs';
 import { getScrollbarWidth, offset, hasVerticalScrollbar, hasHorizontalScrollbar, outerWidth, outerHeight } from '../../helpers/dom/element.mjs';
@@ -11,10 +27,32 @@ export const EDITOR_STATE = Object.freeze({
     WAITING: 'STATE_WAITING',
     FINISHED: 'STATE_FINISHED'
 });
+var /**
+   * Calculates the top offset of the edited cell within the overlay's coordinate space.
+   *
+   * @param {HTMLTableCellElement} TD The edited cell element.
+   * @param {string} overlayName The name of the overlay containing the cell.
+   * @param {number} firstRowOffset The start position of the rows render calculator.
+   * @param {number} verticalScrollPosition The current vertical scroll position.
+   * @param {number} scrollbarWidth The scrollbar width in pixels.
+   * @returns {number}
+   */ _calcCellTopOffset = /*#__PURE__*/ new WeakSet(), /**
+   * Calculates the inline-start offset of the edited cell within the overlay's coordinate space.
+   *
+   * @param {HTMLTableCellElement} TD The edited cell element.
+   * @param {string} overlayName The name of the overlay containing the cell.
+   * @param {object} overlayTable The Walkontable table instance for the overlay.
+   * @param {number} cellWidth The width of the edited cell.
+   * @param {number} firstColumnOffset The start position of the columns render calculator.
+   * @param {number} horizontalScrollPosition The current horizontal scroll position.
+   * @returns {number}
+   */ _calcCellStartOffset = /*#__PURE__*/ new WeakSet();
 /**
  * @class BaseEditor
  */ export class BaseEditor {
-    static get EDITOR_TYPE() {
+    /**
+   * Returns the unique editor type identifier for the base editor.
+   */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
     /**
@@ -38,12 +76,12 @@ export const EDITOR_STATE = Object.freeze({
     }
     /**
    * Required method to set new value into editable element.
-   */ setValue() {
+   */ setValue(_value) {
         throwWithCause('Editor setValue() method unimplemented');
     }
     /**
    * Required method to open editor.
-   */ open() {
+   */ open(_event) {
         throwWithCause('Editor open() method unimplemented');
     }
     /**
@@ -52,6 +90,11 @@ export const EDITOR_STATE = Object.freeze({
         throwWithCause('Editor close() method unimplemented');
     }
     /**
+   * Required method to focus editor.
+   */ focus() {
+        throwWithCause('Editor focus() method unimplemented');
+    }
+    /**
    * Prepares editor's meta data.
    *
    * @param {number} row The visual row index.
@@ -90,12 +133,12 @@ export const EDITOR_STATE = Object.freeze({
         // if ctrl+enter and multiple cells selected, behave like Excel (finish editing and apply to all cells)
         if (ctrlDown) {
             const activeRange = this.hot.getSelectedRangeActive();
-            const topStartCorner = activeRange.getTopStartCorner();
-            const bottomEndCorner = activeRange.getBottomEndCorner();
-            visualRowFrom = topStartCorner.row;
-            visualColumnFrom = topStartCorner.col;
-            visualRowTo = bottomEndCorner.row;
-            visualColumnTo = bottomEndCorner.col;
+            const topStartCorner = activeRange?.getTopStartCorner();
+            const bottomEndCorner = activeRange?.getBottomEndCorner();
+            visualRowFrom = topStartCorner?.row ?? this.row;
+            visualColumnFrom = topStartCorner?.col ?? this.col;
+            visualRowTo = bottomEndCorner?.row ?? this.row;
+            visualColumnTo = bottomEndCorner?.col ?? this.col;
         } else {
             [visualRowFrom, visualColumnFrom, visualRowTo, visualColumnTo] = [
                 this.row,
@@ -120,12 +163,21 @@ export const EDITOR_STATE = Object.freeze({
         if (this.state !== EDITOR_STATE.VIRGIN) {
             return;
         }
+        if (this.row === null || this.col === null) {
+            warn('Editor opened without valid cell coordinates.');
+            return;
+        }
         const hotInstance = this.hot;
         // We have to convert visual indexes into renderable indexes
         // due to hidden columns don't participate in the rendering process
         const renderableRowIndex = hotInstance.rowIndexMapper.getRenderableFromVisualIndex(this.row);
         const renderableColumnIndex = hotInstance.columnIndexMapper.getRenderableFromVisualIndex(this.col);
-        hotInstance.view.scrollViewport(hotInstance._createCellCoords(renderableRowIndex, renderableColumnIndex));
+        if (renderableRowIndex !== null && renderableColumnIndex !== null) {
+            hotInstance.view.scrollViewport({
+                row: renderableRowIndex,
+                col: renderableColumnIndex
+            });
+        }
         this.state = EDITOR_STATE.EDITING;
         // Set the editor value only in the full edit mode. In other mode the focusable element has to be empty,
         // otherwise IME (editor for Asia users) doesn't work.
@@ -149,6 +201,7 @@ export const EDITOR_STATE = Object.freeze({
    * @param {boolean} ctrlDown If true, then saveValue will save editor's value to each cell in the last selected range.
    * @param {Function} callback The callback function, fired after editor closing.
    */ finishEditing(restoreOriginalValue, ctrlDown, callback) {
+        let val;
         if (callback) {
             const previousCloseCallback = this._closeCallback;
             this._closeCallback = (result)=>{
@@ -215,6 +268,9 @@ export const EDITOR_STATE = Object.freeze({
         }
         // validator was defined and failed
         if (result === false && this.cellProperties.allowInvalid !== true) {
+            if (this.row === null || this.col === null) {
+                return;
+            }
             this.hot.selectCell(this.row, this.col);
             this.focus();
             this.state = EDITOR_STATE.EDITING;
@@ -256,7 +312,7 @@ export const EDITOR_STATE = Object.freeze({
    */ isWaiting() {
         return this.state === EDITOR_STATE.WAITING;
     }
-    /* eslint-disable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Gets the object that provides information about the edited cell size and its position
    * relative to the table viewport.
    *
@@ -281,8 +337,8 @@ export const EDITOR_STATE = Object.freeze({
         const cellWidth = outerWidth(TD);
         const containerOffset = offset(this.hot.rootElement);
         const containerWidth = outerWidth(this.hot.rootElement);
-        const scrollableContainerTop = wtOverlays.topOverlay.holder;
-        const scrollableContainerLeft = wtOverlays.inlineStartOverlay.holder;
+        const scrollableContainerTop = wtOverlays.topOverlay?.holder;
+        const scrollableContainerLeft = wtOverlays.inlineStartOverlay?.holder;
         const containerScrollTop = scrollableContainerTop !== rootWindow ? scrollableContainerTop.scrollTop : 0;
         const containerScrollLeft = scrollableContainerLeft !== rootWindow ? scrollableContainerLeft.scrollLeft : 0;
         const gridMostRightPos = rootWindow.innerWidth - containerOffset.left - containerWidth;
@@ -313,72 +369,42 @@ export const EDITOR_STATE = Object.freeze({
             'top',
             'top_inline_start_corner'
         ].includes(overlayName)) {
-            topPos += wtOverlays.topOverlay.getOverlayOffset();
+            topPos += wtOverlays.topOverlay?.getOverlayOffset() ?? 0;
         }
         if ([
             'inline_start',
             'top_inline_start_corner'
         ].includes(overlayName)) {
-            inlineStartPos += Math.abs(wtOverlays.inlineStartOverlay.getOverlayOffset());
+            inlineStartPos += Math.abs(wtOverlays.inlineStartOverlay?.getOverlayOffset() ?? 0);
         }
         const hasColumnHeaders = this.hot.hasColHeaders();
-        const renderableRow = this.hot.rowIndexMapper.getRenderableFromVisualIndex(this.row);
-        const renderableColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(this.col);
+        const renderableRow = this.hot.rowIndexMapper.getRenderableFromVisualIndex(this.row ?? 0);
+        const renderableColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(this.col ?? 0);
         const nrOfRenderableRowIndexes = this.hot.rowIndexMapper.getRenderableIndexesLength();
         const firstRowIndexOfTheBottomOverlay = nrOfRenderableRowIndexes - this.hot.view._wt.getSetting('fixedRowsBottom');
-        if (hasColumnHeaders && renderableRow <= 0 || renderableRow === firstRowIndexOfTheBottomOverlay) {
+        if (hasColumnHeaders && (renderableRow ?? 0) <= 0 || renderableRow === firstRowIndexOfTheBottomOverlay) {
             topPos += 1;
         }
-        if (renderableColumn <= 0) {
+        if ((renderableColumn ?? 0) <= 0) {
             inlineStartPos += 1;
         }
-        const firstRowOffset = wtViewport.rowsRenderCalculator.startPosition;
-        const firstColumnOffset = wtViewport.columnsRenderCalculator.startPosition;
-        const horizontalScrollPosition = Math.abs(wtOverlays.inlineStartOverlay.getScrollPosition());
-        const verticalScrollPosition = wtOverlays.topOverlay.getScrollPosition();
+        const firstRowOffset = wtViewport.rowsRenderCalculator?.startPosition ?? 0;
+        const firstColumnOffset = wtViewport.columnsRenderCalculator?.startPosition ?? 0;
+        const horizontalScrollPosition = Math.abs(wtOverlays.inlineStartOverlay?.getScrollPosition() ?? 0);
+        const verticalScrollPosition = wtOverlays.topOverlay?.getScrollPosition() ?? 0;
         const scrollbarWidth = getScrollbarWidth(this.hot.rootDocument);
-        let cellTopOffset = TD.offsetTop;
-        if ([
-            'inline_start',
-            'master'
-        ].includes(overlayName)) {
-            cellTopOffset += firstRowOffset - verticalScrollPosition;
-        }
-        if ([
-            'bottom',
-            'bottom_inline_start_corner'
-        ].includes(overlayName)) {
-            const { wtViewport: bottomWtViewport, wtTable: bottomWtTable } = wtOverlays.bottomOverlay.clone;
-            cellTopOffset += bottomWtViewport.getWorkspaceHeight() - bottomWtTable.getHeight() - scrollbarWidth;
-        }
-        let cellStartOffset = TD.offsetLeft;
-        if (this.hot.isRtl()) {
-            if (cellStartOffset >= 0) {
-                cellStartOffset = overlayTable.getWidth() - TD.offsetLeft;
-            } else {
-                // The `offsetLeft` returns negative values when the parent offset element has position relative
-                // (it happens when on the cell the selection is applied - the `area` CSS class).
-                // When it happens the `offsetLeft` value is calculated from the right edge of the parent element.
-                cellStartOffset = Math.abs(cellStartOffset);
-            }
-            cellStartOffset += firstColumnOffset - horizontalScrollPosition - cellWidth;
-        } else if ([
-            'top',
-            'master',
-            'bottom'
-        ].includes(overlayName)) {
-            cellStartOffset += firstColumnOffset - horizontalScrollPosition;
-        }
-        const cellComputedStyle = rootWindow.getComputedStyle(this.TD);
+        const cellTopOffset = _class_private_method_get(this, _calcCellTopOffset, calcCellTopOffset).call(this, TD, overlayName, firstRowOffset, verticalScrollPosition, scrollbarWidth);
+        const cellStartOffset = _class_private_method_get(this, _calcCellStartOffset, calcCellStartOffset).call(this, TD, overlayName, overlayTable, cellWidth, firstColumnOffset, horizontalScrollPosition);
+        const cellComputedStyle = rootWindow.getComputedStyle(TD);
         const borderPhysicalWidthProp = this.hot.isRtl() ? 'borderRightWidth' : 'borderLeftWidth';
-        const inlineStartBorderCompensation = parseInt(cellComputedStyle[borderPhysicalWidthProp], 10) > 0 ? 0 : 1;
-        const topBorderCompensation = parseInt(cellComputedStyle.borderTopWidth, 10) > 0 ? 0 : 1;
+        const inlineStartBorderCompensation = Number.parseInt(cellComputedStyle[borderPhysicalWidthProp], 10) > 0 ? 0 : 1;
+        const topBorderCompensation = Number.parseInt(cellComputedStyle.borderTopWidth, 10) > 0 ? 0 : 1;
         const width = outerWidth(TD) + inlineStartBorderCompensation;
         const height = outerHeight(TD) + topBorderCompensation;
-        const actualVerticalScrollbarWidth = hasVerticalScrollbar(scrollableContainerTop) ? scrollbarWidth : 0;
-        const actualHorizontalScrollbarWidth = hasHorizontalScrollbar(scrollableContainerLeft) ? scrollbarWidth : 0;
+        const actualVerticalScrollbarWidth = scrollableContainerTop && hasVerticalScrollbar(scrollableContainerTop) ? scrollbarWidth : 0;
+        const actualHorizontalScrollbarWidth = scrollableContainerLeft && hasHorizontalScrollbar(scrollableContainerLeft) ? scrollbarWidth : 0;
         const maxWidth = this.hot.view.maximumVisibleElementWidth(cellStartOffset) - actualVerticalScrollbarWidth + inlineStartBorderCompensation;
-        const maxHeight = Math.max(this.hot.view.maximumVisibleElementHeight(cellTopOffset) - actualHorizontalScrollbarWidth + topBorderCompensation, this.hot.stylesHandler.getDefaultRowHeight());
+        const maxHeight = Math.max(this.hot.view.maximumVisibleElementHeight(cellTopOffset ?? 0) - actualHorizontalScrollbarWidth + topBorderCompensation, this.hot.stylesHandler.getDefaultRowHeight() ?? 0);
         return {
             top: topPos,
             start: inlineStartPos,
@@ -388,7 +414,7 @@ export const EDITOR_STATE = Object.freeze({
             maxWidth
         };
     }
-    /* eslint-enable jsdoc/require-description-complete-sentence */ /**
+    /**
    * Gets className of the edited cell if exist.
    *
    * @returns {string}
@@ -414,6 +440,9 @@ export const EDITOR_STATE = Object.freeze({
    *
    * @returns {HTMLTableCellElement|null}
    */ getEditedCell() {
+        if (this.row === null || this.col === null) {
+            return null;
+        }
         return this.hot.getCell(this.row, this.col, true);
     }
     /**
@@ -422,21 +451,25 @@ export const EDITOR_STATE = Object.freeze({
    * @private
    * @returns {string}
    */ checkEditorSection() {
+        if (this.row === null || this.col === null) {
+            return '';
+        }
         const totalRows = this.hot.countRows();
+        const settings = this.hot.getSettings();
         let section = '';
-        if (this.row < this.hot.getSettings().fixedRowsTop) {
-            if (this.col < this.hot.getSettings().fixedColumnsStart) {
+        if (this.row < (settings.fixedRowsTop ?? 0)) {
+            if (this.col < (settings.fixedColumnsStart ?? 0)) {
                 section = 'top-inline-start-corner';
             } else {
                 section = 'top';
             }
-        } else if (this.hot.getSettings().fixedRowsBottom && this.row >= totalRows - this.hot.getSettings().fixedRowsBottom) {
-            if (this.col < this.hot.getSettings().fixedColumnsStart) {
+        } else if (settings.fixedRowsBottom && this.row >= totalRows - settings.fixedRowsBottom) {
+            if (this.col < (settings.fixedColumnsStart ?? 0)) {
                 section = 'bottom-inline-start-corner';
             } else {
                 section = 'bottom';
             }
-        } else if (this.col < this.hot.getSettings().fixedColumnsStart) {
+        } else if (this.col < (settings.fixedColumnsStart ?? 0)) {
             section = 'inline-start';
         }
         return section;
@@ -444,6 +477,8 @@ export const EDITOR_STATE = Object.freeze({
     /**
    * @param {Handsontable} hotInstance A reference to the source instance of the Handsontable.
    */ constructor(hotInstance){
+        _class_private_method_init(this, _calcCellTopOffset);
+        _class_private_method_init(this, _calcCellStartOffset);
         /**
    * Editor's state.
    *
@@ -498,13 +533,47 @@ export const EDITOR_STATE = Object.freeze({
    *
    * @type {*}
    */ this.originalValue = null;
-        /**
-   * Object containing the cell's properties.
-   *
-   * @type {object}
-   */ this.cellProperties = null;
         this.hot = hotInstance;
         this.init();
     }
 }
+function calcCellTopOffset(TD, overlayName, firstRowOffset, verticalScrollPosition, scrollbarWidth) {
+    let cellTopOffset = TD.offsetTop;
+    const { wtOverlays } = this.hot.view._wt;
+    if ([
+        'inline_start',
+        'master'
+    ].includes(overlayName)) {
+        cellTopOffset += firstRowOffset - verticalScrollPosition;
+    }
+    if ([
+        'bottom',
+        'bottom_inline_start_corner'
+    ].includes(overlayName) && wtOverlays.bottomOverlay?.clone) {
+        const { wtViewport: bottomWtViewport, wtTable: bottomWtTable } = wtOverlays.bottomOverlay.clone;
+        cellTopOffset += bottomWtViewport.getWorkspaceHeight() - bottomWtTable.getHeight() - scrollbarWidth;
+    }
+    return cellTopOffset;
+}
+function calcCellStartOffset(TD, overlayName, overlayTable, cellWidth, firstColumnOffset, horizontalScrollPosition) {
+    let cellStartOffset = TD.offsetLeft;
+    if (this.hot.isRtl()) {
+        if (cellStartOffset >= 0) {
+            cellStartOffset = overlayTable.getWidth() - TD.offsetLeft;
+        } else {
+            // The `offsetLeft` returns negative values when the parent offset element has position relative
+            // (it happens when on the cell the selection is applied - the `area` CSS class).
+            // When it happens the `offsetLeft` value is calculated from the right edge of the parent element.
+            cellStartOffset = Math.abs(cellStartOffset);
+        }
+        cellStartOffset += firstColumnOffset - horizontalScrollPosition - cellWidth;
+    } else if ([
+        'top',
+        'master',
+        'bottom'
+    ].includes(overlayName)) {
+        cellStartOffset += firstColumnOffset - horizontalScrollPosition;
+    }
+    return cellStartOffset;
+}
 mixin(BaseEditor, hooksRefRegisterer);

package/editors/baseEditor/index.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/editors/baseEditor/index.d.ts

@@ -1 +1 @@
-export { EDITOR_STATE, EDITOR_TYPE, BaseEditor } from './baseEditor';
+export { EDITOR_STATE, EDITOR_TYPE, BaseEditor, } from './baseEditor';

package/editors/checkboxEditor/checkboxEditor.d.mts

@@ -0,0 +1 @@
+export * from './checkboxEditor.js';

package/editors/checkboxEditor/checkboxEditor.d.ts

@@ -1,12 +1,44 @@
-import Core from '../../core';
 import { BaseEditor } from '../baseEditor';
-
-export const EDITOR_TYPE: 'checkbox';
-export class CheckboxEditor extends BaseEditor {
-  constructor(instance: Core);
-  close(): void;
-  focus(): void;
-  getValue(): any;
-  open(): void;
-  setValue(newValue?: any): void;
+export declare const EDITOR_TYPE = "checkbox";
+/**
+ * @private
+ * @class CheckboxEditor
+ */
+export declare class CheckboxEditor extends BaseEditor {
+    /**
+     * Returns the unique editor type identifier for the checkbox editor.
+     */
+    static get EDITOR_TYPE(): string;
+    /**
+     * Handles the mouseup event on the cell TD element to trigger a checkbox click via a double-click interaction.
+     */
+    beginEditing(initialValue?: unknown, event?: Event): void;
+    /**
+     * No-op override — the checkbox editor does not perform a finish step.
+     */
+    finishEditing(): void;
+    /**
+     * No-op override — the checkbox editor requires no DOM initialization.
+     */
+    init(): void;
+    /**
+     * No-op override — the checkbox editor has no visible editing element to open.
+     */
+    open(): void;
+    /**
+     * No-op override — the checkbox editor has no visible editing element to close.
+     */
+    close(): void;
+    /**
+     * Returns undefined because checkbox state is written directly to the cell; no separate value is held.
+     */
+    getValue(): unknown;
+    /**
+     * No-op override — the checkbox editor writes its value directly via DOM events.
+     */
+    setValue(): void;
+    /**
+     * No-op override — the checkbox editor delegates focus to the native checkbox element.
+     */
+    focus(): void;
 }

package/editors/checkboxEditor/checkboxEditor.js

@@ -20,26 +20,46 @@ const _baseEditor = require("../baseEditor");
 const _element = require("../../helpers/dom/element");
 const EDITOR_TYPE = 'checkbox';
 class CheckboxEditor extends _baseEditor.BaseEditor {
-    static get EDITOR_TYPE() {
+    /**
+   * Returns the unique editor type identifier for the checkbox editor.
+   */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
-    beginEditing(initialValue, event) {
+    /**
+   * Handles the mouseup event on the cell TD element to trigger a checkbox click via a double-click interaction.
+   */ beginEditing(initialValue, event) {
         // Just some events connected with the checkbox editor are delegated here. Some `keydown` events like `enter` and
         // `space` key presses are handled inside `checkboxRenderer`. Some events come here from `editorManager`. The below
         // `if` statement was created by the author for the purpose of handling only the `doubleclick` event on the TD
         // element with a checkbox.
-        if (event && event.type === 'mouseup' && event.target.nodeName === 'TD') {
+        if (event && event.type === 'mouseup' && (0, _element.eventTargetEl)(event).nodeName === 'TD') {
             const checkbox = this.TD.querySelector('input[type="checkbox"]');
             if (!(0, _element.hasClass)(checkbox, 'htBadValue')) {
                 checkbox.click();
             }
         }
     }
-    finishEditing() {}
-    init() {}
-    open() {}
-    close() {}
-    getValue() {}
-    setValue() {}
-    focus() {}
+    /**
+   * No-op override — the checkbox editor does not perform a finish step.
+   */ finishEditing() {}
+    /**
+   * No-op override — the checkbox editor requires no DOM initialization.
+   */ init() {}
+    /**
+   * No-op override — the checkbox editor has no visible editing element to open.
+   */ open() {}
+    /**
+   * No-op override — the checkbox editor has no visible editing element to close.
+   */ close() {}
+    /**
+   * Returns undefined because checkbox state is written directly to the cell; no separate value is held.
+   */ getValue() {
+        return undefined;
+    }
+    /**
+   * No-op override — the checkbox editor writes its value directly via DOM events.
+   */ setValue() {}
+    /**
+   * No-op override — the checkbox editor delegates focus to the native checkbox element.
+   */ focus() {}
 }

package/editors/checkboxEditor/checkboxEditor.mjs

@@ -1,30 +1,50 @@
 import { BaseEditor } from '../baseEditor/index.mjs';
-import { hasClass } from '../../helpers/dom/element.mjs';
+import { eventTargetEl, hasClass } from '../../helpers/dom/element.mjs';
 export const EDITOR_TYPE = 'checkbox';
 /**
  * @private
  * @class CheckboxEditor
  */ export class CheckboxEditor extends BaseEditor {
-    static get EDITOR_TYPE() {
+    /**
+   * Returns the unique editor type identifier for the checkbox editor.
+   */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
-    beginEditing(initialValue, event) {
+    /**
+   * Handles the mouseup event on the cell TD element to trigger a checkbox click via a double-click interaction.
+   */ beginEditing(initialValue, event) {
         // Just some events connected with the checkbox editor are delegated here. Some `keydown` events like `enter` and
         // `space` key presses are handled inside `checkboxRenderer`. Some events come here from `editorManager`. The below
         // `if` statement was created by the author for the purpose of handling only the `doubleclick` event on the TD
         // element with a checkbox.
-        if (event && event.type === 'mouseup' && event.target.nodeName === 'TD') {
+        if (event && event.type === 'mouseup' && eventTargetEl(event).nodeName === 'TD') {
             const checkbox = this.TD.querySelector('input[type="checkbox"]');
             if (!hasClass(checkbox, 'htBadValue')) {
                 checkbox.click();
             }
         }
     }
-    finishEditing() {}
-    init() {}
-    open() {}
-    close() {}
-    getValue() {}
-    setValue() {}
-    focus() {}
+    /**
+   * No-op override — the checkbox editor does not perform a finish step.
+   */ finishEditing() {}
+    /**
+   * No-op override — the checkbox editor requires no DOM initialization.
+   */ init() {}
+    /**
+   * No-op override — the checkbox editor has no visible editing element to open.
+   */ open() {}
+    /**
+   * No-op override — the checkbox editor has no visible editing element to close.
+   */ close() {}
+    /**
+   * Returns undefined because checkbox state is written directly to the cell; no separate value is held.
+   */ getValue() {
+        return undefined;
+    }
+    /**
+   * No-op override — the checkbox editor writes its value directly via DOM events.
+   */ setValue() {}
+    /**
+   * No-op override — the checkbox editor delegates focus to the native checkbox element.
+   */ focus() {}
 }

package/editors/checkboxEditor/index.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/editors/checkboxEditor/index.d.ts

@@ -1 +1 @@
-export { EDITOR_TYPE, CheckboxEditor } from './checkboxEditor';
+export { EDITOR_TYPE, CheckboxEditor, } from './checkboxEditor';

package/editors/dateEditor/dateEditor.d.mts

@@ -0,0 +1 @@
+export * from './dateEditor.js';

package/editors/dateEditor/dateEditor.d.ts

@@ -1,16 +1,37 @@
-import { PikadayOptions } from '@handsontable/pikaday';
-import Core from '../../core';
+import type { CellProperties } from '../../settings';
 import { TextEditor } from '../textEditor';
-
-export const EDITOR_TYPE: 'date';
-export class DateEditor extends TextEditor {
-  constructor(instance: Core);
-
-  parentDestroyed: boolean;
-
-  destroyElements(): void;
-  open(event?: Event): void;
-  showDatepicker(event?: Event): void;
-  hideDatepicker(): void;
-  getDatePickerConfig(): PikadayOptions;
+export declare const EDITOR_TYPE = "date";
+/**
+ * @private
+ * @class DateEditor
+ */
+export declare class DateEditor extends TextEditor {
+    /**
+     * Returns the unique editor type identifier for the date editor.
+     */
+    static get EDITOR_TYPE(): string;
+    /**
+     * Initializes the editor and registers an afterSetTheme hook to close on theme changes.
+     */
+    init(): void;
+    /**
+     * Prepares the editor, replacing the display value with the raw ISO source data for the native date input.
+     */
+    prepare(row: number, col: number, prop: string | number, td: HTMLTableCellElement, value: unknown, cellProperties: CellProperties): void;
+    /**
+     * Creates the editor's textarea element as a native date input.
+     */
+    createElements(type?: string): void;
+    /**
+     * Sets the editor value, falling back to `defaultDate` when the value is empty, and warns if the value is not a valid ISO date string.
+     */
+    setValue(value?: unknown): void;
+    /**
+     * Selects all text in the date input element when the editor receives focus.
+     */
+    focus(): void;
+    /**
+     * Opens the editor and programmatically invokes the native date picker via showPicker().
+     */
+    open(): void;
 }