handsontable 18.0.0 → 18.1.0-rc7

package/core/layout/domSlot.js

@@ -70,7 +70,7 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
    * The user-configured key order applied before weight ordering.
    *
    * @type {string[]}
-   */ _order = /*#__PURE__*/ new WeakMap(), _itemClass = /*#__PURE__*/ new WeakMap(), /**
+   */ _order = /*#__PURE__*/ new WeakMap(), _itemClass = /*#__PURE__*/ new WeakMap(), _onContentChange = /*#__PURE__*/ new WeakMap(), /**
    * Returns the registered keys sorted by configured order, then weight, then registration order.
    *
    * @returns {string[]} The sorted keys.
@@ -123,6 +123,7 @@ class DomSlot {
             _class_private_field_set(this, _seq, _class_private_field_get(this, _seq) + 1);
         }
         _class_private_method_get(this, _reorder, reorder).call(this);
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * Unregisters a key and detaches its element from the DOM.
@@ -139,6 +140,7 @@ class DomSlot {
         }
         entry.element.remove();
         _class_private_field_get(this, _entries).delete(key);
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * Sets the user-configured key order and re-applies it.
@@ -164,12 +166,14 @@ class DomSlot {
    */ clear() {
         _class_private_field_get(this, _entries).forEach((entry)=>entry.element.remove());
         _class_private_field_get(this, _entries).clear();
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * @param {HTMLElement} parent The slot container element.
    * @param {object} [options] Slot options.
    * @param {string} [options.itemClass=''] Class added to every registered element.
-   */ constructor(parent, { itemClass = '' } = {}){
+   * @param {Function} [options.onContentChange] Called after any registered-content mutation.
+   */ constructor(parent, { itemClass = '', onContentChange = ()=>{} } = {}){
         _class_private_method_init(this, _sortedKeys);
         _class_private_method_init(this, _reorder);
         /**
@@ -200,11 +204,21 @@ class DomSlot {
             writable: true,
             value: void 0
         });
+        /**
+   * Optional callback fired after any registered-content mutation (add, remove, clear), so the
+   * owner can derive slot-dependent state from the resulting DOM.
+   *
+   * @type {Function}
+   */ _class_private_field_init(this, _onContentChange, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _entries, new Map());
         _class_private_field_set(this, _seq, 0);
         _class_private_field_set(this, _order, []);
         _class_private_field_set(this, _parent, parent);
         _class_private_field_set(this, _itemClass, itemClass);
+        _class_private_field_set(this, _onContentChange, onContentChange);
     }
 }
 function sortedKeys() {

package/core/layout/domSlot.mjs

@@ -60,7 +60,7 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
    * The user-configured key order applied before weight ordering.
    *
    * @type {string[]}
-   */ _order = /*#__PURE__*/ new WeakMap(), _itemClass = /*#__PURE__*/ new WeakMap(), /**
+   */ _order = /*#__PURE__*/ new WeakMap(), _itemClass = /*#__PURE__*/ new WeakMap(), _onContentChange = /*#__PURE__*/ new WeakMap(), /**
    * Returns the registered keys sorted by configured order, then weight, then registration order.
    *
    * @returns {string[]} The sorted keys.
@@ -119,6 +119,7 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
             _class_private_field_set(this, _seq, _class_private_field_get(this, _seq) + 1);
         }
         _class_private_method_get(this, _reorder, reorder).call(this);
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * Unregisters a key and detaches its element from the DOM.
@@ -135,6 +136,7 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
         }
         entry.element.remove();
         _class_private_field_get(this, _entries).delete(key);
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * Sets the user-configured key order and re-applies it.
@@ -160,12 +162,14 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
    */ clear() {
         _class_private_field_get(this, _entries).forEach((entry)=>entry.element.remove());
         _class_private_field_get(this, _entries).clear();
+        _class_private_field_get(this, _onContentChange).call(this);
     }
     /**
    * @param {HTMLElement} parent The slot container element.
    * @param {object} [options] Slot options.
    * @param {string} [options.itemClass=''] Class added to every registered element.
-   */ constructor(parent, { itemClass = '' } = {}){
+   * @param {Function} [options.onContentChange] Called after any registered-content mutation.
+   */ constructor(parent, { itemClass = '', onContentChange = ()=>{} } = {}){
         _class_private_method_init(this, _sortedKeys);
         _class_private_method_init(this, _reorder);
         /**
@@ -196,11 +200,21 @@ var _parent = /*#__PURE__*/ new WeakMap(), /**
             writable: true,
             value: void 0
         });
+        /**
+   * Optional callback fired after any registered-content mutation (add, remove, clear), so the
+   * owner can derive slot-dependent state from the resulting DOM.
+   *
+   * @type {Function}
+   */ _class_private_field_init(this, _onContentChange, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_set(this, _entries, new Map());
         _class_private_field_set(this, _seq, 0);
         _class_private_field_set(this, _order, []);
         _class_private_field_set(this, _parent, parent);
         _class_private_field_set(this, _itemClass, itemClass);
+        _class_private_field_set(this, _onContentChange, onContentChange);
     }
 }
 function sortedKeys() {

package/core/layout/index.d.ts

@@ -1,5 +1,5 @@
 export { DomSlot } from './domSlot';
-export { LayoutManager } from './layoutManager';
+export { LayoutManager, refreshSlotFilledState } from './layoutManager';
 export type { LayoutConfig, LayoutRegisterOptions } from './layoutManager';
-export { LAYOUT_SLOTS, SLOT_ITEM_CLASS } from './constants';
+export { LAYOUT_SLOTS, SLOT_ITEM_CLASS, getSlotFilledClassName } from './constants';
 export type { LayoutSlotName, LayoutSide } from './constants';

package/core/layout/index.js

@@ -20,6 +20,12 @@ _export(exports, {
     },
     get SLOT_ITEM_CLASS () {
         return _constants.SLOT_ITEM_CLASS;
+    },
+    get getSlotFilledClassName () {
+        return _constants.getSlotFilledClassName;
+    },
+    get refreshSlotFilledState () {
+        return _layoutManager.refreshSlotFilledState;
     }
 });
 const _domSlot = require("./domSlot");

package/core/layout/index.mjs

@@ -1,3 +1,3 @@
 export { DomSlot } from './domSlot.mjs';
-export { LayoutManager } from './layoutManager.mjs';
-export { LAYOUT_SLOTS, SLOT_ITEM_CLASS } from './constants.mjs';
+export { LayoutManager, refreshSlotFilledState } from './layoutManager.mjs';
+export { LAYOUT_SLOTS, SLOT_ITEM_CLASS, getSlotFilledClassName } from './constants.mjs';

package/core/layout/layoutManager.d.ts

@@ -1,5 +1,18 @@
 import { DomSlot } from './domSlot';
 import { type LayoutSlotName, type LayoutSide } from './constants';
+/**
+ * Mirrors the slot's fill state onto its parent (the root wrapper) as a `ht-slot-<name>-filled`
+ * class. "Filled" is derived from the DOM — at least one direct `.ht-slot-element` child — not
+ * from the registration registry, because foreign nodes (the license notification) carry the
+ * slot-item class without registering. The class replaces the former
+ * `.ht-root-wrapper:has(> .ht-slot-<name> > .ht-slot-element)` selectors, whose `:has()` made
+ * every grid DOM mutation trigger a style invalidation scaled to the whole host page.
+ *
+ * @param {LayoutSlotName} name The slot name.
+ * @param {HTMLElement} slotElement The slot container element.
+ * @returns {void}
+ */
+export declare function refreshSlotFilledState(name: LayoutSlotName, slotElement: HTMLElement): void;
 /**
  * User-facing layout configuration: an ordered list of element keys per user-orderable slot. The
  * shape derives from {@link LayoutSide}, so introducing a new slot extends it automatically.

package/core/layout/layoutManager.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "LayoutManager", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get LayoutManager () {
         return LayoutManager;
+    },
+    get refreshSlotFilledState () {
+        return refreshSlotFilledState;
     }
 });
 const _errors = require("../../helpers/errors");
@@ -51,6 +59,14 @@ function _class_private_field_set(receiver, privateMap, value) {
     _class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
+function refreshSlotFilledState(name, slotElement) {
+    const wrapper = slotElement.parentElement;
+    if (!wrapper) {
+        return;
+    }
+    const isFilled = slotElement.querySelector(`:scope > .${_constants.SLOT_ITEM_CLASS}`) !== null;
+    wrapper.classList.toggle((0, _constants.getSlotFilledClassName)(name), isFilled);
+}
 var /**
    * The slots keyed by their name.
    *
@@ -119,7 +135,8 @@ class LayoutManager {
         _class_private_field_set(this, _slots, new Map(Object.keys(elements).map((name)=>[
                 name,
                 new _domSlot.DomSlot(elements[name], {
-                    itemClass: _constants.SLOT_ITEM_CLASS
+                    itemClass: _constants.SLOT_ITEM_CLASS,
+                    onContentChange: ()=>refreshSlotFilledState(name, elements[name])
                 })
             ])));
     }

package/core/layout/layoutManager.mjs

@@ -40,7 +40,26 @@ function _class_private_field_set(receiver, privateMap, value) {
 }
 import { throwWithCause } from '../../helpers/errors.mjs';
 import { DomSlot } from './domSlot.mjs';
-import { LAYOUT_SLOTS, SLOT_ITEM_CLASS } from './constants.mjs';
+import { LAYOUT_SLOTS, SLOT_ITEM_CLASS, getSlotFilledClassName } from './constants.mjs';
+/**
+ * Mirrors the slot's fill state onto its parent (the root wrapper) as a `ht-slot-<name>-filled`
+ * class. "Filled" is derived from the DOM — at least one direct `.ht-slot-element` child — not
+ * from the registration registry, because foreign nodes (the license notification) carry the
+ * slot-item class without registering. The class replaces the former
+ * `.ht-root-wrapper:has(> .ht-slot-<name> > .ht-slot-element)` selectors, whose `:has()` made
+ * every grid DOM mutation trigger a style invalidation scaled to the whole host page.
+ *
+ * @param {LayoutSlotName} name The slot name.
+ * @param {HTMLElement} slotElement The slot container element.
+ * @returns {void}
+ */ export function refreshSlotFilledState(name, slotElement) {
+    const wrapper = slotElement.parentElement;
+    if (!wrapper) {
+        return;
+    }
+    const isFilled = slotElement.querySelector(`:scope > .${SLOT_ITEM_CLASS}`) !== null;
+    wrapper.classList.toggle(getSlotFilledClassName(name), isFilled);
+}
 var /**
    * The slots keyed by their name.
    *
@@ -111,7 +130,8 @@ var /**
         _class_private_field_set(this, _slots, new Map(Object.keys(elements).map((name)=>[
                 name,
                 new DomSlot(elements[name], {
-                    itemClass: SLOT_ITEM_CLASS
+                    itemClass: SLOT_ITEM_CLASS,
+                    onContentChange: ()=>refreshSlotFilledState(name, elements[name])
                 })
             ])));
     }

package/core/settings.d.ts

@@ -3,7 +3,7 @@
  * Moved here from common.ts as part of the common.ts decomposition.
  */
 import type { CellCoords as WalkontableCellCoords, CellRange as WalkontableCellRange } from '../3rdparty/walkontable/src';
-import type { CellChange, ChangeSource, RowObject, CellValue, CellProperties, ColumnSettings } from '../settings';
+import type { CellChange, ChangeSource, RowObject, CellValue, CellProperties, ColumnSettings, RemoveIndexSignature } from '../settings';
 import type { ColumnConditions } from '../plugins/filters';
 import type { LayoutConfig } from './layout';
 import type { PredefinedMenuItemKey, MenuItemConfig, ContextMenu } from '../plugins/contextMenu';
@@ -13,6 +13,47 @@ import type { NestedHeader } from '../plugins/nestedHeaders';
 import type { UndoRedoAction } from '../plugins/undoRedo';
 import type { DataProviderBeforeFetchParameters, DataProviderQueryParameters, DataProviderFetchResult, RowMutationPayload, DataProviderConfig } from '../plugins/dataProvider';
 import type { RangeType, HotInstance } from './types';
+import type { ThemeColorScheme, DensityType } from '../themes/types';
+/**
+ * The function shape of the `sourceDataValidator` option. Returns `true` when the value is valid.
+ * The optional `rowIndependent` flag marks a validator whose result depends only on the value and
+ * column/global-level meta, never on per-row meta - letting the source-data validation pass batch
+ * whole columns instead of scanning every cell.
+ */
+export type SourceDataValidatorFn = {
+    (value: CellValue, cellMeta: CellProperties, source?: string): boolean;
+    rowIndependent?: boolean;
+};
+/**
+ * The write surface passed as the second argument to the `sanitizer` option, so a sanitizer can
+ * apply different rules per surface (for example, stricter for pasted content).
+ *
+ * Annotate the parameter with it to get completion on the values you branch on:
+ *
+ * ```ts
+ * import type { SanitizerContext } from 'handsontable';
+ *
+ * const settings = {
+ *   sanitizer: (content: string, source: SanitizerContext) =>
+ *     source === 'CopyPaste.paste' ? strict(content) : loose(content),
+ * };
+ * ```
+ *
+ * The listed values are the ones a grid write surface passes to a configured sanitizer. Two more
+ * strings reach `fastInnerHTML` and are deliberately not listed:
+ *
+ * - `'html'`, from the `allowHtml` autocomplete and dropdown path only. It always travels with
+ *   `sanitizer: false`, so no sanitizer ever sees it. (The `html` cell type passes no context at all
+ *   and so falls through to the default below.)
+ * - `'innerHTML'`, the `context` parameter's own default. No grid surface reaches a sanitizer under
+ *   it, but `Handsontable.dom.fastInnerHTML()` is public, so a caller passing their own sanitizer
+ *   and no context of their own does receive it.
+ *
+ * The `(string & {})` member is what keeps that last case compiling, along with a sanitizer shared
+ * with another library or one branching on a surface added in a later release. The trade is that the
+ * type cannot reject a wrong value: a misspelled comparison comes out as a branch that never runs.
+ */
+export type SanitizerContext = 'header' | 'password' | 'contextMenu' | 'selectEditor' | 'dialog' | 'notification' | 'CopyPaste.paste' | 'CopyPaste.paste.sourceData' | (string & {});
 /**
  * Grid settings interface representing all possible Handsontable configuration options.
  * Derived from the metaSchema factory in dataMap/metaManager/metaSchema.ts.
@@ -31,6 +72,8 @@ export interface GridSettings {
     readOnlyCellClassName?: string;
     tableClassName?: string | string[];
     themeName?: string;
+    colorScheme?: ThemeColorScheme;
+    density?: DensityType;
     width?: number | string | (() => number | string);
     height?: number | string | (() => number | string);
     colWidths?: number | number[] | string | ((column: number) => number | string) | Array<number | string>;
@@ -91,6 +134,8 @@ export interface GridSettings {
     readOnly?: boolean;
     skipColumnOnPaste?: boolean;
     skipRowOnPaste?: boolean;
+    sourceDataValidator?: SourceDataValidatorFn;
+    sourceDataWarningMessage?: string;
     tabMoves?: {
         row: number;
         col: number;
@@ -120,6 +165,8 @@ export interface GridSettings {
     navigableHeaders?: boolean;
     outsideClickDeselects?: boolean | ((target: HTMLElement, coords?: WalkontableCellCoords) => boolean);
     selectionMode?: 'single' | 'range' | 'multiple';
+    selectionHandles?: boolean;
+    moveCells?: boolean;
     tabNavigation?: boolean;
     autoWrapCol?: boolean;
     autoWrapRow?: boolean;
@@ -145,6 +192,9 @@ export interface GridSettings {
     comments?: boolean | object | object[];
     contextMenu?: boolean | object | string[];
     customBorders?: boolean | object[];
+    customBordersProgressive?: boolean | {
+        chunkSize?: number;
+    };
     dialog?: boolean | object;
     dataProvider?: DataProviderConfig;
     dragToScroll?: boolean | {
@@ -160,6 +210,7 @@ export interface GridSettings {
     formulas?: boolean | {
         engine: unknown;
         sheetName?: string;
+        hyperlinks?: boolean;
         [key: string]: unknown;
     };
     hiddenColumns?: boolean | object;
@@ -180,6 +231,7 @@ export interface GridSettings {
     uncheckedTemplate?: unknown;
     dateFormat?: Intl.DateTimeFormatOptions;
     timeFormat?: Intl.DateTimeFormatOptions;
+    dateTimeFormat?: Intl.DateTimeFormatOptions;
     defaultDate?: string;
     hashLength?: number;
     hashRevealDelay?: number;
@@ -190,6 +242,7 @@ export interface GridSettings {
     locale?: string;
     language?: string;
     numericFormat?: object;
+    preserveNumericLiteral?: boolean;
     selectOptions?: string[] | number[] | object[] | Record<string, string> | ((visualRow: number, visualColumn: number, prop: string | number) => string[] | Record<string, string>);
     strict?: boolean;
     title?: string;
@@ -217,6 +270,7 @@ export interface GridSettings {
     afterColumnMove?: (movedColumns: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean, orderChanged: boolean) => void;
     afterColumnResize?: (newSize: number, column: number, isDoubleClick: boolean) => void;
     afterColumnSequenceChange?: (source: ChangeSource) => void;
+    afterCustomBordersUpdate?: () => void;
     afterColumnSequenceCacheUpdate?: (indexesChangesState: {
         indexesSequenceChanged: boolean;
         trimmedIndexesChanged: boolean;
@@ -236,7 +290,7 @@ export interface GridSettings {
     afterCut?: (data: CellValue[][], coords: RangeType[]) => void;
     afterDeselect?: () => void;
     afterDestroy?: () => void;
-    afterDetachChild?: (parent: RowObject, element: RowObject) => void;
+    afterDetachChild?: (parent: RowObject, element: RowObject, finalElementPosition: number | null) => void;
     afterDialogFocus?: (focusSource: 'tab_from_above' | 'tab_from_below' | 'click' | 'show') => void;
     afterDialogHide?: () => void;
     afterDialogShow?: () => void;
@@ -272,6 +326,12 @@ export interface GridSettings {
     afterModifyTransformFocus?: (coords: WalkontableCellCoords, rowTransformDir: number, colTransformDir: number) => void;
     afterModifyTransformStart?: (coords: WalkontableCellCoords, rowTransformDir: number, colTransformDir: number) => void;
     afterMomentumScroll?: () => void;
+    /**
+     * Fired after a `moveCells` drag has relocated a selection.
+     *
+     * @since 18.1.0
+     */
+    afterMoveCells?: (sourceRange: WalkontableCellRange, targetRange: WalkontableCellRange, isCopy: boolean) => void;
     afterNamedExpressionAdded?: (namedExpressionName: string, changes: unknown[]) => void;
     afterNamedExpressionRemoved?: (namedExpressionName: string, changes: unknown[]) => void;
     afterNotificationHide?: (id: string) => void;
@@ -292,9 +352,12 @@ export interface GridSettings {
     afterOnCellContextMenu?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     afterOnCellCornerDblClick?: (event: MouseEvent) => void;
     afterOnCellCornerMouseDown?: (event: MouseEvent) => void;
+    afterOnSelectionHandleMouseDown?: (event: MouseEvent, edge: 'top' | 'bottom' | 'start' | 'end') => void;
+    afterOnSelectionEdgeMouseDown?: (event: MouseEvent, edge: 'top' | 'bottom' | 'start' | 'end') => void;
     afterOnCellMouseDown?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     afterOnCellMouseOut?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     afterOnCellMouseOver?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
+    afterOnCellMouseOverOutside?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     afterOnCellMouseUp?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     afterPageChange?: (oldPage: number, newPage: number) => void;
     afterPageCounterVisibilityChange?: (isVisible: boolean) => void;
@@ -317,6 +380,8 @@ export interface GridSettings {
     afterRemoveRow?: (index: number, amount: number, physicalRows: number[], source?: ChangeSource) => void;
     afterRender?: (isForced: boolean) => void;
     afterRenderer?: (TD: HTMLTableCellElement, row: number, column: number, prop: string | number, value: CellValue, cellProperties: CellProperties) => void;
+    afterRowCollapse?: (currentCollapsedRows: number[], destinationCollapsedRows: number[], collapsePossible: boolean, successfullyCollapsed: boolean) => void;
+    afterRowExpand?: (currentCollapsedRows: number[], destinationCollapsedRows: number[], expandPossible: boolean, successfullyExpanded: boolean) => void;
     afterRowMove?: (movedRows: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean, orderChanged: boolean) => void;
     afterRowResize?: (newSize: number, row: number, isDoubleClick: boolean) => void;
     afterRowSequenceChange?: (source: ChangeSource) => void;
@@ -438,6 +503,12 @@ export interface GridSettings {
     beforeLoadingHide?: () => boolean | void;
     beforeLoadingShow?: () => boolean | void;
     beforeMergeCells?: (cellRange: WalkontableCellRange, auto: boolean) => void;
+    /**
+     * Fired before a `moveCells` drag relocates a selection. Return `false` to cancel the move.
+     *
+     * @since 18.1.0
+     */
+    beforeMoveCells?: (sourceRange: WalkontableCellRange, targetTopLeft: WalkontableCellCoords, isCopy: boolean) => void | boolean;
     beforeNotificationHide?: (id: string) => boolean | void;
     beforeNotificationShow?: (options: {
         id: string;
@@ -461,6 +532,11 @@ export interface GridSettings {
     beforeOnCellMouseOver?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement, controller: {
         preventDefault: boolean;
     }) => void;
+    beforeOnCellMouseOverOutside?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement, controller: {
+        row: boolean;
+        column: boolean;
+        cell: boolean;
+    }) => void;
     beforeOnCellMouseUp?: (event: MouseEvent, coords: WalkontableCellCoords, TD: HTMLTableCellElement) => void;
     beforePageChange?: (oldPage: number, newPage: number) => void | boolean;
     beforePageSizeChange?: (oldPageSize: number | 'auto', newPageSize: number | 'auto') => void | boolean;
@@ -475,11 +551,13 @@ export interface GridSettings {
         height: number;
     }, actionPossible: boolean) => boolean | void;
     beforeRemoveCellClassNames?: () => string[] | void;
-    beforeRemoveCellMeta?: (row: number, column: number, key: string, value: unknown) => void;
+    beforeRemoveCellMeta?: (row: number, column: number, key: string, value: unknown) => boolean | void;
     beforeRemoveCol?: (index: number, amount: number, physicalColumns: number[], source?: ChangeSource) => void;
     beforeRemoveRow?: (index: number, amount: number, physicalRows: number[], source?: ChangeSource) => void;
     beforeRender?: (isForced: boolean) => void;
     beforeRenderer?: (TD: HTMLTableCellElement, row: number, column: number, prop: string | number, value: CellValue, cellProperties: CellProperties) => void;
+    beforeRowCollapse?: (currentCollapsedRows: number[], destinationCollapsedRows: number[], collapsePossible: boolean) => void | boolean;
+    beforeRowExpand?: (currentCollapsedRows: number[], destinationCollapsedRows: number[], expandPossible: boolean) => void | boolean;
     beforeRowMove?: (movedRows: number[], finalIndex: number, dropIndex: number | undefined, movePossible: boolean) => void | boolean;
     beforeRowResize?: (newSize: number, row: number, isDoubleClick: boolean) => number | void | false;
     beforeRowsMutation?: (operation: string, payload: RowMutationPayload) => void | boolean;
@@ -525,7 +603,7 @@ export interface GridSettings {
     modifyColumnHeaderHeight?: () => void;
     modifyColumnHeaderValue?: (headerValue: string, visualColumnIndex: number, headerLevel: number) => void | string;
     modifyColWidth?: (width: number, column: number, source?: string) => void | number;
-    modifyCopyableRange?: (copyableRanges: RangeType[]) => void;
+    modifyCopyableRange?: (copyableRanges: RangeType[]) => RangeType[] | void;
     modifyData?: (row: number, column: number, valueHolder: {
         value: CellValue;
     }, ioMode: 'get' | 'set') => void;
@@ -539,6 +617,7 @@ export interface GridSettings {
     modifyRowHeaderWidth?: (rowHeaderWidth: number) => void | number;
     modifyRowHeight?: (height: number, row: number, source?: string) => void | number;
     modifyRowHeightByOverlayName?: (height: number, row: number, overlayType: string) => void | number;
+    modifySinglePassLayout?: (singlePassLayout: boolean) => void | boolean;
     modifySourceData?: (row: number, column: number, valueHolder: {
         value: CellValue;
     }, ioMode: 'get' | 'set') => void;
@@ -550,10 +629,27 @@ export interface GridSettings {
 /**
  * Extracts all hook callback keys from GridSettings.
  * Used to derive the Events type for addHook/removeHook generics.
+ *
+ * Derived from `RemoveIndexSignature<GridSettings>` rather than `GridSettings` directly -- the raw
+ * type's `[key: string]: any` index signature makes `keyof GridSettings` include `string`, which
+ * collapses this mapped type to `string` and, in turn, collapses `Events` to `{ [key: string]: any }`.
  */
 type HookKey = {
-    [K in keyof GridSettings]-?: NonNullable<GridSettings[K]> extends (...args: any[]) => any ? K : never;
-}[keyof GridSettings];
+    [K in keyof RemoveIndexSignature<GridSettings>]-?: NonNullable<GridSettings[K]> extends (...args: never[]) => unknown ? K : never;
+}[keyof RemoveIndexSignature<GridSettings>];
+/**
+ * The shape of a configured `sanitizer`, derived from the option so the two cannot drift apart.
+ *
+ * `RemoveIndexSignature` is what makes that guarantee real. `GridSettings` carries a
+ * `[key: string]: any`, so a plain `GridSettings['sanitizer']` lookup would keep resolving - to
+ * `any` - if the option were ever renamed, silently un-typing every internal consumer. Stripping the
+ * index signature first turns the same rename into a compile error here.
+ *
+ * Not re-exported from the package entry points: with the option's second parameter absorbed by
+ * `...args: any[]`, annotating with this type conveys no context, so `SanitizerContext` is what
+ * users are given instead.
+ */
+export type SanitizerFn = NonNullable<RemoveIndexSignature<GridSettings>['sanitizer']>;
 /**
  * Map of all Handsontable hook names to their typed callback signatures.
  * Use with addHook/addHookOnce/removeHook for IDE autocomplete and compile-time safety.

package/core/types.d.ts

@@ -9,6 +9,7 @@ import type { IndexMapper } from '../translations';
 import type CellCoords from '../3rdparty/walkontable/src/cell/coords';
 import type CellRange from '../3rdparty/walkontable/src/cell/range';
 import type { Events, GridSettings } from './settings';
+import type { CellProperties } from '../settings';
 import type { default as SelectionManager } from '../selection/selection';
 import type { default as ViewInstance } from '../tableView';
 import type { ShortcutManager } from '../shortcuts/manager';
@@ -53,13 +54,25 @@ export interface ViewportScrollerInstance {
 /**
  * Handsontable Core instance interface.
  * Provides type-safe access to the Core API without requiring circular imports.
+ *
+ * The `addHook`/`addHookOnce`/`removeHook` methods form a three-rung overload ladder:
+ * 1. Strict -- a known hook name with a callback typed as `Events[K]`. Unannotated inline arrow
+ *    functions get full parameter inference from this rung.
+ * 2. Lenient -- a known hook name with any explicitly-annotated callback. `HookCallback` is the
+ *    sound function "top type" (see `core/hooks/bucket.ts`), so a callback whose annotations don't
+ *    exactly match the declared hook signature is still accepted, matching the runtime behavior and
+ *    keeping previously-compiling listener code compiling.
+ * 3. Fallback -- any string, for dynamically-named and plugin-local hooks.
  */
 export interface HotInstance {
     addHook<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>, orderIndex?: number): void;
+    addHook<K extends keyof Events>(key: K, callback: HookCallback | HookCallback[], orderIndex?: number): void;
     addHook(key: string, callback: HookCallback | HookCallback[], orderIndex?: number): void;
     addHookOnce<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>, orderIndex?: number): void;
+    addHookOnce<K extends keyof Events>(key: K, callback: HookCallback | HookCallback[], orderIndex?: number): void;
     addHookOnce(key: string, callback: HookCallback | HookCallback[], orderIndex?: number): void;
     removeHook<K extends keyof Events>(key: K, callback: Events[K]): void;
+    removeHook<K extends keyof Events>(key: K, callback: HookCallback): void;
     removeHook(key: string, callback: HookCallback): void;
     runHooks<R = unknown>(name: string, ...args: unknown[]): R;
     hasHook(name: string): boolean;
@@ -107,7 +120,8 @@ export interface HotInstance {
     updateData(data: unknown[][] | object[], source?: string): void;
     emptySelectedCells(source?: string): void;
     populateFromArray(row: number, column: number, input: unknown[][], endRow?: number | null, endCol?: number | null, source?: string, method?: string): object | false | undefined;
-    getCellMeta<M extends object = Record<string, unknown>>(row: number, column: number, options?: object): M;
+    getCellMeta<M extends object = CellProperties>(row: number, column: number, options?: object): M;
+    getCellMetaTransient<M extends object = CellProperties>(row: number, column: number): M;
     getCellMetaAtRow(row: number): Record<string, unknown>[];
     setCellMeta(row: number, column: number, key: string, value: unknown): void;
     setCellMetaObject(row: number, column: number, prop: Record<string, unknown>): void;

package/core/types.mjs

@@ -4,4 +4,13 @@
  */ /**
  * Handsontable Core instance interface.
  * Provides type-safe access to the Core API without requiring circular imports.
+ *
+ * The `addHook`/`addHookOnce`/`removeHook` methods form a three-rung overload ladder:
+ * 1. Strict -- a known hook name with a callback typed as `Events[K]`. Unannotated inline arrow
+ *    functions get full parameter inference from this rung.
+ * 2. Lenient -- a known hook name with any explicitly-annotated callback. `HookCallback` is the
+ *    sound function "top type" (see `core/hooks/bucket.ts`), so a callback whose annotations don't
+ *    exactly match the declared hook signature is still accepted, matching the runtime behavior and
+ *    keeping previously-compiling listener code compiling.
+ * 3. Fallback -- any string, for dynamically-named and plugin-local hooks.
  */ export { };