@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/renderer/components/st-cell/st-cell.component.mjs

@@ -0,0 +1,391 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, HostListener } from '@angular/core';
+import { EditMode, NavigationKey, NavigationDirection } from '../../../models/cell-types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class StCellComponent {
+    constructor() {
+        this.editMode = EditMode.CLICK;
+        this.cellChange = new EventEmitter();
+        this.cellEdit = new EventEmitter();
+        this.cellSave = new EventEmitter();
+        this.cellCancel = new EventEmitter();
+        this.cellSaveAndNavigate = new EventEmitter();
+    }
+    ngOnInit() {
+        // Subscribe to editing position changes
+        // When another cell starts editing, save this cell if it's currently editing
+        if (this.tableState && this.columnIndex !== undefined) {
+            this.editingPositionSubscription = this.tableState.editingCellPosition$.subscribe(position => {
+                const rowIndex = this.cell.getRowIndex();
+                // If this cell is currently editing
+                if (this.cell.isEditing() && rowIndex !== undefined) {
+                    // And the new editing position is a different cell
+                    if (position &&
+                        (position.rowIndex !== rowIndex || position.columnIndex !== this.columnIndex)) {
+                        // Force save this cell
+                        this.saveEdit(this.cell.getValue());
+                    }
+                }
+            });
+        }
+    }
+    ngAfterViewInit() {
+        // If cell is already in editing mode, render the editor
+        if (this.cell.isEditing() && this.editorContainer) {
+            this.renderEditor();
+        }
+    }
+    ngOnDestroy() {
+        this.cleanupEditor();
+        // Unsubscribe from editing position changes
+        if (this.editingPositionSubscription) {
+            this.editingPositionSubscription.unsubscribe();
+        }
+    }
+    get isEditable() {
+        const config = this.cell.getColumnConfig();
+        return config.editable ?? false;
+    }
+    get validationError() {
+        // Read validation state without triggering validation
+        // This prevents ExpressionChangedAfterItHasBeenCheckedError
+        const state = this.cell.getState();
+        if (state.error) {
+            return state.error;
+        }
+        if (state.errors && Array.isArray(state.errors) && state.errors.length > 0) {
+            return state.errors.join(', ');
+        }
+        // Only return generic message if cell is marked as invalid
+        if (!this.cell.isValid()) {
+            return 'Invalid value';
+        }
+        return undefined;
+    }
+    get hasCellTemplate() {
+        const config = this.cell.getColumnConfig();
+        return !!config.cellTemplate;
+    }
+    get cellTemplate() {
+        return this.cell.getColumnConfig().cellTemplate || null;
+    }
+    get templateContext() {
+        return {
+            $implicit: this.cell.getValue(),
+            cell: this.cell,
+            rowData: this.cell.getRowData(),
+            rowIndex: this.cell.getRowIndex()
+        };
+    }
+    onCellKeyDown(event) {
+        // Only handle if this cell is focused
+        if (!this.cell.isFocused()) {
+            return;
+        }
+        // Use NavigationKey enum for type-safe key checking
+        switch (event.key) {
+            case NavigationKey.ENTER:
+                if (this.cell.isEditing()) {
+                    // Save and let navigation happen
+                    event.preventDefault();
+                    event.stopPropagation();
+                    this.saveEdit(this.cell.getValue());
+                    // Emit event to trigger navigation down
+                    this.cellSaveAndNavigate.emit({ event, direction: NavigationDirection.DOWN });
+                }
+                // If not editing, let directive handle navigation
+                break;
+            case NavigationKey.TAB:
+                if (this.cell.isEditing()) {
+                    // Save and let navigation happen
+                    event.preventDefault();
+                    event.stopPropagation();
+                    this.saveEdit(this.cell.getValue());
+                    const direction = event.shiftKey ? NavigationDirection.LEFT : NavigationDirection.RIGHT;
+                    this.cellSaveAndNavigate.emit({ event, direction });
+                }
+                // If not editing, let directive handle navigation
+                break;
+            case NavigationKey.ESCAPE:
+                if (this.cell.isEditing()) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    this.cancelEdit();
+                    // Stay focused on same cell (no navigation)
+                }
+                break;
+            default:
+                // Check for alphanumeric keys when focused but not editing
+                if (!this.cell.isEditing() && this.isAlphanumericKey(event)) {
+                    if (this.canEditViaKeyboard()) {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        // Start editing with the pressed key as initial value
+                        this.startEditWithKey(event.key);
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * Check if Enter key can trigger editing
+     * Using EditMode enum values
+     */
+    canEditViaEnter() {
+        return this.isEditable &&
+            (this.editMode === EditMode.ENTER || this.editMode === EditMode.CLICK);
+    }
+    /**
+     * Check if keyboard can trigger editing (for alphanumeric and double-click)
+     */
+    canEditViaKeyboard() {
+        return this.isEditable &&
+            (this.editMode === EditMode.ENTER || this.editMode === EditMode.CLICK);
+    }
+    /**
+     * Check if a key is alphanumeric (single character)
+     */
+    isAlphanumericKey(event) {
+        // Single character keys (letters, numbers, symbols)
+        return event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey;
+    }
+    /**
+     * Start editing with a specific key as the initial value
+     */
+    startEditWithKey(key) {
+        const canStart = this.cell.startEdit();
+        if (canStart) {
+            // Replace current value with the key
+            this.cell.setValue(key, false);
+            const column = this.cell.getColumnConfig();
+            const editEvent = {
+                cell: this.cell,
+                value: key,
+                rowData: this.cell.getRowData(),
+                columnKey: column.key,
+                rowIndex: this.cell.getRowIndex(),
+                cellState: this.cell.getState()
+            };
+            this.cellEdit.emit(editEvent);
+            setTimeout(() => {
+                this.renderEditor();
+            }, 0);
+        }
+    }
+    onCellClick() {
+        // Single click now only focuses, doesn't start editing
+        // Focus is handled by parent st-table component
+    }
+    onCellDoubleClick() {
+        // Double-click starts editing regardless of EditMode (Excel-like behavior)
+        if (this.isEditable && !this.cell.isEditing()) {
+            this.startEdit();
+        }
+    }
+    startEdit() {
+        const canStart = this.cell.startEdit();
+        if (canStart) {
+            const column = this.cell.getColumnConfig();
+            // Notify TableState that this cell is now editing
+            if (this.tableState && this.columnIndex !== undefined) {
+                const rowIndex = this.cell.getRowIndex();
+                if (rowIndex !== undefined) {
+                    this.tableState.setEditingCell(rowIndex, this.columnIndex);
+                }
+            }
+            const editEvent = {
+                cell: this.cell,
+                value: this.cell.getValue(),
+                rowData: this.cell.getRowData(),
+                columnKey: column.key,
+                rowIndex: this.cell.getRowIndex(),
+                cellState: this.cell.getState()
+            };
+            this.cellEdit.emit(editEvent);
+            // Wait for Angular to render the editor container
+            setTimeout(() => {
+                this.renderEditor();
+            }, 0);
+        }
+    }
+    renderEditor() {
+        if (!this.editorContainer) {
+            return;
+        }
+        const column = this.cell.getColumnConfig();
+        const editor = column.editor;
+        if (!editor) {
+            console.warn('No editor configured for column:', column.key);
+            return;
+        }
+        const value = this.cell.getValue();
+        const container = this.editorContainer.nativeElement;
+        // Create editor context
+        const context = {
+            value,
+            rowData: this.cell.getRowData(),
+            columnKey: column.key,
+            rowIndex: this.cell.getRowIndex(),
+            onChange: (newValue) => {
+                // Trigger eager validation if enabled
+                if (this.tableConfig?.validation?.mode === 'eager') {
+                    // Update cell value temporarily for validation
+                    this.cell.setValue(newValue, true); // skip validation to avoid double validation
+                    this.triggerEagerValidation();
+                }
+            },
+            onSave: (newValue) => {
+                this.saveEdit(newValue);
+            },
+            onCancel: () => {
+                this.cancelEdit();
+            },
+            container
+        };
+        // Call editor's edit method
+        editor.edit(context);
+        // Store cleanup callback
+        this.editorCleanup = () => {
+            if (editor.destroy) {
+                editor.destroy();
+            }
+            // Clear container
+            while (container.firstChild) {
+                container.removeChild(container.firstChild);
+            }
+        };
+    }
+    saveEdit(newValue) {
+        const previousValue = this.cell.getValue();
+        const wasValid = this.cell.isValid();
+        const success = this.cell.saveEdit(newValue);
+        if (success) {
+            const column = this.cell.getColumnConfig();
+            const cellState = this.cell.getState();
+            const isValid = this.cell.isValid();
+            // Notify TableState that editing ended
+            if (this.tableState) {
+                this.tableState.clearEditingCell();
+                // Update validation state (lazy mode - on save)
+                this.updateValidationState();
+            }
+            // Emit save event
+            const saveEvent = {
+                cell: this.cell,
+                newValue: newValue,
+                previousValue: previousValue,
+                rowData: this.cell.getRowData(),
+                columnKey: column.key,
+                rowIndex: this.cell.getRowIndex(),
+                isValid: isValid,
+                validationErrors: cellState.error ? [cellState.error] : undefined,
+                cellState: cellState
+            };
+            this.cellSave.emit(saveEvent);
+            // Emit change event
+            const changeEvent = {
+                cell: this.cell,
+                oldValue: previousValue,
+                newValue: newValue,
+                rowData: this.cell.getRowData(),
+                columnKey: column.key,
+                rowIndex: this.cell.getRowIndex(),
+                wasValid: wasValid,
+                isValid: isValid,
+                cellState: cellState
+            };
+            this.cellChange.emit(changeEvent);
+            this.cleanupEditor();
+        }
+        // If validation fails, keep editing mode
+    }
+    /**
+     * Update validation state in TableState
+     * Called on save (lazy mode) or on change (eager mode)
+     */
+    updateValidationState() {
+        if (!this.tableState)
+            return;
+        const column = this.cell.getColumnConfig();
+        const isValid = this.cell.isValid();
+        const error = this.cell.getState().error;
+        const rowIndex = this.cell.getRowIndex();
+        // Only update if rowIndex is defined
+        if (rowIndex === undefined)
+            return;
+        this.tableState.updateCellValidation(rowIndex, column.key, isValid, error);
+    }
+    /**
+     * Trigger eager validation (on every change)
+     */
+    triggerEagerValidation() {
+        if (!this.tableState || !this.tableConfig)
+            return;
+        const validationMode = this.tableConfig.validation?.mode || 'lazy';
+        if (validationMode !== 'eager')
+            return;
+        // Re-validate the cell
+        this.cell.validate();
+        // Update validation state
+        this.updateValidationState();
+    }
+    cancelEdit() {
+        const column = this.cell.getColumnConfig();
+        const cellState = this.cell.getState();
+        // Notify TableState that editing ended
+        if (this.tableState) {
+            this.tableState.clearEditingCell();
+        }
+        const cancelEvent = {
+            cell: this.cell,
+            value: this.cell.getValue(),
+            previousValue: cellState.previousValue,
+            rowData: this.cell.getRowData(),
+            columnKey: column.key,
+            rowIndex: this.cell.getRowIndex(),
+            cellState: cellState
+        };
+        this.cell.cancelEdit();
+        this.cellCancel.emit(cancelEvent);
+        this.cleanupEditor();
+    }
+    cleanupEditor() {
+        if (this.editorCleanup) {
+            this.editorCleanup();
+            this.editorCleanup = undefined;
+        }
+    }
+}
+StCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StCellComponent, selector: "st-cell", inputs: { cell: "cell", editMode: "editMode", tableState: "tableState", tableConfig: "tableConfig", columnIndex: "columnIndex" }, outputs: { cellChange: "cellChange", cellEdit: "cellEdit", cellSave: "cellSave", cellCancel: "cellCancel", cellSaveAndNavigate: "cellSaveAndNavigate" }, host: { listeners: { "keydown": "onCellKeyDown($event)" } }, viewQueries: [{ propertyName: "editorContainer", first: true, predicate: ["editorContainer"], descendants: true, read: ElementRef }], ngImport: i0, template: "<div class=\"st-cell\" \n  [ngClass]=\"{\n    'editing': cell.isEditing(),\n    'dirty': cell.isDirty(),\n    'invalid': !cell.isValid(),\n    'readonly': !isEditable\n  }\"\n  (click)=\"onCellClick()\" \n  (dblclick)=\"onCellDoubleClick()\">\n\n  <!-- Display Mode with Template Support -->\n  <ng-container *ngIf=\"!cell.isEditing()\">\n    <!-- Custom Template -->\n    <ng-container *ngIf=\"hasCellTemplate\">\n      <ng-container *ngTemplateOutlet=\"cellTemplate; context: templateContext\"></ng-container>\n    </ng-container>\n\n    <!-- Default Text Rendering -->\n    <span *ngIf=\"!hasCellTemplate\" class=\"cell-display\">\n      {{ cell.render() }}\n    </span>\n  </ng-container>\n\n  <!-- Edit Mode -->\n  <div *ngIf=\"cell.isEditing()\" class=\"cell-editor\" #editorContainer>\n  </div>\n</div>", styles: [".st-cell{position:relative;cursor:pointer;transition:background-color .2s;min-height:28px;display:flex;flex-direction:column;align-items:center;justify-content:center;width:100%;box-sizing:border-box}.st-cell.invalid{border-left:2px solid #e53e3e}.st-cell.readonly{cursor:default}.cell-display{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;align-content:center;width:100%;height:100%;padding-left:4px;font-size:12px;font-weight:300;letter-spacing:.2px;line-height:14px}.cell-editor{display:flex;height:100%;width:100%}.cell-editor input,.cell-editor select,.cell-editor textarea{width:100%;border:none;outline:none;font:inherit;padding:0;background:transparent;color:inherit}.cell-editor input[type=number]{text-align:inherit}.cell-error{position:absolute;right:4px;top:50%;transform:translateY(-50%);color:#e53e3e;font-weight:700;cursor:help;font-size:14px}\n"], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-cell', template: "<div class=\"st-cell\" \n  [ngClass]=\"{\n    'editing': cell.isEditing(),\n    'dirty': cell.isDirty(),\n    'invalid': !cell.isValid(),\n    'readonly': !isEditable\n  }\"\n  (click)=\"onCellClick()\" \n  (dblclick)=\"onCellDoubleClick()\">\n\n  <!-- Display Mode with Template Support -->\n  <ng-container *ngIf=\"!cell.isEditing()\">\n    <!-- Custom Template -->\n    <ng-container *ngIf=\"hasCellTemplate\">\n      <ng-container *ngTemplateOutlet=\"cellTemplate; context: templateContext\"></ng-container>\n    </ng-container>\n\n    <!-- Default Text Rendering -->\n    <span *ngIf=\"!hasCellTemplate\" class=\"cell-display\">\n      {{ cell.render() }}\n    </span>\n  </ng-container>\n\n  <!-- Edit Mode -->\n  <div *ngIf=\"cell.isEditing()\" class=\"cell-editor\" #editorContainer>\n  </div>\n</div>", styles: [".st-cell{position:relative;cursor:pointer;transition:background-color .2s;min-height:28px;display:flex;flex-direction:column;align-items:center;justify-content:center;width:100%;box-sizing:border-box}.st-cell.invalid{border-left:2px solid #e53e3e}.st-cell.readonly{cursor:default}.cell-display{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;align-content:center;width:100%;height:100%;padding-left:4px;font-size:12px;font-weight:300;letter-spacing:.2px;line-height:14px}.cell-editor{display:flex;height:100%;width:100%}.cell-editor input,.cell-editor select,.cell-editor textarea{width:100%;border:none;outline:none;font:inherit;padding:0;background:transparent;color:inherit}.cell-editor input[type=number]{text-align:inherit}.cell-error{position:absolute;right:4px;top:50%;transform:translateY(-50%);color:#e53e3e;font-weight:700;cursor:help;font-size:14px}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { cell: [{
+                type: Input
+            }], editMode: [{
+                type: Input
+            }], tableState: [{
+                type: Input
+            }], tableConfig: [{
+                type: Input
+            }], columnIndex: [{
+                type: Input
+            }], cellChange: [{
+                type: Output
+            }], cellEdit: [{
+                type: Output
+            }], cellSave: [{
+                type: Output
+            }], cellCancel: [{
+                type: Output
+            }], cellSaveAndNavigate: [{
+                type: Output
+            }], editorContainer: [{
+                type: ViewChild,
+                args: ['editorContainer', { read: ElementRef }]
+            }], onCellKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-cell.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-cell/st-cell.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-cell/st-cell.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, OnInit, OnDestroy, ViewChild, ElementRef, AfterViewInit, TemplateRef, HostListener } from '@angular/core';\nimport { Cell } from '../../models/cell.class';\nimport { CellEditorContext } from '../../../models/cell-strategies.interface';\nimport { CellEditEvent, CellSaveEvent, CellChangeEvent, CellCancelEvent, EditMode, NavigationKey, NavigationDirection } from '../../../models/cell-types';\nimport { TableState } from '../../models/table-state.class';\nimport { TableConfig } from '../../../models/table-config.interface';\n\n@Component({\n  selector: 'st-cell',\n  templateUrl: './st-cell.component.html',\n  styleUrls: ['./st-cell.component.scss'],\n})\nexport class StCellComponent implements OnInit, OnDestroy, AfterViewInit {\n  @Input() cell!: Cell<any>;\n  @Input() editMode: EditMode = EditMode.CLICK;\n  @Input() tableState?: TableState;\n  @Input() tableConfig?: TableConfig;\n  @Input() columnIndex?: number;\n  \n  @Output() cellChange = new EventEmitter<CellChangeEvent>();\n  @Output() cellEdit = new EventEmitter<CellEditEvent>();\n  @Output() cellSave = new EventEmitter<CellSaveEvent>();\n  @Output() cellCancel = new EventEmitter<CellCancelEvent>();\n  @Output() cellSaveAndNavigate = new EventEmitter<{event: KeyboardEvent, direction: NavigationDirection}>();\n  \n  @ViewChild('editorContainer', { read: ElementRef }) editorContainer?: ElementRef;\n  \n  private editorCleanup?: () => void;\n\n  private editingPositionSubscription?: any;\n\n  constructor(\n  ) {}\n\n  ngOnInit(): void {\n    // Subscribe to editing position changes\n    // When another cell starts editing, save this cell if it's currently editing\n    if (this.tableState && this.columnIndex !== undefined) {\n      this.editingPositionSubscription = this.tableState.editingCellPosition$.subscribe(position => {\n        const rowIndex = this.cell.getRowIndex();\n        \n        // If this cell is currently editing\n        if (this.cell.isEditing() && rowIndex !== undefined) {\n          // And the new editing position is a different cell\n          if (position && \n              (position.rowIndex !== rowIndex || position.columnIndex !== this.columnIndex)) {\n            // Force save this cell\n            this.saveEdit(this.cell.getValue());\n          }\n        }\n      });\n    }\n  }\n\n  ngAfterViewInit(): void {\n    // If cell is already in editing mode, render the editor\n    if (this.cell.isEditing() && this.editorContainer) {\n      this.renderEditor();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanupEditor();\n    \n    // Unsubscribe from editing position changes\n    if (this.editingPositionSubscription) {\n      this.editingPositionSubscription.unsubscribe();\n    }\n  }\n\n  get isEditable(): boolean {\n    const config = this.cell.getColumnConfig();\n    return config.editable ?? false;\n  }\n\n  get validationError(): string | undefined {\n    // Read validation state without triggering validation\n    // This prevents ExpressionChangedAfterItHasBeenCheckedError\n    const state = this.cell.getState();\n    \n    if (state.error) {\n      return state.error;\n    }\n    \n    if (state.errors && Array.isArray(state.errors) && state.errors.length > 0) {\n      return state.errors.join(', ');\n    }\n    \n    // Only return generic message if cell is marked as invalid\n    if (!this.cell.isValid()) {\n      return 'Invalid value';\n    }\n    \n    return undefined;\n  }\n\n  get hasCellTemplate(): boolean {\n    const config = this.cell.getColumnConfig();\n    return !!config.cellTemplate;\n  }\n\n  get cellTemplate(): TemplateRef<any> | null {\n    return this.cell.getColumnConfig().cellTemplate || null;\n  }\n\n  get templateContext(): any {\n    return {\n      $implicit: this.cell.getValue(),\n      cell: this.cell,\n      rowData: this.cell.getRowData(),\n      rowIndex: this.cell.getRowIndex()\n    };\n  }\n\n  @HostListener('keydown', ['$event'])\n  onCellKeyDown(event: KeyboardEvent): void {\n    // Only handle if this cell is focused\n    if (!this.cell.isFocused()) {\n      return;\n    }\n    \n    // Use NavigationKey enum for type-safe key checking\n    switch (event.key as NavigationKey) {\n      case NavigationKey.ENTER:\n        if (this.cell.isEditing()) {\n          // Save and let navigation happen\n          event.preventDefault();\n          event.stopPropagation();\n          this.saveEdit(this.cell.getValue());\n          // Emit event to trigger navigation down\n          this.cellSaveAndNavigate.emit({ event, direction: NavigationDirection.DOWN });\n        }\n        // If not editing, let directive handle navigation\n        break;\n        \n      case NavigationKey.TAB:\n        if (this.cell.isEditing()) {\n          // Save and let navigation happen\n          event.preventDefault();\n          event.stopPropagation();\n          this.saveEdit(this.cell.getValue());\n          const direction = event.shiftKey ? NavigationDirection.LEFT : NavigationDirection.RIGHT;\n          this.cellSaveAndNavigate.emit({ event, direction });\n        }\n        // If not editing, let directive handle navigation\n        break;\n        \n      case NavigationKey.ESCAPE:\n        if (this.cell.isEditing()) {\n          event.preventDefault();\n          event.stopPropagation();\n          this.cancelEdit();\n          // Stay focused on same cell (no navigation)\n        }\n        break;\n        \n      default:\n        // Check for alphanumeric keys when focused but not editing\n        if (!this.cell.isEditing() && this.isAlphanumericKey(event)) {\n          if (this.canEditViaKeyboard()) {\n            event.preventDefault();\n            event.stopPropagation();\n            // Start editing with the pressed key as initial value\n            this.startEditWithKey(event.key);\n          }\n        }\n        break;\n    }\n  }\n  \n  /**\n   * Check if Enter key can trigger editing\n   * Using EditMode enum values\n   */\n  private canEditViaEnter(): boolean {\n    return this.isEditable && \n           (this.editMode === EditMode.ENTER || this.editMode === EditMode.CLICK);\n  }\n  \n  /**\n   * Check if keyboard can trigger editing (for alphanumeric and double-click)\n   */\n  private canEditViaKeyboard(): boolean {\n    return this.isEditable && \n           (this.editMode === EditMode.ENTER || this.editMode === EditMode.CLICK);\n  }\n  \n  /**\n   * Check if a key is alphanumeric (single character)\n   */\n  private isAlphanumericKey(event: KeyboardEvent): boolean {\n    // Single character keys (letters, numbers, symbols)\n    return event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey;\n  }\n  \n  /**\n   * Start editing with a specific key as the initial value\n   */\n  private startEditWithKey(key: string): void {\n    const canStart = this.cell.startEdit();\n    if (canStart) {\n      // Replace current value with the key\n      this.cell.setValue(key, false);\n      \n      const column = this.cell.getColumnConfig();\n      const editEvent: CellEditEvent = {\n        cell: this.cell,\n        value: key,\n        rowData: this.cell.getRowData(),\n        columnKey: column.key,\n        rowIndex: this.cell.getRowIndex(),\n        cellState: this.cell.getState()\n      };\n      this.cellEdit.emit(editEvent);\n      \n      setTimeout(() => {\n        this.renderEditor();\n      }, 0);\n    }\n  }\n\n  onCellClick(): void {\n    // Single click now only focuses, doesn't start editing\n    // Focus is handled by parent st-table component\n  }\n\n  onCellDoubleClick(): void {\n    // Double-click starts editing regardless of EditMode (Excel-like behavior)\n    if (this.isEditable && !this.cell.isEditing()) {\n      this.startEdit();\n    }\n  }\n\n  private startEdit(): void {\n    const canStart = this.cell.startEdit();\n    if (canStart) {\n      const column = this.cell.getColumnConfig();\n      \n      // Notify TableState that this cell is now editing\n      if (this.tableState && this.columnIndex !== undefined) {\n        const rowIndex = this.cell.getRowIndex();\n        if (rowIndex !== undefined) {\n          this.tableState.setEditingCell(rowIndex, this.columnIndex);\n        }\n      }\n      \n      const editEvent: CellEditEvent = {\n        cell: this.cell,\n        value: this.cell.getValue(),\n        rowData: this.cell.getRowData(),\n        columnKey: column.key,\n        rowIndex: this.cell.getRowIndex(),\n        cellState: this.cell.getState()\n      };\n      this.cellEdit.emit(editEvent);\n      \n      // Wait for Angular to render the editor container\n      setTimeout(() => {\n        this.renderEditor();\n      }, 0);\n    }\n  }\n\n  private renderEditor(): void {\n    if (!this.editorContainer) {\n      return;\n    }\n\n    const column = this.cell.getColumnConfig();\n    const editor = column.editor;\n    \n    if (!editor) {\n      console.warn('No editor configured for column:', column.key);\n      return;\n    }\n\n    const value = this.cell.getValue();\n    const container = this.editorContainer.nativeElement;\n    \n    // Create editor context\n    const context: CellEditorContext<any> = {\n      value,\n      rowData: this.cell.getRowData(),\n      columnKey: column.key,\n      rowIndex: this.cell.getRowIndex(),\n      onChange: (newValue: any) => {\n        // Trigger eager validation if enabled\n        if (this.tableConfig?.validation?.mode === 'eager') {\n          // Update cell value temporarily for validation\n          this.cell.setValue(newValue, true); // skip validation to avoid double validation\n          this.triggerEagerValidation();\n        }\n      },\n      onSave: (newValue: any) => {\n        this.saveEdit(newValue);\n      },\n      onCancel: () => {\n        this.cancelEdit();\n      },\n      container\n    };\n    \n    // Call editor's edit method\n    editor.edit(context);\n    \n    // Store cleanup callback\n    this.editorCleanup = () => {\n      if (editor.destroy) {\n        editor.destroy();\n      }\n      // Clear container\n      while (container.firstChild) {\n        container.removeChild(container.firstChild);\n      }\n    };\n  }\n\n  private saveEdit(newValue: any): void {\n    const previousValue = this.cell.getValue();\n    const wasValid = this.cell.isValid();\n    const success = this.cell.saveEdit(newValue);\n    \n    if (success) {\n      const column = this.cell.getColumnConfig();\n      const cellState = this.cell.getState();\n      const isValid = this.cell.isValid();\n      \n      // Notify TableState that editing ended\n      if (this.tableState) {\n        this.tableState.clearEditingCell();\n        \n        // Update validation state (lazy mode - on save)\n        this.updateValidationState();\n      }\n      \n      // Emit save event\n      const saveEvent: CellSaveEvent = {\n        cell: this.cell,\n        newValue: newValue,\n        previousValue: previousValue,\n        rowData: this.cell.getRowData(),\n        columnKey: column.key,\n        rowIndex: this.cell.getRowIndex(),\n        isValid: isValid,\n        validationErrors: cellState.error ? [cellState.error] : undefined,\n        cellState: cellState\n      };\n      this.cellSave.emit(saveEvent);\n      \n      // Emit change event\n      const changeEvent: CellChangeEvent = {\n        cell: this.cell,\n        oldValue: previousValue,\n        newValue: newValue,\n        rowData: this.cell.getRowData(),\n        columnKey: column.key,\n        rowIndex: this.cell.getRowIndex(),\n        wasValid: wasValid,\n        isValid: isValid,\n        cellState: cellState\n      };\n      this.cellChange.emit(changeEvent);\n      \n      this.cleanupEditor();\n    }\n    // If validation fails, keep editing mode\n  }\n  \n  /**\n   * Update validation state in TableState\n   * Called on save (lazy mode) or on change (eager mode)\n   */\n  private updateValidationState(): void {\n    if (!this.tableState) return;\n    \n    const column = this.cell.getColumnConfig();\n    const isValid = this.cell.isValid();\n    const error = this.cell.getState().error;\n    const rowIndex = this.cell.getRowIndex();\n    \n    // Only update if rowIndex is defined\n    if (rowIndex === undefined) return;\n    \n    this.tableState.updateCellValidation(\n      rowIndex,\n      column.key,\n      isValid,\n      error\n    );\n  }\n  \n  /**\n   * Trigger eager validation (on every change)\n   */\n  private triggerEagerValidation(): void {\n    if (!this.tableState || !this.tableConfig) return;\n    \n    const validationMode = this.tableConfig.validation?.mode || 'lazy';\n    if (validationMode !== 'eager') return;\n    \n    // Re-validate the cell\n    this.cell.validate();\n    \n    // Update validation state\n    this.updateValidationState();\n  }\n\n  private cancelEdit(): void {\n    const column = this.cell.getColumnConfig();\n    const cellState = this.cell.getState();\n    \n    // Notify TableState that editing ended\n    if (this.tableState) {\n      this.tableState.clearEditingCell();\n    }\n    \n    const cancelEvent: CellCancelEvent = {\n      cell: this.cell,\n      value: this.cell.getValue(),\n      previousValue: cellState.previousValue,\n      rowData: this.cell.getRowData(),\n      columnKey: column.key,\n      rowIndex: this.cell.getRowIndex(),\n      cellState: cellState\n    };\n    \n    this.cell.cancelEdit();\n    this.cellCancel.emit(cancelEvent);\n    this.cleanupEditor();\n  }\n\n  private cleanupEditor(): void {\n    if (this.editorCleanup) {\n      this.editorCleanup();\n      this.editorCleanup = undefined;\n    }\n  }\n}\n","<div class=\"st-cell\" \n  [ngClass]=\"{\n    'editing': cell.isEditing(),\n    'dirty': cell.isDirty(),\n    'invalid': !cell.isValid(),\n    'readonly': !isEditable\n  }\"\n  (click)=\"onCellClick()\" \n  (dblclick)=\"onCellDoubleClick()\">\n\n  <!-- Display Mode with Template Support -->\n  <ng-container *ngIf=\"!cell.isEditing()\">\n    <!-- Custom Template -->\n    <ng-container *ngIf=\"hasCellTemplate\">\n      <ng-container *ngTemplateOutlet=\"cellTemplate; context: templateContext\"></ng-container>\n    </ng-container>\n\n    <!-- Default Text Rendering -->\n    <span *ngIf=\"!hasCellTemplate\" class=\"cell-display\">\n      {{ cell.render() }}\n    </span>\n  </ng-container>\n\n  <!-- Edit Mode -->\n  <div *ngIf=\"cell.isEditing()\" class=\"cell-editor\" #editorContainer>\n  </div>\n</div>"]}

package/esm2020/lib/renderer/components/st-column-editor-modal/st-column-editor-modal.component.mjs

@@ -0,0 +1,103 @@
+import { Component, Output, EventEmitter, ViewChild } from '@angular/core';
+import { CellDataType } from '../../../models/cell-types';
+import { ColumnConfigFactory } from '../../../factories/column-config.factory';
+import { ColumnEditorComponent } from '../../../builder/components/column-editor/column-editor.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../builder/components/column-editor/column-editor.component";
+export class StColumnEditorModalComponent {
+    constructor() {
+        this.columnCreated = new EventEmitter();
+        this.cancelled = new EventEmitter();
+        this.columnIndex = -1;
+    }
+    ngOnInit() {
+        // Create a default column that will be edited
+        this.newColumn = this.createDefaultColumn();
+    }
+    ngOnDestroy() {
+        // Cleanup if needed
+    }
+    /**
+     * Create a default column configuration
+     */
+    createDefaultColumn() {
+        return ColumnConfigFactory.text('newColumn', {
+            header: 'New Column',
+            editable: true,
+            sortable: true,
+            filterable: true,
+            resizable: true,
+            hideable: true,
+            visible: true
+        });
+    }
+    /**
+     * Trigger save from external button
+     */
+    onSave() {
+        // Call the column editor's save method
+        if (this.columnEditor) {
+            this.columnEditor.onSave();
+        }
+    }
+    /**
+     * Handle column updates from the editor
+     */
+    onColumnUpdated(updates) {
+        // Merge updates into the new column
+        this.newColumn = { ...this.newColumn, ...updates };
+        // Use ColumnConfigFactory to create proper column based on data type
+        let finalColumn;
+        const key = updates.key || this.newColumn.key;
+        const dataType = updates.dataType || this.newColumn.dataType;
+        switch (dataType) {
+            case CellDataType.NUMBER:
+                finalColumn = ColumnConfigFactory.number(key, this.newColumn);
+                break;
+            case CellDataType.DATE:
+                finalColumn = ColumnConfigFactory.date(key, this.newColumn);
+                break;
+            case CellDataType.BOOLEAN:
+                finalColumn = ColumnConfigFactory.boolean(key, this.newColumn);
+                break;
+            default:
+                finalColumn = ColumnConfigFactory.text(key, this.newColumn);
+        }
+        // Emit the created column
+        this.columnCreated.emit(finalColumn);
+    }
+    /**
+     * Handle cancel from the editor
+     */
+    onCancel() {
+        this.cancelled.emit();
+    }
+    /**
+     * Handle backdrop click to close modal
+     */
+    onBackdropClick(event) {
+        if (event.target === event.currentTarget) {
+            this.cancelled.emit();
+        }
+    }
+    /**
+     * Prevent event propagation from modal content
+     */
+    onModalContentClick(event) {
+        event.stopPropagation();
+    }
+}
+StColumnEditorModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StColumnEditorModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StColumnEditorModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StColumnEditorModalComponent, selector: "st-column-editor-modal", outputs: { columnCreated: "columnCreated", cancelled: "cancelled" }, viewQueries: [{ propertyName: "columnEditor", first: true, predicate: ColumnEditorComponent, descendants: true }], ngImport: i0, template: "<div class=\"modal-backdrop\" (click)=\"onBackdropClick($event)\">\n  <div class=\"modal-content\" (click)=\"onModalContentClick($event)\">\n    <div class=\"modal-header\">\n      <h2>Add New Column</h2>\n      <button class=\"close-button\" (click)=\"onCancel()\" type=\"button\" aria-label=\"Close\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <path d=\"M18 6L6 18M6 6L18 18\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n        </svg>\n      </button>\n    </div>\n    <div class=\"modal-body\">\n      <!-- Now using the shared st-column-editor component from SharedTableComponentsModule -->\n      <st-column-editor\n        [column]=\"newColumn\"\n        [columnIndex]=\"columnIndex\"\n        (columnUpdated)=\"onColumnUpdated($event)\"\n        (cancel)=\"onCancel()\">\n      </st-column-editor>\n    </div>\n    <div class=\"modal-footer\">\n      <button type=\"button\" class=\"btn btn-secondary\" (click)=\"onCancel()\">Cancel</button>\n      <button type=\"button\" class=\"btn btn-primary\" (click)=\"onSave()\">Add Column</button>\n    </div>\n  </div>\n</div>\n", styles: [".modal-backdrop{position:fixed;inset:0;background-color:#00000080;display:flex;align-items:center;justify-content:center;z-index:2000;animation:fadeIn .2s ease-in-out}.modal-content{background:white;border-radius:8px;box-shadow:0 11px 15px -7px #0003,0 24px 38px 3px #00000024,0 9px 46px 8px #0000001f;max-width:600px;max-height:90vh;width:90%;display:flex;flex-direction:column;animation:slideUp .3s cubic-bezier(.4,0,.2,1)}.modal-header{display:flex;justify-content:space-between;align-items:center;padding:20px 24px;border-bottom:1px solid #e0e0e0;flex-shrink:0}.modal-header h2{margin:0;font-size:20px;font-weight:500;color:#212121}.close-button{background:none;border:none;cursor:pointer;padding:8px;display:flex;align-items:center;justify-content:center;border-radius:50%;color:#757575;transition:all .2s ease}.close-button:hover{background-color:#0000000a;color:#212121}.close-button:active{background-color:#00000014}.close-button:focus{outline:none;box-shadow:0 0 0 2px #1976d24d}.close-button svg{width:24px;height:24px}.modal-body{padding:0;overflow-y:auto;flex:1;min-height:0}.modal-body ::ng-deep st-column-editor{display:block}.modal-body ::ng-deep st-column-editor .column-editor{padding:0;border:none;box-shadow:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-header{display:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-actions{display:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-form{padding:24px}.modal-footer{display:flex;justify-content:flex-end;gap:12px;padding:16px 24px;border-top:1px solid #e0e0e0;flex-shrink:0;background-color:#f5f5f5}.modal-footer .btn{padding:10px 20px;border:none;border-radius:4px;font-size:14px;font-weight:500;cursor:pointer;transition:all .2s}.modal-footer .btn:focus{outline:none;box-shadow:0 0 0 2px #0000001a}.modal-footer .btn.btn-secondary{background-color:#fff;color:#424242;border:1px solid #d0d0d0}.modal-footer .btn.btn-secondary:hover{background-color:#f5f5f5}.modal-footer .btn.btn-secondary:active{background-color:#eee}.modal-footer .btn.btn-primary{background-color:#1976d2;color:#fff}.modal-footer .btn.btn-primary:hover{background-color:#1565c0}.modal-footer .btn.btn-primary:active{background-color:#0d47a1}@keyframes fadeIn{0%{opacity:0}to{opacity:1}}@keyframes slideUp{0%{opacity:0;transform:translateY(50px)}to{opacity:1;transform:translateY(0)}}\n"], components: [{ type: i1.ColumnEditorComponent, selector: "st-column-editor", inputs: ["column", "columnIndex"], outputs: ["columnUpdated", "cancel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StColumnEditorModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-column-editor-modal', template: "<div class=\"modal-backdrop\" (click)=\"onBackdropClick($event)\">\n  <div class=\"modal-content\" (click)=\"onModalContentClick($event)\">\n    <div class=\"modal-header\">\n      <h2>Add New Column</h2>\n      <button class=\"close-button\" (click)=\"onCancel()\" type=\"button\" aria-label=\"Close\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <path d=\"M18 6L6 18M6 6L18 18\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n        </svg>\n      </button>\n    </div>\n    <div class=\"modal-body\">\n      <!-- Now using the shared st-column-editor component from SharedTableComponentsModule -->\n      <st-column-editor\n        [column]=\"newColumn\"\n        [columnIndex]=\"columnIndex\"\n        (columnUpdated)=\"onColumnUpdated($event)\"\n        (cancel)=\"onCancel()\">\n      </st-column-editor>\n    </div>\n    <div class=\"modal-footer\">\n      <button type=\"button\" class=\"btn btn-secondary\" (click)=\"onCancel()\">Cancel</button>\n      <button type=\"button\" class=\"btn btn-primary\" (click)=\"onSave()\">Add Column</button>\n    </div>\n  </div>\n</div>\n", styles: [".modal-backdrop{position:fixed;inset:0;background-color:#00000080;display:flex;align-items:center;justify-content:center;z-index:2000;animation:fadeIn .2s ease-in-out}.modal-content{background:white;border-radius:8px;box-shadow:0 11px 15px -7px #0003,0 24px 38px 3px #00000024,0 9px 46px 8px #0000001f;max-width:600px;max-height:90vh;width:90%;display:flex;flex-direction:column;animation:slideUp .3s cubic-bezier(.4,0,.2,1)}.modal-header{display:flex;justify-content:space-between;align-items:center;padding:20px 24px;border-bottom:1px solid #e0e0e0;flex-shrink:0}.modal-header h2{margin:0;font-size:20px;font-weight:500;color:#212121}.close-button{background:none;border:none;cursor:pointer;padding:8px;display:flex;align-items:center;justify-content:center;border-radius:50%;color:#757575;transition:all .2s ease}.close-button:hover{background-color:#0000000a;color:#212121}.close-button:active{background-color:#00000014}.close-button:focus{outline:none;box-shadow:0 0 0 2px #1976d24d}.close-button svg{width:24px;height:24px}.modal-body{padding:0;overflow-y:auto;flex:1;min-height:0}.modal-body ::ng-deep st-column-editor{display:block}.modal-body ::ng-deep st-column-editor .column-editor{padding:0;border:none;box-shadow:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-header{display:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-actions{display:none}.modal-body ::ng-deep st-column-editor .column-editor .editor-form{padding:24px}.modal-footer{display:flex;justify-content:flex-end;gap:12px;padding:16px 24px;border-top:1px solid #e0e0e0;flex-shrink:0;background-color:#f5f5f5}.modal-footer .btn{padding:10px 20px;border:none;border-radius:4px;font-size:14px;font-weight:500;cursor:pointer;transition:all .2s}.modal-footer .btn:focus{outline:none;box-shadow:0 0 0 2px #0000001a}.modal-footer .btn.btn-secondary{background-color:#fff;color:#424242;border:1px solid #d0d0d0}.modal-footer .btn.btn-secondary:hover{background-color:#f5f5f5}.modal-footer .btn.btn-secondary:active{background-color:#eee}.modal-footer .btn.btn-primary{background-color:#1976d2;color:#fff}.modal-footer .btn.btn-primary:hover{background-color:#1565c0}.modal-footer .btn.btn-primary:active{background-color:#0d47a1}@keyframes fadeIn{0%{opacity:0}to{opacity:1}}@keyframes slideUp{0%{opacity:0;transform:translateY(50px)}to{opacity:1;transform:translateY(0)}}\n"] }]
+        }], propDecorators: { columnCreated: [{
+                type: Output
+            }], cancelled: [{
+                type: Output
+            }], columnEditor: [{
+                type: ViewChild,
+                args: [ColumnEditorComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-column-editor-modal.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-column-editor-modal/st-column-editor-modal.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-column-editor-modal/st-column-editor-modal.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Output, EventEmitter, OnInit, OnDestroy, ViewChild } from '@angular/core';\nimport { ColumnConfig } from '../../../models/column-config.interface';\nimport { CellDataType } from '../../../models/cell-types';\nimport { ColumnConfigFactory } from '../../../factories/column-config.factory';\nimport { ColumnEditorComponent } from '../../../builder/components/column-editor/column-editor.component';\n\n@Component({\n  selector: 'st-column-editor-modal',\n  templateUrl: './st-column-editor-modal.component.html',\n  styleUrls: ['./st-column-editor-modal.component.scss']\n})\nexport class StColumnEditorModalComponent implements OnInit, OnDestroy {\n  @Output() columnCreated = new EventEmitter<ColumnConfig>();\n  @Output() cancelled = new EventEmitter<void>();\n  \n  @ViewChild(ColumnEditorComponent) columnEditor!: ColumnEditorComponent;\n  \n  newColumn!: ColumnConfig;\n  columnIndex: number = -1;\n  \n  ngOnInit(): void {\n    // Create a default column that will be edited\n    this.newColumn = this.createDefaultColumn();\n  }\n  \n  ngOnDestroy(): void {\n    // Cleanup if needed\n  }\n  \n  /**\n   * Create a default column configuration\n   */\n  private createDefaultColumn(): ColumnConfig {\n    return ColumnConfigFactory.text('newColumn', {\n      header: 'New Column',\n      editable: true,\n      sortable: true,\n      filterable: true,\n      resizable: true,\n      hideable: true,\n      visible: true\n    });\n  }\n  \n  /**\n   * Trigger save from external button\n   */\n  onSave(): void {\n    // Call the column editor's save method\n    if (this.columnEditor) {\n      this.columnEditor.onSave();\n    }\n  }\n  \n  /**\n   * Handle column updates from the editor\n   */\n  onColumnUpdated(updates: Partial<ColumnConfig>): void {\n    // Merge updates into the new column\n    this.newColumn = { ...this.newColumn, ...updates };\n    \n    // Use ColumnConfigFactory to create proper column based on data type\n    let finalColumn: ColumnConfig;\n    const key = updates.key || this.newColumn.key;\n    const dataType = updates.dataType || this.newColumn.dataType;\n    \n    switch (dataType) {\n      case CellDataType.NUMBER:\n        finalColumn = ColumnConfigFactory.number(key, this.newColumn);\n        break;\n      case CellDataType.DATE:\n        finalColumn = ColumnConfigFactory.date(key, this.newColumn);\n        break;\n      case CellDataType.BOOLEAN:\n        finalColumn = ColumnConfigFactory.boolean(key, this.newColumn);\n        break;\n      default:\n        finalColumn = ColumnConfigFactory.text(key, this.newColumn);\n    }\n    \n    // Emit the created column\n    this.columnCreated.emit(finalColumn);\n  }\n  \n  /**\n   * Handle cancel from the editor\n   */\n  onCancel(): void {\n    this.cancelled.emit();\n  }\n  \n  /**\n   * Handle backdrop click to close modal\n   */\n  onBackdropClick(event: Event): void {\n    if (event.target === event.currentTarget) {\n      this.cancelled.emit();\n    }\n  }\n  \n  /**\n   * Prevent event propagation from modal content\n   */\n  onModalContentClick(event: Event): void {\n    event.stopPropagation();\n  }\n}\n","<div class=\"modal-backdrop\" (click)=\"onBackdropClick($event)\">\n  <div class=\"modal-content\" (click)=\"onModalContentClick($event)\">\n    <div class=\"modal-header\">\n      <h2>Add New Column</h2>\n      <button class=\"close-button\" (click)=\"onCancel()\" type=\"button\" aria-label=\"Close\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <path d=\"M18 6L6 18M6 6L18 18\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n        </svg>\n      </button>\n    </div>\n    <div class=\"modal-body\">\n      <!-- Now using the shared st-column-editor component from SharedTableComponentsModule -->\n      <st-column-editor\n        [column]=\"newColumn\"\n        [columnIndex]=\"columnIndex\"\n        (columnUpdated)=\"onColumnUpdated($event)\"\n        (cancel)=\"onCancel()\">\n      </st-column-editor>\n    </div>\n    <div class=\"modal-footer\">\n      <button type=\"button\" class=\"btn btn-secondary\" (click)=\"onCancel()\">Cancel</button>\n      <button type=\"button\" class=\"btn btn-primary\" (click)=\"onSave()\">Add Column</button>\n    </div>\n  </div>\n</div>\n"]}