@aquera/ngx-smart-table 0.0.2-alpha

package/lib/builder/utils/typescript-generator.util.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TypeScript code generator utility
+ * Converts TableConfig to TypeScript code using ColumnConfigFactory
+ */
+import { TableConfig } from '../../models/table-config.interface';
+/**
+ * Options for TypeScript code generation
+ */
+export interface TypeScriptGeneratorOptions {
+    /**
+     * Variable name for the exported config
+     */
+    variableName?: string;
+    /**
+     * Include comments in generated code
+     */
+    includeComments?: boolean;
+    /**
+     * Indentation string (default: 2 spaces)
+     */
+    indent?: string;
+}
+/**
+ * Generate TypeScript code from TableConfig
+ * @param config Table configuration
+ * @param options Generation options
+ * @returns TypeScript code string
+ */
+export declare function generateTypeScriptCode(config: TableConfig, options?: TypeScriptGeneratorOptions): string;

package/lib/editors/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Custom cell editors for ngx-smart-table
+ */
+export { NileInputEditor, NileInputEditorOptions } from './nile-input-editor';
+export { NileSelectEditor, NileSelectEditorOptions, SelectOption } from './nile-select-editor';
+export { NileAutoCompleteEditor, NileAutoCompleteEditorOptions, AutoCompleteOption } from './nile-autocomplete-editor';
+export { NileCalendarEditor, NileCalendarEditorOptions, AllowedDatesRange } from './nile-calendar-editor';
+export { NileDatePickerEditor, NileDatePickerEditorOptions, DateRange } from './nile-date-picker-editor';

package/lib/editors/nile-autocomplete-editor.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Custom editor using NileAutoComplete from @aquera/nile-elements
+ * Provides real-time suggestions as users type in table cells
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+/**
+ * Autocomplete option configuration
+ */
+export interface AutoCompleteOption {
+    /** The option's value */
+    value: string;
+    /** Display label for the option */
+    label: string;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+}
+/**
+ * Options interface for NileAutoCompleteEditor
+ */
+export interface NileAutoCompleteEditorOptions {
+    /** Array of autocomplete suggestions - supports both simple string array or detailed AutoCompleteOption objects */
+    options: AutoCompleteOption[] | string[];
+    /** Placeholder text to show as a hint when the search is empty */
+    placeholder?: string;
+    /** Disable the autocomplete control */
+    disabled?: boolean;
+    /** Help text to display below the control */
+    helpText?: string;
+    /** Size of the autocomplete control */
+    size?: 'small' | 'medium' | 'large';
+    /** Adds clear button when value is not empty */
+    clearable?: boolean;
+    /** Make the autocomplete required */
+    required?: boolean;
+    /** Auto-focus the input when editor opens */
+    autoFocus?: boolean;
+    /** Select all text when focused */
+    selectOnFocus?: boolean;
+    /** Warning state styling */
+    warning?: boolean;
+    /** Error state styling */
+    error?: boolean;
+    /** Success state styling */
+    success?: boolean;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Minimum number of characters before showing suggestions */
+    minSearchLength?: number;
+    /** Maximum number of suggestions to show */
+    maxSuggestions?: number;
+    /** Case-sensitive matching */
+    caseSensitive?: boolean;
+    /** Filter mode for matching suggestions */
+    filterMode?: 'startsWith' | 'contains' | 'custom';
+    /** Custom filter function for matching */
+    customFilter?: (input: string, option: AutoCompleteOption) => boolean;
+    /** Draws a filled autocomplete style */
+    filled?: boolean;
+    /** Pill-style with rounded edges */
+    pill?: boolean;
+    /** Use fixed positioning to prevent clipping */
+    hoist?: boolean;
+    /** Placement of the suggestions dropdown */
+    placement?: 'top' | 'bottom';
+    /** Validate before saving (default: true) */
+    validateOnSave?: boolean;
+}
+/**
+ * Custom editor that uses NileAutoComplete component
+ * @template T The value type (string by default)
+ */
+export declare class NileAutoCompleteEditor<T = string> implements CellEditor<T> {
+    private readonly options;
+    private autocomplete?;
+    private eventListeners;
+    constructor(options: NileAutoCompleteEditorOptions);
+    edit(context: CellEditorContext<T>): void;
+    /**
+     * Set allMenuItems property for autocomplete suggestions
+     * NileAutoComplete requires allMenuItems to be set as a property, not child elements
+     */
+    private setMenuItems;
+    /**
+     * Apply all configuration options to the NileAutoComplete element
+     */
+    private applyOptions;
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    private setupEventListeners;
+    /**
+     * Save value with optional validation
+     */
+    private saveValue;
+    /**
+     * Parse value to appropriate type
+     */
+    private parseValue;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): T;
+}

