@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/editors/nile-date-picker-editor.mjs

@@ -0,0 +1,227 @@
+/**
+ * Custom editor using NileDatePicker from @aquera/nile-elements
+ * Supports both single date and range selection with slot-based trigger input
+ * Returns string values for both modes:
+ *   - Single mode: 'YYYY-MM-DD'
+ *   - Range mode: 'YYYY-MM-DD - YYYY-MM-DD'
+ */
+/**
+ * Custom editor using NileDatePicker component
+ * Supports both single date and range selection
+ * @template T The value type - string for both single and range modes
+ *            Single mode: 'YYYY-MM-DD'
+ *            Range mode: 'YYYY-MM-DD - YYYY-MM-DD'
+ */
+export class NileDatePickerEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileDatePickerEditor requires a container element');
+            return;
+        }
+        // Create NileDatePicker using document.createElement
+        this.datePicker = document.createElement('nile-date-picker');
+        this.datePicker.className = 'st-cell-editor st-nile-date-picker-editor';
+        // Apply styles for cell fitting
+        this.datePicker.style.width = 'inherit';
+        this.datePicker.style.height = 'inherit';
+        this.datePicker.style.boxSizing = 'border-box';
+        // Create trigger input with slot using document.createElement
+        this.triggerInput = document.createElement('nile-input');
+        this.triggerInput.setAttribute('slot', 'trigger');
+        // Set initial value
+        this.setInitialValue(context.value);
+        if (this.options?.label) {
+            this.triggerInput.label = this.options.label;
+        }
+        // Apply configuration options
+        this.applyOptions();
+        // Append trigger to date picker (slot-based)
+        this.datePicker.appendChild(this.triggerInput);
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Append to container
+        context.container.innerHTML = '';
+        context.container.appendChild(this.datePicker);
+        // Auto focus and open the date picker
+        if (this.options?.autoFocus !== false) {
+            setTimeout(() => {
+                this.triggerInput?.focus();
+                // Trigger a click to open the date picker dropdown
+                this.triggerInput?.click();
+            }, 0);
+        }
+    }
+    /**
+     * Set initial value in the trigger input
+     */
+    setInitialValue(value) {
+        if (!this.triggerInput)
+            return;
+        if (!value) {
+            this.triggerInput.value = '';
+            return;
+        }
+        // Both single and range modes use string value
+        this.triggerInput.value = String(value);
+    }
+    /**
+     * Apply all configuration options to both NileDatePicker and trigger input
+     */
+    applyOptions() {
+        if (!this.datePicker || !this.triggerInput)
+            return;
+        // Configure NileDatePicker
+        const dateFormat = this.options?.dateFormat || 'YYYY-MM-DD';
+        this.datePicker.setAttribute('dateFormat', dateFormat);
+        if (this.options?.range) {
+            this.datePicker.setAttribute('range', String(this.options.range));
+        }
+        if (this.options?.syncDatePicker) {
+            this.datePicker.setAttribute('syncDatePicker', String(this.options.syncDatePicker));
+        }
+        // Configure trigger input
+        if (this.options?.disabled) {
+            this.triggerInput.disabled = this.options.disabled;
+        }
+        if (this.options?.clearable) {
+            this.triggerInput.clearable = this.options.clearable;
+        }
+        if (this.options?.helpText) {
+            this.triggerInput.setAttribute('help-text', this.options.helpText);
+        }
+        // Visual states on trigger
+        if (this.options?.warning) {
+            this.triggerInput.setAttribute('warning', String(this.options.warning));
+        }
+        if (this.options?.error) {
+            this.triggerInput.setAttribute('error', String(this.options.error));
+        }
+        if (this.options?.success) {
+            this.triggerInput.setAttribute('success', String(this.options.success));
+        }
+        if (this.options?.errorMessage) {
+            this.triggerInput.setAttribute('error-message', this.options.errorMessage);
+        }
+        // Styling
+        if (this.options?.size) {
+            this.triggerInput.setAttribute('size', String(this.options.size));
+        }
+        if (this.options?.filled) {
+            this.triggerInput.setAttribute('filled', String(this.options.filled));
+        }
+        if (this.options?.pill) {
+            this.triggerInput.setAttribute('pill', String(this.options.pill));
+        }
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.datePicker || !this.triggerInput)
+            return;
+        const validateOnSave = this.options?.validateOnSave !== false;
+        // Keyboard events on trigger input
+        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.triggerInput.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // nile-change event on date picker
+        const changeHandler = (e) => {
+            const customEvent = e;
+            // NileDatePicker detail has startDate and endDate, not a single value
+            const detail = customEvent.detail;
+            let dateValue = '';
+            if (detail.startDate && detail.endDate) {
+                // Range mode: combine startDate and endDate
+                dateValue = `${detail.startDate} - ${detail.endDate}`;
+            }
+            else if (detail.startDate) {
+                // Single mode: only startDate
+                dateValue = detail.startDate;
+            }
+            context.onSave(this.parseValue(dateValue));
+        };
+        this.datePicker.addEventListener('nile-change', changeHandler);
+        this.eventListeners.push({ event: 'nile-change', handler: changeHandler });
+        // nile-blur event on trigger input
+        const blurHandler = (e) => {
+            const customEvent = e;
+            // For blur, get value from trigger input directly
+            const inputValue = this.triggerInput?.value || '';
+            if (inputValue) {
+                context.onSave(this.parseValue(inputValue));
+            }
+        };
+        this.triggerInput.addEventListener('nile-blur', blurHandler);
+        this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });
+        // nile-clear event
+        if (this.options?.clearable) {
+            const clearHandler = (e) => {
+                context.onSave('');
+            };
+            this.triggerInput.addEventListener('nile-clear', clearHandler);
+            this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });
+        }
+    }
+    /**
+     * Save value with optional validation
+     */
+    saveValue(context, validate) {
+        if (!this.datePicker)
+            return;
+        context.onSave(this.getCurrentValue());
+    }
+    /**
+     * Parse value from string to appropriate type
+     */
+    parseValue(value) {
+        // Both single and range modes return string
+        // Single mode: 'YYYY-MM-DD'
+        // Range mode: 'YYYY-MM-DD - YYYY-MM-DD'
+        return (value || '');
+    }
+    getCurrentValue() {
+        if (!this.triggerInput) {
+            return '';
+        }
+        return this.parseValue(this.triggerInput.value ?? '');
+    }
+    destroy() {
+        if (this.datePicker || this.triggerInput) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.datePicker?.removeEventListener(event, handler);
+                this.triggerInput?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            if (this.datePicker) {
+                this.datePicker.remove();
+                this.datePicker = undefined;
+            }
+            this.triggerInput = undefined;
+        }
+    }
+    focus() {
+        this.triggerInput?.focus();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-date-picker-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-date-picker-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileDatePicker from @aquera/nile-elements\n * Supports both single date and range selection with slot-based trigger input\n * Returns string values for both modes:\n *   - Single mode: 'YYYY-MM-DD'\n *   - Range mode: 'YYYY-MM-DD - YYYY-MM-DD'\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Date range value interface (kept for reference but not used as return type)\n * The editor returns string values instead\n */\nexport interface DateRange {\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 NileDatePickerEditor\n */\nexport interface NileDatePickerEditorOptions {\n  // Basic properties\n  /** Placeholder text to show when no date is selected */\n  placeholder?: string;\n  /** Label for the trigger input */\n  label?: string;\n  /** Disable the date picker 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  /** Enable range selection mode */\n  range?: boolean;\n  /** Sync date pickers in range mode */\n  syncDatePicker?: boolean;\n  \n  // Behavior options\n  /** Show clear button for removing date */\n  clearable?: boolean;\n  /** Auto-focus the date picker 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 (for trigger input)\n  /** Size of the date picker control */\n  size?: number;\n  /** Filled style for the input */\n  filled?: boolean;\n  /** Pill style for the input */\n  pill?: boolean;\n  \n  // Advanced\n  /** Validate before saving (default: true) */\n  validateOnSave?: boolean;\n}\n\n/**\n * Custom editor using NileDatePicker component\n * Supports both single date and range selection\n * @template T The value type - string for both single and range modes\n *            Single mode: 'YYYY-MM-DD'\n *            Range mode: 'YYYY-MM-DD - YYYY-MM-DD'\n */\nexport class NileDatePickerEditor<T = string> implements CellEditor<T> {\n  private datePicker?: any;\n  private triggerInput?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n\n  constructor(private readonly options?: NileDatePickerEditorOptions) {}\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileDatePickerEditor requires a container element');\n      return;\n    }\n\n    // Create NileDatePicker using document.createElement\n    this.datePicker = document.createElement('nile-date-picker');\n    this.datePicker.className = 'st-cell-editor st-nile-date-picker-editor';\n    \n    // Apply styles for cell fitting\n    this.datePicker.style.width = 'inherit';\n    this.datePicker.style.height = 'inherit';\n    this.datePicker.style.boxSizing = 'border-box';\n    \n    // Create trigger input with slot using document.createElement\n    this.triggerInput = document.createElement('nile-input');\n    this.triggerInput.setAttribute('slot', 'trigger');\n    \n    // Set initial value\n    this.setInitialValue(context.value);\n    \n    \n    if (this.options?.label) {\n      this.triggerInput.label = this.options.label;\n    }\n    \n    \n    // Apply configuration options\n    this.applyOptions();\n    \n    // Append trigger to date picker (slot-based)\n    this.datePicker.appendChild(this.triggerInput);\n    \n    // Set up event listeners\n    this.setupEventListeners(context);\n    \n    // Append to container\n    context.container.innerHTML = '';\n    context.container.appendChild(this.datePicker);\n    \n    // Auto focus and open the date picker\n    if (this.options?.autoFocus !== false) {\n      setTimeout(() => {\n        this.triggerInput?.focus();\n        // Trigger a click to open the date picker dropdown\n        this.triggerInput?.click();\n      }, 0);\n    }\n  }\n\n  /**\n   * Set initial value in the trigger input\n   */\n  private setInitialValue(value: T | null | undefined): void {\n    if (!this.triggerInput) return;\n    \n    if (!value) {\n      this.triggerInput.value = '';\n      return;\n    }\n    \n    // Both single and range modes use string value\n    this.triggerInput.value = String(value);\n  }\n\n  /**\n   * Apply all configuration options to both NileDatePicker and trigger input\n   */\n  private applyOptions(): void {\n    if (!this.datePicker || !this.triggerInput) return;\n    \n    // Configure NileDatePicker\n    const dateFormat = this.options?.dateFormat || 'YYYY-MM-DD';\n    this.datePicker.setAttribute('dateFormat', dateFormat);\n    \n    if (this.options?.range) {\n      this.datePicker.setAttribute('range', String(this.options.range));\n    }\n    \n    if (this.options?.syncDatePicker) {\n      this.datePicker.setAttribute('syncDatePicker', String(this.options.syncDatePicker));\n    }\n    \n    // Configure trigger input\n    if (this.options?.disabled) {\n      this.triggerInput.disabled = this.options.disabled;\n    }\n    \n    if (this.options?.clearable) {\n      this.triggerInput.clearable = this.options.clearable;\n    }\n    \n    if (this.options?.helpText) {\n      this.triggerInput.setAttribute('help-text', this.options.helpText);\n    }\n    \n    // Visual states on trigger\n    if (this.options?.warning) {\n      this.triggerInput.setAttribute('warning', String(this.options.warning));\n    }\n    \n    if (this.options?.error) {\n      this.triggerInput.setAttribute('error', String(this.options.error));\n    }\n    \n    if (this.options?.success) {\n      this.triggerInput.setAttribute('success', String(this.options.success));\n    }\n    \n    if (this.options?.errorMessage) {\n      this.triggerInput.setAttribute('error-message', this.options.errorMessage);\n    }\n    \n    // Styling\n    if (this.options?.size) {\n      this.triggerInput.setAttribute('size', String(this.options.size));\n    }\n    \n    if (this.options?.filled) {\n      this.triggerInput.setAttribute('filled', String(this.options.filled));\n    }\n    \n    if (this.options?.pill) {\n      this.triggerInput.setAttribute('pill', String(this.options.pill));\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.datePicker || !this.triggerInput) return;\n    \n    const validateOnSave = this.options?.validateOnSave !== false;\n    \n    // Keyboard events on trigger input\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.triggerInput.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n    \n    // nile-change event on date picker\n    const changeHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // NileDatePicker detail has startDate and endDate, not a single value\n      const detail = customEvent.detail;\n      let dateValue = '';\n      \n      if (detail.startDate && detail.endDate) {\n        // Range mode: combine startDate and endDate\n        dateValue = `${detail.startDate} - ${detail.endDate}`;\n      } else if (detail.startDate) {\n        // Single mode: only startDate\n        dateValue = detail.startDate;\n      }\n      \n      context.onSave(this.parseValue(dateValue));\n    };\n    this.datePicker.addEventListener('nile-change', changeHandler);\n    this.eventListeners.push({ event: 'nile-change', handler: changeHandler });\n    \n    // nile-blur event on trigger input\n    const blurHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      // For blur, get value from trigger input directly\n      const inputValue = this.triggerInput?.value || '';\n      if (inputValue) {\n        context.onSave(this.parseValue(inputValue));\n      }\n    };\n    this.triggerInput.addEventListener('nile-blur', blurHandler);\n    this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });\n    \n    // nile-clear event\n    if (this.options?.clearable) {\n      const clearHandler = (e: Event) => {\n        context.onSave('' as unknown as T);\n      };\n      this.triggerInput.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.datePicker) return;\n    context.onSave(this.getCurrentValue());\n  }\n\n  /**\n   * Parse value from string to appropriate type\n   */\n  private parseValue(value: string): T {\n    // Both single and range modes return string\n    // Single mode: 'YYYY-MM-DD'\n    // Range mode: 'YYYY-MM-DD - YYYY-MM-DD'\n    return (value || '') as unknown as T;\n  }\n\n  getCurrentValue(): T {\n    if (!this.triggerInput) {\n      return '' as unknown as T;\n    }\n    \n    return this.parseValue(this.triggerInput.value ?? '');\n  }\n\n  destroy(): void {\n    if (this.datePicker || this.triggerInput) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.datePicker?.removeEventListener(event, handler);\n        this.triggerInput?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n      \n      if (this.datePicker) {\n        this.datePicker.remove();\n        this.datePicker = undefined;\n      }\n      \n      this.triggerInput = undefined;\n    }\n  }\n\n  focus(): void {\n    this.triggerInput?.focus();\n  }\n}\n"]}

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

@@ -0,0 +1,235 @@
+/**
+ * Custom editor using NileInput from @aquera/nile-elements
+ * This demonstrates how to create custom editors for ngx-smart-table
+ */
+/**
+ * Custom editor that uses NileInput component
+ * @template T The value type (string, number, or both)
+ */
+export class NileInputEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileInputEditor requires a container element');
+            return;
+        }
+        // Create NileInput custom element using document.createElement
+        this.input = document.createElement('nile-input');
+        this.input.type = this.options?.type || 'text';
+        this.input.value = String(context.value ?? '');
+        this.input.className = 'st-cell-editor st-nile-input-editor';
+        // Apply inline styles for proper cell fitting
+        this.input.style.width = '100%';
+        this.input.style.height = '100%';
+        this.input.style.boxSizing = 'border-box';
+        // Set NileInput specific properties
+        this.input.noOutline = true;
+        this.input.noPadding = true;
+        this.input.size = this.options?.size || 'small';
+        // Apply all configuration options
+        this.applyOptions();
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Clear container and append input
+        context.container.innerHTML = '';
+        context.container.appendChild(this.input);
+        // Auto focus and select
+        if (this.options?.autoFocus !== false) {
+            // Use setTimeout to ensure element is rendered before focusing
+            setTimeout(() => {
+                this.input?.focus();
+                if (this.options?.selectOnFocus !== false) {
+                    this.input?.select();
+                }
+            }, 0);
+        }
+    }
+    /**
+     * Apply all configuration options to the NileInput element
+     */
+    applyOptions() {
+        if (!this.input)
+            return;
+        // Basic options
+        if (this.options?.placeholder) {
+            this.input.placeholder = this.options.placeholder;
+        }
+        if (this.options?.maxLength) {
+            this.input.maxlength = this.options.maxLength;
+        }
+        if (this.options?.minLength) {
+            this.input.minlength = this.options.minLength;
+        }
+        // Style options
+        if (this.options?.filled !== undefined) {
+            this.input.filled = this.options.filled;
+        }
+        if (this.options?.pill) {
+            this.input.pill = this.options.pill;
+        }
+        // Behavior options
+        if (this.options?.clearable) {
+            this.input.clearable = this.options.clearable;
+        }
+        if (this.options?.disabled) {
+            this.input.disabled = this.options.disabled;
+        }
+        if (this.options?.readonly) {
+            this.input.readonly = this.options.readonly;
+        }
+        if (this.options?.required) {
+            this.input.required = this.options.required;
+        }
+        // Validation properties
+        if (this.options?.pattern) {
+            this.input.pattern = this.options.pattern;
+        }
+        if (this.options?.min !== undefined) {
+            this.input.min = this.options.min;
+        }
+        if (this.options?.max !== undefined) {
+            this.input.max = this.options.max;
+        }
+        if (this.options?.step !== undefined) {
+            this.input.step = this.options.step;
+        }
+        // Visual states
+        if (this.options?.warning) {
+            this.input.warning = this.options.warning;
+        }
+        if (this.options?.error) {
+            this.input.error = this.options.error;
+        }
+        if (this.options?.success) {
+            this.input.success = this.options.success;
+        }
+        if (this.options?.errorMessage) {
+            this.input.errorMessage = this.options.errorMessage;
+        }
+        if (this.options?.helpText) {
+            this.input.helpText = this.options.helpText;
+        }
+        // Advanced options
+        if (this.options?.enterkeyhint) {
+            this.input.enterkeyhint = this.options.enterkeyhint;
+        }
+        else {
+            // Default to 'done' for better mobile UX
+            this.input.enterkeyhint = 'done';
+        }
+        if (this.options?.spellcheck !== undefined) {
+            this.input.spellcheck = this.options.spellcheck;
+        }
+        if (this.options?.autocomplete) {
+            this.input.autocomplete = this.options.autocomplete;
+        }
+        if (this.options?.inputmode) {
+            this.input.inputmode = this.options.inputmode;
+        }
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.input)
+            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();
+            }
+        };
+        this.input.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // Use nile-blur custom event instead of native blur
+        const blurHandler = (e) => {
+            const customEvent = e;
+            if (validateOnSave && !this.input?.checkValidity()) {
+                // Show validation error but don't save
+                this.input?.reportValidity();
+                return;
+            }
+            context.onSave(this.parseValue(customEvent.detail.value));
+        };
+        this.input.addEventListener('nile-blur', blurHandler);
+        this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });
+        // Optional: Real-time value updates using nile-input
+        const inputHandler = (e) => {
+            const customEvent = e;
+            context.onChange(this.parseValue(customEvent.detail.value));
+        };
+        this.input.addEventListener('nile-input', inputHandler);
+        this.eventListeners.push({ event: 'nile-input', handler: inputHandler });
+        // Handle clear button if enabled
+        if (this.options?.clearable) {
+            const clearHandler = (e) => {
+                context.onSave(this.parseValue(''));
+            };
+            this.input.addEventListener('nile-clear', clearHandler);
+            this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });
+        }
+    }
+    /**
+     * Save value with optional validation
+     */
+    saveValue(context, validate) {
+        if (!this.input)
+            return;
+        if (validate && !this.input.checkValidity()) {
+            // Show validation error
+            this.input.reportValidity();
+            return;
+        }
+        context.onSave(this.getCurrentValue());
+    }
+    /**
+     * Parse value based on input type
+     */
+    parseValue(value) {
+        if (this.options?.type === 'number' && value !== '') {
+            const num = parseFloat(value);
+            return (isNaN(num) ? 0 : num);
+        }
+        return value;
+    }
+    destroy() {
+        // Remove all event listeners
+        if (this.input) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.input?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            this.input.remove();
+            this.input = undefined;
+        }
+    }
+    focus() {
+        this.input?.focus();
+    }
+    getCurrentValue() {
+        if (!this.input)
+            return '';
+        // Return appropriate value based on type
+        if (this.options?.type === 'number') {
+            return (this.input.valueAsNumber ?? 0);
+        }
+        if (this.options?.type === 'date' || this.options?.type === 'datetime-local') {
+            const date = this.input.valueAsDate;
+            return (date ? date.toISOString() : '');
+        }
+        return (this.input.value ?? '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-input-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-input-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileInput from @aquera/nile-elements\n * This demonstrates how to create custom editors for ngx-smart-table\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\n\n/**\n * Options interface for NileInputEditor\n */\nexport interface NileInputEditorOptions {\n  // Basic properties\n  placeholder?: string;\n  maxLength?: number;\n  minLength?: number;\n  autoFocus?: boolean;\n  selectOnFocus?: boolean;\n  type?: 'text' | 'email' | 'tel' | 'url' | 'search' | 'number' | 'password' | 'date' | 'time' | 'datetime-local';\n  size?: 'small' | 'medium' | 'large';\n  \n  // Style options\n  filled?: boolean;              // Draws a filled input style\n  pill?: boolean;                // Pill-style with rounded edges\n  \n  // Behavior options\n  clearable?: boolean;           // Adds clear button\n  disabled?: boolean;            // Disable the input\n  readonly?: boolean;            // Make it readonly\n  required?: boolean;            // Required field\n  \n  // Validation\n  pattern?: string;              // Regex pattern\n  min?: number | string;         // Min value (for number/date)\n  max?: number | string;         // Max value (for number/date)\n  step?: number | 'any';         // Step for number inputs\n  \n  // Visual states\n  warning?: boolean;             // Warning state\n  error?: boolean;               // Error state\n  success?: boolean;             // Success state\n  errorMessage?: string;         // Error message to display\n  helpText?: string;             // Help text\n  \n  // Advanced options\n  enterkeyhint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';\n  spellcheck?: boolean;\n  autocomplete?: string;\n  inputmode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';\n  \n  // Validation behavior\n  validateOnSave?: boolean;      // Validate before saving (default: true)\n}\n\n/**\n * Custom editor that uses NileInput component\n * @template T The value type (string, number, or both)\n */\nexport class NileInputEditor<T = string> implements CellEditor<T> {\n  private input?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n\n  constructor(private readonly options?: NileInputEditorOptions) {}\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileInputEditor requires a container element');\n      return;\n    }\n\n    // Create NileInput custom element using document.createElement\n    this.input = document.createElement('nile-input');\n    this.input.type = this.options?.type || 'text';\n    this.input.value = String(context.value ?? '');\n    this.input.className = 'st-cell-editor st-nile-input-editor';\n    \n    // Apply inline styles for proper cell fitting\n    this.input.style.width = '100%';\n    this.input.style.height = '100%';\n    this.input.style.boxSizing = 'border-box';\n    \n    // Set NileInput specific properties\n    this.input.noOutline = true;\n    this.input.noPadding = true;\n    this.input.size = this.options?.size || 'small';\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 input\n    context.container.innerHTML = '';\n    context.container.appendChild(this.input);\n\n    // Auto focus and select\n    if (this.options?.autoFocus !== false) {\n      // Use setTimeout to ensure element is rendered before focusing\n      setTimeout(() => {\n        this.input?.focus();\n        \n        if (this.options?.selectOnFocus !== false) {\n          this.input?.select();\n        }\n      }, 0);\n    }\n  }\n\n  /**\n   * Apply all configuration options to the NileInput element\n   */\n  private applyOptions(): void {\n    if (!this.input) return;\n\n    // Basic options\n    if (this.options?.placeholder) {\n      this.input.placeholder = this.options.placeholder;\n    }\n\n    if (this.options?.maxLength) {\n      this.input.maxlength = this.options.maxLength;\n    }\n\n    if (this.options?.minLength) {\n      this.input.minlength = this.options.minLength;\n    }\n\n    // Style options\n    if (this.options?.filled !== undefined) {\n      this.input.filled = this.options.filled;\n    }\n\n    if (this.options?.pill) {\n      this.input.pill = this.options.pill;\n    }\n\n    // Behavior options\n    if (this.options?.clearable) {\n      this.input.clearable = this.options.clearable;\n    }\n\n    if (this.options?.disabled) {\n      this.input.disabled = this.options.disabled;\n    }\n\n    if (this.options?.readonly) {\n      this.input.readonly = this.options.readonly;\n    }\n\n    if (this.options?.required) {\n      this.input.required = this.options.required;\n    }\n\n    // Validation properties\n    if (this.options?.pattern) {\n      this.input.pattern = this.options.pattern;\n    }\n\n    if (this.options?.min !== undefined) {\n      this.input.min = this.options.min;\n    }\n\n    if (this.options?.max !== undefined) {\n      this.input.max = this.options.max;\n    }\n\n    if (this.options?.step !== undefined) {\n      this.input.step = this.options.step;\n    }\n\n    // Visual states\n    if (this.options?.warning) {\n      this.input.warning = this.options.warning;\n    }\n\n    if (this.options?.error) {\n      this.input.error = this.options.error;\n    }\n\n    if (this.options?.success) {\n      this.input.success = this.options.success;\n    }\n\n    if (this.options?.errorMessage) {\n      this.input.errorMessage = this.options.errorMessage;\n    }\n\n    if (this.options?.helpText) {\n      this.input.helpText = this.options.helpText;\n    }\n\n    // Advanced options\n    if (this.options?.enterkeyhint) {\n      this.input.enterkeyhint = this.options.enterkeyhint;\n    } else {\n      // Default to 'done' for better mobile UX\n      this.input.enterkeyhint = 'done';\n    }\n\n    if (this.options?.spellcheck !== undefined) {\n      this.input.spellcheck = this.options.spellcheck;\n    }\n\n    if (this.options?.autocomplete) {\n      this.input.autocomplete = this.options.autocomplete;\n    }\n\n    if (this.options?.inputmode) {\n      this.input.inputmode = this.options.inputmode;\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.input) 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      }\n    };\n    this.input.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n\n    // Use nile-blur custom event instead of native blur\n    const blurHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      if (validateOnSave && !this.input?.checkValidity()) {\n        // Show validation error but don't save\n        this.input?.reportValidity();\n        return;\n      }\n      context.onSave(this.parseValue(customEvent.detail.value));\n    };\n    this.input.addEventListener('nile-blur', blurHandler);\n    this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });\n\n    // Optional: Real-time value updates using nile-input\n    const inputHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      context.onChange(this.parseValue(customEvent.detail.value));\n    };\n    this.input.addEventListener('nile-input', inputHandler);\n    this.eventListeners.push({ event: 'nile-input', handler: inputHandler });\n\n    // Handle clear button if enabled\n    if (this.options?.clearable) {\n      const clearHandler = (e: Event) => {\n        context.onSave(this.parseValue(''));\n      };\n      this.input.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.input) return;\n\n    if (validate && !this.input.checkValidity()) {\n      // Show validation error\n      this.input.reportValidity();\n      return;\n    }\n\n    context.onSave(this.getCurrentValue());\n  }\n\n  /**\n   * Parse value based on input type\n   */\n  private parseValue(value: string): T {\n    if (this.options?.type === 'number' && value !== '') {\n      const num = parseFloat(value);\n      return (isNaN(num) ? 0 : num) as unknown as T;\n    }\n    return value as unknown as T;\n  }\n\n  destroy(): void {\n    // Remove all event listeners\n    if (this.input) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.input?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n      \n      this.input.remove();\n      this.input = undefined;\n    }\n  }\n\n  focus(): void {\n    this.input?.focus();\n  }\n\n  getCurrentValue(): T {\n    if (!this.input) return '' as unknown as T;\n    \n    // Return appropriate value based on type\n    if (this.options?.type === 'number') {\n      return (this.input.valueAsNumber ?? 0) as unknown as T;\n    }\n    \n    if (this.options?.type === 'date' || this.options?.type === 'datetime-local') {\n      const date = this.input.valueAsDate;\n      return (date ? date.toISOString() : '') as unknown as T;\n    }\n    \n    return (this.input.value ?? '') as unknown as T;\n  }\n}\n"]}