@handsontable/angular-wrapper 17.1.0-rc9 → 18.0.0-rc1

package/lib/editor/hot-cell-editor-base.directive.d.ts

@@ -0,0 +1,25 @@
+import Handsontable from 'handsontable/base';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Shared base directive for HotCellEditorComponent and HotCellEditorAdvancedComponent.
+ * Holds all @Input(), @Output() and @HostBinding() declarations that both editor variants share.
+ *
+ * @template T - The type of the edited cell value.
+ */
+export declare abstract class HotCellEditorBase<T extends string | number | boolean | Record<string, any> | Array<any>> {
+    protected heightFitParentContainer: number;
+    protected widthFitParentContainer: number;
+    row: number;
+    column: number;
+    prop: string | number;
+    originalValue: T;
+    cellProperties: Handsontable.CellProperties;
+    finishEdit: EventEmitter<void>;
+    cancelEdit: EventEmitter<void>;
+    protected value: T;
+    getValue(): T;
+    setValue(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotCellEditorBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HotCellEditorBase<any>, never, never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "originalValue": { "alias": "originalValue"; "required": false; }; "cellProperties": { "alias": "cellProperties"; "required": false; }; }, { "finishEdit": "finishEdit"; "cancelEdit": "cancelEdit"; }, never, never, true, never>;
+}

package/lib/editor/hot-cell-editor.component.d.ts

@@ -1,10 +1,13 @@
-import { EventEmitter } from '@angular/core';
-import { CellProperties } from 'handsontable/settings';
+import { HotCellEditorBase } from './hot-cell-editor-base.directive';
 import * as i0 from "@angular/core";
 /**
- * Abstract class representing a Handsontable editor in angular.
+ * Abstract class representing a basic Handsontable cell editor in Angular.
+ *
+ * Extend this class and decorate the subclass with `@Component()` to implement a custom editor.
+ * Value type is limited to primitives (`string | number | boolean`).
+ * For object and array values use {@link HotCellEditorAdvancedComponent}.
  */
