@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/editors/nile-autocomplete-editor.mjs

@@ -0,0 +1,228 @@
+/**
+ * Custom editor using NileAutoComplete from @aquera/nile-elements
+ * Provides real-time suggestions as users type in table cells
+ */
+/**
+ * Custom editor that uses NileAutoComplete component
+ * @template T The value type (string by default)
+ */
+export class NileAutoCompleteEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+        if (!options.options || options.options.length === 0) {
+            console.warn('NileAutoCompleteEditor requires options array to be provided');
+        }
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileAutoCompleteEditor requires a container element');
+            return;
+        }
+        // Create NileAutoComplete custom element using document.createElement
+        this.autocomplete = document.createElement('nile-autocomplete');
+        this.autocomplete.value = String(context.value ?? '');
+        this.autocomplete.className = 'st-cell-editor st-nile-autocomplete-editor';
+        // Apply inline styles for proper cell fitting
+        this.autocomplete.style.width = 'inherit';
+        this.autocomplete.style.height = 'inherit';
+        this.autocomplete.style.boxSizing = 'border-box';
+        // Apply all configuration options
+        this.applyOptions();
+        // Set allMenuItems property for autocomplete suggestions
+        this.setMenuItems();
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Clear container and append autocomplete
+        context.container.innerHTML = '';
+        context.container.appendChild(this.autocomplete);
+        // Auto focus
+        if (this.options?.autoFocus !== false) {
+            setTimeout(() => {
+                this.autocomplete?.focus();
+            }, 0);
+        }
+    }
+    /**
+     * Set allMenuItems property for autocomplete suggestions
+     * NileAutoComplete requires allMenuItems to be set as a property, not child elements
+     */
+    setMenuItems() {
+        if (!this.autocomplete)
+            return;
+        const options = this.options.options || [];
+        // Convert options to string array for allMenuItems
+        const menuItems = options.map(opt => {
+            if (typeof opt === 'string') {
+                return opt;
+            }
+            else {
+                // For AutoCompleteOption objects, use the label for display
+                return opt.label;
+            }
+        });
+        // Set the allMenuItems property directly on the element
+        this.autocomplete.allMenuItems = menuItems;
+    }
+    /**
+     * Apply all configuration options to the NileAutoComplete element
+     */
+    applyOptions() {
+        if (!this.autocomplete)
+            return;
+        // Basic properties
+        if (this.options?.placeholder) {
+            this.autocomplete.placeholder = this.options.placeholder;
+        }
+        if (this.options?.disabled) {
+            this.autocomplete.disabled = this.options.disabled;
+        }
+        // Note: Some properties may not be available on NileAutoComplete
+        // Setting via attributes as fallback
+        if (this.options?.helpText) {
+            this.autocomplete.setAttribute('help-text', this.options.helpText);
+        }
+        // Size (if supported by NileAutoComplete)
+        if (this.options?.size) {
+            this.autocomplete.setAttribute('size', this.options.size);
+        }
+        // Behavior options - using attributes for properties that may not exist
+        if (this.options?.clearable) {
+            this.autocomplete.setAttribute('clearable', String(this.options.clearable));
+        }
+        if (this.options?.required) {
+            this.autocomplete.setAttribute('required', String(this.options.required));
+        }
+        // Styling options
+        if (this.options?.filled !== undefined) {
+            this.autocomplete.setAttribute('filled', String(this.options.filled));
+        }
+        if (this.options?.pill) {
+            this.autocomplete.setAttribute('pill', String(this.options.pill));
+        }
+        // Visual states - using attributes for properties that may not exist
+        if (this.options?.warning) {
+            this.autocomplete.setAttribute('warning', String(this.options.warning));
+        }
+        if (this.options?.error) {
+            this.autocomplete.setAttribute('error', String(this.options.error));
+        }
+        if (this.options?.success) {
+            this.autocomplete.setAttribute('success', String(this.options.success));
+        }
+        if (this.options?.errorMessage) {
+            this.autocomplete.setAttribute('error-message', this.options.errorMessage);
+        }
+        // Autocomplete specific options
+        if (this.options?.minSearchLength !== undefined) {
+            this.autocomplete.setAttribute('min-search-length', String(this.options.minSearchLength));
+        }
+        if (this.options?.maxSuggestions !== undefined) {
+            this.autocomplete.setAttribute('max-suggestions', String(this.options.maxSuggestions));
+        }
+        if (this.options?.caseSensitive !== undefined) {
+            this.autocomplete.setAttribute('case-sensitive', String(this.options.caseSensitive));
+        }
+        // Advanced options
+        if (this.options?.hoist) {
+            this.autocomplete.setAttribute('hoist', String(this.options.hoist));
+        }
+        if (this.options?.placement) {
+            this.autocomplete.setAttribute('placement', this.options.placement);
+        }
+        // Set portal attribute for proper dropdown rendering
+        this.autocomplete.setAttribute('portal', 'true');
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.autocomplete)
+            return;
+        const validateOnSave = this.options?.validateOnSave !== false;
+        // Handle keyboard events (keydown is not replaced by custom events)
+        const keydownHandler = (e) => {
+            const keyEvent = e;
+            if (keyEvent.key === 'Enter') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.saveValue(context, validateOnSave);
+            }
+            else if (keyEvent.key === 'Escape') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onCancel();
+            }
+            else if (keyEvent.key === 'Tab') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.saveValue(context, validateOnSave);
+            }
+        };
+        this.autocomplete.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // Use nile-complete custom event for when user selects an autocomplete suggestion
+        const completeHandler = (e) => {
+            const customEvent = e;
+            // Save the selected value from autocomplete
+            if (customEvent.detail && customEvent.detail.value !== undefined) {
+                context.onSave(this.parseValue(customEvent.detail.value));
+            }
+        };
+        this.autocomplete.addEventListener('nile-complete', completeHandler);
+        this.eventListeners.push({ event: 'nile-complete', handler: completeHandler });
+        // Use native blur event (NileAutoComplete doesn't have nile-blur)
+        const blurHandler = (e) => {
+            const customEvent = e;
+            // Get current value directly from the component
+            const currentValue = customEvent.detail?.value ?? '';
+            // Save on blur - TableState coordination ensures only one cell is editing at a time
+            context.onSave(this.parseValue(currentValue));
+        };
+        this.autocomplete.addEventListener('blur', blurHandler);
+        this.eventListeners.push({ event: 'blur', handler: blurHandler });
+        // Use native input event for real-time value updates (NileAutoComplete doesn't have nile-input)
+        const inputHandler = () => {
+            const currentValue = this.autocomplete?.value ?? '';
+            context.onChange(this.parseValue(currentValue));
+        };
+        this.autocomplete.addEventListener('input', inputHandler);
+        this.eventListeners.push({ event: 'input', handler: inputHandler });
+    }
+    /**
+     * Save value with optional validation
+     */
+    saveValue(context, validate) {
+        if (!this.autocomplete)
+            return;
+        // Note: NileAutoComplete may not have validation methods
+        // Validation should be handled by the validator strategy instead
+        context.onSave(this.getCurrentValue());
+    }
+    /**
+     * Parse value to appropriate type
+     */
+    parseValue(value) {
+        return value;
+    }
+    destroy() {
+        // Remove all event listeners
+        if (this.autocomplete) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.autocomplete?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            this.autocomplete.remove();
+            this.autocomplete = undefined;
+        }
+    }
+    focus() {
+        this.autocomplete?.focus();
+    }
+    getCurrentValue() {
+        if (!this.autocomplete)
+            return '';
+        return (this.autocomplete.value ?? '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-autocomplete-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-autocomplete-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileAutoComplete from @aquera/nile-elements\n * Provides real-time suggestions as users type in table cells\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Autocomplete option configuration\n */\nexport interface AutoCompleteOption {\n  /** The option's value */\n  value: string;\n  /** Display label for the option */\n  label: string;\n  /** Whether the option is disabled */\n  disabled?: boolean;\n}\n\n/**\n * Options interface for NileAutoCompleteEditor\n */\nexport interface NileAutoCompleteEditorOptions {\n  // Options configuration (REQUIRED)\n  /** Array of autocomplete suggestions - supports both simple string array or detailed AutoCompleteOption objects */\n  options: AutoCompleteOption[] | string[];\n  \n  // Basic properties\n  /** Placeholder text to show as a hint when the search is empty */\n  placeholder?: string;\n  /** Disable the autocomplete control */\n  disabled?: boolean;\n  /** Help text to display below the control */\n  helpText?: string;\n  /** Size of the autocomplete control */\n  size?: 'small' | 'medium' | 'large';\n  \n  // Behavior options\n  /** Adds clear button when value is not empty */\n  clearable?: boolean;\n  /** Make the autocomplete required */\n  required?: boolean;\n  /** Auto-focus the input when editor opens */\n  autoFocus?: boolean;\n  /** Select all text when focused */\n  selectOnFocus?: boolean;\n  \n  // Visual states\n  /** Warning state styling */\n  warning?: boolean;\n  /** Error state styling */\n  error?: boolean;\n  /** Success state styling */\n  success?: boolean;\n  /** Error message to display */\n  errorMessage?: string;\n  \n  // Autocomplete specific options\n  /** Minimum number of characters before showing suggestions */\n  minSearchLength?: number;\n  /** Maximum number of suggestions to show */\n  maxSuggestions?: number;\n  /** Case-sensitive matching */\n  caseSensitive?: boolean;\n  /** Filter mode for matching suggestions */\n  filterMode?: 'startsWith' | 'contains' | 'custom';\n  /** Custom filter function for matching */\n  customFilter?: (input: string, option: AutoCompleteOption) => boolean;\n  \n  // Styling options\n  /** Draws a filled autocomplete style */\n  filled?: boolean;\n  /** Pill-style with rounded edges */\n  pill?: boolean;\n  \n  // Advanced options\n  /** Use fixed positioning to prevent clipping */\n  hoist?: boolean;\n  /** Placement of the suggestions dropdown */\n  placement?: 'top' | 'bottom';\n  \n  // Validation\n  /** Validate before saving (default: true) */\n  validateOnSave?: boolean;\n}\n\n/**\n * Custom editor that uses NileAutoComplete component\n * @template T The value type (string by default)\n */\nexport class NileAutoCompleteEditor<T = string> implements CellEditor<T> {\n  private autocomplete?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n\n  constructor(private readonly options: NileAutoCompleteEditorOptions) {\n    if (!options.options || options.options.length === 0) {\n      console.warn('NileAutoCompleteEditor requires options array to be provided');\n    }\n  }\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileAutoCompleteEditor requires a container element');\n      return;\n    }\n\n    // Create NileAutoComplete custom element using document.createElement\n    this.autocomplete = document.createElement('nile-autocomplete');\n    this.autocomplete.value = String(context.value ?? '');\n    this.autocomplete.className = 'st-cell-editor st-nile-autocomplete-editor';\n    \n    // Apply inline styles for proper cell fitting\n    this.autocomplete.style.width = 'inherit';\n    this.autocomplete.style.height = 'inherit';\n    this.autocomplete.style.boxSizing = 'border-box';\n    \n    // Apply all configuration options\n    this.applyOptions();\n\n    // Set allMenuItems property for autocomplete suggestions\n    this.setMenuItems();\n\n    // Set up event listeners\n    this.setupEventListeners(context);\n\n    // Clear container and append autocomplete\n    context.container.innerHTML = '';\n    context.container.appendChild(this.autocomplete);\n\n    // Auto focus\n    if (this.options?.autoFocus !== false) {\n      setTimeout(() => {\n        this.autocomplete?.focus();\n      }, 0);\n    }\n  }\n\n  /**\n   * Set allMenuItems property for autocomplete suggestions\n   * NileAutoComplete requires allMenuItems to be set as a property, not child elements\n   */\n  private setMenuItems(): void {\n    if (!this.autocomplete) return;\n\n    const options = this.options.options || [];\n    \n    // Convert options to string array for allMenuItems\n    const menuItems: string[] = options.map(opt => {\n      if (typeof opt === 'string') {\n        return opt;\n      } else {\n        // For AutoCompleteOption objects, use the label for display\n        return opt.label;\n      }\n    });\n\n    // Set the allMenuItems property directly on the element\n    (this.autocomplete as any).allMenuItems = menuItems;\n  }\n\n  /**\n   * Apply all configuration options to the NileAutoComplete element\n   */\n  private applyOptions(): void {\n    if (!this.autocomplete) return;\n\n    // Basic properties\n    if (this.options?.placeholder) {\n      this.autocomplete.placeholder = this.options.placeholder;\n    }\n\n    if (this.options?.disabled) {\n      this.autocomplete.disabled = this.options.disabled;\n    }\n\n    // Note: Some properties may not be available on NileAutoComplete\n    // Setting via attributes as fallback\n    if (this.options?.helpText) {\n      this.autocomplete.setAttribute('help-text', this.options.helpText);\n    }\n\n    // Size (if supported by NileAutoComplete)\n    if (this.options?.size) {\n      this.autocomplete.setAttribute('size', this.options.size);\n    }\n\n    // Behavior options - using attributes for properties that may not exist\n    if (this.options?.clearable) {\n      this.autocomplete.setAttribute('clearable', String(this.options.clearable));\n    }\n\n    if (this.options?.required) {\n      this.autocomplete.setAttribute('required', String(this.options.required));\n    }\n\n    // Styling options\n    if (this.options?.filled !== undefined) {\n      this.autocomplete.setAttribute('filled', String(this.options.filled));\n    }\n\n    if (this.options?.pill) {\n      this.autocomplete.setAttribute('pill', String(this.options.pill));\n    }\n\n    // Visual states - using attributes for properties that may not exist\n    if (this.options?.warning) {\n      this.autocomplete.setAttribute('warning', String(this.options.warning));\n    }\n\n    if (this.options?.error) {\n      this.autocomplete.setAttribute('error', String(this.options.error));\n    }\n\n    if (this.options?.success) {\n      this.autocomplete.setAttribute('success', String(this.options.success));\n    }\n\n    if (this.options?.errorMessage) {\n      this.autocomplete.setAttribute('error-message', this.options.errorMessage);\n    }\n\n    // Autocomplete specific options\n    if (this.options?.minSearchLength !== undefined) {\n      this.autocomplete.setAttribute('min-search-length', String(this.options.minSearchLength));\n    }\n\n    if (this.options?.maxSuggestions !== undefined) {\n      this.autocomplete.setAttribute('max-suggestions', String(this.options.maxSuggestions));\n    }\n\n    if (this.options?.caseSensitive !== undefined) {\n      this.autocomplete.setAttribute('case-sensitive', String(this.options.caseSensitive));\n    }\n\n    // Advanced options\n    if (this.options?.hoist) {\n      this.autocomplete.setAttribute('hoist', String(this.options.hoist));\n    }\n\n    if (this.options?.placement) {\n      this.autocomplete.setAttribute('placement', this.options.placement);\n    }\n\n    // Set portal attribute for proper dropdown rendering\n    this.autocomplete.setAttribute('portal', 'true');\n  }\n\n  /**\n   * Set up all event listeners with proper cleanup tracking\n   */\n  private setupEventListeners(context: CellEditorContext<T>): void {\n    if (!this.autocomplete) return;\n\n    const validateOnSave = this.options?.validateOnSave !== false;\n\n    // Handle keyboard events (keydown is not replaced by custom events)\n    const keydownHandler = (e: Event) => {\n      const keyEvent = e as KeyboardEvent;\n      if (keyEvent.key === 'Enter') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        this.saveValue(context, validateOnSave);\n      } else if (keyEvent.key === 'Escape') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onCancel();\n      } else if (keyEvent.key === 'Tab') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        this.saveValue(context, validateOnSave);\n      }\n    };\n    this.autocomplete.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n\n    // Use nile-complete custom event for when user selects an autocomplete suggestion\n    const completeHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // Save the selected value from autocomplete\n      if (customEvent.detail && customEvent.detail.value !== undefined) {\n        context.onSave(this.parseValue(customEvent.detail.value));\n      }\n    };\n    this.autocomplete.addEventListener('nile-complete', completeHandler);\n    this.eventListeners.push({ event: 'nile-complete', handler: completeHandler });\n\n    // Use native blur event (NileAutoComplete doesn't have nile-blur)\n    const blurHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // Get current value directly from the component\n      const currentValue = customEvent.detail?.value ?? '';\n      // Save on blur - TableState coordination ensures only one cell is editing at a time\n      context.onSave(this.parseValue(currentValue));\n    };\n    this.autocomplete.addEventListener('blur', blurHandler);\n    this.eventListeners.push({ event: 'blur', handler: blurHandler });\n\n    // Use native input event for real-time value updates (NileAutoComplete doesn't have nile-input)\n    const inputHandler = () => {\n      const currentValue = this.autocomplete?.value ?? '';\n      context.onChange(this.parseValue(currentValue));\n    };\n    this.autocomplete.addEventListener('input', inputHandler);\n    this.eventListeners.push({ event: 'input', handler: inputHandler });\n  }\n\n  /**\n   * Save value with optional validation\n   */\n  private saveValue(context: CellEditorContext<T>, validate: boolean): void {\n    if (!this.autocomplete) return;\n\n    // Note: NileAutoComplete may not have validation methods\n    // Validation should be handled by the validator strategy instead\n    context.onSave(this.getCurrentValue());\n  }\n\n  /**\n   * Parse value to appropriate type\n   */\n  private parseValue(value: string): T {\n    return value as unknown as T;\n  }\n\n  destroy(): void {\n    // Remove all event listeners\n    if (this.autocomplete) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.autocomplete?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n      \n      this.autocomplete.remove();\n      this.autocomplete = undefined;\n    }\n  }\n\n  focus(): void {\n    this.autocomplete?.focus();\n  }\n\n  getCurrentValue(): T {\n    if (!this.autocomplete) return '' as unknown as T;\n    return (this.autocomplete.value ?? '') as unknown as T;\n  }\n}\n"]}

package/esm2020/lib/editors/nile-calendar-editor.mjs

@@ -0,0 +1,214 @@
+/**
+ * Custom editor using NileCalendar from @aquera/nile-elements
+ * Provides date selection functionality for table cells
+ */
+/**
+ * Custom editor that uses NileCalendar component for date selection
+ * @template T The value type (string by default, formatted as YYYY-MM-DD)
+ */
+export class NileCalendarEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileCalendarEditor requires a container element');
+            return;
+        }
+        // Create NileCalendar custom element using document.createElement
+        this.calendar = document.createElement('nile-calendar');
+        // Set initial value (NileCalendar expects Date object)
+        if (context.value) {
+            const dateValue = String(context.value);
+            // Convert string to Date object
+            const date = new Date(dateValue);
+            if (!isNaN(date.getTime())) {
+                this.calendar.value = date;
+            }
+        }
+        this.calendar.className = 'st-cell-editor st-nile-calendar-editor';
+        // Apply inline styles for proper cell fitting
+        this.calendar.style.width = 'inherit';
+        this.calendar.style.height = 'inherit';
+        this.calendar.style.boxSizing = 'border-box';
+        // Apply all configuration options
+        this.applyOptions();
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Clear container and append calendar
+        context.container.innerHTML = '';
+        context.container.appendChild(this.calendar);
+        // Auto focus
+        if (this.options?.autoFocus !== false) {
+            setTimeout(() => {
+                this.calendar?.focus();
+            }, 0);
+        }
+    }
+    /**
+     * Apply all configuration options to the NileCalendar element
+     */
+    applyOptions() {
+        if (!this.calendar)
+            return;
+        // Date format (default: ISO format)
+        const dateFormat = this.options?.dateFormat || 'YYYY-MM-DD';
+        this.calendar.setAttribute('dateFormat', dateFormat);
+        // Basic properties
+        if (this.options?.disabled) {
+            this.calendar.setAttribute('disabled', String(this.options.disabled));
+        }
+        if (this.options?.placeholder) {
+            this.calendar.setAttribute('placeholder', this.options.placeholder);
+        }
+        if (this.options?.helpText) {
+            this.calendar.setAttribute('help-text', this.options.helpText);
+        }
+        // Behavior options
+        if (this.options?.allowClear) {
+            this.calendar.setAttribute('allowClear', String(this.options.allowClear));
+        }
+        if (this.options?.doubleClickUnselect) {
+            this.calendar.setAttribute('doubleClickUnselect', String(this.options.doubleClickUnselect));
+        }
+        if (this.options?.showMonthDropdown) {
+            this.calendar.setAttribute('showMonthDropdown', String(this.options.showMonthDropdown));
+        }
+        if (this.options?.showYearDropdown) {
+            this.calendar.setAttribute('showYearDropdown', String(this.options.showYearDropdown));
+        }
+        if (this.options?.showManualInputs) {
+            this.calendar.setAttribute('showManualInputs', String(this.options.showManualInputs));
+        }
+        // Year range
+        if (this.options?.startYear) {
+            this.calendar.setAttribute('startYear', String(this.options.startYear));
+        }
+        if (this.options?.endYear) {
+            this.calendar.setAttribute('endYear', String(this.options.endYear));
+        }
+        // Allowed dates range
+        if (this.options?.allowedDates) {
+            this.calendar.setAttribute('allowedDates', JSON.stringify(this.options.allowedDates));
+        }
+        // Visual states - using attributes for properties that may not exist
+        if (this.options?.warning) {
+            this.calendar.setAttribute('warning', String(this.options.warning));
+        }
+        if (this.options?.error) {
+            this.calendar.setAttribute('error', String(this.options.error));
+        }
+        if (this.options?.success) {
+            this.calendar.setAttribute('success', String(this.options.success));
+        }
+        if (this.options?.errorMessage) {
+            this.calendar.setAttribute('error-message', this.options.errorMessage);
+        }
+        // Size
+        if (this.options?.size) {
+            this.calendar.setAttribute('size', this.options.size);
+        }
+        // Portal rendering (default: true)
+        if (this.options?.portal !== false) {
+            this.calendar.setAttribute('portal', 'true');
+        }
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.calendar)
+            return;
+        const validateOnSave = this.options?.validateOnSave !== false;
+        // Handle keyboard events (keydown is not replaced by custom events)
+        const keydownHandler = (e) => {
+            const keyEvent = e;
+            if (keyEvent.key === 'Enter') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.saveValue(context, validateOnSave);
+            }
+            else if (keyEvent.key === 'Escape') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onCancel();
+            }
+            else if (keyEvent.key === 'Tab') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                this.saveValue(context, validateOnSave);
+            }
+        };
+        this.calendar.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // Use nile-change custom event for date selection
+        const changeHandler = (e) => {
+            const customEvent = e;
+            context.onSave(this.parseValue(customEvent.detail.value));
+        };
+        this.calendar.addEventListener('nile-change', changeHandler);
+        this.eventListeners.push({ event: 'nile-change', handler: changeHandler });
+        // Use nile-blur custom event (save on blur)
+        const blurHandler = (e) => {
+            const customEvent = e;
+            // Note: NileCalendar may not have validation methods
+            // Validation should be handled by the validator strategy instead
+            context.onSave(this.parseValue(customEvent.detail.value));
+        };
+        this.calendar.addEventListener('nile-blur', blurHandler);
+        this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });
+        // Handle clear button if enabled
+        if (this.options?.allowClear) {
+            const clearHandler = (e) => {
+                context.onSave(this.parseValue(''));
+            };
+            this.calendar.addEventListener('nile-clear', clearHandler);
+            this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });
+        }
+    }
+    /**
+     * Save value with optional validation
+     */
+    saveValue(context, validate) {
+        if (!this.calendar)
+            return;
+        // Note: NileCalendar may not have validation methods
+        // Validation should be handled by the validator strategy instead
+        context.onSave(this.getCurrentValue());
+    }
+    /**
+     * Parse value to appropriate type
+     */
+    parseValue(value) {
+        // Value is already in the correct format from nile-calendar
+        return (value || '');
+    }
+    destroy() {
+        // Remove all event listeners
+        if (this.calendar) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.calendar?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            this.calendar.remove();
+            this.calendar = undefined;
+        }
+    }
+    focus() {
+        this.calendar?.focus();
+    }
+    getCurrentValue() {
+        if (!this.calendar)
+            return '';
+        // NileCalendar.value is a Date object, convert to ISO string format
+        if (this.calendar.value instanceof Date) {
+            const year = this.calendar.value.getFullYear();
+            const month = String(this.calendar.value.getMonth() + 1).padStart(2, '0');
+            const day = String(this.calendar.value.getDate()).padStart(2, '0');
+            return `${year}-${month}-${day}`;
+        }
+        return '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-calendar-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-calendar-editor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAuEH;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IAI7B,YAA6B,OAAmC;QAAnC,YAAO,GAAP,OAAO,CAA4B;QAFxD,mBAAc,GAAqD,EAAE,CAAC;IAEX,CAAC;IAEpE,IAAI,CAAC,OAA6B;QAChC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YACtB,OAAO,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;YAChE,OAAO;SACR;QAED,kEAAkE;QAClE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;QAExD,uDAAuD;QACvD,IAAI,OAAO,CAAC,KAAK,EAAE;YACjB,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACxC,gCAAgC;YAChC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;gBAC1B,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC;aAC5B;SACF;QAED,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,wCAAwC,CAAC;QAEnE,8CAA8C;QAC9C,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,GAAG,SAAS,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;QACvC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,GAAG,YAAY,CAAC;QAE7C,kCAAkC;QAClC,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,yBAAyB;QACzB,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAElC,sCAAsC;QACtC,OAAO,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC;QACjC,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE7C,aAAa;QACb,IAAI,IAAI,CAAC,OAAO,EAAE,SAAS,KAAK,KAAK,EAAE;YACrC,UAAU,CAAC,GAAG,EAAE;gBACd,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC;YACzB,CAAC,EAAE,CAAC,CAAC,CAAC;SACP;IACH,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAE3B,oCAAoC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,EAAE,UAAU,IAAI,YAAY,CAAC;QAC5D,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAErD,mBAAmB;QACnB,IAAI,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE;YAC1B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;SACvE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE;YAC7B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;SACrE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE;YAC1B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;SAChE;QAED,mBAAmB;QACnB,IAAI,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE;YAC5B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;SAC3E;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,mBAAmB,EAAE;YACrC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,qBAAqB,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC;SAC7F;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE;YACnC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,mBAAmB,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC;SACzF;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE;YAClC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACvF;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE;YAClC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACvF;QAED,aAAa;QACb,IAAI,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE;YAC3B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;SACzE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE;YACzB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;SACrE;QAED,sBAAsB;QACtB,IAAI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE;YAC9B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;SACvF;QAED,qEAAqE;QACrE,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE;YACzB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;SACrE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE;YACvB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;SACjE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE;YACzB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;SACrE;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE;YAC9B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;SACxE;QAED,OAAO;QACP,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE;YACtB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SACvD;QAED,mCAAmC;QACnC,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,KAAK,KAAK,EAAE;YAClC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;SAC9C;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,OAA6B;QACvD,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAE3B,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,EAAE,cAAc,KAAK,KAAK,CAAC;QAE9D,oEAAoE;QACpE,MAAM,cAAc,GAAG,CAAC,CAAQ,EAAE,EAAE;YAClC,MAAM,QAAQ,GAAG,CAAkB,CAAC;YACpC,IAAI,QAAQ,CAAC,GAAG,KAAK,OAAO,EAAE;gBAC5B,QAAQ,CAAC,cAAc,EAAE,CAAC;gBAC1B,QAAQ,CAAC,eAAe,EAAE,CAAC;gBAC3B,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;aACzC;iBAAM,IAAI,QAAQ,CAAC,GAAG,KAAK,QAAQ,EAAE;gBACpC,QAAQ,CAAC,cAAc,EAAE,CAAC;gBAC1B,QAAQ,CAAC,eAAe,EAAE,CAAC;gBAC3B,OAAO,CAAC,QAAQ,EAAE,CAAC;aACpB;iBAAM,IAAI,QAAQ,CAAC,GAAG,KAAK,KAAK,EAAE;gBACjC,QAAQ,CAAC,cAAc,EAAE,CAAC;gBAC1B,QAAQ,CAAC,eAAe,EAAE,CAAC;gBAC3B,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;aACzC;QACH,CAAC,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QAC1D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;QAExE,kDAAkD;QAClD,MAAM,aAAa,GAAG,CAAC,CAAQ,EAAE,EAAE;YACjC,MAAM,WAAW,GAAG,CAAgB,CAAC;YACrC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QAC7D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;QAE3E,4CAA4C;QAC5C,MAAM,WAAW,GAAG,CAAC,CAAQ,EAAE,EAAE;YAC/B,MAAM,WAAW,GAAG,CAAgB,CAAC;YACrC,qDAAqD;YACrD,iEAAiE;YACjE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;QAEvE,iCAAiC;QACjC,IAAI,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE;YAC5B,MAAM,YAAY,GAAG,CAAC,CAAQ,EAAE,EAAE;gBAChC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;YACtC,CAAC,CAAC;YACF,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;YAC3D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC;SAC1E;IACH,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,OAA6B,EAAE,QAAiB;QAChE,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAE3B,qDAAqD;QACrD,iEAAiE;QACjE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACK,UAAU,CAAC,KAAa;QAC9B,4DAA4D;QAC5D,OAAO,CAAC,KAAK,IAAI,EAAE,CAAiB,CAAC;IACvC,CAAC;IAED,OAAO;QACL,6BAA6B;QAC7B,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE;gBACjD,IAAI,CAAC,QAAQ,EAAE,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACrD,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;YAEzB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;SAC3B;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC;IACzB,CAAC;IAED,eAAe;QACb,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO,EAAkB,CAAC;QAE9C,oEAAoE;QACpE,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,YAAY,IAAI,EAAE;YACvC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YAC1E,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YACnE,OAAO,GAAG,IAAI,IAAI,KAAK,IAAI,GAAG,EAAkB,CAAC;SAClD;QAED,OAAO,EAAkB,CAAC;IAC5B,CAAC;CACF","sourcesContent":["/**\n * Custom editor using NileCalendar from @aquera/nile-elements\n * Provides date selection functionality for table cells\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Date range configuration for restricting allowed dates\n */\nexport interface AllowedDatesRange {\n  /** Start date in ISO format (YYYY-MM-DD) */\n  startDate?: string;\n  /** End date in ISO format (YYYY-MM-DD) */\n  endDate?: string;\n}\n\n/**\n * Options interface for NileCalendarEditor\n */\nexport interface NileCalendarEditorOptions {\n  // Basic properties\n  /** Placeholder text to show when no date is selected */\n  placeholder?: string;\n  /** Disable the calendar control */\n  disabled?: boolean;\n  /** Help text to display below the control */\n  helpText?: string;\n  \n  // Date configuration\n  /** Date format for display (default: 'YYYY-MM-DD') */\n  dateFormat?: string;\n  /** Start year for year dropdown */\n  startYear?: number;\n  /** End year for year dropdown */\n  endYear?: number;\n  /** Date range restrictions */\n  allowedDates?: AllowedDatesRange;\n  \n  // Behavior options\n  /** Show clear button for removing date */\n  allowClear?: boolean;\n  /** Allow double-click to unselect date */\n  doubleClickUnselect?: boolean;\n  /** Show month selection dropdown */\n  showMonthDropdown?: boolean;\n  /** Show year selection dropdown */\n  showYearDropdown?: boolean;\n  /** Allow manual date input via text fields */\n  showManualInputs?: boolean;\n  /** Auto-focus the calendar when editor opens */\n  autoFocus?: boolean;\n  \n  // Visual states\n  /** Warning state styling */\n  warning?: boolean;\n  /** Error state styling */\n  error?: boolean;\n  /** Success state styling */\n  success?: boolean;\n  /** Error message to display */\n  errorMessage?: string;\n  \n  // Styling\n  /** Size of the calendar control */\n  size?: 'small' | 'medium' | 'large';\n  \n  // Advanced options\n  /** Use portal for dropdown rendering to prevent clipping */\n  portal?: boolean;\n  /** Validate before saving (default: true) */\n  validateOnSave?: boolean;\n}\n\n/**\n * Custom editor that uses NileCalendar component for date selection\n * @template T The value type (string by default, formatted as YYYY-MM-DD)\n */\nexport class NileCalendarEditor<T = string> implements CellEditor<T> {\n  private calendar?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n\n  constructor(private readonly options?: NileCalendarEditorOptions) {}\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileCalendarEditor requires a container element');\n      return;\n    }\n\n    // Create NileCalendar custom element using document.createElement\n    this.calendar = document.createElement('nile-calendar');\n    \n    // Set initial value (NileCalendar expects Date object)\n    if (context.value) {\n      const dateValue = String(context.value);\n      // Convert string to Date object\n      const date = new Date(dateValue);\n      if (!isNaN(date.getTime())) {\n        this.calendar.value = date;\n      }\n    }\n    \n    this.calendar.className = 'st-cell-editor st-nile-calendar-editor';\n    \n    // Apply inline styles for proper cell fitting\n    this.calendar.style.width = 'inherit';\n    this.calendar.style.height = 'inherit';\n    this.calendar.style.boxSizing = 'border-box';\n    \n    // Apply all configuration options\n    this.applyOptions();\n    \n    // Set up event listeners\n    this.setupEventListeners(context);\n    \n    // Clear container and append calendar\n    context.container.innerHTML = '';\n    context.container.appendChild(this.calendar);\n    \n    // Auto focus\n    if (this.options?.autoFocus !== false) {\n      setTimeout(() => {\n        this.calendar?.focus();\n      }, 0);\n    }\n  }\n\n  /**\n   * Apply all configuration options to the NileCalendar element\n   */\n  private applyOptions(): void {\n    if (!this.calendar) return;\n    \n    // Date format (default: ISO format)\n    const dateFormat = this.options?.dateFormat || 'YYYY-MM-DD';\n    this.calendar.setAttribute('dateFormat', dateFormat);\n    \n    // Basic properties\n    if (this.options?.disabled) {\n      this.calendar.setAttribute('disabled', String(this.options.disabled));\n    }\n    \n    if (this.options?.placeholder) {\n      this.calendar.setAttribute('placeholder', this.options.placeholder);\n    }\n    \n    if (this.options?.helpText) {\n      this.calendar.setAttribute('help-text', this.options.helpText);\n    }\n    \n    // Behavior options\n    if (this.options?.allowClear) {\n      this.calendar.setAttribute('allowClear', String(this.options.allowClear));\n    }\n    \n    if (this.options?.doubleClickUnselect) {\n      this.calendar.setAttribute('doubleClickUnselect', String(this.options.doubleClickUnselect));\n    }\n    \n    if (this.options?.showMonthDropdown) {\n      this.calendar.setAttribute('showMonthDropdown', String(this.options.showMonthDropdown));\n    }\n    \n    if (this.options?.showYearDropdown) {\n      this.calendar.setAttribute('showYearDropdown', String(this.options.showYearDropdown));\n    }\n    \n    if (this.options?.showManualInputs) {\n      this.calendar.setAttribute('showManualInputs', String(this.options.showManualInputs));\n    }\n    \n    // Year range\n    if (this.options?.startYear) {\n      this.calendar.setAttribute('startYear', String(this.options.startYear));\n    }\n    \n    if (this.options?.endYear) {\n      this.calendar.setAttribute('endYear', String(this.options.endYear));\n    }\n    \n    // Allowed dates range\n    if (this.options?.allowedDates) {\n      this.calendar.setAttribute('allowedDates', JSON.stringify(this.options.allowedDates));\n    }\n    \n    // Visual states - using attributes for properties that may not exist\n    if (this.options?.warning) {\n      this.calendar.setAttribute('warning', String(this.options.warning));\n    }\n    \n    if (this.options?.error) {\n      this.calendar.setAttribute('error', String(this.options.error));\n    }\n    \n    if (this.options?.success) {\n      this.calendar.setAttribute('success', String(this.options.success));\n    }\n    \n    if (this.options?.errorMessage) {\n      this.calendar.setAttribute('error-message', this.options.errorMessage);\n    }\n    \n    // Size\n    if (this.options?.size) {\n      this.calendar.setAttribute('size', this.options.size);\n    }\n    \n    // Portal rendering (default: true)\n    if (this.options?.portal !== false) {\n      this.calendar.setAttribute('portal', 'true');\n    }\n  }\n\n  /**\n   * Set up all event listeners with proper cleanup tracking\n   */\n  private setupEventListeners(context: CellEditorContext<T>): void {\n    if (!this.calendar) return;\n    \n    const validateOnSave = this.options?.validateOnSave !== false;\n    \n    // Handle keyboard events (keydown is not replaced by custom events)\n    const keydownHandler = (e: Event) => {\n      const keyEvent = e as KeyboardEvent;\n      if (keyEvent.key === 'Enter') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        this.saveValue(context, validateOnSave);\n      } else if (keyEvent.key === 'Escape') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onCancel();\n      } else if (keyEvent.key === 'Tab') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        this.saveValue(context, validateOnSave);\n      }\n    };\n    this.calendar.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n    \n    // Use nile-change custom event for date selection\n    const changeHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      context.onSave(this.parseValue(customEvent.detail.value));\n    };\n    this.calendar.addEventListener('nile-change', changeHandler);\n    this.eventListeners.push({ event: 'nile-change', handler: changeHandler });\n    \n    // Use nile-blur custom event (save on blur)\n    const blurHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // Note: NileCalendar may not have validation methods\n      // Validation should be handled by the validator strategy instead\n      context.onSave(this.parseValue(customEvent.detail.value));\n    };\n    this.calendar.addEventListener('nile-blur', blurHandler);\n    this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });\n    \n    // Handle clear button if enabled\n    if (this.options?.allowClear) {\n      const clearHandler = (e: Event) => {\n        context.onSave(this.parseValue(''));\n      };\n      this.calendar.addEventListener('nile-clear', clearHandler);\n      this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });\n    }\n  }\n\n  /**\n   * Save value with optional validation\n   */\n  private saveValue(context: CellEditorContext<T>, validate: boolean): void {\n    if (!this.calendar) return;\n    \n    // Note: NileCalendar may not have validation methods\n    // Validation should be handled by the validator strategy instead\n    context.onSave(this.getCurrentValue());\n  }\n\n  /**\n   * Parse value to appropriate type\n   */\n  private parseValue(value: string): T {\n    // Value is already in the correct format from nile-calendar\n    return (value || '') as unknown as T;\n  }\n\n  destroy(): void {\n    // Remove all event listeners\n    if (this.calendar) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.calendar?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n      \n      this.calendar.remove();\n      this.calendar = undefined;\n    }\n  }\n\n  focus(): void {\n    this.calendar?.focus();\n  }\n\n  getCurrentValue(): T {\n    if (!this.calendar) return '' as unknown as T;\n    \n    // NileCalendar.value is a Date object, convert to ISO string format\n    if (this.calendar.value instanceof Date) {\n      const year = this.calendar.value.getFullYear();\n      const month = String(this.calendar.value.getMonth() + 1).padStart(2, '0');\n      const day = String(this.calendar.value.getDate()).padStart(2, '0');\n      return `${year}-${month}-${day}` as unknown as T;\n    }\n    \n    return '' as unknown as T;\n  }\n}\n"]}