@aquera/ngx-smart-table 0.0.2-alpha

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

@@ -0,0 +1,317 @@
+/**
+ * Custom editor using NileSelect from @aquera/nile-elements
+ * This demonstrates how to create dropdown/select editors for ngx-smart-table
+ */
+import { isObservable } from 'rxjs';
+/**
+ * Custom editor that uses NileSelect component
+ * @template T The value type (string for single selection, string[] for multiple)
+ */
+export class NileSelectEditor {
+    constructor(options) {
+        this.options = options;
+        this.eventListeners = [];
+        this.currentOptions = [];
+        // Handle Observable options
+        if (isObservable(options.options)) {
+            this.optionsSubscription = options.options.subscribe(opts => {
+                this.currentOptions = opts;
+                // If editor is already active, update the DOM
+                if (this.select) {
+                    this.updateOptions();
+                }
+            });
+        }
+        else {
+            // Static options
+            this.currentOptions = options.options || [];
+            if (this.currentOptions.length === 0) {
+                console.warn('NileSelectEditor: options array is empty');
+            }
+        }
+    }
+    edit(context) {
+        if (!context.container) {
+            console.warn('NileSelectEditor requires a container element');
+            return;
+        }
+        // Create NileSelect custom element using document.createElement
+        this.select = document.createElement('nile-select');
+        this.select.className = 'st-cell-editor';
+        // Apply inline styles for proper cell fitting
+        this.select.style.width = '100%';
+        this.select.style.height = 'inherit';
+        this.select.style.boxSizing = 'border-box';
+        // Set initial value
+        this.setInitialValue(context.value);
+        // Apply all configuration options
+        this.applyOptions();
+        // Create and append options with current options
+        this.createAndAppendOptions(this.currentOptions);
+        // Set up event listeners
+        this.setupEventListeners(context);
+        // Clear container and append select
+        context.container.innerHTML = '';
+        context.container.appendChild(this.select);
+        // Focus after render
+        setTimeout(() => {
+            this.select?.focus();
+            this.select?.click();
+        }, 0);
+    }
+    /**
+     * Set the initial value for the select
+     */
+    setInitialValue(value) {
+        if (!this.select)
+            return;
+        if (this.options.multiple) {
+            // Handle multiple selection - value should be array
+            if (Array.isArray(value)) {
+                this.select.value = value;
+            }
+            else if (value) {
+                this.select.value = [String(value)];
+            }
+            else {
+                this.select.value = [];
+            }
+        }
+        else {
+            // Handle single selection
+            this.select.value = value ? String(value) : '';
+        }
+    }
+    /**
+     * Apply all configuration options to the NileSelect element
+     */
+    applyOptions() {
+        if (!this.select)
+            return;
+        // Basic options
+        if (this.options.placeholder) {
+            this.select.placeholder = this.options.placeholder;
+        }
+        if (this.options.size) {
+            this.select.size = this.options.size;
+        }
+        else {
+            this.select.size = 'small'; // Default for table cells
+        }
+        if (this.options.multiple) {
+            this.select.multiple = this.options.multiple;
+        }
+        // Behavior options
+        if (this.options.clearable) {
+            this.select.clearable = this.options.clearable;
+        }
+        if (this.options.disabled) {
+            this.select.disabled = this.options.disabled;
+        }
+        if (this.options.required) {
+            this.select.required = this.options.required;
+        }
+        if (this.options.searchEnabled) {
+            this.select.searchEnabled = this.options.searchEnabled;
+        }
+        // Visual states
+        if (this.options.warning) {
+            this.select.warning = this.options.warning;
+        }
+        if (this.options.error) {
+            this.select.error = this.options.error;
+        }
+        if (this.options.success) {
+            this.select.success = this.options.success;
+        }
+        if (this.options.errorMessage) {
+            this.select.errorMessage = this.options.errorMessage;
+        }
+        if (this.options.helpText) {
+            this.select.helpText = this.options.helpText;
+        }
+        // Advanced features
+        if (this.options.maxOptionsVisible !== undefined) {
+            this.select.maxOptionsVisible = this.options.maxOptionsVisible;
+        }
+        if (this.options.filled !== undefined) {
+            this.select.filled = this.options.filled;
+        }
+        if (this.options.pill) {
+            this.select.pill = this.options.pill;
+        }
+        if (this.options.hoist) {
+            this.select.hoist = this.options.hoist;
+        }
+        if (this.options.placement) {
+            this.select.placement = this.options.placement;
+        }
+        if (this.options.enableVirtualScroll) {
+            this.select.enableVirtualScroll = this.options.enableVirtualScroll;
+        }
+        if (this.options.disableLocalSearch) {
+            this.select.disableLocalSearch = this.options.disableLocalSearch;
+        }
+        if (this.options.portal !== undefined) {
+            this.select.portal = this.options.portal;
+        }
+        // Prevent width syncing issues in table cells
+        this.select.noWidthSync = true;
+    }
+    /**
+     * Update options dynamically while editor is active
+     */
+    updateOptions() {
+        if (!this.select)
+            return;
+        // Clear existing options
+        while (this.select.firstChild) {
+            this.select.removeChild(this.select.firstChild);
+        }
+        // Re-append with new options
+        this.createAndAppendOptions(this.currentOptions);
+        // Trigger update on the web component
+        if (this.select.requestUpdate) {
+            this.select.requestUpdate();
+        }
+    }
+    /**
+     * Create NileOption elements and append them to the select
+     * @param options - The options to render
+     */
+    createAndAppendOptions(options) {
+        if (!this.select)
+            return;
+        options.forEach(opt => {
+            const nileOption = document.createElement('nile-option');
+            // Auto-detect format: string or SelectOption object
+            if (typeof opt === 'string') {
+                nileOption.value = opt;
+                nileOption.setAttribute('value', opt);
+                nileOption.textContent = opt;
+            }
+            else {
+                nileOption.value = opt.value;
+                nileOption.setAttribute('value', opt.value);
+                nileOption.textContent = opt.label;
+                if (opt.disabled) {
+                    nileOption.disabled = true;
+                    nileOption.setAttribute('disabled', 'true');
+                }
+                // Handle prefix if provided (could be icon name or content)
+                if (opt.prefix) {
+                    // nileOption.setAttribute('slot', 'prefix');
+                    // nileOption.innerHTML = `<nile-icon name="${opt.prefix}"></nile-icon>`;
+                }
+            }
+            this.select.appendChild(nileOption);
+        });
+    }
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    setupEventListeners(context) {
+        if (!this.select)
+            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 === 'Escape') {
+                keyEvent.preventDefault();
+                keyEvent.stopPropagation();
+                context.onCancel();
+            }
+        };
+        this.select.addEventListener('keydown', keydownHandler);
+        this.eventListeners.push({ event: 'keydown', handler: keydownHandler });
+        // Use nile-change custom event as primary save trigger
+        const changeHandler = (e) => {
+            const customEvent = e;
+            if (validateOnSave && !this.select?.checkValidity()) {
+                this.select?.reportValidity();
+                return;
+            }
+            context.onSave(this.parseValue(customEvent.detail.value));
+        };
+        this.select.addEventListener('nile-change', changeHandler);
+        this.eventListeners.push({ event: 'nile-change', handler: changeHandler });
+        // Handle blur as secondary save trigger
+        const blurHandler = (e) => {
+            if (validateOnSave && !this.select?.checkValidity()) {
+                this.select?.reportValidity();
+                return;
+            }
+            // context.onSave(this.getCurrentValue());
+        };
+        this.select.addEventListener('nile-blur', blurHandler);
+        this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });
+        // Handle clear button if enabled
+        if (this.options.clearable) {
+            const clearHandler = (e) => {
+                context.onSave(this.parseValue(this.options.multiple ? [] : ''));
+            };
+            this.select.addEventListener('nile-clear', clearHandler);
+            this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });
+        }
+        // Handle search for server-side search scenarios
+        if (this.options.disableLocalSearch) {
+            const searchHandler = (e) => {
+                const customEvent = e;
+                // Emit search query through onChange for external handling
+                context.onChange(customEvent.detail);
+            };
+            this.select.addEventListener('nile-search', searchHandler);
+            this.eventListeners.push({ event: 'nile-search', handler: searchHandler });
+        }
+    }
+    /**
+     * Parse value based on selection mode
+     */
+    parseValue(value) {
+        if (this.options.multiple) {
+            // Ensure array for multiple selection
+            if (Array.isArray(value)) {
+                return value;
+            }
+            return (value ? [value] : []);
+        }
+        // Single selection - return string
+        if (Array.isArray(value)) {
+            return (value.length > 0 ? value[0] : '');
+        }
+        return value;
+    }
+    destroy() {
+        // Unsubscribe from options Observable
+        if (this.optionsSubscription) {
+            this.optionsSubscription.unsubscribe();
+            this.optionsSubscription = undefined;
+        }
+        // Remove all event listeners
+        if (this.select) {
+            this.eventListeners.forEach(({ event, handler }) => {
+                this.select?.removeEventListener(event, handler);
+            });
+            this.eventListeners = [];
+            this.select.remove();
+            this.select = undefined;
+        }
+    }
+    focus() {
+        this.select?.focus();
+    }
+    getCurrentValue() {
+        if (!this.select) {
+            return (this.options.multiple ? [] : '');
+        }
+        const value = this.select.value;
+        // Handle multiple selection
+        if (this.options.multiple) {
+            return (Array.isArray(value) ? value : [value]);
+        }
+        // Handle single selection
+        return (Array.isArray(value) ? (value.length > 0 ? value[0] : '') : value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nile-select-editor.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/editors/nile-select-editor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom editor using NileSelect from @aquera/nile-elements\n * This demonstrates how to create dropdown/select editors for ngx-smart-table\n */\n\nimport { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';\nimport { Observable, Subscription, isObservable } from 'rxjs';\n\n/**\n * Select option configuration\n */\nexport interface SelectOption {\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  /** Optional prefix icon or content */\n  prefix?: string;\n}\n\n/**\n * Options interface for NileSelectEditor\n */\nexport interface NileSelectEditorOptions {\n  // Options configuration (REQUIRED)\n  /** Array of options - supports static arrays, Observable, or BehaviorSubject for reactive updates */\n  options: SelectOption[] | string[] | Observable<SelectOption[] | string[]>;\n  \n  // Basic properties\n  /** Placeholder text when no selection is made */\n  placeholder?: string;\n  /** Size of the select control */\n  size?: 'small' | 'medium' | 'large';\n  /** Enable multiple selection mode */\n  multiple?: boolean;\n  \n  // Behavior options\n  /** Adds clear button when value is not empty */\n  clearable?: boolean;\n  /** Disable the select control */\n  disabled?: boolean;\n  /** Make the select required */\n  required?: boolean;\n  /** Enable search functionality */\n  searchEnabled?: 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  /** Help text to display */\n  helpText?: string;\n  \n  // Advanced features\n  /** Maximum number of selected options to show in multiple mode (0 = no limit) */\n  maxOptionsVisible?: number;\n  /** Draws a filled select style */\n  filled?: boolean;\n  /** Pill-style with rounded edges */\n  pill?: boolean;\n  /** Use fixed positioning to prevent clipping */\n  hoist?: boolean;\n  /** Placement of the dropdown menu */\n  placement?: 'top' | 'bottom';\n  \n  // Virtual scroll for large lists\n  /** Enable virtual scrolling for better performance with many options */\n  enableVirtualScroll?: boolean;\n  \n  // Search configuration\n  /** Disable local search (use for server-side search) */\n  disableLocalSearch?: boolean;\n  \n  // Validation\n  /** Validate before saving (default: true) */\n  validateOnSave?: boolean;\n  \n  // Portal options\n  /** Append dropdown to document body instead of parent */\n  portal?: boolean;\n}\n\n/**\n * Custom editor that uses NileSelect component\n * @template T The value type (string for single selection, string[] for multiple)\n */\nexport class NileSelectEditor<T = string> implements CellEditor<T> {\n  private select?: any;\n  private eventListeners: Array<{ event: string; handler: EventListener }> = [];\n  private optionsSubscription?: Subscription;\n  private currentOptions: (SelectOption | string)[] = [];\n\n  constructor(private readonly options: NileSelectEditorOptions) {\n    // Handle Observable options\n    if (isObservable(options.options)) {\n      this.optionsSubscription = options.options.subscribe(opts => {\n        this.currentOptions = opts;\n        // If editor is already active, update the DOM\n        if (this.select) {\n          this.updateOptions();\n        }\n      });\n    } else {\n      // Static options\n      this.currentOptions = options.options || [];\n      if (this.currentOptions.length === 0) {\n        console.warn('NileSelectEditor: options array is empty');\n      }\n    }\n  }\n\n  edit(context: CellEditorContext<T>): void {\n    if (!context.container) {\n      console.warn('NileSelectEditor requires a container element');\n      return;\n    }\n\n    // Create NileSelect custom element using document.createElement\n    this.select = document.createElement('nile-select');\n    this.select.className = 'st-cell-editor';\n    \n    // Apply inline styles for proper cell fitting\n    this.select.style.width = '100%';\n    this.select.style.height = 'inherit';\n    this.select.style.boxSizing = 'border-box';\n    \n    // Set initial value\n    this.setInitialValue(context.value);\n\n    // Apply all configuration options\n    this.applyOptions();\n\n    // Create and append options with current options\n    this.createAndAppendOptions(this.currentOptions);\n\n    // Set up event listeners\n    this.setupEventListeners(context);\n\n    // Clear container and append select\n    context.container.innerHTML = '';\n    context.container.appendChild(this.select);\n\n    // Focus after render\n    setTimeout(() => {\n      this.select?.focus();\n      this.select?.click();\n    }, 0);\n  }\n\n  /**\n   * Set the initial value for the select\n   */\n  private setInitialValue(value: T): void {\n    if (!this.select) return;\n\n    if (this.options.multiple) {\n      // Handle multiple selection - value should be array\n      if (Array.isArray(value)) {\n        this.select.value = value;\n      } else if (value) {\n        this.select.value = [String(value)];\n      } else {\n        this.select.value = [];\n      }\n    } else {\n      // Handle single selection\n      this.select.value = value ? String(value) : '';\n    }\n  }\n\n  /**\n   * Apply all configuration options to the NileSelect element\n   */\n  private applyOptions(): void {\n    if (!this.select) return;\n\n    // Basic options\n    if (this.options.placeholder) {\n      this.select.placeholder = this.options.placeholder;\n    }\n\n    if (this.options.size) {\n      this.select.size = this.options.size;\n    } else {\n      this.select.size = 'small'; // Default for table cells\n    }\n\n    if (this.options.multiple) {\n      this.select.multiple = this.options.multiple;\n    }\n\n    // Behavior options\n    if (this.options.clearable) {\n      this.select.clearable = this.options.clearable;\n    }\n\n    if (this.options.disabled) {\n      this.select.disabled = this.options.disabled;\n    }\n\n    if (this.options.required) {\n      this.select.required = this.options.required;\n    }\n\n    if (this.options.searchEnabled) {\n      this.select.searchEnabled = this.options.searchEnabled;\n    }\n\n    // Visual states\n    if (this.options.warning) {\n      this.select.warning = this.options.warning;\n    }\n\n    if (this.options.error) {\n      this.select.error = this.options.error;\n    }\n\n    if (this.options.success) {\n      this.select.success = this.options.success;\n    }\n\n    if (this.options.errorMessage) {\n      this.select.errorMessage = this.options.errorMessage;\n    }\n\n    if (this.options.helpText) {\n      this.select.helpText = this.options.helpText;\n    }\n\n    // Advanced features\n    if (this.options.maxOptionsVisible !== undefined) {\n      this.select.maxOptionsVisible = this.options.maxOptionsVisible;\n    }\n\n    if (this.options.filled !== undefined) {\n      this.select.filled = this.options.filled;\n    }\n\n    if (this.options.pill) {\n      this.select.pill = this.options.pill;\n    }\n\n    if (this.options.hoist) {\n      this.select.hoist = this.options.hoist;\n    }\n\n    if (this.options.placement) {\n      this.select.placement = this.options.placement;\n    }\n\n    if (this.options.enableVirtualScroll) {\n      this.select.enableVirtualScroll = this.options.enableVirtualScroll;\n    }\n\n    if (this.options.disableLocalSearch) {\n      this.select.disableLocalSearch = this.options.disableLocalSearch;\n    }\n\n    if (this.options.portal !== undefined) {\n      this.select.portal = this.options.portal;\n    }\n\n    // Prevent width syncing issues in table cells\n    this.select.noWidthSync = true;\n  }\n\n  /**\n   * Update options dynamically while editor is active\n   */\n  private updateOptions(): void {\n    if (!this.select) return;\n\n    // Clear existing options\n    while (this.select.firstChild) {\n      this.select.removeChild(this.select.firstChild);\n    }\n\n    // Re-append with new options\n    this.createAndAppendOptions(this.currentOptions);\n    \n    // Trigger update on the web component\n    if (this.select.requestUpdate) {\n      this.select.requestUpdate();\n    }\n  }\n\n  /**\n   * Create NileOption elements and append them to the select\n   * @param options - The options to render\n   */\n  private createAndAppendOptions(options: (SelectOption | string)[]): void {\n    if (!this.select) return;\n\n    options.forEach(opt => {\n      const nileOption = document.createElement('nile-option') as any;\n\n      // Auto-detect format: string or SelectOption object\n      if (typeof opt === 'string') {\n        nileOption.value = opt;\n        nileOption.setAttribute('value', opt);\n        nileOption.textContent = opt;\n      } else {\n        nileOption.value = opt.value;\n        nileOption.setAttribute('value', opt.value);\n        nileOption.textContent = opt.label;\n        \n        if (opt.disabled) {\n          nileOption.disabled = true;\n          nileOption.setAttribute('disabled', 'true');\n        }\n\n        // Handle prefix if provided (could be icon name or content)\n        if (opt.prefix) {\n          // nileOption.setAttribute('slot', 'prefix');\n          // nileOption.innerHTML = `<nile-icon name=\"${opt.prefix}\"></nile-icon>`;\n        }\n      }\n\n      this.select!.appendChild(nileOption);\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.select) 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 === 'Escape') {\n        keyEvent.preventDefault();\n        keyEvent.stopPropagation();\n        context.onCancel();\n      }\n    };\n    this.select.addEventListener('keydown', keydownHandler);\n    this.eventListeners.push({ event: 'keydown', handler: keydownHandler });\n\n    // Use nile-change custom event as primary save trigger\n    const changeHandler = (e: Event) => {\n      const customEvent = e as CustomEvent;\n      if (validateOnSave && !this.select?.checkValidity()) {\n        this.select?.reportValidity();\n        return;\n      }\n      context.onSave(this.parseValue(customEvent.detail.value));\n    };\n    this.select.addEventListener('nile-change', changeHandler);\n    this.eventListeners.push({ event: 'nile-change', handler: changeHandler });\n\n    // Handle blur as secondary save trigger\n    const blurHandler = (e: Event) => {\n      if (validateOnSave && !this.select?.checkValidity()) {\n        this.select?.reportValidity();\n        return;\n      }\n      // context.onSave(this.getCurrentValue());\n    };\n    this.select.addEventListener('nile-blur', blurHandler);\n    this.eventListeners.push({ event: 'nile-blur', handler: blurHandler });\n\n    // Handle clear button if enabled\n    if (this.options.clearable) {\n      const clearHandler = (e: Event) => {\n        context.onSave(this.parseValue(this.options.multiple ? [] : ''));\n      };\n      this.select.addEventListener('nile-clear', clearHandler);\n      this.eventListeners.push({ event: 'nile-clear', handler: clearHandler });\n    }\n\n    // Handle search for server-side search scenarios\n    if (this.options.disableLocalSearch) {\n      const searchHandler = (e: Event) => {\n        const customEvent = e as CustomEvent;\n        // Emit search query through onChange for external handling\n        context.onChange(customEvent.detail as T);\n      };\n      this.select.addEventListener('nile-search', searchHandler);\n      this.eventListeners.push({ event: 'nile-search', handler: searchHandler });\n    }\n  }\n\n  /**\n   * Parse value based on selection mode\n   */\n  private parseValue(value: string | string[]): T {\n    if (this.options.multiple) {\n      // Ensure array for multiple selection\n      if (Array.isArray(value)) {\n        return value as unknown as T;\n      }\n      return (value ? [value] : []) as unknown as T;\n    }\n    \n    // Single selection - return string\n    if (Array.isArray(value)) {\n      return (value.length > 0 ? value[0] : '') as unknown as T;\n    }\n    return value as unknown as T;\n  }\n\n  destroy(): void {\n    // Unsubscribe from options Observable\n    if (this.optionsSubscription) {\n      this.optionsSubscription.unsubscribe();\n      this.optionsSubscription = undefined;\n    }\n    \n    // Remove all event listeners\n    if (this.select) {\n      this.eventListeners.forEach(({ event, handler }) => {\n        this.select?.removeEventListener(event, handler);\n      });\n      this.eventListeners = [];\n      \n      this.select.remove();\n      this.select = undefined;\n    }\n  }\n\n  focus(): void {\n    this.select?.focus();\n  }\n\n  getCurrentValue(): T {\n    if (!this.select) {\n      return (this.options.multiple ? [] : '') as unknown as T;\n    }\n    \n    const value = this.select.value;\n    \n    // Handle multiple selection\n    if (this.options.multiple) {\n      return (Array.isArray(value) ? value : [value]) as unknown as T;\n    }\n    \n    // Handle single selection\n    return (Array.isArray(value) ? (value.length > 0 ? value[0] : '') : value) as unknown as T;\n  }\n}\n"]}

package/esm2020/lib/factories/column-config.factory.mjs

@@ -0,0 +1,231 @@
+/**
+ * Column configuration factory
+ * Simplifies creation of common column types with sensible defaults
+ */
+import { DEFAULT_COLUMN_CONFIG } from '../models/column-config.interface';
+import { CellDataType } from '../models/cell-types';
+import { Cell } from '../renderer/models/cell.class';
+import { StringFormatter, NumberFormatter, CurrencyFormatter, DateFormatter, BooleanFormatter } from '../strategies/default-formatters';
+import { PatternValidators } from '../strategies/default-validators';
+import { TextEditor, NumberEditor, DateEditor, SelectEditor, BooleanEditor } from '../strategies/default-editors';
+import { deepMergeColumnConfig } from '../models/column-config.utils';
+/**
+ * Column configuration factory - Factory Pattern
+ * Provides convenient methods to create pre-configured column types
+ */
+export class ColumnConfigFactory {
+    /**
+     * Create a text column
+     */
+    static text(key, options) {
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.STRING,
+            formatter: new StringFormatter(),
+            editor: new TextEditor(),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a number column
+     */
+    static number(key, options) {
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.NUMBER,
+            formatter: new NumberFormatter({ decimals: 2 }),
+            validator: PatternValidators.custom((val) => typeof val === 'number' && !isNaN(val), 'Must be a valid number'),
+            editor: new NumberEditor(),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a currency column
+     */
+    static currency(key, options) {
+        const currency = options?.currency || 'USD';
+        const locale = options?.locale || 'en-US';
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.NUMBER,
+            formatter: new CurrencyFormatter({ currency, locale }),
+            validator: PatternValidators.chain(PatternValidators.custom((val) => typeof val === 'number' && !isNaN(val), 'Must be a valid number'), PatternValidators.range(0, undefined, 'Amount must be positive')),
+            editor: new NumberEditor({ min: 0, step: 0.01 }),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a date column
+     */
+    static date(key, options) {
+        const dateStyle = options?.dateStyle || 'medium';
+        const locale = options?.locale || 'en-US';
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.DATE,
+            formatter: new DateFormatter({ dateStyle, locale }),
+            editor: new DateEditor(),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a boolean column
+     */
+    static boolean(key, options) {
+        const trueValue = options?.trueValue || 'Yes';
+        const falseValue = options?.falseValue || 'No';
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.BOOLEAN,
+            formatter: new BooleanFormatter({ trueValue, falseValue }),
+            editor: new BooleanEditor(),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a select/dropdown column
+     */
+    static select(key, selectOptions, options) {
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            editor: new SelectEditor({ options: selectOptions }),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create an email column
+     */
+    static email(key, options) {
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            dataType: CellDataType.STRING,
+            formatter: new StringFormatter(),
+            validator: PatternValidators.email(),
+            editor: new TextEditor({ placeholder: 'email@example.com' }),
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a readonly column
+     */
+    static readonly(key, options) {
+        const config = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+            editable: false,
+        }, options || {});
+        return {
+            ...config,
+            createCell(rowData, rowIndex) {
+                const valueGetter = options?.valueGetter || ((data) => data[key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create a custom column with full control
+     */
+    static custom(config) {
+        if (!config.key) {
+            throw new Error('Column key is required');
+        }
+        const mergedConfig = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, {
+            header: config.key.charAt(0).toUpperCase() + config.key.slice(1),
+        }, config);
+        return {
+            ...mergedConfig,
+            createCell(rowData, rowIndex) {
+                const valueGetter = config.valueGetter || ((data) => data[config.key]);
+                const value = valueGetter(rowData);
+                return new Cell(this, value, rowData, rowIndex);
+            }
+        };
+    }
+    /**
+     * Create multiple columns at once from a simple configuration
+     */
+    static fromKeys(keys) {
+        return keys.map(keyConfig => {
+            if (typeof keyConfig === 'string' || typeof keyConfig === 'number' || typeof keyConfig === 'symbol') {
+                return ColumnConfigFactory.text(String(keyConfig));
+            }
+            else {
+                const { key, type = 'text', options = {} } = keyConfig;
+                const keyStr = String(key);
+                switch (type) {
+                    case 'number':
+                        return ColumnConfigFactory.number(keyStr, options);
+                    case 'date':
+                        return ColumnConfigFactory.date(keyStr, options);
+                    case 'boolean':
+                        return ColumnConfigFactory.boolean(keyStr, options);
+                    case 'text':
+                    default:
+                        return ColumnConfigFactory.text(keyStr, options);
+                }
+            }
+        });
+    }
+}
+/**
+ * Convenience exports for common column types
+ */
+export const Columns = ColumnConfigFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-config.factory.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/factories/column-config.factory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Column configuration factory\n * Simplifies creation of common column types with sensible defaults\n */\n\nimport { ColumnConfig, DEFAULT_COLUMN_CONFIG } from '../models/column-config.interface';\nimport { CellDataType } from '../models/cell-types';\nimport { Cell } from '../renderer/models/cell.class';\nimport {\n  StringFormatter,\n  NumberFormatter,\n  CurrencyFormatter,\n  DateFormatter,\n  BooleanFormatter\n} from '../strategies/default-formatters';\nimport {\n  PatternValidators\n} from '../strategies/default-validators';\nimport {\n  TextEditor,\n  NumberEditor,\n  DateEditor,\n  SelectEditor,\n  BooleanEditor\n} from '../strategies/default-editors';\nimport { deepMergeColumnConfig } from '../models/column-config.utils';\n\n/**\n * Column configuration factory - Factory Pattern\n * Provides convenient methods to create pre-configured column types\n */\nexport class ColumnConfigFactory {\n  /**\n   * Create a text column\n   */\n  static text(key: string, options?: Partial<ColumnConfig<string>>): ColumnConfig<string> {\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.STRING,\n        formatter: new StringFormatter(),\n        editor: new TextEditor(),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<string> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<string>;\n  }\n\n  /**\n   * Create a number column\n   */\n  static number(key: string, options?: Partial<ColumnConfig<number>>): ColumnConfig<number> {\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.NUMBER,\n        formatter: new NumberFormatter({ decimals: 2 }),\n        validator: PatternValidators.custom((val) => typeof val === 'number' && !isNaN(val), 'Must be a valid number'),\n        editor: new NumberEditor(),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<number> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<number>;\n  }\n\n  /**\n   * Create a currency column\n   */\n  static currency(key: string, options?: Partial<ColumnConfig<number>> & {\n    currency?: string;\n    locale?: string;\n  }): ColumnConfig<number> {\n    const currency = (options as any)?.currency || 'USD';\n    const locale = (options as any)?.locale || 'en-US';\n\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.NUMBER,\n        formatter: new CurrencyFormatter({ currency, locale }),\n        validator: PatternValidators.chain(\n          PatternValidators.custom((val) => typeof val === 'number' && !isNaN(val), 'Must be a valid number'),\n          PatternValidators.range(0, undefined, 'Amount must be positive')\n        ),\n        editor: new NumberEditor({ min: 0, step: 0.01 }),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<number> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<number>;\n  }\n\n  /**\n   * Create a date column\n   */\n  static date(key: string, options?: Partial<ColumnConfig<Date>> & {\n    dateStyle?: 'full' | 'long' | 'medium' | 'short';\n    locale?: string;\n  }): ColumnConfig<Date> {\n    const dateStyle = (options as any)?.dateStyle || 'medium';\n    const locale = (options as any)?.locale || 'en-US';\n\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.DATE,\n        formatter: new DateFormatter({ dateStyle, locale }),\n        editor: new DateEditor(),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<Date> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<Date>;\n  }\n\n  /**\n   * Create a boolean column\n   */\n  static boolean(key: string, options?: Partial<ColumnConfig<boolean>> & {\n    trueValue?: string;\n    falseValue?: string;\n  }): ColumnConfig<boolean> {\n    const trueValue = (options as any)?.trueValue || 'Yes';\n    const falseValue = (options as any)?.falseValue || 'No';\n\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.BOOLEAN,\n        formatter: new BooleanFormatter({ trueValue, falseValue }),\n        editor: new BooleanEditor(),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<boolean> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<boolean>;\n  }\n\n  /**\n   * Create a select/dropdown column\n   */\n  static select<T = string>(\n    key: string,\n    selectOptions: Array<{ value: T; label: string }>,\n    options?: Partial<ColumnConfig<T>>\n  ): ColumnConfig<T> {\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        editor: new SelectEditor({ options: selectOptions }),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<T> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<T>;\n  }\n\n  /**\n   * Create an email column\n   */\n  static email(key: string, options?: Partial<ColumnConfig<string>>): ColumnConfig<string> {\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        dataType: CellDataType.STRING,\n        formatter: new StringFormatter(),\n        validator: PatternValidators.email(),\n        editor: new TextEditor({ placeholder: 'email@example.com' }),\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<string> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<string>;\n  }\n\n  /**\n   * Create a readonly column\n   */\n  static readonly<T = any>(key: string, options?: Partial<ColumnConfig<T>>): ColumnConfig<T> {\n    const config = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        key,\n        header: key.charAt(0).toUpperCase() + key.slice(1),\n        editable: false,\n      },\n      options || {}\n    );\n\n    return {\n      ...config,\n      createCell(rowData: any, rowIndex?: number): Cell<T> {\n        const valueGetter = options?.valueGetter || ((data: any) => data[key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<T>;\n  }\n\n  /**\n   * Create a custom column with full control\n   */\n  static custom<T = any>(config: Partial<ColumnConfig<T>> & { key: string }): ColumnConfig<T> {\n    if (!config.key) {\n      throw new Error('Column key is required');\n    }\n\n    const mergedConfig = deepMergeColumnConfig(\n      DEFAULT_COLUMN_CONFIG,\n      {\n        header: config.key.charAt(0).toUpperCase() + config.key.slice(1),\n      },\n      config\n    );\n\n    return {\n      ...mergedConfig,\n      createCell(rowData: any, rowIndex?: number): Cell<T> {\n        const valueGetter = config.valueGetter || ((data: any) => data[config.key]);\n        const value = valueGetter(rowData);\n        return new Cell(this, value, rowData, rowIndex);\n      }\n    } as ColumnConfig<T>;\n  }\n\n  /**\n   * Create multiple columns at once from a simple configuration\n   */\n  static fromKeys<T extends Record<string, any>>(\n    keys: Array<keyof T | { key: keyof T; type?: 'text' | 'number' | 'date' | 'boolean'; options?: any }>\n  ): ColumnConfig<any>[] {\n    return keys.map(keyConfig => {\n      if (typeof keyConfig === 'string' || typeof keyConfig === 'number' || typeof keyConfig === 'symbol') {\n        return ColumnConfigFactory.text(String(keyConfig));\n      } else {\n        const { key, type = 'text', options = {} } = keyConfig;\n        const keyStr = String(key);\n        \n        switch (type) {\n          case 'number':\n            return ColumnConfigFactory.number(keyStr, options);\n          case 'date':\n            return ColumnConfigFactory.date(keyStr, options);\n          case 'boolean':\n            return ColumnConfigFactory.boolean(keyStr, options);\n          case 'text':\n          default:\n            return ColumnConfigFactory.text(keyStr, options);\n        }\n      }\n    });\n  }\n}\n\n/**\n * Convenience exports for common column types\n */\nexport const Columns = ColumnConfigFactory;\n\n"]}