package/lib/editors/nile-calendar-editor.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Custom editor using NileCalendar from @aquera/nile-elements
+ * Provides date selection functionality for table cells
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+/**
+ * Date range configuration for restricting allowed dates
+ */
+export interface AllowedDatesRange {
+    /** Start date in ISO format (YYYY-MM-DD) */
+    startDate?: string;
+    /** End date in ISO format (YYYY-MM-DD) */
+    endDate?: string;
+}
+/**
+ * Options interface for NileCalendarEditor
+ */
+export interface NileCalendarEditorOptions {
+    /** Placeholder text to show when no date is selected */
+    placeholder?: string;
+    /** Disable the calendar control */
+    disabled?: boolean;
+    /** Help text to display below the control */
+    helpText?: string;
+    /** Date format for display (default: 'YYYY-MM-DD') */
+    dateFormat?: string;
+    /** Start year for year dropdown */
+    startYear?: number;
+    /** End year for year dropdown */
+    endYear?: number;
+    /** Date range restrictions */
+    allowedDates?: AllowedDatesRange;
+    /** Show clear button for removing date */
+    allowClear?: boolean;
+    /** Allow double-click to unselect date */
+    doubleClickUnselect?: boolean;
+    /** Show month selection dropdown */
+    showMonthDropdown?: boolean;
+    /** Show year selection dropdown */
+    showYearDropdown?: boolean;
+    /** Allow manual date input via text fields */
+    showManualInputs?: boolean;
+    /** Auto-focus the calendar when editor opens */
+    autoFocus?: boolean;
+    /** Warning state styling */
+    warning?: boolean;
+    /** Error state styling */
+    error?: boolean;
+    /** Success state styling */
+    success?: boolean;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Size of the calendar control */
+    size?: 'small' | 'medium' | 'large';
+    /** Use portal for dropdown rendering to prevent clipping */
+    portal?: boolean;
+    /** Validate before saving (default: true) */
+    validateOnSave?: boolean;
+}
+/**
+ * Custom editor that uses NileCalendar component for date selection
+ * @template T The value type (string by default, formatted as YYYY-MM-DD)
+ */
+export declare class NileCalendarEditor<T = string> implements CellEditor<T> {
+    private readonly options?;
+    private calendar?;
+    private eventListeners;
+    constructor(options?: NileCalendarEditorOptions | undefined);
+    edit(context: CellEditorContext<T>): void;
+    /**
+     * Apply all configuration options to the NileCalendar element
+     */
+    private applyOptions;
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    private setupEventListeners;
+    /**
+     * Save value with optional validation
+     */
+    private saveValue;
+    /**
+     * Parse value to appropriate type
+     */
+    private parseValue;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): T;
+}

package/lib/editors/nile-date-picker-editor.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 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'
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+/**
+ * Date range value interface (kept for reference but not used as return type)
+ * The editor returns string values instead
+ */
+export interface DateRange {
+    /** Start date in ISO format (YYYY-MM-DD) */
+    startDate: string;
+    /** End date in ISO format (YYYY-MM-DD) */
+    endDate: string;
+}
+/**
+ * Options interface for NileDatePickerEditor
+ */
+export interface NileDatePickerEditorOptions {
+    /** Placeholder text to show when no date is selected */
+    placeholder?: string;
+    /** Label for the trigger input */
+    label?: string;
+    /** Disable the date picker control */
+    disabled?: boolean;
+    /** Help text to display below the control */
+    helpText?: string;
+    /** Date format for display (default: 'YYYY-MM-DD') */
+    dateFormat?: string;
+    /** Enable range selection mode */
+    range?: boolean;
+    /** Sync date pickers in range mode */
+    syncDatePicker?: boolean;
+    /** Show clear button for removing date */
+    clearable?: boolean;
+    /** Auto-focus the date picker when editor opens */
+    autoFocus?: boolean;
+    /** Warning state styling */
+    warning?: boolean;
+    /** Error state styling */
+    error?: boolean;
+    /** Success state styling */
+    success?: boolean;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Size of the date picker control */
+    size?: number;
+    /** Filled style for the input */
+    filled?: boolean;
+    /** Pill style for the input */
+    pill?: boolean;
+    /** Validate before saving (default: true) */
+    validateOnSave?: boolean;
+}
+/**
+ * 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 declare class NileDatePickerEditor<T = string> implements CellEditor<T> {
+    private readonly options?;
+    private datePicker?;
+    private triggerInput?;
+    private eventListeners;
+    constructor(options?: NileDatePickerEditorOptions | undefined);
+    edit(context: CellEditorContext<T>): void;
+    /**
+     * Set initial value in the trigger input
+     */
+    private setInitialValue;
+    /**
+     * Apply all configuration options to both NileDatePicker and trigger input
+     */
+    private applyOptions;
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    private setupEventListeners;
+    /**
+     * Save value with optional validation
+     */
+    private saveValue;
+    /**
+     * Parse value from string to appropriate type
+     */
+    private parseValue;
+    getCurrentValue(): T;
+    destroy(): void;
+    focus(): void;
+}

