@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/models/autosave-config.interface.mjs

@@ -0,0 +1,8 @@
+/**
+ * Default autosave configuration
+ */
+export const DEFAULT_AUTOSAVE_CONFIG = {
+    enabled: true,
+    strategy: 'lazy'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b3NhdmUtY29uZmlnLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LXRhYmxlL3NyYy9saWIvbW9kZWxzL2F1dG9zYXZlLWNvbmZpZy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQW1CO0lBQ3JELE9BQU8sRUFBRSxJQUFJO0lBQ2IsUUFBUSxFQUFFLE1BQU07Q0FDakIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQXV0b3NhdmUgc3RyYXRlZ3kgdHlwZXNcbiAqL1xuZXhwb3J0IHR5cGUgQXV0b3NhdmVTdHJhdGVneSA9ICdsYXp5JyB8ICdlYWdlcic7XG5cbi8qKlxuICogQXV0b3NhdmUgY29uZmlndXJhdGlvbiBpbnRlcmZhY2VcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBBdXRvc2F2ZUNvbmZpZyB7XG4gIC8qKlxuICAgKiBXaGV0aGVyIGF1dG9zYXZlIGlzIGVuYWJsZWRcbiAgICovXG4gIGVuYWJsZWQ6IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEF1dG9zYXZlIHN0cmF0ZWd5OlxuICAgKiAtICdsYXp5JzogU2F2ZXMgYWZ0ZXIgdXNlciBzdG9wcyBtYWtpbmcgY2hhbmdlcyAoMnMgZGVib3VuY2UpXG4gICAqIC0gJ2VhZ2VyJzogU2F2ZXMgb24gZXZlcnkgY2hhbmdlICgxMDBtcyBkZWJvdW5jZSlcbiAgICovXG4gIHN0cmF0ZWd5OiBBdXRvc2F2ZVN0cmF0ZWd5O1xufVxuXG4vKipcbiAqIERlZmF1bHQgYXV0b3NhdmUgY29uZmlndXJhdGlvblxuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9BVVRPU0FWRV9DT05GSUc6IEF1dG9zYXZlQ29uZmlnID0ge1xuICBlbmFibGVkOiB0cnVlLFxuICBzdHJhdGVneTogJ2xhenknXG59O1xuXG4iXX0=

package/esm2020/lib/models/base-column-config.class.mjs

@@ -0,0 +1,253 @@
+/**
+ * Base column configuration class implementing Template Method pattern
+ */
+import { DEFAULT_COLUMN_CONFIG } from './column-config.interface';
+import { Cell } from '../renderer/models/cell.class';
+import { deepMergeColumnConfig } from './column-config.utils';
+/**
+ * Abstract base class for column configurations
+ * Implements Template Method pattern for cell operations
+ */
+export class BaseColumnConfig {
+    constructor(config) {
+        const merged = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, config);
+        this.key = merged.key;
+        this.header = merged.header;
+        this.dataType = merged.dataType;
+        this.formatter = merged.formatter;
+        this.validator = merged.validator;
+        this.editor = merged.editor;
+        this.parser = merged.parser;
+        this.editable = merged.editable;
+        this.editMode = merged.editMode;
+        this.sortable = merged.sortable;
+        this.filterable = merged.filterable;
+        this.resizable = merged.resizable;
+        this.width = merged.width;
+        this.minWidth = merged.minWidth;
+        this.maxWidth = merged.maxWidth;
+        this.alignment = merged.alignment;
+        this.verticalAlignment = merged.verticalAlignment;
+        this.truncate = merged.truncate;
+        this.tooltip = merged.tooltip;
+        this.className = merged.className;
+        this.style = merged.style;
+        this.cellTemplate = merged.cellTemplate;
+        this.headerTemplate = merged.headerTemplate;
+        this.visible = merged.visible;
+        this.pinned = merged.pinned;
+        this.sortPriority = merged.sortPriority;
+        this.comparator = merged.comparator;
+        this.valueGetter = merged.valueGetter;
+        this.valueSetter = merged.valueSetter;
+        this.hooks = merged.hooks;
+        this.showLoadingIndicator = merged.showLoadingIndicator;
+        this.metadata = merged.metadata;
+    }
+    /**
+     * Factory method to create a cell (Factory Pattern)
+     * Can be overridden by subclasses for custom cell creation
+     */
+    createCell(rowData, rowIndex) {
+        const value = this.extractValue(rowData);
+        const cell = new Cell(this, value, rowData, rowIndex);
+        // Apply any post-creation hooks
+        this.afterCellCreated(cell, rowData, rowIndex);
+        return cell;
+    }
+    /**
+     * Template method for processing cell edit workflow
+     * Defines the algorithm steps that subclasses can customize
+     */
+    processEdit(cell, newValue) {
+        // Step 1: Before edit hook
+        if (!this.beforeEdit(cell, newValue)) {
+            return false;
+        }
+        // Step 2: Parse the value
+        const parsedValue = this.parseValue(newValue);
+        if (parsedValue === undefined) {
+            return false;
+        }
+        // Step 3: Validate the parsed value
+        const validationResult = this.validateValue(parsedValue, cell.getRowData());
+        if (!validationResult.valid) {
+            this.onValidationFailed(cell, validationResult);
+            return false;
+        }
+        // Step 4: Apply the value
+        const success = cell.saveEdit(parsedValue);
+        if (success) {
+            // Step 5: After edit hook
+            this.afterEdit(cell, parsedValue);
+            // Step 6: Update row data if valueSetter is provided
+            if (this.valueSetter) {
+                this.valueSetter(cell.getRowData(), parsedValue);
+            }
+        }
+        return success;
+    }
+    /**
+     * Hook: Before edit validation (can be overridden)
+     */
+    beforeEdit(cell, newValue) {
+        if (this.hooks?.beforeEdit) {
+            this.hooks.beforeEdit({
+                value: newValue,
+                previousValue: cell.getValue(),
+                rowData: cell.getRowData(),
+                columnKey: this.key,
+                rowIndex: cell.getRowIndex()
+            });
+        }
+        return true;
+    }
+    /**
+     * Hook: After edit completion (can be overridden)
+     */
+    afterEdit(cell, newValue) {
+        if (this.hooks?.afterEdit) {
+            this.hooks.afterEdit({
+                value: newValue,
+                previousValue: cell.getValue(),
+                rowData: cell.getRowData(),
+                columnKey: this.key,
+                rowIndex: cell.getRowIndex()
+            });
+        }
+    }
+    /**
+     * Hook: After cell is created (can be overridden)
+     */
+    afterCellCreated(cell, rowData, rowIndex) {
+        // Subclasses can override to perform post-creation setup
+    }
+    /**
+     * Hook: When validation fails (can be overridden)
+     */
+    onValidationFailed(cell, validationResult) {
+        if (this.hooks?.onValidationError) {
+            this.hooks.onValidationError({
+                value: cell.getValue(),
+                rowData: cell.getRowData(),
+                columnKey: this.key,
+                rowIndex: cell.getRowIndex()
+            });
+        }
+    }
+    /**
+     * Extract value from row data (can be overridden)
+     */
+    extractValue(rowData) {
+        if (this.valueGetter) {
+            return this.valueGetter(rowData);
+        }
+        return rowData[this.key];
+    }
+    /**
+     * Parse value using parser if available (can be overridden)
+     */
+    parseValue(value) {
+        if (this.parser) {
+            try {
+                return this.parser.parse(value);
+            }
+            catch (error) {
+                console.error(`Failed to parse value for column ${this.key}:`, error);
+                return undefined;
+            }
+        }
+        return value;
+    }
+    /**
+     * Validate value using validator if available (can be overridden)
+     */
+    validateValue(value, rowData) {
+        if (this.validator) {
+            if (this.validator.validateWithContext) {
+                return this.validator.validateWithContext(value, rowData, this.key);
+            }
+            return this.validator.validate(value);
+        }
+        return { valid: true };
+    }
+    /**
+     * Format value for display (can be overridden)
+     */
+    formatValue(value, rowData) {
+        if (this.formatter) {
+            if (this.formatter.formatWithContext && rowData) {
+                return this.formatter.formatWithContext(value, rowData, this.key);
+            }
+            return this.formatter.format(value);
+        }
+        return String(value ?? '');
+    }
+    /**
+     * Get cell tooltip (can be overridden)
+     */
+    getTooltip(value, rowData) {
+        if (!this.tooltip) {
+            return undefined;
+        }
+        if (typeof this.tooltip === 'function') {
+            return this.tooltip(value, rowData);
+        }
+        return this.tooltip;
+    }
+    /**
+     * Get cell class names (can be overridden)
+     */
+    getClassName(value, rowData) {
+        if (!this.className) {
+            return undefined;
+        }
+        if (typeof this.className === 'function') {
+            return this.className(value, rowData);
+        }
+        return this.className;
+    }
+    /**
+     * Get cell styles (can be overridden)
+     */
+    getStyle(value, rowData) {
+        if (!this.style) {
+            return undefined;
+        }
+        if (typeof this.style === 'function') {
+            return this.style(value, rowData);
+        }
+        return this.style;
+    }
+    /**
+     * Compare two values for sorting (can be overridden)
+     */
+    compare(a, b) {
+        if (this.comparator) {
+            return this.comparator(a, b);
+        }
+        // Default comparison
+        if (a === b)
+            return 0;
+        if (a == null)
+            return -1;
+        if (b == null)
+            return 1;
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a - b;
+        }
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() - b.getTime();
+        }
+        return String(a).localeCompare(String(b));
+    }
+}
+/**
+ * Concrete implementation for simple use cases
+ */
+export class SimpleColumnConfig extends BaseColumnConfig {
+    constructor(config) {
+        super(config);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-column-config.class.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/models/base-column-config.class.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Base column configuration class implementing Template Method pattern\n */\n\nimport { ColumnConfig, DEFAULT_COLUMN_CONFIG } from './column-config.interface';\nimport { Cell } from '../renderer/models/cell.class';\nimport { CellFormatter, CellValidator, CellEditor, CellParser, CellLifecycleHooks } from './cell-strategies.interface';\nimport { CellAlignment, CellVerticalAlignment, EditMode, CellDataType, ValidationResult } from './cell-types';\nimport { TemplateRef } from '@angular/core';\nimport { deepMergeColumnConfig } from './column-config.utils';\n\n/**\n * Abstract base class for column configurations\n * Implements Template Method pattern for cell operations\n */\nexport abstract class BaseColumnConfig<T = any> implements ColumnConfig<T> {\n  readonly key: string;\n  readonly header?: string;\n  readonly dataType?: CellDataType;\n  readonly formatter?: CellFormatter<T>;\n  readonly validator?: CellValidator<T>;\n  readonly editor?: CellEditor<T>;\n  readonly parser?: CellParser<T>;\n  readonly editable?: boolean;\n  readonly editMode?: EditMode;\n  readonly sortable?: boolean;\n  readonly filterable?: boolean;\n  readonly resizable?: boolean;\n  readonly width?: number | string;\n  readonly minWidth?: number;\n  readonly maxWidth?: number;\n  readonly alignment?: CellAlignment;\n  readonly verticalAlignment?: CellVerticalAlignment;\n  readonly truncate?: boolean;\n  readonly tooltip?: string | ((value: T, rowData: any) => string);\n  readonly className?: string | string[] | ((value: T, rowData: any) => string | string[]);\n  readonly style?: Record<string, any> | ((value: T, rowData: any) => Record<string, any>);\n  readonly cellTemplate?: TemplateRef<any>;\n  readonly headerTemplate?: TemplateRef<any>;\n  readonly visible?: boolean;\n  readonly pinned?: 'left' | 'right' | false;\n  readonly sortPriority?: number;\n  readonly comparator?: (a: T, b: T) => number;\n  readonly valueGetter?: (rowData: any) => T;\n  readonly valueSetter?: (rowData: any, value: T) => void;\n  readonly hooks?: CellLifecycleHooks<T>;\n  readonly showLoadingIndicator?: boolean;\n  readonly metadata?: Record<string, any>;\n\n  constructor(config: Partial<ColumnConfig<T>> & { key: string }) {\n    const merged = deepMergeColumnConfig(DEFAULT_COLUMN_CONFIG, config) as ColumnConfig<T>;\n    \n    this.key = merged.key;\n    this.header = merged.header;\n    this.dataType = merged.dataType;\n    this.formatter = merged.formatter;\n    this.validator = merged.validator;\n    this.editor = merged.editor;\n    this.parser = merged.parser;\n    this.editable = merged.editable;\n    this.editMode = merged.editMode;\n    this.sortable = merged.sortable;\n    this.filterable = merged.filterable;\n    this.resizable = merged.resizable;\n    this.width = merged.width;\n    this.minWidth = merged.minWidth;\n    this.maxWidth = merged.maxWidth;\n    this.alignment = merged.alignment;\n    this.verticalAlignment = merged.verticalAlignment;\n    this.truncate = merged.truncate;\n    this.tooltip = merged.tooltip;\n    this.className = merged.className;\n    this.style = merged.style;\n    this.cellTemplate = merged.cellTemplate;\n    this.headerTemplate = merged.headerTemplate;\n    this.visible = merged.visible;\n    this.pinned = merged.pinned;\n    this.sortPriority = merged.sortPriority;\n    this.comparator = merged.comparator;\n    this.valueGetter = merged.valueGetter;\n    this.valueSetter = merged.valueSetter;\n    this.hooks = merged.hooks;\n    this.showLoadingIndicator = merged.showLoadingIndicator;\n    this.metadata = merged.metadata;\n  }\n\n  /**\n   * Factory method to create a cell (Factory Pattern)\n   * Can be overridden by subclasses for custom cell creation\n   */\n  createCell(rowData: any, rowIndex?: number): Cell<T> {\n    const value = this.extractValue(rowData);\n    const cell = new Cell<T>(this, value, rowData, rowIndex);\n    \n    // Apply any post-creation hooks\n    this.afterCellCreated(cell, rowData, rowIndex);\n    \n    return cell;\n  }\n\n  /**\n   * Template method for processing cell edit workflow\n   * Defines the algorithm steps that subclasses can customize\n   */\n  processEdit(cell: Cell<T>, newValue: T): boolean {\n    // Step 1: Before edit hook\n    if (!this.beforeEdit(cell, newValue)) {\n      return false;\n    }\n\n    // Step 2: Parse the value\n    const parsedValue = this.parseValue(newValue);\n    if (parsedValue === undefined) {\n      return false;\n    }\n\n    // Step 3: Validate the parsed value\n    const validationResult = this.validateValue(parsedValue, cell.getRowData());\n    if (!validationResult.valid) {\n      this.onValidationFailed(cell, validationResult);\n      return false;\n    }\n\n    // Step 4: Apply the value\n    const success = cell.saveEdit(parsedValue);\n    \n    if (success) {\n      // Step 5: After edit hook\n      this.afterEdit(cell, parsedValue);\n      \n      // Step 6: Update row data if valueSetter is provided\n      if (this.valueSetter) {\n        this.valueSetter(cell.getRowData(), parsedValue);\n      }\n    }\n\n    return success;\n  }\n\n  /**\n   * Hook: Before edit validation (can be overridden)\n   */\n  protected beforeEdit(cell: Cell<T>, newValue: T): boolean {\n    if (this.hooks?.beforeEdit) {\n      this.hooks.beforeEdit({\n        value: newValue,\n        previousValue: cell.getValue(),\n        rowData: cell.getRowData(),\n        columnKey: this.key,\n        rowIndex: cell.getRowIndex()\n      });\n    }\n    return true;\n  }\n\n  /**\n   * Hook: After edit completion (can be overridden)\n   */\n  protected afterEdit(cell: Cell<T>, newValue: T): void {\n    if (this.hooks?.afterEdit) {\n      this.hooks.afterEdit({\n        value: newValue,\n        previousValue: cell.getValue(),\n        rowData: cell.getRowData(),\n        columnKey: this.key,\n        rowIndex: cell.getRowIndex()\n      });\n    }\n  }\n\n  /**\n   * Hook: After cell is created (can be overridden)\n   */\n  protected afterCellCreated(cell: Cell<T>, rowData: any, rowIndex?: number): void {\n    // Subclasses can override to perform post-creation setup\n  }\n\n  /**\n   * Hook: When validation fails (can be overridden)\n   */\n  protected onValidationFailed(cell: Cell<T>, validationResult: ValidationResult): void {\n    if (this.hooks?.onValidationError) {\n      this.hooks.onValidationError({\n        value: cell.getValue(),\n        rowData: cell.getRowData(),\n        columnKey: this.key,\n        rowIndex: cell.getRowIndex()\n      });\n    }\n  }\n\n  /**\n   * Extract value from row data (can be overridden)\n   */\n  protected extractValue(rowData: any): T {\n    if (this.valueGetter) {\n      return this.valueGetter(rowData);\n    }\n    return rowData[this.key];\n  }\n\n  /**\n   * Parse value using parser if available (can be overridden)\n   */\n  protected parseValue(value: any): T | undefined {\n    if (this.parser) {\n      try {\n        return this.parser.parse(value);\n      } catch (error) {\n        console.error(`Failed to parse value for column ${this.key}:`, error);\n        return undefined;\n      }\n    }\n    return value;\n  }\n\n  /**\n   * Validate value using validator if available (can be overridden)\n   */\n  protected validateValue(value: T, rowData: any): ValidationResult {\n    if (this.validator) {\n      if (this.validator.validateWithContext) {\n        return this.validator.validateWithContext(value, rowData, this.key);\n      }\n      return this.validator.validate(value);\n    }\n    return { valid: true };\n  }\n\n  /**\n   * Format value for display (can be overridden)\n   */\n  formatValue(value: T, rowData?: any): string {\n    if (this.formatter) {\n      if (this.formatter.formatWithContext && rowData) {\n        return this.formatter.formatWithContext(value, rowData, this.key);\n      }\n      return this.formatter.format(value);\n    }\n    return String(value ?? '');\n  }\n\n  /**\n   * Get cell tooltip (can be overridden)\n   */\n  getTooltip(value: T, rowData: any): string | undefined {\n    if (!this.tooltip) {\n      return undefined;\n    }\n    \n    if (typeof this.tooltip === 'function') {\n      return this.tooltip(value, rowData);\n    }\n    \n    return this.tooltip;\n  }\n\n  /**\n   * Get cell class names (can be overridden)\n   */\n  getClassName(value: T, rowData: any): string | string[] | undefined {\n    if (!this.className) {\n      return undefined;\n    }\n    \n    if (typeof this.className === 'function') {\n      return this.className(value, rowData);\n    }\n    \n    return this.className;\n  }\n\n  /**\n   * Get cell styles (can be overridden)\n   */\n  getStyle(value: T, rowData: any): Record<string, any> | undefined {\n    if (!this.style) {\n      return undefined;\n    }\n    \n    if (typeof this.style === 'function') {\n      return this.style(value, rowData);\n    }\n    \n    return this.style;\n  }\n\n  /**\n   * Compare two values for sorting (can be overridden)\n   */\n  compare(a: T, b: T): number {\n    if (this.comparator) {\n      return this.comparator(a, b);\n    }\n    \n    // Default comparison\n    if (a === b) return 0;\n    if (a == null) return -1;\n    if (b == null) return 1;\n    \n    if (typeof a === 'number' && typeof b === 'number') {\n      return a - b;\n    }\n    \n    if (a instanceof Date && b instanceof Date) {\n      return a.getTime() - b.getTime();\n    }\n    \n    return String(a).localeCompare(String(b));\n  }\n}\n\n/**\n * Concrete implementation for simple use cases\n */\nexport class SimpleColumnConfig<T = any> extends BaseColumnConfig<T> {\n  constructor(config: Partial<ColumnConfig<T>> & { key: string }) {\n    super(config);\n  }\n}\n\n"]}

package/esm2020/lib/models/cell-strategies.interface.mjs

@@ -0,0 +1,6 @@
+/**
+ * Strategy interfaces for cell behavior
+ * These interfaces define pluggable strategies for formatting, validation, and editing
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/cell-types.mjs

@@ -0,0 +1,147 @@
+/**
+ * Base type definitions for cell configuration model
+ */
+/**
+ * Data type enumeration for type-specific handling
+ */
+export var CellDataType;
+(function (CellDataType) {
+    CellDataType["STRING"] = "string";
+    CellDataType["NUMBER"] = "number";
+    CellDataType["BOOLEAN"] = "boolean";
+    CellDataType["DATE"] = "date";
+    CellDataType["CUSTOM"] = "custom";
+})(CellDataType || (CellDataType = {}));
+/**
+ * Cell alignment options
+ */
+export var CellAlignment;
+(function (CellAlignment) {
+    CellAlignment["LEFT"] = "left";
+    CellAlignment["CENTER"] = "center";
+    CellAlignment["RIGHT"] = "right";
+})(CellAlignment || (CellAlignment = {}));
+/**
+ * Vertical alignment options
+ */
+export var CellVerticalAlignment;
+(function (CellVerticalAlignment) {
+    CellVerticalAlignment["TOP"] = "top";
+    CellVerticalAlignment["MIDDLE"] = "middle";
+    CellVerticalAlignment["BOTTOM"] = "bottom";
+})(CellVerticalAlignment || (CellVerticalAlignment = {}));
+/**
+ * Edit mode trigger options
+ */
+export var EditMode;
+(function (EditMode) {
+    /**
+     * Single click to edit
+     */
+    EditMode["CLICK"] = "click";
+    /**
+     * Enter key to edit (requires keyboard navigation enabled)
+     */
+    EditMode["ENTER"] = "enter";
+    /**
+     * Manual trigger (via API call)
+     */
+    EditMode["MANUAL"] = "manual";
+    /**
+     * Never editable
+     */
+    EditMode["NONE"] = "none";
+})(EditMode || (EditMode = {}));
+/**
+ * Navigation key identifiers for keyboard navigation
+ */
+export var NavigationKey;
+(function (NavigationKey) {
+    /**
+     * Arrow up key
+     */
+    NavigationKey["ARROW_UP"] = "ArrowUp";
+    /**
+     * Arrow down key
+     */
+    NavigationKey["ARROW_DOWN"] = "ArrowDown";
+    /**
+     * Arrow left key
+     */
+    NavigationKey["ARROW_LEFT"] = "ArrowLeft";
+    /**
+     * Arrow right key
+     */
+    NavigationKey["ARROW_RIGHT"] = "ArrowRight";
+    /**
+     * Tab key
+     */
+    NavigationKey["TAB"] = "Tab";
+    /**
+     * Enter key
+     */
+    NavigationKey["ENTER"] = "Enter";
+    /**
+     * Escape key
+     */
+    NavigationKey["ESCAPE"] = "Escape";
+})(NavigationKey || (NavigationKey = {}));
+/**
+ * Navigation directions
+ */
+export var NavigationDirection;
+(function (NavigationDirection) {
+    NavigationDirection["UP"] = "up";
+    NavigationDirection["DOWN"] = "down";
+    NavigationDirection["LEFT"] = "left";
+    NavigationDirection["RIGHT"] = "right";
+})(NavigationDirection || (NavigationDirection = {}));
+/**
+ * Cell lifecycle states
+ */
+export var CellLifecycleState;
+(function (CellLifecycleState) {
+    /**
+     * Cell is displaying value
+     */
+    CellLifecycleState["DISPLAY"] = "display";
+    /**
+     * Cell is in edit mode
+     */
+    CellLifecycleState["EDITING"] = "editing";
+    /**
+     * Cell value is being validated
+     */
+    CellLifecycleState["VALIDATING"] = "validating";
+    /**
+     * Cell value is being saved
+     */
+    CellLifecycleState["SAVING"] = "saving";
+    /**
+     * Cell has error
+     */
+    CellLifecycleState["ERROR"] = "error";
+    /**
+     * Cell is disabled
+     */
+    CellLifecycleState["DISABLED"] = "disabled";
+})(CellLifecycleState || (CellLifecycleState = {}));
+/**
+ * Type guard to check if value is null or undefined
+ */
+export function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/**
+ * Type guard to check if value is a valid date
+ */
+export function isValidDate(value) {
+    return value instanceof Date && !isNaN(value.getTime());
+}
+/**
+ * Type guard to check if validation result is valid
+ */
+export function isValidationSuccess(result) {
+    return result.valid === true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell-types.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/models/cell-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAWH;;GAEG;AACH,MAAM,CAAN,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;IACjB,mCAAmB,CAAA;IACnB,6BAAa,CAAA;IACb,iCAAiB,CAAA;AACnB,CAAC,EANW,YAAY,KAAZ,YAAY,QAMvB;AA2BD;;GAEG;AACH,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,kCAAiB,CAAA;IACjB,gCAAe,CAAA;AACjB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,oCAAW,CAAA;IACX,0CAAiB,CAAA;IACjB,0CAAiB,CAAA;AACnB,CAAC,EAJW,qBAAqB,KAArB,qBAAqB,QAIhC;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,QAoBX;AApBD,WAAY,QAAQ;IAClB;;OAEG;IACH,2BAAe,CAAA;IAEf;;OAEG;IACH,2BAAe,CAAA;IAEf;;OAEG;IACH,6BAAiB,CAAA;IAEjB;;OAEG;IACH,yBAAa,CAAA;AACf,CAAC,EApBW,QAAQ,KAAR,QAAQ,QAoBnB;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,aAmCX;AAnCD,WAAY,aAAa;IACvB;;OAEG;IACH,qCAAoB,CAAA;IAEpB;;OAEG;IACH,yCAAwB,CAAA;IAExB;;OAEG;IACH,yCAAwB,CAAA;IAExB;;OAEG;IACH,2CAA0B,CAAA;IAE1B;;OAEG;IACH,4BAAW,CAAA;IAEX;;OAEG;IACH,gCAAe,CAAA;IAEf;;OAEG;IACH,kCAAiB,CAAA;AACnB,CAAC,EAnCW,aAAa,KAAb,aAAa,QAmCxB;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,gCAAS,CAAA;IACT,oCAAa,CAAA;IACb,oCAAa,CAAA;IACb,sCAAe,CAAA;AACjB,CAAC,EALW,mBAAmB,KAAnB,mBAAmB,QAK9B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,kBA8BX;AA9BD,WAAY,kBAAkB;IAC5B;;OAEG;IACH,yCAAmB,CAAA;IAEnB;;OAEG;IACH,yCAAmB,CAAA;IAEnB;;OAEG;IACH,+CAAyB,CAAA;IAEzB;;OAEG;IACH,uCAAiB,CAAA;IAEjB;;OAEG;IACH,qCAAe,CAAA;IAEf;;OAEG;IACH,2CAAqB,CAAA;AACvB,CAAC,EA9BW,kBAAkB,KAAlB,kBAAkB,QA8B7B;AAqCD;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAU;IAC1C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;AAC/C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,KAAU;IACpC,OAAO,KAAK,YAAY,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAwB;IAC1D,OAAO,MAAM,CAAC,KAAK,KAAK,IAAI,CAAC;AAC/B,CAAC","sourcesContent":["/**\n * Base type definitions for cell configuration model\n */\n\n// Forward declarations for event interfaces\nimport type { Cell } from '../renderer/models/cell.class';\nimport type { CellState } from '../renderer/models/cell-state.interface';\n\n/**\n * Supported cell data types\n */\nexport type CellValue = string | number | boolean | Date | null | undefined | any;\n\n/**\n * Data type enumeration for type-specific handling\n */\nexport enum CellDataType {\n  STRING = 'string',\n  NUMBER = 'number',\n  BOOLEAN = 'boolean',\n  DATE = 'date',\n  CUSTOM = 'custom'\n}\n\n/**\n * Result of cell validation\n */\nexport interface ValidationResult {\n  /**\n   * Whether the value is valid\n   */\n  valid: boolean;\n\n  /**\n   * Error message if validation failed\n   */\n  error?: string;\n\n  /**\n   * Field-specific error messages for complex validations\n   */\n  errors?: Record<string, string>;\n\n  /**\n   * Warning messages (non-blocking)\n   */\n  warnings?: string[];\n}\n\n/**\n * Cell alignment options\n */\nexport enum CellAlignment {\n  LEFT = 'left',\n  CENTER = 'center',\n  RIGHT = 'right'\n}\n\n/**\n * Vertical alignment options\n */\nexport enum CellVerticalAlignment {\n  TOP = 'top',\n  MIDDLE = 'middle',\n  BOTTOM = 'bottom'\n}\n\n/**\n * Edit mode trigger options\n */\nexport enum EditMode {\n  /**\n   * Single click to edit\n   */\n  CLICK = 'click',\n  \n  /**\n   * Enter key to edit (requires keyboard navigation enabled)\n   */\n  ENTER = 'enter',\n\n  /**\n   * Manual trigger (via API call)\n   */\n  MANUAL = 'manual',\n\n  /**\n   * Never editable\n   */\n  NONE = 'none'\n}\n\n/**\n * Navigation key identifiers for keyboard navigation\n */\nexport enum NavigationKey {\n  /**\n   * Arrow up key\n   */\n  ARROW_UP = 'ArrowUp',\n  \n  /**\n   * Arrow down key\n   */\n  ARROW_DOWN = 'ArrowDown',\n  \n  /**\n   * Arrow left key\n   */\n  ARROW_LEFT = 'ArrowLeft',\n  \n  /**\n   * Arrow right key\n   */\n  ARROW_RIGHT = 'ArrowRight',\n  \n  /**\n   * Tab key\n   */\n  TAB = 'Tab',\n  \n  /**\n   * Enter key\n   */\n  ENTER = 'Enter',\n  \n  /**\n   * Escape key\n   */\n  ESCAPE = 'Escape'\n}\n\n/**\n * Navigation directions\n */\nexport enum NavigationDirection {\n  UP = 'up',\n  DOWN = 'down',\n  LEFT = 'left',\n  RIGHT = 'right'\n}\n\n/**\n * Cell lifecycle states\n */\nexport enum CellLifecycleState {\n  /**\n   * Cell is displaying value\n   */\n  DISPLAY = 'display',\n\n  /**\n   * Cell is in edit mode\n   */\n  EDITING = 'editing',\n\n  /**\n   * Cell value is being validated\n   */\n  VALIDATING = 'validating',\n\n  /**\n   * Cell value is being saved\n   */\n  SAVING = 'saving',\n\n  /**\n   * Cell has error\n   */\n  ERROR = 'error',\n\n  /**\n   * Cell is disabled\n   */\n  DISABLED = 'disabled'\n}\n\n/**\n * Generic cell event data\n */\nexport interface CellEvent<T = any> {\n  /**\n   * The cell value\n   */\n  value: T;\n\n  /**\n   * Previous value (for change events)\n   */\n  previousValue?: T;\n\n  /**\n   * Row data context\n   */\n  rowData?: any;\n\n  /**\n   * Column key\n   */\n  columnKey: string;\n\n  /**\n   * Row index\n   */\n  rowIndex?: number;\n\n  /**\n   * Native event if triggered by user interaction\n   */\n  originalEvent?: Event;\n}\n\n/**\n * Type guard to check if value is null or undefined\n */\nexport function isNullOrUndefined(value: any): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * Type guard to check if value is a valid date\n */\nexport function isValidDate(value: any): value is Date {\n  return value instanceof Date && !isNaN(value.getTime());\n}\n\n/**\n * Type guard to check if validation result is valid\n */\nexport function isValidationSuccess(result: ValidationResult): boolean {\n  return result.valid === true;\n}\n\n/**\n * Cell edit started event\n * Emitted when a cell enters edit mode\n */\nexport interface CellEditEvent<T = any> {\n  /**\n   * The cell instance\n   */\n  cell: Cell<T>;\n  \n  /**\n   * Current cell value\n   */\n  value: T;\n  \n  /**\n   * Row data context\n   */\n  rowData: any;\n  \n  /**\n   * Column key\n   */\n  columnKey: string;\n  \n  /**\n   * Row index\n   */\n  rowIndex?: number;\n  \n  /**\n   * Current cell state snapshot\n   */\n  cellState: CellState<T>;\n}\n\n/**\n * Cell value saved event\n * Emitted when a cell value is successfully saved after editing\n */\nexport interface CellSaveEvent<T = any> {\n  /**\n   * The cell instance\n   */\n  cell: Cell<T>;\n  \n  /**\n   * New value after save\n   */\n  newValue: T;\n  \n  /**\n   * Previous value before save\n   */\n  previousValue?: T;\n  \n  /**\n   * Row data context\n   */\n  rowData: any;\n  \n  /**\n   * Column key\n   */\n  columnKey: string;\n  \n  /**\n   * Row index\n   */\n  rowIndex?: number;\n  \n  /**\n   * Whether the saved value is valid\n   */\n  isValid: boolean;\n  \n  /**\n   * Validation error messages if any\n   */\n  validationErrors?: string[];\n  \n  /**\n   * Current cell state snapshot after save\n   */\n  cellState: CellState<T>;\n}\n\n/**\n * Cell value changed event\n * Emitted after a successful cell value change (after save and validation)\n */\nexport interface CellChangeEvent<T = any> {\n  /**\n   * The cell instance\n   */\n  cell: Cell<T>;\n  \n  /**\n   * Old value before change\n   */\n  oldValue: T;\n  \n  /**\n   * New value after change\n   */\n  newValue: T;\n  \n  /**\n   * Row data context\n   */\n  rowData: any;\n  \n  /**\n   * Column key\n   */\n  columnKey: string;\n  \n  /**\n   * Row index\n   */\n  rowIndex?: number;\n  \n  /**\n   * Whether the old value was valid\n   */\n  wasValid: boolean;\n  \n  /**\n   * Whether the new value is valid\n   */\n  isValid: boolean;\n  \n  /**\n   * Current cell state snapshot\n   */\n  cellState: CellState<T>;\n}\n\n/**\n * Cell edit cancelled event\n * Emitted when cell editing is cancelled without saving\n */\nexport interface CellCancelEvent<T = any> {\n  /**\n   * The cell instance\n   */\n  cell: Cell<T>;\n  \n  /**\n   * Current value (unchanged)\n   */\n  value: T;\n  \n  /**\n   * Previous value that was being edited\n   */\n  previousValue?: T;\n  \n  /**\n   * Row data context\n   */\n  rowData: any;\n  \n  /**\n   * Column key\n   */\n  columnKey: string;\n  \n  /**\n   * Row index\n   */\n  rowIndex?: number;\n  \n  /**\n   * Current cell state snapshot\n   */\n  cellState: CellState<T>;\n}\n\n"]}

package/esm2020/lib/models/column-action.interface.mjs

@@ -0,0 +1,6 @@
+/**
+ * Column action interface - defines actions that can be performed on table columns
+ * Similar to RowAction but for column-level operations
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/column-config.interface.mjs

@@ -0,0 +1,43 @@
+/**
+ * Column configuration interface - Flyweight pattern
+ * This configuration is shared across all cells in a column
+ */
+import { CellAlignment, CellVerticalAlignment, EditMode } from './cell-types';
+import { SortDirection, FilterOperator } from '../renderer/models/table-types';
+import { DefaultFormatter } from '../strategies/default-formatters';
+import { TextEditor } from '../strategies/default-editors';
+/**
+ * Default column configuration values
+ */
+export const DEFAULT_COLUMN_CONFIG = {
+    editable: true,
+    editMode: EditMode.CLICK,
+    sortable: true,
+    filterable: true,
+    resizable: true,
+    hideable: true,
+    movable: true,
+    pinnable: true,
+    enableMenu: true,
+    columnActions: [],
+    includeBuiltInActions: true,
+    minWidth: 50,
+    maxWidth: 1000,
+    visible: true,
+    alignment: CellAlignment.LEFT,
+    verticalAlignment: CellVerticalAlignment.MIDDLE,
+    truncate: false,
+    pinned: false,
+    sticky: false,
+    showStickyShadow: true,
+    showLoadingIndicator: true,
+    sortDirection: SortDirection.NONE,
+    sortEnabled: false,
+    editor: new TextEditor(),
+    formatter: new DefaultFormatter(),
+    filterConfig: {
+        operator: FilterOperator.CONTAINS,
+        enabled: false
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-config.interface.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/models/column-config.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,QAAQ,EAAgB,MAAM,cAAc,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAG/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AA0T3D;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA+B;IAC/D,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,QAAQ,CAAC,KAAK;IACxB,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,IAAI;IACf,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,IAAI;IACd,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,EAAE;IACjB,qBAAqB,EAAE,IAAI;IAC3B,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,aAAa,CAAC,IAAI;IAC7B,iBAAiB,EAAE,qBAAqB,CAAC,MAAM;IAC/C,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,KAAK;IACb,gBAAgB,EAAE,IAAI;IACtB,oBAAoB,EAAE,IAAI;IAC1B,aAAa,EAAE,aAAa,CAAC,IAAI;IACjC,WAAW,EAAE,KAAK;IAClB,MAAM,EAAE,IAAI,UAAU,EAAE;IACxB,SAAS,EAAE,IAAI,gBAAgB,EAAE;IACjC,YAAY,EAAE;QACZ,QAAQ,EAAE,cAAc,CAAC,QAAQ;QACjC,OAAO,EAAE,KAAK;KACf;CACF,CAAC","sourcesContent":["/**\n * Column configuration interface - Flyweight pattern\n * This configuration is shared across all cells in a column\n */\n\nimport { CellFormatter, CellValidator, CellEditor, CellParser, CellLifecycleHooks } from './cell-strategies.interface';\nimport { CellAlignment, CellVerticalAlignment, EditMode, CellDataType } from './cell-types';\nimport { SortDirection, FilterOperator } from '../renderer/models/table-types';\nimport { Cell } from '../renderer/models/cell.class';\nimport { TemplateRef } from '@angular/core';\nimport { DefaultFormatter } from '../strategies/default-formatters';\nimport { TextEditor } from '../strategies/default-editors';\nimport { ColumnAction } from './column-action.interface';\n\n\n/**\n * Filter options configuration for custom dropdown filters\n */\nexport interface FilterOptions {\n  /**\n   * Array of data items to display in the dropdown\n   */\n  data: any[];\n  \n  /**\n   * Handler function to transform data items into {label, value} pairs\n   * @param item The data item to transform\n   * @returns Object with label (displayed text) and value (stored value)\n   */\n  handler: (item: any) => { label: string; value: any };\n  \n  /**\n   * Whether to allow multiple selections\n   * @default false\n   */\n  multiselect?: boolean;\n}\n\n/**\n * Column configuration - shared immutable config for all cells in a column (Flyweight)\n * Contains behavior, metadata, and strategies but NO state\n */\nexport interface ColumnConfig<T = any> {\n  /**\n   * Unique key for the column (maps to row data property)\n   */\n  readonly key: string;\n\n  /**\n   * Display header text for the column\n   */\n  readonly header?: string;\n\n  /**\n   * Data type of the column values\n   */\n  readonly dataType?: CellDataType;\n\n  /**\n   * Formatter strategy for displaying cell values\n   */\n  readonly formatter?: CellFormatter<T>;\n\n  /**\n   * Validator strategy for validating cell values\n   */\n  readonly validator?: CellValidator<T>;\n\n  /**\n   * Editor strategy for inline editing\n   */\n  readonly editor?: CellEditor<T>;\n\n  /**\n   * Parser strategy for converting user input to typed values\n   */\n  readonly parser?: CellParser<T>;\n\n  /**\n   * Whether cells in this column are editable\n   */\n  readonly editable?: boolean;\n\n  /**\n   * Edit mode trigger\n   */\n  readonly editMode?: EditMode;\n\n  /**\n   * Whether this column is sortable\n   */\n  readonly sortable?: boolean;\n\n  /**\n   * Whether this column is filterable\n   */\n  readonly filterable?: boolean;\n\n  /**\n   * Whether this column's visibility can be toggled by users\n   */\n  readonly hideable?: boolean;\n\n  /**\n   * Whether this column can be moved left/right by users\n   * Note: Pinned/sticky columns cannot be moved\n   * @default true\n   */\n  readonly movable?: boolean;\n\n  /**\n   * Whether this column can be pinned/unpinned by users\n   * @default true\n   */\n  readonly pinnable?: boolean;\n\n  /**\n   * Whether to show the column menu dropdown for this column\n   * @default true\n   */\n  readonly enableMenu?: boolean;\n\n  /**\n   * Custom actions for this column (shown in column menu dropdown)\n   * Similar to row actions but for column-level operations\n   * @default []\n   */\n  readonly columnActions?: ColumnAction[];\n\n  /**\n   * Whether to include built-in actions (sort, filter, pin, move) in the column menu\n   * Set to false to show only custom actions\n   * @default true\n   */\n  readonly includeBuiltInActions?: boolean;\n\n  /**\n   * Current sort direction for this column\n   * @default 'none'\n   */\n  sortDirection?: SortDirection;\n\n  /**\n   * Whether sorting is currently active/enabled on this column\n   * @default false\n   */\n  sortEnabled?: boolean;\n\n  /**\n   * Filter configuration for this column\n   * Contains operator, value, enabled state, and custom dropdown options\n   */\n  filterConfig?: {\n    /**\n     * Filter operator\n     * @default 'contains'\n     */\n    operator?: FilterOperator;\n    \n    /**\n     * Current filter value\n     */\n    value?: any;\n    \n    /**\n     * Whether filtering is currently active/enabled on this column\n     * @default false\n     */\n    enabled?: boolean;\n    \n    /**\n     * Custom filter options for dropdown-based filtering\n     * Both data and handler must be provided together, otherwise falls back to text input\n     */\n    options?: FilterOptions;\n  };\n\n  /**\n   * Whether this column is resizable\n   */\n  readonly resizable?: boolean;\n\n  /**\n   * Column width (px, %, or 'auto')\n   */\n  readonly width?: number | string;\n\n  /**\n   * Minimum column width (px)\n   */\n  readonly minWidth?: number;\n\n  /**\n   * Maximum column width (px)\n   */\n  readonly maxWidth?: number;\n\n  /**\n   * Whether this column is sticky (left or right)\n   */\n  readonly sticky?: 'left' | 'right' | false;\n\n  /**\n   * Calculated offset for sticky positioning (px)\n   * Auto-calculated by table component based on column order\n   */\n  stickyOffset?: number;\n\n  /**\n   * Whether to show shadow indicator on sticky columns\n   * @default true\n   */\n  readonly showStickyShadow?: boolean;\n\n  /**\n   * Cell content alignment\n   */\n  readonly alignment?: CellAlignment;\n\n  /**\n   * Cell vertical alignment\n   */\n  readonly verticalAlignment?: CellVerticalAlignment;\n\n  /**\n   * Whether to truncate overflowing text\n   */\n  readonly truncate?: boolean;\n\n  /**\n   * Tooltip configuration\n   */\n  readonly tooltip?: string | ((value: T, rowData: any) => string);\n\n  /**\n   * CSS class name(s) for cells in this column\n   */\n  readonly className?: string | string[] | ((value: T, rowData: any) => string | string[]);\n\n  /**\n   * Inline styles for cells in this column\n   */\n  readonly style?: Record<string, any> | ((value: T, rowData: any) => Record<string, any>);\n\n  /**\n   * Custom cell template (Angular TemplateRef)\n   */\n  readonly cellTemplate?: TemplateRef<any>;\n\n  /**\n   * Custom header template\n   */\n  readonly headerTemplate?: TemplateRef<any>;\n\n  /**\n   * Whether column is visible\n   */\n  readonly visible?: boolean;\n\n  /**\n   * Whether column is pinned (left, right, or none)\n   */\n  readonly pinned?: 'left' | 'right' | false;\n\n  /**\n   * Sort order priority (for multi-column sort)\n   */\n  readonly sortPriority?: number;\n\n  /**\n   * Custom comparator for sorting\n   */\n  readonly comparator?: (a: T, b: T) => number;\n\n  /**\n   * Function to extract value from row data (for nested properties)\n   */\n  readonly valueGetter?: (rowData: any) => T;\n\n  /**\n   * Function to set value in row data (for nested properties)\n   */\n  readonly valueSetter?: (rowData: any, value: T) => void;\n\n  /**\n   * Lifecycle hooks for cells in this column\n   */\n  readonly hooks?: CellLifecycleHooks<T>;\n\n  /**\n   * Whether cells should show loading indicator during async operations\n   */\n  readonly showLoadingIndicator?: boolean;\n\n  /**\n   * Custom metadata for column\n   */\n  readonly metadata?: Record<string, any>;\n\n  /**\n   * Factory method to create a cell instance for this column (Factory Pattern)\n   * @param rowData The row data object\n   * @param rowIndex Optional row index\n   * @returns A new Cell instance\n   */\n  createCell(rowData: any, rowIndex?: number): Cell<T>;\n}\n\n/**\n * Partial column config for extending existing configs\n */\nexport type PartialColumnConfig<T = any> = Partial<ColumnConfig<T>>;\n\n/**\n * Column config builder options\n */\nexport interface ColumnConfigOptions<T = any> extends Omit<ColumnConfig<T>, 'key' | 'createCell'> {\n  // All properties from ColumnConfig except key and createCell\n}\n\n/**\n * Helper type for column config with required key\n */\nexport type ColumnConfigWithKey<T = any> = Required<Pick<ColumnConfig<T>, 'key'>> & Partial<Omit<ColumnConfig<T>, 'key'>>;\n\n/**\n * Default column configuration values\n */\nexport const DEFAULT_COLUMN_CONFIG: Partial<ColumnConfig<any>> = {\n  editable: true,\n  editMode: EditMode.CLICK,\n  sortable: true,\n  filterable: true,\n  resizable: true,\n  hideable: true,\n  movable: true,\n  pinnable: true,\n  enableMenu: true,\n  columnActions: [],\n  includeBuiltInActions: true,\n  minWidth: 50,\n  maxWidth: 1000,\n  visible: true,\n  alignment: CellAlignment.LEFT,\n  verticalAlignment: CellVerticalAlignment.MIDDLE,\n  truncate: false,\n  pinned: false,\n  sticky: false,\n  showStickyShadow: true,\n  showLoadingIndicator: true,\n  sortDirection: SortDirection.NONE,\n  sortEnabled: false,\n  editor: new TextEditor(), // Add default editor to prevent runtime errors\n  formatter: new DefaultFormatter(), // Add default formatter to prevent runtime errors\n  filterConfig: {\n    operator: FilterOperator.CONTAINS,\n    enabled: false\n  }\n};\n\n\n\n"]}