handsontable 17.1.0 → 18.0.0-rc2

package/editors/multiSelectEditor/multiSelectEditor.mjs

@@ -55,7 +55,7 @@ import { SelectedItemsController } from './controllers/selectedItemsController.m
 import { addClass, setAttribute } from '../../helpers/dom/element.mjs';
 import { isPrintableChar } from '../../helpers/unicode.mjs';
 import { A11Y_LABEL, A11Y_GROUP } from '../../helpers/a11y.mjs';
-import { EDITOR_EDIT_GROUP } from '../../shortcutContexts/constants.mjs';
+import { EDITOR_EDIT_GROUP } from '../../shortcuts/contexts/constants.mjs';
 import { getValuesIntersection, parseStringifiedValue } from './utils/utils.mjs';
 export const EDITOR_TYPE = 'multiselect';
 const DROPDOWN_ELEMENT_CSS_CLASSNAME = 'ht-multi-select-editor';
@@ -63,91 +63,54 @@ const DROPDOWN_ARIA_LABEL = 'Select options';
 const SHORTCUTS_GROUP = 'multiselectEditor';
 const EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible';
 var /**
-   * Set of values that are currently checked in the dropdown.
-   *
-   * @private
-   * @type {SelectedItemsController}
+   * Controller managing the set of currently selected values in the editor.
    */ _selectedItems = /*#__PURE__*/ new WeakMap(), /**
-   * Container element that hosts the editor.
-   *
-   * @private
-   * @type {HTMLDivElement}
+   * The outer wrapper element that positions the dropdown relative to the edited cell.
    */ _editorContainer = /*#__PURE__*/ new WeakMap(), /**
-   * Gets the source (options) for the editor.
-   *
-   * @returns {Array} The source (options) for the editor.
+   * Returns the `source` cell property as an array of dropdown entries, defaulting to an empty array.
    */ _getSource = /*#__PURE__*/ new WeakSet(), /**
-   * Register shortcuts responsible for handling editor.
-   *
-   * @private
+   * Registers ArrowUp/ArrowDown and Enter/Space shortcuts for keyboard navigation and checkbox toggling.
    */ _registerShortcuts = /*#__PURE__*/ new WeakSet(), /**
-   * Unregister shortcuts responsible for handling editor.
-   *
-   * @private
+   * Removes all keyboard shortcuts registered under the multiselect editor's shortcut group.
    */ _unregisterShortcuts = /*#__PURE__*/ new WeakSet(), /**
-   * Shows the editable element.
+   * Makes the outer editor container visible by clearing its `display` style.
    */ _showEditableElement = /*#__PURE__*/ new WeakSet(), /**
-   * Hides the editable element.
+   * Hides the outer editor container by setting its `display` style to `'none'`.
    */ _hideEditableElement = /*#__PURE__*/ new WeakSet(), /**
-   * Blocks new selections.
+   * Disables all unchecked checkboxes in the dropdown when the maximum selection count is reached.
    */ _blockNewSelections = /*#__PURE__*/ new WeakSet(), /**
-   * Unblocks new selections.
+   * Re-enables all checkboxes in the dropdown when the selection count drops below the maximum.
    */ _unblockNewSelections = /*#__PURE__*/ new WeakSet(), /**
-   * Filters the dropdown entries.
-   *
-   * @param {string} query The value of the input.
-   * @param {boolean} filterSelectedItems If true, the selected items will be filtered out of the dropdown.
+   * Filters the source entries by the given query string and re-renders the dropdown with matching items.
    */ _filterEntries = /*#__PURE__*/ new WeakSet(), /**
-   * Gets the available space for the dropdown.
-   *
-   * @returns {{spaceAbove: number, spaceBelow: number, cellHeight: number}} The available space.
+   * Calculates the available vertical space above and below the edited cell for positioning the dropdown.
    */ _getAvailableSpace = /*#__PURE__*/ new WeakSet(), /**
-   * Saves the current selection state to the cell without closing the editor.
-   *
-   * @private
+   * Reads the current selected items array and writes it to the cell via saveValue.
    */ _saveCurrentSelection = /*#__PURE__*/ new WeakSet(), /**
-   * Adds a value reported by the dropdown to the selection set and saves to the cell.
-   *
-   * @private
-   * @param {string} selectedKey Key of the selected value.
-   * @param {string} selectedValue Value of the selected value.
+   * Adds the given key/value pair (or bare value) to the selected items and persists the new selection.
    */ _addSelectedValue = /*#__PURE__*/ new WeakSet(), /**
-   * Removes a deselected dropdown value from the selection set and saves to the cell.
-   *
-   * @private
-   * @param {string} deselectedKey Key of the deselected value.
-   * @param {string} deselectedValue Value of the deselected value.
+   * Removes the given key/value pair (or bare value) from the selected items and persists the new selection.
    */ _removeSelectedValue = /*#__PURE__*/ new WeakSet(), /**
-   * Synchronizes the internal selection set with data deserialized from the cell value.
-   *
-   * @private
-   * @param {Array<*>} valuesArray Values decoded from the stored JSON string.
+   * Replaces the internal SelectedItemsController with a new one pre-populated from the given values array.
    */ _syncSelectedValues = /*#__PURE__*/ new WeakSet(), /**
-   * Helper for reading editor-related settings directly from the cell meta.
-   *
-   * @private
-   * @param {string} settingKey Cell meta key to read.
-   * @returns {*} Returns the stored value for the provided key.
+   * Reads a typed setting value from the cell properties by the given key.
    */ _getEditorSetting = /*#__PURE__*/ new WeakSet(), /**
-   * `afterSetSourceDataAtCell` hook callback.
-   *
-   * @private
-   * @param {Array<*>} changes The changes.
-   * @param {string} source The source of the change.
+   * Handles the afterSetSourceDataAtCell hook to re-sync the dropdown when the renderer updates the source data for the edited cell.
    */ _onAfterSetSourceDataAtCell = /*#__PURE__*/ new WeakSet();
 /**
+ * Cell editor that lets users pick one or more values from a checkbox dropdown list.
+ * Saves on every check/uncheck rather than on editor close.
+ *
  * @private
  * @class MultiSelectEditor
  */ export class MultiSelectEditor extends BaseEditor {
     /**
-   * Returns the editor type.
-   *
-   * @returns {string} The editor type.
+   * Returns the unique editor type identifier for the multiselect editor.
    */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
     /**
-   * Creates an editor's elements and adds necessary CSS classnames.
+   * Creates the outer container, dropdown container, accessibility attributes, and the DropdownController instance.
    */ createElements() {
         const { rootDocument } = this.hot;
         _class_private_field_set(this, _editorContainer, rootDocument.createElement('div'));
@@ -164,14 +127,7 @@ var /**
         this.dropdownController = new DropdownController(this.dropdownContainerElement, this.hot.guid);
     }
     /**
-   * Prepares editor's meta data.
-   *
-   * @param {number} row The visual row index.
-   * @param {number} col The visual column index.
-   * @param {number|string} prop The column property (passed when datasource is an array of objects).
-   * @param {HTMLTableCellElement} td The rendered cell element.
-   * @param {*} value The rendered value.
-   * @param {object} cellProperties The cell meta object (see {@link Core#getCellMeta}).
+   * Prepares the editor for the given cell, resets the dropdown, syncs the current selection, and applies cell settings.
    */ prepare(row, col, prop, td, value, cellProperties) {
         super.prepare(row, col, prop, td, value, cellProperties);
         const parsedValue = parseStringifiedValue(value);
@@ -184,58 +140,52 @@ var /**
             _class_private_method_get(this, _blockNewSelections, blockNewSelections).call(this);
         }
         _class_private_method_get(this, _syncSelectedValues, syncSelectedValues).call(this, valuesIntersection);
-        this.dropdownController.setSourceSortFunction(this.cellProperties.sourceSortFunction);
+        this.dropdownController.setSourceSortFunction(_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'sourceSortFunction') ?? null);
         this.dropdownController.fillDropdown(_class_private_method_get(this, _getSource, getSource).call(this), valuesIntersection);
         this.dropdownController.setVisibleRowsNumberSetting(_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'visibleRows'));
         this.dropdownController.setSearchInputVisibility(_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'searchInput'));
         if (cellProperties.maxSelections !== undefined) {
-            _class_private_field_get(this, _selectedItems).setMaxSelectionCount(cellProperties.maxSelections);
+            _class_private_field_get(this, _selectedItems).setMaxSelectionCount(_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'maxSelections'));
         }
     }
     /**
-   * Finishes editing and start saving or restoring process for editing cell.
-   *
-   * @param {boolean} restoreOriginalValue If true, then closes editor without saving value from the editor into a cell.
-   * @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.
+   * Delegates to the base finishEditing to complete saving or restoring the cell value.
    */ finishEditing(restoreOriginalValue, ctrlDown, callback) {
         super.finishEditing(restoreOriginalValue, ctrlDown, callback);
     }
     /**
-   * Binds events to the editor.
-   *
-   * @private
+   * Wires dropdown check/uncheck hooks, scroll hooks, destroy cleanup, and the search filter trigger.
    */ bindEvents() {
         this.dropdownController.addLocalHook('afterDropdownItemChecked', (selectedKey, selectedValue)=>{
             _class_private_method_get(this, _addSelectedValue, addSelectedValue).call(this, selectedKey, selectedValue);
-            if (_class_private_field_get(this, _selectedItems).getSize() >= this.cellProperties.maxSelections) {
+            if (_class_private_field_get(this, _selectedItems).getSize() >= _class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'maxSelections')) {
                 _class_private_method_get(this, _blockNewSelections, blockNewSelections).call(this);
             }
         });
         this.dropdownController.addLocalHook('afterDropdownItemUnchecked', (deselectedKey, deselectedValue)=>{
             _class_private_method_get(this, _removeSelectedValue, removeSelectedValue).call(this, deselectedKey, deselectedValue);
-            if (_class_private_field_get(this, _selectedItems).getSize() < this.cellProperties.maxSelections) {
+            if (_class_private_field_get(this, _selectedItems).getSize() < _class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'maxSelections')) {
                 _class_private_method_get(this, _unblockNewSelections, unblockNewSelections).call(this);
             }
         });
         this.addHook('afterDestroy', ()=>this.destroy());
-        this.addHook('afterSetSourceDataAtCell', (...args)=>_class_private_method_get(this, _onAfterSetSourceDataAtCell, onAfterSetSourceDataAtCell).call(this, ...args));
+        this.addHook('afterSetSourceDataAtCell', (changes, source)=>_class_private_method_get(this, _onAfterSetSourceDataAtCell, onAfterSetSourceDataAtCell).call(this, changes, source));
         this.addHook('afterScrollHorizontally', ()=>this.refreshDimensions());
         this.addHook('afterScrollVertically', ()=>this.refreshDimensions());
         this.dropdownController.getInputController().addLocalHook('triggerFilter', (value)=>_class_private_method_get(this, _filterEntries, filterEntries).call(this, value));
     }
     /**
-   * Opens the editor.
-   *
-   * @param {Event} event The event object.
+   * Shows the dropdown, positions it next to the edited cell, registers keyboard shortcuts, and focuses the appropriate element.
    */ open(event) {
-        if (isPrintableChar(event?.keyCode)) {
-            const character = event.key.length === 1 ? event.key : String.fromCharCode(event.keyCode);
+        const keyCode = event && 'keyCode' in event ? event.keyCode : 0;
+        const keyStr = event && 'key' in event ? event.key : '';
+        if (keyCode && isPrintableChar(keyCode)) {
+            const character = keyStr.length === 1 ? keyStr : String.fromCharCode(keyCode);
             if (this.dropdownController.getInputController().enabled) {
                 this.dropdownController.getInputController().setValue(character);
                 _class_private_method_get(this, _filterEntries, filterEntries).call(this, character);
             }
-            event.preventDefault();
+            event?.preventDefault();
             this.enableFullEditMode();
         }
         _class_private_method_get(this, _showEditableElement, showEditableElement).call(this);
@@ -246,33 +196,25 @@ var /**
         this.dropdownController.updateDimensions(_class_private_method_get(this, _getAvailableSpace, getAvailableSpace).call(this));
     }
     /**
-   * Closes the editor.
+   * Hides the dropdown element, unregisters keyboard shortcuts, and stops the search input listener.
    */ close() {
         _class_private_method_get(this, _hideEditableElement, hideEditableElement).call(this);
         _class_private_method_get(this, _unregisterShortcuts, unregisterShortcuts).call(this);
         this.dropdownController.getInputController().unlisten();
     }
     /**
-   * Returns the editor's value.
-   *
-   * @returns {string} The editor's value.
+   * Returns the currently selected values as an array to be written to the cell.
    */ getValue() {
         return _class_private_field_get(this, _selectedItems).getItemsArray();
     }
     /**
-   * Sets the editor's value.
+   * No-op override — MultiSelectEditor saves data immediately on each check/uncheck event.
    */ setValue() {
-    // Currently not implemented.
-    //
-    // As the MultiSelectEditor saves data after every change, there's no need to set the value when
-    // the editor is closed.
-    //
-    // TODO: discuss this behavior and consider implementing an option for the data-saving strategy.
+    // Currently not implemented - MultiSelectEditor saves data after every change.
     }
     /**
-   * Refreshes the editor's dimensions.
+   * Repositions the dropdown next to the edited cell; closes the editor if the cell is no longer rendered.
    */ refreshDimensions() {
-        // TD is outside of the viewport.
         if (!this.getEditedCell()) {
             this.close();
             return;
@@ -284,7 +226,7 @@ var /**
         addClass(_class_private_field_get(this, _editorContainer), EDITOR_VISIBLE_CLASS_NAME);
     }
     /**
-   * Focuses the editor.
+   * Focuses the first dropdown item when search input is disabled, or the search input otherwise.
    */ focus() {
         if (_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'searchInput') === false) {
             this.dropdownController.focusFirstItem();
@@ -293,22 +235,18 @@ var /**
         }
     }
     /**
-   * Gets the input element.
-   *
-   * @returns {HTMLInputElement} The input element.
+   * Returns the underlying search input element from the dropdown's input controller.
    */ getInputElement() {
         return this.dropdownController.getInputController().getInputElement();
     }
     /**
-   * Called when the editor is destroyed.
-   *
-   * @private
+   * Closes the editor and resets the dropdown controller state, releasing DOM resources.
    */ destroy() {
         this.close();
         this.dropdownController.reset();
     }
     /**
-   * @param {Core} hotInstance The Handsontable instance.
+   * Initializes the editor, creates DOM elements, and binds dropdown and hook events.
    */ constructor(hotInstance){
         super(hotInstance), _class_private_method_init(this, _getSource), _class_private_method_init(this, _registerShortcuts), _class_private_method_init(this, _unregisterShortcuts), _class_private_method_init(this, _showEditableElement), _class_private_method_init(this, _hideEditableElement), _class_private_method_init(this, _blockNewSelections), _class_private_method_init(this, _unblockNewSelections), _class_private_method_init(this, _filterEntries), _class_private_method_init(this, _getAvailableSpace), _class_private_method_init(this, _saveCurrentSelection), _class_private_method_init(this, _addSelectedValue), _class_private_method_init(this, _removeSelectedValue), _class_private_method_init(this, _syncSelectedValues), _class_private_method_init(this, _getEditorSetting), _class_private_method_init(this, _onAfterSetSourceDataAtCell), _class_private_field_init(this, _selectedItems, {
             writable: true,
@@ -317,20 +255,12 @@ var /**
             writable: true,
             value: void 0
         }), /**
-   * Prevent the editor from closing after data change.
-   *
-   * @type {boolean}
+   * Overrides the base flag to keep the editor open after data changes — multiselect saves on each selection.
    */ this._closeAfterDataChange = false, _class_private_field_set(this, _selectedItems, new SelectedItemsController()), _class_private_field_set(this, _editorContainer, null), /**
-   * Container element that hosts the dropdown with checkbox options.
-   *
-   * @private
-   * @type {HTMLDivElement}
+   * The container element passed to `DropdownController` that holds the dropdown UI.
    */ this.dropdownContainerElement = null, /**
-   * Dropdown controller responsible for rendering and syncing option states.
-   *
-   * @private
-   * @type {DropdownController|null}
-   */ this.dropdownController = this.dropdownController ?? null;
+   * The controller responsible for rendering and managing the dropdown list.
+   */ this.dropdownController = null;
         this.eventManager = new EventManager(this);
         this.createElements();
         this.bindEvents();
@@ -393,7 +323,7 @@ function registerShortcuts() {
             runOnlyIf: ()=>!_class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'enterCommits'),
             callback: (event)=>{
                 const activeElement = this.hot.rootDocument.activeElement;
-                if (activeElement.tagName === 'INPUT' && activeElement.type === 'checkbox') {
+                if (activeElement instanceof HTMLInputElement && activeElement.type === 'checkbox') {
                     activeElement.checked = !activeElement.checked;
                     activeElement.dispatchEvent(new Event('change'));
                 }
@@ -437,14 +367,14 @@ function unblockNewSelections() {
 }
 function filterEntries(query, filterSelectedItems = _class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'filterSelectedItems') ?? true) {
     const filteredItems = _class_private_method_get(this, _getSource, getSource).call(this).filter((item)=>{
-        const value = item?.value ?? item;
+        const value = typeof item === 'object' && item !== null && 'value' in item ? item.value : item;
         if (!filterSelectedItems && _class_private_field_get(this, _selectedItems).has(item)) {
             return true;
         }
         if (this.cellProperties.filteringCaseSensitive) {
-            return value.includes(query);
+            return String(value).includes(query);
         }
-        return value.toLowerCase().includes(query.toLowerCase());
+        return String(value).toLowerCase().includes(query.toLowerCase());
     });
     this.dropdownController.fillDropdown(filteredItems, _class_private_field_get(this, _selectedItems).getItemsArray());
     this.dropdownController.updateDimensions(_class_private_method_get(this, _getAvailableSpace, getAvailableSpace).call(this), true);
@@ -508,11 +438,11 @@ function getEditorSetting(settingKey) {
     return this.cellProperties[settingKey];
 }
 function onAfterSetSourceDataAtCell(changes, source) {
-    if (this.isOpened() && source === `${EDITOR_TYPE}-renderer` && parseInt(changes[0][0], 10) === this.cellProperties.visualRow && parseInt(changes[0][1], 10) === this.cellProperties.visualCol) {
+    if (this.isOpened() && source === `${EDITOR_TYPE}-renderer` && parseInt(String(changes[0][0]), 10) === this.cellProperties.visualRow && parseInt(String(changes[0][1]), 10) === this.cellProperties.visualCol) {
         _class_private_method_get(this, _syncSelectedValues, syncSelectedValues).call(this, changes[0][3]);
         this.dropdownController.fillDropdown(_class_private_method_get(this, _getSource, getSource).call(this), _class_private_field_get(this, _selectedItems).getItemsArray());
         this.dropdownController.focusItem(0);
-        if (_class_private_field_get(this, _selectedItems).getSize() >= this.cellProperties.maxSelections) {
+        if (_class_private_field_get(this, _selectedItems).getSize() >= _class_private_method_get(this, _getEditorSetting, getEditorSetting).call(this, 'maxSelections')) {
             _class_private_method_get(this, _blockNewSelections, blockNewSelections).call(this);
         } else {
             _class_private_method_get(this, _unblockNewSelections, unblockNewSelections).call(this);

package/editors/multiSelectEditor/utils/utils.d.mts

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

package/editors/multiSelectEditor/utils/utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Retrieves checkbox element from the item element.
+ *
+ * @param {HTMLLIElement} itemElement Parent element.
+ * @returns {HTMLInputElement|null}
+ */
+export declare function getCheckboxElement(itemElement: HTMLLIElement): HTMLInputElement | null;
+/**
+ * Parses a stringified value and returns a JavaScript value when possible.
+ *
+ * @param {string} value Value originating from the textarea or dataset.
+ * @returns {*}
+ */
+export declare function parseStringifiedValue(value: unknown): unknown;
+/**
+ * Returns an array containing only values present in both provided arrays.
+ *
+ * @param {Array} valuesArray Values currently selected in the editor.
+ * @param {Array} source Array of available source items.
+ * @returns {Array}
+ */
+export declare function getValuesIntersection(valuesArray: unknown[], source: unknown[]): unknown[];
+/**
+ * Checks if an array contains a value using JSON.stringify for comparison.
+ *
+ * @param {Array} array Array of values.
+ * @param {string|object} element Value to check.
+ * @returns {boolean}
+ */
+export declare function includesValue(array: unknown[], element: unknown): boolean;

package/editors/multiSelectEditor/utils/utils.js

@@ -29,7 +29,7 @@ function getCheckboxElement(itemElement) {
     return itemElement.querySelector('input[type="checkbox"]');
 }
 function parseStringifiedValue(value) {
-    return (0, _string.isJSON)(value) ? JSON.parse(value) : value;
+    return typeof value === 'string' && (0, _string.isJSON)(value) ? JSON.parse(value) : value;
 }
 function getValuesIntersection(valuesArray, source) {
     return (0, _array.getIntersectionOfArrays)(valuesArray, source, (a, b)=>JSON.stringify(a) === JSON.stringify(b));
@@ -39,7 +39,6 @@ function includesValue(array, element) {
         return Array.isArray(array) && array.some((value)=>{
             return (0, _object.isKeyValueObject)(value) ? (0, _object.isObjectEqual)(value, element) : value === element;
         });
-    } else {
-        return array.includes(element);
     }
+    return array.includes(element);
 }

package/editors/multiSelectEditor/utils/utils.mjs

@@ -15,7 +15,7 @@ import { isJSON } from '../../../helpers/string.mjs';
  * @param {string} value Value originating from the textarea or dataset.
  * @returns {*}
  */ export function parseStringifiedValue(value) {
-    return isJSON(value) ? JSON.parse(value) : value;
+    return typeof value === 'string' && isJSON(value) ? JSON.parse(value) : value;
 }
 /**
  * Returns an array containing only values present in both provided arrays.
@@ -37,7 +37,6 @@ import { isJSON } from '../../../helpers/string.mjs';
         return Array.isArray(array) && array.some((value)=>{
             return isKeyValueObject(value) ? isObjectEqual(value, element) : value === element;
         });
-    } else {
-        return array.includes(element);
     }
+    return array.includes(element);
 }

package/editors/numericEditor/index.d.mts

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

package/editors/numericEditor/index.d.ts

@@ -1 +1 @@
-export { EDITOR_TYPE, NumericEditor } from './numericEditor';
+export { EDITOR_TYPE, NumericEditor, } from './numericEditor';

package/editors/numericEditor/numericEditor.d.mts

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

package/editors/numericEditor/numericEditor.d.ts

@@ -1,7 +1,12 @@
-import Core from '../../core';
 import { TextEditor } from '../textEditor';
-
-export const EDITOR_TYPE: 'numeric';
-export class NumericEditor extends TextEditor {
-  constructor(instance: Core);
+export declare const EDITOR_TYPE = "numeric";
+/**
+ * @private
+ * @class NumericEditor
+ */
+export declare class NumericEditor extends TextEditor {
+    /**
+     * Returns the unique editor type identifier for the numeric editor.
+     */
+    static get EDITOR_TYPE(): string;
 }

package/editors/numericEditor/numericEditor.js

@@ -19,7 +19,9 @@ _export(exports, {
 const _textEditor = require("../textEditor");
 const EDITOR_TYPE = 'numeric';
 class NumericEditor extends _textEditor.TextEditor {
-    static get EDITOR_TYPE() {
+    /**
+   * Returns the unique editor type identifier for the numeric editor.
+   */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
 }

package/editors/numericEditor/numericEditor.mjs

@@ -4,7 +4,9 @@ export const EDITOR_TYPE = 'numeric';
  * @private
  * @class NumericEditor
  */ export class NumericEditor extends TextEditor {
-    static get EDITOR_TYPE() {
+    /**
+   * Returns the unique editor type identifier for the numeric editor.
+   */ static get EDITOR_TYPE() {
         return EDITOR_TYPE;
     }
 }

package/editors/passwordEditor/index.d.mts

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

package/editors/passwordEditor/index.d.ts

@@ -1 +1 @@
-export { EDITOR_TYPE, PasswordEditor } from './passwordEditor';
+export { EDITOR_TYPE, PasswordEditor, } from './passwordEditor';

package/editors/passwordEditor/passwordEditor.d.mts

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

package/editors/passwordEditor/passwordEditor.d.ts

@@ -1,7 +1,64 @@
-import Core from '../../core';
 import { TextEditor } from '../textEditor';
-
-export const EDITOR_TYPE: 'password';
-export class PasswordEditor extends TextEditor {
-  constructor(instance: Core);
+export declare const EDITOR_TYPE = "password";
+/**
+ * @private
+ * @class PasswordEditor
+ */
+export declare class PasswordEditor extends TextEditor {
+    #private;
+    /**
+     * The password input element replacing the `<textarea>` from `TextEditor`.
+     *
+     * @type {HTMLInputElement}
+     */
+    TEXTAREA: HTMLInputElement;
+    /**
+     * Autoresize instance for resizing the editor to the size of the entered text. Its overwrites the default
+     * resizer of the TextEditor.
+     *
+     * @private
+     * @type {Function}
+     */
+    autoResize: {
+        init: (elementToObserve: HTMLElement, config: Record<string, unknown>, doObserve?: boolean) => void;
+        resize: () => void;
+        unObserve(): void;
+    };
+    /**
+     * @returns {string}
+     */
+    static get EDITOR_TYPE(): string;
+    /**
+     * Creates the editor's DOM elements. Replaces the `<textarea>` from `TextEditor` with an
+     * `<input type="password">` element so that the browser masks its content natively.
+     */
+    createElements(): void;
+    /**
+     * Opens the editor. When `hashRevealDelay` is set, switches the input to `type="text"` and
+     * installs a manual masking handler so each typed character is briefly visible before being
+     * replaced by `hashSymbol`.
+     */
+    open(): void;
+    /**
+     * Closes the editor. Removes the input event listener, cancels any pending reveal timer,
+     * resets reveal-mode state, and restores the input to `type="password"`.
+     */
+    close(): void;
+    /**
+     * Returns the current editor value. In reveal-delay mode returns the real (unmasked) value
+     * stored in `#realValue` rather than reading the input's display value, which may contain
+     * hash symbols.
+     *
+     * @returns {string}
+     */
+    getValue(): unknown;
+    /**
+     * Sets the editor value. In reveal-delay mode stores the plain value in `#realValue` and
+     * updates the input display with masked characters. When called from `beginEditing()` before
+     * `open()` has set `#inRevealMode`, pre-populates `#realValue` so `open()` can mask it
+     * immediately on display.
+     *
+     * @param {string} [value] The value to set.
+     */
+    setValue(value?: string): void;
 }