package/lib/editors/nile-input-editor.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Custom editor using NileInput from @aquera/nile-elements
+ * This demonstrates how to create custom editors for ngx-smart-table
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+/**
+ * Options interface for NileInputEditor
+ */
+export interface NileInputEditorOptions {
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    autoFocus?: boolean;
+    selectOnFocus?: boolean;
+    type?: 'text' | 'email' | 'tel' | 'url' | 'search' | 'number' | 'password' | 'date' | 'time' | 'datetime-local';
+    size?: 'small' | 'medium' | 'large';
+    filled?: boolean;
+    pill?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    pattern?: string;
+    min?: number | string;
+    max?: number | string;
+    step?: number | 'any';
+    warning?: boolean;
+    error?: boolean;
+    success?: boolean;
+    errorMessage?: string;
+    helpText?: string;
+    enterkeyhint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+    spellcheck?: boolean;
+    autocomplete?: string;
+    inputmode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+    validateOnSave?: boolean;
+}
+/**
+ * Custom editor that uses NileInput component
+ * @template T The value type (string, number, or both)
+ */
+export declare class NileInputEditor<T = string> implements CellEditor<T> {
+    private readonly options?;
+    private input?;
+    private eventListeners;
+    constructor(options?: NileInputEditorOptions | undefined);
+    edit(context: CellEditorContext<T>): void;
+    /**
+     * Apply all configuration options to the NileInput element
+     */
+    private applyOptions;
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    private setupEventListeners;
+    /**
+     * Save value with optional validation
+     */
+    private saveValue;
+    /**
+     * Parse value based on input type
+     */
+    private parseValue;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): T;
+}

package/lib/editors/nile-select-editor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Custom editor using NileSelect from @aquera/nile-elements
+ * This demonstrates how to create dropdown/select editors for ngx-smart-table
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+import { Observable } from 'rxjs';
+/**
+ * Select option configuration
+ */
+export interface SelectOption {
+    /** The option's value */
+    value: string;
+    /** Display label for the option */
+    label: string;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+    /** Optional prefix icon or content */
+    prefix?: string;
+}
+/**
+ * Options interface for NileSelectEditor
+ */
+export interface NileSelectEditorOptions {
+    /** Array of options - supports static arrays, Observable, or BehaviorSubject for reactive updates */
+    options: SelectOption[] | string[] | Observable<SelectOption[] | string[]>;
+    /** Placeholder text when no selection is made */
+    placeholder?: string;
+    /** Size of the select control */
+    size?: 'small' | 'medium' | 'large';
+    /** Enable multiple selection mode */
+    multiple?: boolean;
+    /** Adds clear button when value is not empty */
+    clearable?: boolean;
+    /** Disable the select control */
+    disabled?: boolean;
+    /** Make the select required */
+    required?: boolean;
+    /** Enable search functionality */
+    searchEnabled?: boolean;
+    /** Warning state styling */
+    warning?: boolean;
+    /** Error state styling */
+    error?: boolean;
+    /** Success state styling */
+    success?: boolean;
+    /** Error message to display */
+    errorMessage?: string;
+    /** Help text to display */
+    helpText?: string;
+    /** Maximum number of selected options to show in multiple mode (0 = no limit) */
+    maxOptionsVisible?: number;
+    /** Draws a filled select style */
+    filled?: boolean;
+    /** Pill-style with rounded edges */
+    pill?: boolean;
+    /** Use fixed positioning to prevent clipping */
+    hoist?: boolean;
+    /** Placement of the dropdown menu */
+    placement?: 'top' | 'bottom';
+    /** Enable virtual scrolling for better performance with many options */
+    enableVirtualScroll?: boolean;
+    /** Disable local search (use for server-side search) */
+    disableLocalSearch?: boolean;
+    /** Validate before saving (default: true) */
+    validateOnSave?: boolean;
+    /** Append dropdown to document body instead of parent */
+    portal?: boolean;
+}
+/**
+ * Custom editor that uses NileSelect component
+ * @template T The value type (string for single selection, string[] for multiple)
+ */
+export declare class NileSelectEditor<T = string> implements CellEditor<T> {
+    private readonly options;
+    private select?;
+    private eventListeners;
+    private optionsSubscription?;
+    private currentOptions;
+    constructor(options: NileSelectEditorOptions);
+    edit(context: CellEditorContext<T>): void;
+    /**
+     * Set the initial value for the select
+     */
+    private setInitialValue;
+    /**
+     * Apply all configuration options to the NileSelect element
+     */
+    private applyOptions;
+    /**
+     * Update options dynamically while editor is active
+     */
+    private updateOptions;
+    /**
+     * Create NileOption elements and append them to the select
+     * @param options - The options to render
+     */
+    private createAndAppendOptions;
+    /**
+     * Set up all event listeners with proper cleanup tracking
+     */
+    private setupEventListeners;
+    /**
+     * Parse value based on selection mode
+     */
+    private parseValue;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): T;
+}

