@handsontable/angular-wrapper 0.0.0-next-7e304b5-20250401

package/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) HANDSONCODE sp. z o. o.
+
+HANDSONTABLE is a software distributed by HANDSONCODE sp. z o. o., a Polish corporation based in
+Gdynia, Poland, at Aleja Zwyciestwa 96-98, registered by the District Court in Gdansk under number
+538651, EU tax ID number: PL5862294002, share capital: PLN 62,800.00.
+
+This software is protected by applicable copyright laws, including international treaties, and dual-
+licensed - depending on whether your use for commercial purposes, meaning intended for or
+resulting in commercial advantage or monetary compensation, or not.
+
+If your use is strictly personal or solely for evaluation purposes, meaning for the purposes of testing
+the suitability, performance, and usefulness of this software outside the production environment,
+you agree to be bound by the terms included in the "handsontable-non-commercial-license.pdf" file.
+
+Your use of this software for commercial purposes is subject to the terms included in an applicable
+license agreement.
+
+In any case, you must not make any such use of this software as to develop software which may be
+considered competitive with this software.
+
+UNLESS EXPRESSLY AGREED OTHERWISE, HANDSONCODE PROVIDES THIS SOFTWARE ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, AND IN NO EVENT AND UNDER NO
+LEGAL THEORY, SHALL HANDSONCODE BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
+INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
+USE OR INABILITY TO USE THIS SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+##  New Angular wrapper for Handsontable.
+
+WORK IN PROGRESS AS OF MAR 2025
+
+Release candidate - not ready to production.

package/esm2022/handsontable-angular-wrapper.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZHNvbnRhYmxlLWFuZ3VsYXItd3JhcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvaGFuZHNvbnRhYmxlLWFuZ3VsYXItd3JhcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/editor/base-editor-adapter.mjs

