@handsontable/angular-wrapper 0.0.0-next-2645bc1-20260401 → 0.0.0-next-e3f6190-20260401

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/base';
+import { createComponent, } from '@angular/core';
+import { CustomEditorPlaceholderComponent } from './custom-editor-placeholder.component';
+import { take } from 'rxjs/operators';
+/**
+ * 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/base';\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 } from 'rxjs';\nimport { take } from 'rxjs/operators';\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,89 @@
+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;
+    }
+    placeholderCustomClass = 'handsontableInputHolder ht_clone_master';
+    /** 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", placeholderCustomClass: "placeholderCustomClass", componentRef: "componentRef" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["inputPlaceholder"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: ` <div
+    [class]="placeholderCustomClass"
+    [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]="placeholderCustomClass"
+    [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
+            }], placeholderCustomClass: [{
+                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/editor-factory-adapter.mjs

@@ -0,0 +1,140 @@
+import { createComponent } from '@angular/core';
+import { CustomEditorPlaceholderComponent } from './custom-editor-placeholder.component';
+import { editorFactory } from 'handsontable/editors/factory';
+import { take } from 'rxjs/operators';
+/**
+ * Factory function to create a custom Handsontable editor adapter for Angular components.
+ *
+ * This adapter integrates Angular components with Handsontable's editor system using the new
+ * editorFactory API, allowing you to use Angular components as custom cell editors while
+ * maintaining full Angular lifecycle management and change detection.
+ *
+ * @returns A custom editor class that can be used in Handsontable column settings.
+ *
+ */
+export const FactoryEditorAdapter = (componentRef) => editorFactory({
+    position: componentRef.instance.position,
+    shortcuts: componentRef.instance.shortcuts,
+    config: componentRef.instance.config,
+    init(editor) {
+        editor._componentRef = componentRef;
+        editor._editorPlaceHolderRef = undefined;
+        editor._finishEditSubscription = undefined;
+        editor._cancelEditSubscription = undefined;
+        createEditorPlaceholder(editor, editor.hot._angularEnvironmentInjector);
+        editor.input = editor._editorPlaceHolderRef.location.nativeElement;
+        editor._afterRowResizeCallback = () => {
+            if (editor.isOpened()) {
+                applyPropsToEditor(editor);
+            }
+        };
+        editor._afterColumnResizeCallback = () => {
+            if (editor.isOpened()) {
+                applyPropsToEditor(editor);
+            }
+        };
+        editor._afterDestroyCallback = () => {
+            if (editor._editorPlaceHolderRef) {
+                editor._editorPlaceHolderRef.destroy();
+            }
+        };
+        // Hooks are automatically removed by Handsontable on table destroy
+        editor.hot.addHook('afterRowResize', editor._afterRowResizeCallback);
+        editor.hot.addHook('afterColumnResize', editor._afterColumnResizeCallback);
+        editor.hot.addHook('afterDestroy', editor._afterDestroyCallback);
+    },
+    afterInit: (editor) => editor._componentRef.instance.afterInit?.(editor),
+    beforeOpen: (editor, context) => {
+        cleanupSubscriptions(editor);
+        applyPropsToEditor(editor);
+        editor._finishEditSubscription = editor._componentRef.instance.finishEdit.pipe(take(1)).subscribe(() => {
+            editor.finishEditing();
+        });
+        editor._cancelEditSubscription = editor._componentRef.instance.cancelEdit.pipe(take(1)).subscribe(() => {
+            editor.cancelChanges();
+        });
+        editor._componentRef.instance.beforeOpen?.(editor, context);
+    },
+    afterOpen: (editor, event) => {
+        editor._componentRef.instance.afterOpen?.(editor, event);
+    },
+    onFocus: (editor) => editor._componentRef.instance.onFocus?.(editor),
+    afterClose: (editor) => {
+        resetEditorState(editor);
+        editor._editorPlaceHolderRef.changeDetectorRef.detectChanges();
+        editor._editorPlaceHolderRef.instance.detachEditor();
+        editor._componentRef.instance.afterClose?.(editor);
+    },
+    getValue: (editor) => editor._componentRef.instance.getValue(),
+    setValue: (editor, value) => {
+        editor.value = value;
+        editor._componentRef.instance.setValue(value);
+        editor._componentRef.changeDetectorRef.detectChanges();
+    },
+});
+/**
+ * Creates the editor placeholder component.
+ * @param editor The editor instance.
+ * @param injector The environment injector from Angular.
+ */
+function createEditorPlaceholder(editor, injector) {
+    if (!injector) {
+        return;
+    }
+    editor._editorPlaceHolderRef = createComponent(CustomEditorPlaceholderComponent, {
+        environmentInjector: injector,
+    });
+}
+/**
+ * Applies properties to the custom Angular editor and editor placeholder.
+ * Updates position, size, and cell context information.
+ * @param editor The editor instance.
+ */
+function applyPropsToEditor(editor) {
+    if (!editor._componentRef || !editor._editorPlaceHolderRef) {
+        return;
+    }
+    editor._componentRef.setInput('originalValue', editor.originalValue);
+    editor._componentRef.setInput('row', editor.row);
+    editor._componentRef.setInput('column', editor.col);
+    editor._componentRef.setInput('prop', editor.prop);
+    editor._componentRef.setInput('cellProperties', editor.cellProperties);
+    const rect = editor.hot.getCell(editor.row, editor.col)?.getBoundingClientRect();
+    editor._editorPlaceHolderRef.setInput('placeholderCustomClass', '');
+    editor._editorPlaceHolderRef.setInput('height', rect.height);
+    editor._editorPlaceHolderRef.setInput('width', rect.width);
+    editor._editorPlaceHolderRef.setInput('isVisible', true);
+    editor._editorPlaceHolderRef.setInput('componentRef', editor._componentRef);
+    editor._editorPlaceHolderRef.changeDetectorRef.detectChanges();
+}
+/**
+ * Resets the editor placeholder state.
+ * Clears all positioning and visibility settings.
+ * @param editor The editor instance.
+ */
+function resetEditorState(editor) {
+    if (!editor._editorPlaceHolderRef) {
+        return;
+    }
+    editor._editorPlaceHolderRef.setInput('top', undefined);
+    editor._editorPlaceHolderRef.setInput('left', undefined);
+    editor._editorPlaceHolderRef.setInput('height', undefined);
+    editor._editorPlaceHolderRef.setInput('width', undefined);
+    editor._editorPlaceHolderRef.setInput('isVisible', false);
+    editor._editorPlaceHolderRef.setInput('componentRef', undefined);
+}
+/**
+ * Cleans up existing subscriptions.
+ * @param editor The editor instance.
+ */
+function cleanupSubscriptions(editor) {
+    if (editor._finishEditSubscription) {
+        editor._finishEditSubscription.unsubscribe();
+        editor._finishEditSubscription = undefined;
+    }
+    if (editor._cancelEditSubscription) {
+        editor._cancelEditSubscription.unsubscribe();
+        editor._cancelEditSubscription = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-factory-adapter.js","sourceRoot":"","sources":["../../../../../projects/hot-table/src/lib/editor/editor-factory-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, createComponent, EnvironmentInjector } from '@angular/core';\nimport { CustomEditorPlaceholderComponent } from './custom-editor-placeholder.component';\nimport { AngularEditorProperties } from './models/factory-editor-properties';\nimport { editorFactory, ExtendedEditor } from 'handsontable/editors/factory';\nimport { take } from 'rxjs/operators';\nimport { HotCellEditorAdvancedComponent } from './hot-cell-editor-advanced.component';\n\n/**\n * Combined type representing an extended editor with Angular component properties.\n * Used internally by the factory adapter to bridge Angular and Handsontable.\n */\ntype EditorInstance = ExtendedEditor<AngularEditorProperties & HotCellEditorAdvancedComponent<any>>;\n\n/**\n * Factory function to create a custom Handsontable editor adapter for Angular components.\n *\n * This adapter integrates Angular components with Handsontable's editor system using the new\n * editorFactory API, allowing you to use Angular components as custom cell editors while\n * maintaining full Angular lifecycle management and change detection.\n *\n * @returns A custom editor class that can be used in Handsontable column settings.\n *\n */\nexport const FactoryEditorAdapter = (componentRef: ComponentRef<HotCellEditorAdvancedComponent<any>>) =>\n  editorFactory<ExtendedEditor<any>>({\n    position: componentRef.instance.position,\n    shortcuts: componentRef.instance.shortcuts,\n    config: componentRef.instance.config,\n    init(editor: EditorInstance): void {\n      editor._componentRef = componentRef;\n      editor._editorPlaceHolderRef = undefined;\n      editor._finishEditSubscription = undefined;\n      editor._cancelEditSubscription = undefined;\n\n      createEditorPlaceholder(editor, (editor.hot as any)._angularEnvironmentInjector);\n      editor.input = editor._editorPlaceHolderRef.location.nativeElement;\n\n      editor._afterRowResizeCallback = (): void => {\n        if (editor.isOpened()) {\n          applyPropsToEditor(editor);\n        }\n      };\n\n      editor._afterColumnResizeCallback = (): void => {\n        if (editor.isOpened()) {\n          applyPropsToEditor(editor);\n        }\n      };\n\n      editor._afterDestroyCallback = (): void => {\n        if (editor._editorPlaceHolderRef) {\n          editor._editorPlaceHolderRef.destroy();\n        }\n      };\n\n      // Hooks are automatically removed by Handsontable on table destroy\n      editor.hot.addHook('afterRowResize', editor._afterRowResizeCallback);\n      editor.hot.addHook('afterColumnResize', editor._afterColumnResizeCallback);\n      editor.hot.addHook('afterDestroy', editor._afterDestroyCallback);\n    },\n\n    afterInit: (editor) => editor._componentRef.instance.afterInit?.(editor),\n    beforeOpen: (editor: EditorInstance, context) => {\n      cleanupSubscriptions(editor);\n\n      applyPropsToEditor(editor);\n\n      editor._finishEditSubscription = editor._componentRef.instance.finishEdit.pipe(take(1)).subscribe((): void => {\n        editor.finishEditing();\n      });\n\n      editor._cancelEditSubscription = editor._componentRef.instance.cancelEdit.pipe(take(1)).subscribe((): void => {\n        editor.cancelChanges();\n      });\n      editor._componentRef.instance.beforeOpen?.(editor, context);\n    },\n    afterOpen: (editor, event) => {\n      editor._componentRef.instance.afterOpen?.(editor, event);\n    },\n    onFocus: (editor) => editor._componentRef.instance.onFocus?.(editor),\n    afterClose: (editor: EditorInstance) => {\n      resetEditorState(editor);\n      editor._editorPlaceHolderRef.changeDetectorRef.detectChanges();\n      editor._editorPlaceHolderRef.instance.detachEditor();\n      editor._componentRef.instance.afterClose?.(editor);\n    },\n    getValue: (editor) => editor._componentRef.instance.getValue(),\n    setValue: (editor: EditorInstance, value) => {\n      editor.value = value;\n      editor._componentRef.instance.setValue(value);\n      editor._componentRef.changeDetectorRef.detectChanges();\n    },\n  });\n\n/**\n * Creates the editor placeholder component.\n * @param editor The editor instance.\n * @param injector The environment injector from Angular.\n */\nfunction createEditorPlaceholder(editor: EditorInstance, injector: EnvironmentInjector | undefined): void {\n  if (!injector) {\n    return;\n  }\n\n  editor._editorPlaceHolderRef = createComponent(CustomEditorPlaceholderComponent, {\n    environmentInjector: injector,\n  });\n}\n\n/**\n * Applies properties to the custom Angular editor and editor placeholder.\n * Updates position, size, and cell context information.\n * @param editor The editor instance.\n */\nfunction applyPropsToEditor(editor: EditorInstance): void {\n  if (!editor._componentRef || !editor._editorPlaceHolderRef) {\n    return;\n  }\n\n  editor._componentRef.setInput('originalValue', editor.originalValue);\n  editor._componentRef.setInput('row', editor.row);\n  editor._componentRef.setInput('column', editor.col);\n  editor._componentRef.setInput('prop', editor.prop);\n  editor._componentRef.setInput('cellProperties', editor.cellProperties);\n\n  const rect = editor.hot.getCell(editor.row, editor.col)?.getBoundingClientRect();\n\n  editor._editorPlaceHolderRef.setInput('placeholderCustomClass', '');\n  editor._editorPlaceHolderRef.setInput('height', rect.height);\n  editor._editorPlaceHolderRef.setInput('width', rect.width);\n  editor._editorPlaceHolderRef.setInput('isVisible', true);\n  editor._editorPlaceHolderRef.setInput('componentRef', editor._componentRef);\n\n  editor._editorPlaceHolderRef.changeDetectorRef.detectChanges();\n}\n\n/**\n * Resets the editor placeholder state.\n * Clears all positioning and visibility settings.\n * @param editor The editor instance.\n */\nfunction resetEditorState(editor: EditorInstance): void {\n  if (!editor._editorPlaceHolderRef) {\n    return;\n  }\n\n  editor._editorPlaceHolderRef.setInput('top', undefined);\n  editor._editorPlaceHolderRef.setInput('left', undefined);\n  editor._editorPlaceHolderRef.setInput('height', undefined);\n  editor._editorPlaceHolderRef.setInput('width', undefined);\n  editor._editorPlaceHolderRef.setInput('isVisible', false);\n  editor._editorPlaceHolderRef.setInput('componentRef', undefined);\n}\n\n/**\n * Cleans up existing subscriptions.\n * @param editor The editor instance.\n */\nfunction cleanupSubscriptions(editor: EditorInstance): void {\n  if (editor._finishEditSubscription) {\n    editor._finishEditSubscription.unsubscribe();\n    editor._finishEditSubscription = undefined;\n  }\n\n  if (editor._cancelEditSubscription) {\n    editor._cancelEditSubscription.unsubscribe();\n    editor._cancelEditSubscription = undefined;\n  }\n}\n"]}

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

@@ -0,0 +1,92 @@
+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 HotCellEditorAdvancedComponent {
+    static EDITOR_MARKER = Symbol('HotCellEditorAdvancedComponent');
+    /** 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 focus the editor.
+     * The user have to define focus logic.
+     */
+    onFocus(editor) { }
+    /**
+     * 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;
+    }
+    /** The position of the editor in the DOM. Used by Handsontable API. Available in advanced mode. */
+    position = 'container';
+    /** The shortcuts available for the editor. Available in advanced mode. */
+    shortcuts;
+    /** The group name for the shortcuts. Available in advanced mode.*/
+    shortcutsGroup;
+    /** Configuration. Available in advanced mode. */
+    config;
+    /** Lifecycle hook called after the editor is opened. Available in advanced mode.*/
+    afterOpen(editor, event) { }
+    /** Lifecycle hook called after the editor is closed. Available in advanced mode. */
+    afterClose(editor) { }
+    /** Lifecycle hook called after the editor is initialized. Available in advanced mode.*/
+    afterInit(editor) { }
+    /** Lifecycle hook called before the editor is opened. Available in advanced mode. */
+    beforeOpen(editor, { row, col, prop, td, originalValue, cellProperties, }) { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellEditorAdvancedComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: HotCellEditorAdvancedComponent, inputs: { row: "row", column: "column", prop: "prop", originalValue: "originalValue", cellProperties: "cellProperties" }, outputs: { finishEdit: "finishEdit", cancelEdit: "cancelEdit" }, host: { properties: { "style.height.%": "this.heightFitParentContainer", "style.width.%": "this.widthFitParentContainer" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HotCellEditorAdvancedComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { 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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