package/lib/factories/column-config.factory.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Column configuration factory
+ * Simplifies creation of common column types with sensible defaults
+ */
+import { ColumnConfig } from '../models/column-config.interface';
+/**
+ * Column configuration factory - Factory Pattern
+ * Provides convenient methods to create pre-configured column types
+ */
+export declare class ColumnConfigFactory {
+    /**
+     * Create a text column
+     */
+    static text(key: string, options?: Partial<ColumnConfig<string>>): ColumnConfig<string>;
+    /**
+     * Create a number column
+     */
+    static number(key: string, options?: Partial<ColumnConfig<number>>): ColumnConfig<number>;
+    /**
+     * Create a currency column
+     */
+    static currency(key: string, options?: Partial<ColumnConfig<number>> & {
+        currency?: string;
+        locale?: string;
+    }): ColumnConfig<number>;
+    /**
+     * Create a date column
+     */
+    static date(key: string, options?: Partial<ColumnConfig<Date>> & {
+        dateStyle?: 'full' | 'long' | 'medium' | 'short';
+        locale?: string;
+    }): ColumnConfig<Date>;
+    /**
+     * Create a boolean column
+     */
+    static boolean(key: string, options?: Partial<ColumnConfig<boolean>> & {
+        trueValue?: string;
+        falseValue?: string;
+    }): ColumnConfig<boolean>;
+    /**
+     * Create a select/dropdown column
+     */
+    static select<T = string>(key: string, selectOptions: Array<{
+        value: T;
+        label: string;
+    }>, options?: Partial<ColumnConfig<T>>): ColumnConfig<T>;
+    /**
+     * Create an email column
+     */
+    static email(key: string, options?: Partial<ColumnConfig<string>>): ColumnConfig<string>;
+    /**
+     * Create a readonly column
+     */
+    static readonly<T = any>(key: string, options?: Partial<ColumnConfig<T>>): ColumnConfig<T>;
+    /**
+     * Create a custom column with full control
+     */
+    static custom<T = any>(config: Partial<ColumnConfig<T>> & {
+        key: string;
+    }): ColumnConfig<T>;
+    /**
+     * Create multiple columns at once from a simple configuration
+     */
+    static fromKeys<T extends Record<string, any>>(keys: Array<keyof T | {
+        key: keyof T;
+        type?: 'text' | 'number' | 'date' | 'boolean';
+        options?: any;
+    }>): ColumnConfig<any>[];
+}
+/**
+ * Convenience exports for common column types
+ */
+export declare const Columns: typeof ColumnConfigFactory;

package/lib/models/autosave-config.interface.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Autosave strategy types
+ */
+export declare type AutosaveStrategy = 'lazy' | 'eager';
+/**
+ * Autosave configuration interface
+ */
+export interface AutosaveConfig {
+    /**
+     * Whether autosave is enabled
+     */
+    enabled: boolean;
+    /**
+     * Autosave strategy:
+     * - 'lazy': Saves after user stops making changes (2s debounce)
+     * - 'eager': Saves on every change (100ms debounce)
+     */
+    strategy: AutosaveStrategy;
+}
+/**
+ * Default autosave configuration
+ */
+export declare const DEFAULT_AUTOSAVE_CONFIG: AutosaveConfig;