-export declare abstract class HotCellEditorComponent<T extends string | number | boolean> {
+export declare abstract class HotCellEditorComponent<T extends string | number | boolean> extends HotCellEditorBase<T> {
     static readonly EDITOR_MARKER: unique symbol;
     /** The tabindex attribute for the editor. */
     protected tabindex: number;
@@ -12,65 +15,23 @@ export declare abstract class HotCellEditorComponent<T extends string | number |
     protected dataHotInput: string;
     /** The handsontableInput class for the editor. */
     protected handsontableInputClass: boolean;
-    /** The height of the editor as a percentage of the parent container. */
-    protected heightFitParentContainer: number;
-    /** The width of the editor as a percentage of the parent container. */
-    protected widthFitParentContainer: number;
-    /** The row index of the cell being edited. */
-    row: number;
-    /** The column index of the cell being edited. */
-    column: number;
-    /** The property name of the cell being edited. */
-    prop: string | number;
-    /** The original value of the cell being edited. */
-    originalValue: T;
-    /** The cell properties of the cell being edited. */
-    cellProperties: CellProperties;
-    /** Event emitted when the edit is finished.
-     * The data will be saved to the model.
-     */
-    finishEdit: EventEmitter<void>;
-    /** Event emitted when the edit is canceled.
-     * The entered data will be reverted to the original value.
-     */
-    cancelEdit: EventEmitter<void>;
-    /** The current value of the editor. */
-    private _value;
-    /** Event triggered by Handsontable on closing the editor.
-     * The user can define their own actions for
-     * the custom editor to be called after the base logic. */
+    /** Event triggered by Handsontable on closing the editor. */
     onClose(): void;
-    /** Event triggered by Handsontable on open the editor.
-     * The user can define their own actions for
-     * the custom editor to be called after the base logic. */
+    /** Event triggered by Handsontable on opening the editor. */
     onOpen(event?: Event): void;
-    /** Event triggered by Handsontable on focus the editor.
-     * The user have to define focus logic.
+    /**
+     * Event triggered by Handsontable on focusing the editor.
+     * Must be implemented by the subclass to move focus to the actual input element.
      * @example
      * ```typescript
-     * component({
-     *  template: `<input #inputElement>`
-     * })
-     * class CustomEditor extends HotEditor<string> {
+     * @Component({ template: `<input #inputElement>` })
+     * class CustomEditor extends HotCellEditorComponent<string> {
      *   @ViewChild('inputElement') inputElement!: ElementRef;
-     *
-     *   onFocus(): void {
-     *     this.inputElement.nativeElement.focus();
-     *   }
+     *   onFocus(): void { this.inputElement.nativeElement.focus(); }
      * }
      * ```
      */
     abstract onFocus(): void;
-    /**
-     * Gets the current value of the editor.
-     * @returns The current value of the editor.
-     */
-    getValue(): T;
-    /**
-     * Sets the current value of the editor.
-     * @param value The value to set.
-     */
-    setValue(value: T): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<HotCellEditorComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<HotCellEditorComponent<any>, never, never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "originalValue": { "alias": "originalValue"; "required": false; }; "cellProperties": { "alias": "cellProperties"; "required": false; }; }, { "finishEdit": "finishEdit"; "cancelEdit": "cancelEdit"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HotCellEditorComponent<any>, never, never, {}, {}, never, never, true, never>;
 }

package/lib/editor/models/factory-editor-properties.d.ts

@@ -1,7 +1,15 @@
-import { ComponentRef } from '@angular/core';
+import { ComponentRef, EnvironmentInjector } from '@angular/core';
 import { CustomEditorPlaceholderComponent } from '../custom-editor-placeholder.component';
 import { Subscription } from 'rxjs';
 import { HotCellEditorAdvancedComponent } from '../hot-cell-editor-advanced.component';
+/**
+ * Handsontable core instance augmented with the Angular `EnvironmentInjector` that the wrapper
+ * stores on it (in `HotTableComponent`) so editor adapters can create components with the right
+ * injection context. Typed here to avoid scattered `as any` casts at the assignment/read sites.
+ */
+export interface HotInstanceWithAngularInjector {
+    _angularEnvironmentInjector?: EnvironmentInjector;
+}
 /**
  * Angular-specific properties that will be added to the editor instance.
  */

package/lib/hot-table.component.d.ts

@@ -1,24 +1,27 @@
-import { AfterViewInit, DestroyRef, EnvironmentInjector, NgZone, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { AfterViewInit, ElementRef, EnvironmentInjector, NgZone, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
 import Handsontable from 'handsontable/base';
 import { HotSettingsResolver } from './services/hot-settings-resolver.service';
 import { HotGlobalConfigService } from './services/hot-global-config.service';
 import { GridSettings } from './models/grid-settings';
+import { DynamicComponentService } from './renderer/hot-dynamic-renderer-component.service';
 import * as i0 from "@angular/core";
-export declare const HOT_DESTROYED_WARNING = "The Handsontable instance bound to this component was destroyed and cannot be used properly.";
+export declare const HOT_DESTROYED_WARNING: string;
 export declare class HotTableComponent implements AfterViewInit, OnChanges, OnDestroy {
-    private readonly _hotSettingsResolver;
-    private readonly _hotConfig;
-    private readonly ngZone;
+    private _hotSettingsResolver;
+    private _hotConfig;
+    ngZone: NgZone;
     private readonly environmentInjector;
-    private readonly destroyRef;
+    private readonly _dynamicComponentService;
     /** The data for the Handsontable instance. */
     data: Handsontable.GridSettings['data'] | null;
     /** The settings for the Handsontable instance. */
     settings: GridSettings;
-    private container;
+    /** The container element for the Handsontable instance. */
+    container: ElementRef<HTMLDivElement>;
     /** The Handsontable instance. */
     private __hotInstance;
-    constructor(_hotSettingsResolver: HotSettingsResolver, _hotConfig: HotGlobalConfigService, ngZone: NgZone, environmentInjector: EnvironmentInjector, destroyRef: DestroyRef);
+    private readonly _destroyRef;
+    constructor(_hotSettingsResolver: HotSettingsResolver, _hotConfig: HotGlobalConfigService, ngZone: NgZone, environmentInjector: EnvironmentInjector, _dynamicComponentService: DynamicComponentService);
     /**
      * Gets the Handsontable instance.
      * @returns The Handsontable instance or `null` if it's not yet been created or has been destroyed.
@@ -39,7 +42,6 @@ export declare class HotTableComponent implements AfterViewInit, OnChanges, OnDe
      * Destroys the Handsontable instance and clears the columns from custom editors.
      */
     ngOnDestroy(): void;
-    private destroyEditorComponentRefs;
     /**
      * Updates the Handsontable instance with new settings.
      * @param newSettings The new settings to apply to the Handsontable instance.

package/lib/hot-table.module.d.ts

@@ -1,11 +1,7 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./hot-table.component";
 export declare class HotTableModule {
-    /**
-     * Placeholder for the library version.
-     * Replaced automatically during the pre-build/post-build process.
-     */
-    static readonly version = "17.1.0-rc9";
+    static readonly version = "18.0.0-rc1";
     static ɵfac: i0.ɵɵFactoryDeclaration<HotTableModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<HotTableModule, never, [typeof i1.HotTableComponent], [typeof i1.HotTableComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<HotTableModule>;

package/lib/models/column-settings.d.ts

@@ -6,6 +6,12 @@ import { HotCellRendererComponent } from '../renderer/hot-cell-renderer.componen
 import { HotCellEditorComponent } from '../editor/hot-cell-editor.component';
 import { HotCellRendererAdvancedComponent } from '../renderer/hot-cell-renderer-advanced.component';
 import { HotCellEditorAdvancedComponent } from '../editor/hot-cell-editor-advanced.component';
+declare module 'handsontable/settings' {
+    interface ColumnSettings {
+        _editorComponentReference?: ComponentRef<HotCellEditorComponent<any>>;
+        _environmentInjector?: EnvironmentInjector;
+    }
+}
 export type CustomValidatorFn<T> = (value: T) => boolean;
 export type ColumnSettings = Handsontable.ColumnSettings | {
     editor?: Type<HotCellEditorComponent<any>> | Type<HotCellEditorAdvancedComponent<any>> | Handsontable.ColumnSettings['editor'] | ExtendedEditor<any>;

package/lib/renderer/hot-cell-renderer-advanced.component.d.ts

@@ -1,33 +1,16 @@
-import Handsontable from 'handsontable/base';
+import { HotCellRendererBase } from './hot-cell-renderer-base.directive';
 import * as i0 from "@angular/core";
 /**
  * Abstract base component for creating advanced custom cell renderer components for Handsontable.
  *
- * This class provides a common interface and properties required by any custom cell renderer.
+ * Extend this component and provide your own template to implement a custom renderer.
+ * Unlike {@link HotCellRendererComponent}, this variant also accepts object and array values.
  *
  * @template TValue - The type of the component renderer.
  * @template TProps - The type of additional renderer properties.
  */
-export declare abstract class HotCellRendererAdvancedComponent<TValue extends string | number | boolean | Record<string, any> | Array<any> = string, TProps extends {} = any> {
+export declare abstract class HotCellRendererAdvancedComponent<TValue extends string | number | boolean | Record<string, any> | Array<any> = string, TProps extends {} = any> extends HotCellRendererBase<TValue, TProps> {
     static readonly RENDERER_MARKER: unique symbol;
-    value: TValue;
-    instance: Handsontable;
-    td: HTMLTableCellElement;
-    row: number;
-    col: number;
-    prop: string;
-    /**
-     * The cell properties provided by Handsontable, extended with optional renderer-specific properties.
-     */
-    cellProperties: Handsontable.CellProperties & {
-        rendererProps?: TProps;
-    };
-    /**
-     * Retrieves the renderer-specific properties from the cell properties.
-     *
-     * @returns The additional properties for the renderer.
-     */
-    getProps(): TProps;
     static ɵfac: i0.ɵɵFactoryDeclaration<HotCellRendererAdvancedComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<HotCellRendererAdvancedComponent<any, any>, "hot-cell-renderer-advanced", never, { "value": { "alias": "value"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; "td": { "alias": "td"; "required": false; }; "row": { "alias": "row"; "required": false; }; "col": { "alias": "col"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "cellProperties": { "alias": "cellProperties"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HotCellRendererAdvancedComponent<any, any>, "hot-cell-renderer-advanced", never, {}, {}, never, never, true, never>;
 }

package/lib/renderer/hot-cell-renderer-base.directive.d.ts

@@ -0,0 +1,23 @@
+import Handsontable from 'handsontable/base';
+import * as i0 from "@angular/core";
+/**
+ * Shared base directive for HotCellRendererComponent and HotCellRendererAdvancedComponent.
+ * Holds all @Input() properties and getProps() that both renderer variants share.
+ *
+ * @template TValue - The type of the rendered cell value.
+ * @template TProps - The type of additional renderer properties.
+ */
+export declare abstract class HotCellRendererBase<TValue extends string | number | boolean | Record<string, any> | Array<any> = string, TProps extends {} = any> {
+    value: TValue;
+    instance: Handsontable;
+    td: HTMLTableCellElement;
+    row: number;
+    col: number;
+    prop: string | number;
+    cellProperties: Handsontable.CellProperties & {
+        rendererProps?: TProps;
+    };
+    getProps(): TProps;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotCellRendererBase<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HotCellRendererBase<any, any>, never, never, { "value": { "alias": "value"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; "td": { "alias": "td"; "required": false; }; "row": { "alias": "row"; "required": false; }; "col": { "alias": "col"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "cellProperties": { "alias": "cellProperties"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/renderer/hot-cell-renderer.component.d.ts

@@ -1,33 +1,17 @@
-import Handsontable from 'handsontable/base';
+import { HotCellRendererBase } from './hot-cell-renderer-base.directive';
 import * as i0 from "@angular/core";
 /**
  * Abstract base component for creating custom cell renderer components for Handsontable.
  *
- * This class provides a common interface and properties required by any custom cell renderer.
+ * Extend this component and provide your own template to implement a custom renderer.
+ * Value type is limited to primitives (`string | number | boolean`).
+ * For object and array values use {@link HotCellRendererAdvancedComponent}.
  *
  * @template TValue - The type of the component renderer.
  * @template TProps - The type of additional renderer properties.
  */
-export declare abstract class HotCellRendererComponent<TValue extends string | number | boolean = string, TProps extends {} = any> {
+export declare abstract class HotCellRendererComponent<TValue extends string | number | boolean = string, TProps extends {} = any> extends HotCellRendererBase<TValue, TProps> {
     static readonly RENDERER_MARKER: unique symbol;
-    value: TValue;
-    instance: Handsontable;
-    td: HTMLTableCellElement;
-    row: number;
-    col: number;
-    prop: string;
-    /**
-     * The cell properties provided by Handsontable, extended with optional renderer-specific properties.
-     */
-    cellProperties: Handsontable.CellProperties & {
-        rendererProps?: TProps;
-    };
-    /**
-     * Retrieves the renderer-specific properties from the cell properties.
-     *
-     * @returns The additional properties for the renderer.
-     */
-    getProps(): TProps;
     static ɵfac: i0.ɵɵFactoryDeclaration<HotCellRendererComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<HotCellRendererComponent<any, any>, "hot-cell-renderer", never, { "value": { "alias": "value"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; "td": { "alias": "td"; "required": false; }; "row": { "alias": "row"; "required": false; }; "col": { "alias": "col"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "cellProperties": { "alias": "cellProperties"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HotCellRendererComponent<any, any>, "hot-cell-renderer", never, {}, {}, never, never, true, never>;
 }

package/lib/renderer/hot-dynamic-renderer-component.service.d.ts

@@ -39,6 +39,11 @@ export declare function isAdvancedHotCellRendererComponent(obj: any): obj is Typ
 export declare class DynamicComponentService {
     private appRef;
     private environmentInjector;
+    private readonly _tdComponentRefs;
+    private readonly _tdEmbeddedViews;
+    private readonly _instanceComponentRefs;
+    private readonly _instanceEmbeddedViews;
+    private readonly _hookedInstances;
     constructor(appRef: ApplicationRef, environmentInjector: EnvironmentInjector);
     /**
      * Creates a custom renderer function for Handsontable from an Angular component or TemplateRef.
@@ -59,13 +64,67 @@ export declare class DynamicComponentService {
      * @param register - If true, registers the renderer with Handsontable using the component's name.
      * @returns A renderer function that can be used in Handsontable's configuration.
      */
-    createRendererWithFactory(component: Type<HotCellRendererAdvancedComponent>, componentProps?: Record<string, any>, register?: boolean): (instance: Handsontable.Core, td: HTMLTableCellElement, row: number, column: number, prop: string | number, value: any, cellProperties: Handsontable.CellProperties) => void;
+    createRendererWithFactory(component: Type<HotCellRendererAdvancedComponent>, componentProps?: Record<string, any>, register?: boolean): (instance: Handsontable, td: HTMLTableCellElement, row: number, column: number, prop: string | number, value: unknown, cellProperties: import("handsontable/settings").CellProperties) => void;
+    /**
+     * Destroys all renderer components and embedded views attached to cells within a container element.
+     * Must be called before destroying the Handsontable instance to prevent Angular component leaks.
+     *
+     * @param container - The root DOM element of the Handsontable instance.
+     * @param instance - The Handsontable instance whose registries should be torn down. When omitted
+     *   (e.g. test stubs), only refs reachable through TDs still in the container are destroyed.
+     */
+    cleanupContainer(container: HTMLElement, instance?: Handsontable.Core): void;
+    /**
+     * Registers a one-time `afterViewRender` hook on the given Handsontable instance that sweeps
+     * renderer refs whose TD is no longer connected to the document. Handsontable recycles a pool of
+     * TD elements while virtualizing rows; cells that leave the viewport are never re-rendered, so
+     * without this sweep their Angular components stay attached to ApplicationRef and leak.
+     *
+     * Guarded against instances that do not expose `addHook` (e.g. test stubs).
+     *
+     * @param instance - The Handsontable instance whose render cycle drives the sweep.
+     */
+    private registerSweepHook;
+    /**
+     * Destroys every renderer ref/view tracked for the given instance whose root node is no longer
+     * attached to the document.
+     *
+     * @param instance - The Handsontable instance whose registries should be swept.
+     */
+    private sweepDetachedViews;
+    /**
+     * @returns True if any of the view's root nodes is still connected to the document.
+     */
+    private isViewConnected;
+    /**
+     * Destroys the renderer ref/view previously attached to a cell and clears the cell content,
+     * so a fresh renderer can take over the TD without leaking the old one.
+     *
+     * @param instance - The Handsontable instance owning the cell, used to update its registries.
+     * @param td - The table cell whose previous content should be torn down.
+     */
+    private replaceCellContent;
+    /**
+     * Tracks a component ref both by its TD (for fast replacement) and in the instance registry
+     * (for sweeping and full teardown).
+     */
+    private trackComponentRef;
+    /**
+     * Tracks an embedded view both by its TD (for fast replacement) and in the instance registry
+     * (for sweeping and full teardown).
+     */
+    private trackEmbeddedView;
+    /**
+     * Returns the per-instance registry set for the given instance, creating it on first use.
+     */
+    private registryFor;
     /**
      * Attaches an embedded view created from a TemplateRef to a given DOM element.
      *
      * @param template - The TemplateRef to create an embedded view from.
      * @param tdEl - The target DOM element (a table cell) to which the view will be appended.
      * @param properties - Context object providing properties to be used within the template.
+     * @returns The created EmbeddedViewRef so the caller can track and destroy it later.
      */
     private attachTemplateToElement;
     /**
@@ -76,6 +135,24 @@ export declare class DynamicComponentService {
      * @returns The ComponentRef of the dynamically created component.
      */
     private createComponent;
+    /**
+     * Renders an Angular component into the given cell, recycling the component already attached to
+     * the TD when it is of the same type. Handsontable recycles its pool of TD elements heavily while
+     * virtualizing rows, so recreating an Angular component on every re-render would cause needless
+     * teardown/instantiation churn and GC pressure. When the type matches we only refresh the inputs.
+     *
+     * @param td - The target table cell.
+     * @param component - The renderer component type to render.
+     * @param properties - The renderer parameters to feed as component inputs.
+     */
+    private renderComponent;
+    /**
+     * Assigns every renderer parameter as an input on the given component ref.
+     *
+     * @param componentRef - The component ref whose inputs should be set.
+     * @param rendererParameters - The renderer parameters to assign.
+     */
+    private applyInputs;
     /**
      * Attaches a dynamically created component's view to a specified DOM container element.
      *
@@ -86,9 +163,21 @@ export declare class DynamicComponentService {
     /**
      * Destroys a dynamically created component and detaches its view from the Angular application.
      *
+     * Idempotent: a TD recycled after `sweepDetachedViews` already destroyed its ref still maps to that
+     * stale ref in `_tdComponentRefs`, so the next render path may reach this with an already-destroyed
+     * ref. Guarding on `destroyed` skips the redundant detach/destroy instead of relying on Angular's
+     * internal no-op behaviour.
+     *
      * @param componentRef - The reference to the component to be destroyed.
      */
     destroyComponent<T>(componentRef: ComponentRef<T>): void;
+    /**
+     * Destroys an embedded view. Idempotent for the same reason as {@link destroyComponent}: a recycled
+     * TD can still map to an already-destroyed view in `_tdEmbeddedViews`.
+     *
+     * @param view - The embedded view to destroy.
+     */
+    private destroyEmbeddedView;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentService>;
 }

package/lib/services/hot-settings-resolver.service.d.ts

@@ -1,6 +1,7 @@
 import { EnvironmentInjector, NgZone } from '@angular/core';
 import { DynamicComponentService } from '../renderer/hot-dynamic-renderer-component.service';
 import { GridSettings, GridSettingsInternal } from '../models/grid-settings';
+import { ColumnSettings } from '../models/column-settings';
 import * as i0 from "@angular/core";
 /**
  * Service to resolve and apply custom settings for Handsontable settings object.
@@ -13,9 +14,12 @@ export declare class HotSettingsResolver {
     /**
      * Applies custom settings to the provided GridSettings.
      * @param settings The original grid settings.
+     * @param previousColumns The previously resolved columns (from the prior settings cycle). When
+     *   supplied, an editor component already created for a column whose editor type is unchanged is
+     *   recycled instead of being recreated, avoiding needless Angular component teardown/rebuild.
      * @returns The merged grid settings with custom settings applied.
      */
-    applyCustomSettings(settings: GridSettings): GridSettingsInternal;
+    applyCustomSettings(settings: GridSettings, previousColumns?: ColumnSettings[]): GridSettingsInternal;
     /**
      * Ensures that hook callbacks in the provided grid settings run inside Angular's zone.
      *
@@ -29,9 +33,33 @@ export declare class HotSettingsResolver {
     private updateColumnRendererForGivenCustomRenderer;
     /**
      * Updates the column editor for columns with a custom editor.
+     *
+     * Iterates by original column index (not a filtered subset) so each column can be matched against
+     * the column at the same index in `previousColumns` for editor-component recycling.
+     *
      * @param mergedSettings The merged grid settings.
+     * @param previousColumns The previously resolved columns, used to recycle editor components.
      */
     private updateColumnEditorForGivenCustomEditor;
+    /**
+     * Returns the previous column's editor component ref when it can be reused for the new column, or
+     * `undefined` to signal a fresh component is needed.
+     *
+     * A ref is only recycled when, at the same index, both the editor component type AND the logical
+     * column identity (its `data` binding) are unchanged. The component-type check alone would already
+     * be functionally safe — a Handsontable editor is not per-cell rendered state but a single
+     * on-demand component that `BaseEditorAdapter`/`FactoryEditorAdapter` re-prepare on every edit
+     * (`prepare()` re-reads the ref from the *current* column meta and `applyPropsToEditor()` re-applies
+     * the full cell context on each `open()`). The extra `data` check is a defensive guard: when columns
+     * are reordered/shortened so a *different* logical column lands on an index, we build a fresh editor
+     * rather than carry the previous column's instance over, so no custom editor that caches
+     * column-specific config at construction can leak stale state into the new cell.
+     *
+     * @param previousColumn The column at the same index in the previous settings cycle.
+     * @param currentColumn The column now occupying this index.
+     * @param editorType The editor component type requested for the new column.
+     */
+    private reusableEditorRef;
     /**
      * Updates the column validator for columns with a custom validator.
      * @param mergedSettings The merged grid settings.

package/package.json

@@ -1 +1 @@
-{"name":"@handsontable/angular-wrapper","version":"17.1.0-rc9","description":"Best Data Grid for Angular with Spreadsheet Look and Feel.","author":"Handsoncode <hello@handsoncode.net> (https://handsoncode.net)","license":"SEE LICENSE IN LICENSE.txt","homepage":"https://handsontable.com","keywords":["handsontable","component","data","table","grid","data table","data grid","spreadsheet","sheet","excel","angular","angular component","angular grid","wrapper","pro","enterprise","sort","formulas","filter","search","conditional formatting","csv"],"repository":{"type":"git","url":"https://github.com/handsontable/handsontable.git"},"bugs":{"url":"https://github.com/handsontable/handsontable/issues"},"peerDependencies":{"@angular/core":">=16.0.0 <22.0.0","handsontable":"^17.0.0","rxjs":"^7.0.0"},"publishConfig":{"directory":"dist/hot-table","linkDirectory":true},"module":"fesm2022/handsontable-angular-wrapper.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/handsontable-angular-wrapper.mjs"}},"sideEffects":false,"optionalDependencies":{"tslib":"^2.3.0"}}
+{"name":"@handsontable/angular-wrapper","version":"18.0.0-rc1","description":"Best Data Grid for Angular with Spreadsheet Look and Feel.","author":"Handsoncode <hello@handsoncode.net> (https://handsoncode.net)","license":"SEE LICENSE IN LICENSE.txt","homepage":"https://handsontable.com","keywords":["handsontable","component","data","table","grid","data table","data grid","spreadsheet","sheet","excel","angular","angular component","angular grid","wrapper","pro","enterprise","sort","formulas","filter","search","conditional formatting","csv"],"repository":{"type":"git","url":"https://github.com/handsontable/handsontable.git"},"bugs":{"url":"https://github.com/handsontable/handsontable/issues"},"peerDependencies":{"@angular/core":">=16.0.0 <23.0.0","handsontable":"^18.0.0","rxjs":"^7.0.0"},"publishConfig":{"directory":"dist/hot-table","linkDirectory":true},"module":"fesm2022/handsontable-angular-wrapper.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/handsontable-angular-wrapper.mjs"}},"sideEffects":false,"optionalDependencies":{"tslib":"^2.3.0"}}