@@ -0,0 +1,180 @@
+import Handsontable from 'handsontable';
+import { createComponent, } from '@angular/core';
+import { CustomEditorPlaceholderComponent } from './custom-editor-placeholder.component';
+import { take } from 'rxjs';
+/**
+ * Adapter for BaseEditor from Handsontable.
+ */
+export class BaseEditorAdapter extends Handsontable.editors.BaseEditor {
+    /** Reference to the custom editor component. */
+    _componentRef;
+    /** Reference to the editor placeholder component. */
+    _editorPlaceHolderRef;
+    /** Flag indicating whether the placeholder is ready. */
+    _isPlaceholderReady = false;
+    /** Subscription for the finish edit event. */
+    _finishEditSubscription;
+    /** Subscription for the cancel edit event. */
+    _cancelEditSubscription;
+    /**
+     * Creates an instance of BaseEditorAdapter.
+     * @param instance The Handsontable instance.
+     */
+    constructor(instance) {
+        super(instance);
+        this.hot.addHook('afterRowResize', this.onAfterRowResize.bind(this));
+        this.hot.addHook('afterColumnResize', this.onAfterColumnResize.bind(this));
+        this.hot.addHook('afterDestroy', this.onAfterDestroy.bind(this));
+    }
+    /**
+     * Prepares the editor for editing. Parameters are passed from Handsontable.
+     * @param row The row index.
+     * @param column The column index.
+     * @param prop The property name.
+     * @param TD The table cell element.
+     * @param originalValue The original value of the cell.
+     * @param cellProperties The cell properties.
+     */
+    prepare(row, column, prop, TD, originalValue, cellProperties) {
+        if (!this.isOpened()) {
+            super.prepare(row, column, prop, TD, originalValue, cellProperties);
+            const columnMeta = this.hot.getColumnMeta(column);
+            if (!this._isPlaceholderReady) {
+                this.createEditorPlaceholder(columnMeta._environmentInjector);
+                this._isPlaceholderReady = true;
+            }
+            this._componentRef = columnMeta._editorComponentReference;
+            if (this._finishEditSubscription) {
+                this._finishEditSubscription.unsubscribe();
+                this._finishEditSubscription = undefined;
+            }
+            if (this._cancelEditSubscription) {
+                this._cancelEditSubscription.unsubscribe();
+                this._cancelEditSubscription = undefined;
+            }
+            this._finishEditSubscription = this._componentRef.instance.finishEdit
+                .pipe(take(1))
+                .subscribe(() => {
+                this.finishEditing();
+            });
+            this._cancelEditSubscription = this._componentRef.instance.cancelEdit
+                .pipe(take(1))
+                .subscribe(() => {
+                this.cancelChanges();
+            });
+        }
+    }
+    /**
+     * Closes the editor. This event is triggered by Handsontable.
+     */
+    close() {
+        if (this.isOpened()) {
+            this.resetEditorState();
+            this._editorPlaceHolderRef.changeDetectorRef.detectChanges();
+            this._editorPlaceHolderRef.instance.detachEditor();
+            this._componentRef.instance.onClose();
+        }
+    }
+    /**
+     * Focuses the editor. This event is triggered by Handsontable.
+     */
+    focus() {
+        this._componentRef.instance.onFocus();
+    }
+    /**
+     * Gets the value from the editor.
+     * @returns The value from the editor.
+     */
+    getValue() {
+        return this._componentRef.instance?.getValue();
+    }
+    /**
+     * Opens the editor. This event is triggered by Handsontable.
+     * When opening, we set the shortcut context to 'editor'.
+     * This allows the built-in keyboard shortcuts to operate within the editor.
+     * @param event The event that triggered the opening of the editor.
+     * @remarks When entering edit mode using double-click, keyboard shortcuts do not work.
+     */
+    open(event) {
+        this.hot.getShortcutManager().setActiveContextName('editor');
+        this.applyPropsToEditor();
+        this._componentRef.instance.onOpen(event);
+    }
+    /**
+     * Sets the value for the custom editor.
+     * @param newValue The value to set.
+     */
+    setValue(newValue) {
+        this._componentRef.instance?.setValue(newValue);
+        this._componentRef.changeDetectorRef.detectChanges();
+    }
+    /**
+     * Applies properties to the custom editor and editor placeholder.
+     */
+    applyPropsToEditor() {
+        const rect = this.getEditedCellRect();
+        if (!this.isInFullEditMode()) {
+            this._componentRef.instance.setValue(null);
+        }
+        this._componentRef.setInput('originalValue', this.originalValue);
+        this._componentRef.setInput('row', this.row);
+        this._componentRef.setInput('column', this.col);
+        this._componentRef.setInput('prop', this.prop);
+        this._componentRef.setInput('cellProperties', this.cellProperties);
+        this._editorPlaceHolderRef.setInput('top', rect.top);
+        this._editorPlaceHolderRef.setInput('left', rect.start);
+        this._editorPlaceHolderRef.setInput('height', rect.height);
+        this._editorPlaceHolderRef.setInput('width', rect.width);
+        this._editorPlaceHolderRef.setInput('isVisible', true);
+        this._editorPlaceHolderRef.setInput('componentRef', this._componentRef);
+        this._editorPlaceHolderRef.changeDetectorRef.detectChanges();
+    }
+    /**
+     * Creates the editor placeholder and append it to hot rootElement.
+     * @param injector The environment injector.
+     */
+    createEditorPlaceholder(injector) {
+        this._editorPlaceHolderRef = createComponent(CustomEditorPlaceholderComponent, {
+            environmentInjector: injector,
+        });
+        this.hot.rootElement.appendChild(this._editorPlaceHolderRef.location.nativeElement);
+    }
+    /**
+     * Handles the after column resize event.
+     * Helps adjust the editor size to the column size and update its position.
+     */
+    onAfterColumnResize() {
+        if (this.isOpened()) {
+            this.applyPropsToEditor();
+        }
+    }
+    /**
+     * Handles the after row resize event.
+     * Helps adjust the editor size to the column size and update its position.
+     */
+    onAfterRowResize() {
+        if (this.isOpened()) {
+            this.applyPropsToEditor();
+        }
+    }
+    /**
+     * Handles the after destroy event.
+     */
+    onAfterDestroy() {
+        this._editorPlaceHolderRef?.destroy();
+    }
+    /**
+     * Resets the editor placeholder state.
+     * We need to reset the editor placeholder state because we use it
+     * to store multiple references to the custom editor.
+     */
+    resetEditorState() {
+        this._editorPlaceHolderRef.setInput('top', undefined);
+        this._editorPlaceHolderRef.setInput('left', undefined);
+        this._editorPlaceHolderRef.setInput('height', undefined);
+        this._editorPlaceHolderRef.setInput('width', undefined);
+        this._editorPlaceHolderRef.setInput('isVisible', false);
+        this._editorPlaceHolderRef.setInput('componentRef', undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-editor-adapter.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/editor/base-editor-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import Handsontable from 'handsontable';\nimport {\n  ComponentRef,\n  createComponent,\n  EnvironmentInjector,\n} from '@angular/core';\nimport { CustomEditorPlaceholderComponent } from './custom-editor-placeholder.component';\nimport { ColumnSettingsInternal } from '../models/column-settings';\nimport { HotCellEditorComponent } from './hot-cell-editor.component';\nimport { Subscription, take } from 'rxjs';\n\n/**\n * Adapter for BaseEditor from Handsontable.\n */\nexport class BaseEditorAdapter extends Handsontable.editors.BaseEditor {\n  /** Reference to the custom editor component. */\n  private _componentRef?: ComponentRef<HotCellEditorComponent<any>>;\n\n  /** Reference to the editor placeholder component. */\n  private _editorPlaceHolderRef: ComponentRef<CustomEditorPlaceholderComponent>;\n\n  /** Flag indicating whether the placeholder is ready. */\n  private _isPlaceholderReady = false;\n\n  /** Subscription for the finish edit event. */\n  private _finishEditSubscription?: Subscription;\n\n  /** Subscription for the cancel edit event. */\n  private _cancelEditSubscription?: Subscription;\n\n  /**\n   * Creates an instance of BaseEditorAdapter.\n   * @param instance The Handsontable instance.\n   */\n  constructor(instance: Handsontable.Core) {\n    super(instance);\n\n    this.hot.addHook('afterRowResize', this.onAfterRowResize.bind(this));\n    this.hot.addHook('afterColumnResize', this.onAfterColumnResize.bind(this));\n    this.hot.addHook('afterDestroy', this.onAfterDestroy.bind(this));\n  }\n\n  /**\n   * Prepares the editor for editing. Parameters are passed from Handsontable.\n   * @param row The row index.\n   * @param column The column index.\n   * @param prop The property name.\n   * @param TD The table cell element.\n   * @param originalValue The original value of the cell.\n   * @param cellProperties The cell properties.\n   */\n  override prepare(\n    row: number,\n    column: number,\n    prop: string | number,\n    TD: HTMLTableCellElement,\n    originalValue: any,\n    cellProperties: Handsontable.CellProperties\n  ): void {\n    if (!this.isOpened()) {\n      super.prepare(row, column, prop, TD, originalValue, cellProperties);\n      const columnMeta: ColumnSettingsInternal = this.hot.getColumnMeta(\n        column\n      ) as ColumnSettingsInternal;\n\n      if (!this._isPlaceholderReady) {\n        this.createEditorPlaceholder(columnMeta._environmentInjector);\n        this._isPlaceholderReady = true;\n      }\n\n      this._componentRef = columnMeta._editorComponentReference;\n\n      if (this._finishEditSubscription) {\n        this._finishEditSubscription.unsubscribe();\n        this._finishEditSubscription = undefined;\n      }\n\n      if (this._cancelEditSubscription) {\n        this._cancelEditSubscription.unsubscribe();\n        this._cancelEditSubscription = undefined;\n      }\n\n      this._finishEditSubscription = this._componentRef.instance.finishEdit\n        .pipe(take(1))\n        .subscribe(() => {\n          this.finishEditing();\n        });\n\n      this._cancelEditSubscription = this._componentRef.instance.cancelEdit\n        .pipe(take(1))\n        .subscribe(() => {\n          this.cancelChanges();\n        });\n    }\n  }\n\n  /**\n   * Closes the editor. This event is triggered by Handsontable.\n   */\n  close(): void {\n    if (this.isOpened()) {\n      this.resetEditorState();\n      this._editorPlaceHolderRef.changeDetectorRef.detectChanges();\n      this._editorPlaceHolderRef.instance.detachEditor();\n      this._componentRef.instance.onClose();\n    }\n  }\n\n  /**\n   * Focuses the editor. This event is triggered by Handsontable.\n   */\n  focus(): void {\n    this._componentRef.instance.onFocus();\n  }\n\n  /**\n   * Gets the value from the editor.\n   * @returns The value from the editor.\n   */\n  getValue(): any {\n    return this._componentRef.instance?.getValue();\n  }\n\n  /**\n   * Opens the editor. This event is triggered by Handsontable.\n   * When opening, we set the shortcut context to 'editor'.\n   * This allows the built-in keyboard shortcuts to operate within the editor.\n   * @param event The event that triggered the opening of the editor.\n   * @remarks When entering edit mode using double-click, keyboard shortcuts do not work.\n   */\n  open(event?: Event): void {\n    this.hot.getShortcutManager().setActiveContextName('editor');\n    this.applyPropsToEditor();\n    this._componentRef.instance.onOpen(event);\n  }\n\n  /**\n   * Sets the value for the custom editor.\n   * @param newValue The value to set.\n   */\n  setValue(newValue?: any): void {\n    this._componentRef.instance?.setValue(newValue);\n    this._componentRef.changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Applies properties to the custom editor and editor placeholder.\n   */\n  private applyPropsToEditor(): void {\n    const rect = this.getEditedCellRect();\n\n    if (!this.isInFullEditMode()) {\n      this._componentRef.instance.setValue(null);\n    }\n\n    this._componentRef.setInput('originalValue', this.originalValue);\n    this._componentRef.setInput('row', this.row);\n    this._componentRef.setInput('column', this.col);\n    this._componentRef.setInput('prop', this.prop);\n    this._componentRef.setInput('cellProperties', this.cellProperties);\n\n    this._editorPlaceHolderRef.setInput('top', rect.top);\n    this._editorPlaceHolderRef.setInput('left', rect.start);\n    this._editorPlaceHolderRef.setInput('height', rect.height);\n    this._editorPlaceHolderRef.setInput('width', rect.width);\n    this._editorPlaceHolderRef.setInput('isVisible', true);\n    this._editorPlaceHolderRef.setInput('componentRef', this._componentRef);\n    this._editorPlaceHolderRef.changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Creates the editor placeholder and append it to hot rootElement.\n   * @param injector The environment injector.\n   */\n  private createEditorPlaceholder(injector: EnvironmentInjector): void {\n    this._editorPlaceHolderRef = createComponent(\n      CustomEditorPlaceholderComponent,\n      {\n        environmentInjector: injector as EnvironmentInjector,\n      }\n    );\n\n    this.hot.rootElement.appendChild(\n      this._editorPlaceHolderRef.location.nativeElement\n    );\n  }\n\n  /**\n   * Handles the after column resize event.\n   * Helps adjust the editor size to the column size and update its position.\n   */\n  private onAfterColumnResize(): void {\n    if (this.isOpened()) {\n      this.applyPropsToEditor();\n    }\n  }\n\n  /**\n   * Handles the after row resize event.\n   * Helps adjust the editor size to the column size and update its position.\n   */\n  private onAfterRowResize(): void {\n    if (this.isOpened()) {\n      this.applyPropsToEditor();\n    }\n  }\n\n  /**\n   * Handles the after destroy event.\n   */\n  private onAfterDestroy(): void {\n    this._editorPlaceHolderRef?.destroy();\n  }\n\n  /**\n   * Resets the editor placeholder state.\n   * We need to reset the editor placeholder state because we use it\n   * to store multiple references to the custom editor.\n   */\n  private resetEditorState(): void {\n    this._editorPlaceHolderRef.setInput('top', undefined);\n    this._editorPlaceHolderRef.setInput('left', undefined);\n    this._editorPlaceHolderRef.setInput('height', undefined);\n    this._editorPlaceHolderRef.setInput('width', undefined);\n    this._editorPlaceHolderRef.setInput('isVisible', false);\n    this._editorPlaceHolderRef.setInput('componentRef', undefined);\n  }\n}\n"]}

package/esm2022/lib/editor/custom-editor-placeholder.component.mjs

@@ -0,0 +1,86 @@
+import { ChangeDetectionStrategy, Component, Input, ViewChild, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Component representing a placeholder for a custom editor in Handsontable.
+ * It is used only within the wrapper.
+ */
+export class CustomEditorPlaceholderComponent {
+    /** The top position of the editor. */
+    top;
+    /** The left position of the editor. */
+    left;
+    /** The height of the editor. */
+    height;
+    /** The width of the editor. */
+    width;
+    set isVisible(value) {
+        this._isVisible = value;
+    }
+    /** The reference to the component instance of the editor. */
+    set componentRef(hotEditorComponentRef) {
+        if (hotEditorComponentRef) {
+            this.container.insert(hotEditorComponentRef.hostView);
+        }
+    }
+    /** The container for the editor's input placeholder. */
+    container;
+    /** The display style of the editor. */
+    get display() {
+        return this._isVisible ? 'block' : 'none';
+    }
+    _isVisible = false;
+    /**
+     * Detaches the container from the Handsontable.
+     */
+    detachEditor() {
+        this.container.detach();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CustomEditorPlaceholderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: CustomEditorPlaceholderComponent, selector: "ng-component", inputs: { top: "top", left: "left", height: "height", width: "width", isVisible: "isVisible", componentRef: "componentRef" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["inputPlaceholder"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: ` <div
+    class="handsontableInputHolder ht_clone_master"
+    [style.display]="display"
+    [style.width.px]="width"
+    [style.height.px]="height"
+    [style.maxWidth.px]="width"
+    [style.maxHeight.px]="height"
+    [style.top.px]="top"
+    [style.left.px]="left"
+  >
+    <ng-template #inputPlaceholder></ng-template>
+  </div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CustomEditorPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ` <div
+    class="handsontableInputHolder ht_clone_master"
+    [style.display]="display"
+    [style.width.px]="width"
+    [style.height.px]="height"
+    [style.maxWidth.px]="width"
+    [style.maxHeight.px]="height"
+    [style.top.px]="top"
+    [style.left.px]="left"
+  >
+    <ng-template #inputPlaceholder></ng-template>
+  </div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: false,
+                }]
+        }], propDecorators: { top: [{
+                type: Input
+            }], left: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], isVisible: [{
+                type: Input
+            }], componentRef: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['inputPlaceholder', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/editor/hot-cell-editor.component.mjs

@@ -0,0 +1,94 @@
+import { Directive, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Abstract class representing a Handsontable editor in angular.
+ */
+export class HotCellEditorComponent {
+    /** The tabindex attribute for the editor. */
+    tabindex = -1;
+    /** The data-hot-input attribute for the editor. */
+    dataHotInput = '';
+    /** The handsontableInput class for the editor. */
+    handsontableInputClass = true;
+    /** The height of the editor as a percentage of the parent container. */
+    heightFitParentContainer = 100;
+    /** The width of the editor as a percentage of the parent container. */
+    widthFitParentContainer = 100;
+    /** The row index of the cell being edited. */
+    row;
+    /** The column index of the cell being edited. */
+    column;
+    /** The property name of the cell being edited. */
+    prop;
+    /** The original value of the cell being edited. */
+    originalValue;
+    /** The cell properties of the cell being edited. */
+    cellProperties;
+    /** Event emitted when the edit is finished.
+     * The data will be saved to the model.
+     */
+    finishEdit = new EventEmitter();
+    /** Event emitted when the edit is canceled.
+     * The entered data will be reverted to the original value.
+     */
+    cancelEdit = new EventEmitter();
+    /** The current value of the editor. */
+    _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. */
+    onClose() { }
+    /** 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. */
+    onOpen(event) { }
+    /**
+     * Gets the current value of the editor.
+     * @returns The current value of the editor.
+     */
+    getValue() {
+        return this._value;
+    }
+    /**
+     * Sets the current value of the editor.
+     * @param value The value to set.
+     */
+    setValue(value) {
+        this._value = value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: HotCellEditorComponent, inputs: { row: "row", column: "column", prop: "prop", originalValue: "originalValue", cellProperties: "cellProperties" }, outputs: { finishEdit: "finishEdit", cancelEdit: "cancelEdit" }, host: { properties: { "attr.tabindex": "this.tabindex", "attr.data-hot-input": "this.dataHotInput", "class.handsontableInput": "this.handsontableInputClass", "style.height.%": "this.heightFitParentContainer", "style.width.%": "this.widthFitParentContainer" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellEditorComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], dataHotInput: [{
+                type: HostBinding,
+                args: ['attr.data-hot-input']
+            }], handsontableInputClass: [{
+                type: HostBinding,
+                args: ['class.handsontableInput']
+            }], heightFitParentContainer: [{
+                type: HostBinding,
+                args: ['style.height.%']
+            }], widthFitParentContainer: [{
+                type: HostBinding,
+                args: ['style.width.%']
+            }], row: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], originalValue: [{
+                type: Input
+            }], cellProperties: [{
+                type: Input
+            }], finishEdit: [{
+                type: Output
+            }], cancelEdit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/hot-table.component.mjs

@@ -0,0 +1,139 @@
+import { Component, Input, ViewChild, ViewEncapsulation, } from '@angular/core';
+import Handsontable from 'handsontable/base';
+import { HotSettingsResolver } from './services/hot-settings-resolver.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/hot-settings-resolver.service";
+import * as i2 from "./services/hot-config.service";
+export const HOT_DESTROYED_WARNING = 'The Handsontable instance bound to this component was destroyed and cannot be' +
+    ' used properly.';
+export class HotTableComponent {
+    _hotSettingsResolver;
+    _hotConfig;
+    ngZone;
+    // component inputs
+    /** The settings for the Handsontable instance. */
+    settings;
+    /** The container element for the Handsontable instance. */
+    container;
+    /** The Handsontable instance. */
+    __hotInstance = null;
+    configSubscription;
+    constructor(_hotSettingsResolver, _hotConfig, ngZone) {
+        this._hotSettingsResolver = _hotSettingsResolver;
+        this._hotConfig = _hotConfig;
+        this.ngZone = ngZone;
+    }
+    /**
+     * Gets the Handsontable instance.
+     * @returns The Handsontable instance or `null` if it's not yet been created or has been destroyed.
+     */
+    get hotInstance() {
+        if (!this.__hotInstance ||
+            (this.__hotInstance && !this.__hotInstance.isDestroyed)) {
+            // Will return the Handsontable instance or `null` if it's not yet been created.
+            return this.__hotInstance;
+        }
+        else {
+            console.warn(HOT_DESTROYED_WARNING);
+            return null;
+        }
+    }
+    /**
+     * Sets the Handsontable instance.
+     * @param hotInstance The Handsontable instance to set.
+     */
+    set hotInstance(hotInstance) {
+        this.__hotInstance = hotInstance;
+    }
+    /**
+     * Initializes the Handsontable instance after the view has been initialized.
+     * The initial settings of the table are also prepared here
+     */
+    ngAfterViewInit() {
+        let options = this._hotSettingsResolver.applyCustomSettings(this.settings);
+        const negotiatedSettings = this.getNegotiatedSettings(options);
+        options = { ...options, ...negotiatedSettings };
+        this.ngZone.runOutsideAngular(() => {
+            this.hotInstance = new Handsontable.Core(this.container.nativeElement, options);
+            // @ts-ignore
+            this.hotInstance.init();
+        });
+        this.configSubscription = this._hotConfig.config$.subscribe((config) => {
+            if (this.hotInstance) {
+                const negotiatedSettings = this.getNegotiatedSettings(this.settings);
+                this.updateHotTable(negotiatedSettings);
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        if (this.hotInstance === null) {
+            return;
+        }
+        if (changes.settings && !changes.settings.firstChange) {
+            const newOptions = this._hotSettingsResolver.applyCustomSettings(changes.settings.currentValue);
+            this.updateHotTable(newOptions);
+        }
+    }
+    /**
+     * Destroys the Handsontable instance and clears the columns from custom editors.
+     */
+    ngOnDestroy() {
+        this.ngZone.runOutsideAngular(() => {
+            if (this.hotInstance) {
+                this.hotInstance.getSettings().columns
+                    ?.filter((column) => column._editorComponentReference)
+                    .forEach((column) => {
+                    column._editorComponentReference?.destroy();
+                });
+                this.hotInstance.destroy();
+            }
+        });
+        this.configSubscription.unsubscribe();
+    }
+    /**
+     * Updates the Handsontable instance with new settings.
+     * @param newSettings The new settings to apply to the Handsontable instance.
+     */
+    updateHotTable(newSettings) {
+        if (!this.hotInstance) {
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.hotInstance?.updateSettings(newSettings, false);
+        });
+    }
+    /**
+     * Merges the provided Handsontable grid settings with the global configuration.
+     *
+     * This method retrieves the global configuration from the HotConfigService and negotiates the final
+     * Handsontable settings by giving precedence to the provided settings.
+     * Additionally, the `layoutDirection` is only merged if the Handsontable instance has not yet been initialized.
+     *
+     * @param settings - The grid settings provided by the user or component.
+     * @returns The final negotiated grid settings after merging with global defaults.
+     */
+    getNegotiatedSettings(settings) {
+        const hotConfig = this._hotConfig.getConfig();
+        const negotiatedSettings = {};
+        negotiatedSettings.licenseKey = settings.licenseKey ?? hotConfig.license;
+        negotiatedSettings.themeName = settings.themeName ?? hotConfig.themeName;
+        negotiatedSettings.language = settings.language ?? hotConfig.language;
+        // settings that can be set only before the Handsontable instance is initialized
+        if (!this.__hotInstance) {
+            negotiatedSettings.layoutDirection = settings.layoutDirection ?? hotConfig.layoutDirection;
+        }
+        return negotiatedSettings;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotTableComponent, deps: [{ token: i1.HotSettingsResolver }, { token: i2.HotConfigService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: HotTableComponent, selector: "hot-table", inputs: { settings: "settings" }, providers: [HotSettingsResolver], viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true }], usesOnChanges: true, ngImport: i0, template: '<div #container></div>', isInline: true, styles: [":host{display:block}\n"], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'hot-table', template: '<div #container></div>', encapsulation: ViewEncapsulation.None, providers: [HotSettingsResolver], styles: [":host{display:block}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.HotSettingsResolver }, { type: i2.HotConfigService }, { type: i0.NgZone }]; }, propDecorators: { settings: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hot-table.component.js","sourceRoot":"","sources":["../../../../projects/hot-table/src/lib/hot-table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  SimpleChanges,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport Handsontable from 'handsontable/base';\nimport { HotSettingsResolver } from './services/hot-settings-resolver.service';\nimport { HotConfigService } from './services/hot-config.service';\nimport { GridSettings } from './models/grid-settings';\nimport { ColumnSettingsInternal } from './models/column-settings';\nimport { Subscription } from 'rxjs';\n\nexport const HOT_DESTROYED_WARNING =\n  'The Handsontable instance bound to this component was destroyed and cannot be' +\n  ' used properly.';\n\n@Component({\n  selector: 'hot-table',\n  template: '<div #container></div>',\n  encapsulation: ViewEncapsulation.None,\n  providers: [HotSettingsResolver],\n  styles: [\n    `\n      :host {\n        display: block;\n      }\n    `,\n  ],\n})\nexport class HotTableComponent implements AfterViewInit, OnChanges, OnDestroy {\n  // component inputs\n  /** The settings for the Handsontable instance. */\n  @Input() settings: GridSettings;\n\n  /** The container element for the Handsontable instance. */\n  @ViewChild('container', { static: false })\n  public container: ElementRef<HTMLDivElement>;\n\n  /** The Handsontable instance. */\n  private __hotInstance: Handsontable | null = null;\n  private configSubscription: Subscription;\n\n  constructor(\n    private _hotSettingsResolver: HotSettingsResolver,\n    private _hotConfig: HotConfigService,\n    public ngZone: NgZone\n  ) {}\n\n  /**\n   * Gets the Handsontable instance.\n   * @returns The Handsontable instance or `null` if it's not yet been created or has been destroyed.\n   */\n  public get hotInstance(): Handsontable | null {\n    if (\n      !this.__hotInstance ||\n      (this.__hotInstance && !this.__hotInstance.isDestroyed)\n    ) {\n      // Will return the Handsontable instance or `null` if it's not yet been created.\n      return this.__hotInstance;\n    } else {\n      console.warn(HOT_DESTROYED_WARNING);\n      return null;\n    }\n  }\n\n  /**\n   * Sets the Handsontable instance.\n   * @param hotInstance The Handsontable instance to set.\n   */\n  private set hotInstance(hotInstance) {\n    this.__hotInstance = hotInstance;\n  }\n\n  /**\n   * Initializes the Handsontable instance after the view has been initialized.\n   * The initial settings of the table are also prepared here\n   */\n  ngAfterViewInit(): void {\n    let options: Handsontable.GridSettings =\n      this._hotSettingsResolver.applyCustomSettings(this.settings);\n\n    const negotiatedSettings = this.getNegotiatedSettings(options);\n    options = {...options, ...negotiatedSettings};\n\n    this.ngZone.runOutsideAngular(() => {\n      this.hotInstance = new Handsontable.Core(\n        this.container.nativeElement,\n        options\n      );\n\n      // @ts-ignore\n      this.hotInstance.init();\n    });\n\n    this.configSubscription = this._hotConfig.config$.subscribe((config) => {\n      if (this.hotInstance) {\n        const negotiatedSettings = this.getNegotiatedSettings(this.settings);\n        this.updateHotTable(negotiatedSettings);\n      }\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.hotInstance === null) {\n      return;\n    }\n\n    if (changes.settings && !changes.settings.firstChange) {\n      const newOptions: Handsontable.GridSettings =\n        this._hotSettingsResolver.applyCustomSettings(\n          changes.settings.currentValue\n        );\n\n      this.updateHotTable(newOptions);\n    }\n  }\n\n  /**\n   * Destroys the Handsontable instance and clears the columns from custom editors.\n   */\n  ngOnDestroy(): void {\n    this.ngZone.runOutsideAngular(() => {\n      if (this.hotInstance) {\n        (this.hotInstance.getSettings().columns as ColumnSettingsInternal[])\n          ?.filter((column) => column._editorComponentReference)\n          .forEach((column) => {\n            column._editorComponentReference?.destroy();\n          });\n        this.hotInstance.destroy();\n      }\n    });\n\n    this.configSubscription.unsubscribe();\n  }\n\n  /**\n   * Updates the Handsontable instance with new settings.\n   * @param newSettings The new settings to apply to the Handsontable instance.\n   */\n  private updateHotTable(newSettings: Handsontable.GridSettings): void {\n    if (!this.hotInstance) {\n      return;\n    }\n\n    this.ngZone.runOutsideAngular(() => {\n      this.hotInstance?.updateSettings(newSettings, false);\n    });\n  }\n\n  /**\n   * Merges the provided Handsontable grid settings with the global configuration.\n   *\n   * This method retrieves the global configuration from the HotConfigService and negotiates the final\n   * Handsontable settings by giving precedence to the provided settings.\n   * Additionally, the `layoutDirection` is only merged if the Handsontable instance has not yet been initialized.\n   *\n   * @param settings - The grid settings provided by the user or component.\n   * @returns The final negotiated grid settings after merging with global defaults.\n   */\n  private getNegotiatedSettings(settings: Handsontable.GridSettings): Handsontable.GridSettings {\n    const hotConfig = this._hotConfig.getConfig();\n    const negotiatedSettings: Handsontable.GridSettings = {}\n\n    negotiatedSettings.licenseKey = settings.licenseKey ?? hotConfig.license;\n    negotiatedSettings.themeName = settings.themeName ?? hotConfig.themeName;\n    negotiatedSettings.language = settings.language ?? hotConfig.language;\n\n    // settings that can be set only before the Handsontable instance is initialized\n    if (!this.__hotInstance) {\n      negotiatedSettings.layoutDirection = settings.layoutDirection ?? hotConfig.layoutDirection;\n    }\n\n    return negotiatedSettings;\n  }\n}\n"]}

package/esm2022/lib/hot-table.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { HotTableComponent } from './hot-table.component';
+import { CustomEditorPlaceholderComponent } from './editor/custom-editor-placeholder.component';
+import * as i0 from "@angular/core";
+export class HotTableModule {
+    static version = '0.0.0-next-7e304b5-20250401';
+    constructor() { }
+    static forRoot() {
+        return {
+            ngModule: HotTableModule,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: HotTableModule, declarations: [HotTableComponent, CustomEditorPlaceholderComponent], exports: [HotTableComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotTableModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [HotTableComponent, CustomEditorPlaceholderComponent],
+                    imports: [],
+                    exports: [HotTableComponent],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG90LXRhYmxlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2hvdC10YWJsZS9zcmMvbGliL2hvdC10YWJsZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBdUIsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDMUQsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sOENBQThDLENBQUM7O0FBT2hHLE1BQU0sT0FBTyxjQUFjO0lBQ3pCLE1BQU0sQ0FBQyxPQUFPLEdBQUcsNkJBQTZCLENBQUM7SUFFL0MsZ0JBQWUsQ0FBQztJQUVULE1BQU0sQ0FBQyxPQUFPO1FBQ25CLE9BQU87WUFDTCxRQUFRLEVBQUUsY0FBYztTQUN6QixDQUFDO0lBQ0osQ0FBQzt3R0FUVSxjQUFjO3lHQUFkLGNBQWMsaUJBSlYsaUJBQWlCLEVBQUUsZ0NBQWdDLGFBRXhELGlCQUFpQjt5R0FFaEIsY0FBYzs7NEZBQWQsY0FBYztrQkFMMUIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxpQkFBaUIsRUFBRSxnQ0FBZ0MsQ0FBQztvQkFDbkUsT0FBTyxFQUFFLEVBQUU7b0JBQ1gsT0FBTyxFQUFFLENBQUMsaUJBQWlCLENBQUM7aUJBQzdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEhvdFRhYmxlQ29tcG9uZW50IH0gZnJvbSAnLi9ob3QtdGFibGUuY29tcG9uZW50JztcbmltcG9ydCB7IEN1c3RvbUVkaXRvclBsYWNlaG9sZGVyQ29tcG9uZW50IH0gZnJvbSAnLi9lZGl0b3IvY3VzdG9tLWVkaXRvci1wbGFjZWhvbGRlci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtIb3RUYWJsZUNvbXBvbmVudCwgQ3VzdG9tRWRpdG9yUGxhY2Vob2xkZXJDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbXSxcbiAgZXhwb3J0czogW0hvdFRhYmxlQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgSG90VGFibGVNb2R1bGUge1xuICBzdGF0aWMgdmVyc2lvbiA9ICcwLjAuMC1uZXh0LTdlMzA0YjUtMjAyNTA0MDEnO1xuXG4gIGNvbnN0cnVjdG9yKCkge31cblxuICBwdWJsaWMgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVyczxIb3RUYWJsZU1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogSG90VGFibGVNb2R1bGUsXG4gICAgfTtcbiAgfVxufVxuIl19