@aquera/ngx-smart-table 0.0.2-alpha

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

@@ -0,0 +1,245 @@
+/**
+ * Table configuration interface - centralizes all table settings
+ * Provides a single source of truth for pagination, sorting, filtering, and display options
+ */
+import { ColumnConfig } from './column-config.interface';
+import { SortDirection, FilterOperator } from '../renderer/models/table-types';
+import { RowManagementConfig } from './row-action.interface';
+import { Observable } from 'rxjs';
+/**
+ * Comprehensive table configuration interface
+ */
+export interface TableConfig {
+    /**
+     * Column definitions (required)
+     */
+    columns: ColumnConfig[];
+    /**
+     * Pagination configuration
+     */
+    pagination?: {
+        /**
+         * Enable pagination
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Number of items per page
+         * @default 25
+         */
+        pageSize?: number;
+        /**
+         * Available page size options for user selection
+         * @default [10, 25, 50, 100]
+         */
+        pageSizeOptions?: number[];
+        /**
+         * Show pagination controls at the top of the table
+         * @default false
+         */
+        showTopControls?: boolean;
+        /**
+         * Show pagination controls at the bottom of the table
+         * @default true
+         */
+        showBottomControls?: boolean;
+        /**
+         * Total number of items available (for server-side pagination)
+         * When set, the pagination controls will display the correct total pages
+         * @default undefined (will be calculated from data length)
+         */
+        totalItems?: number;
+        /**
+         * Variant for nile-pagination component styling
+         * @default 'fluid'
+         */
+        variant?: 'fluid' | 'compact';
+    };
+    /**
+     * Sorting configuration
+     */
+    sorting?: {
+        /**
+         * Enable sorting
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Allow sorting by multiple columns simultaneously
+         * @default false
+         */
+        multiColumn?: boolean;
+        /**
+         * Sorting mode - local (client-side) or server (API-based)
+         * @default 'server'
+         */
+        mode?: 'local' | 'server';
+    };
+    /**
+     * Filtering configuration
+     */
+    filtering?: {
+        /**
+         * Enable filtering
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Filtering mode - local (client-side) or server (API-based)
+         * @default 'server'
+         */
+        mode?: 'local' | 'server';
+    };
+    /**
+     * Selection configuration (future feature)
+     */
+    selection?: {
+        /**
+         * Enable row selection
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * Selection mode - single row or multiple rows
+         * @default 'multiple'
+         */
+        mode?: 'single' | 'multiple';
+    };
+    /**
+     * Display configuration
+     */
+    display?: {
+        /**
+         * Make table header sticky on scroll
+         * @default true
+         */
+        stickyHeader?: boolean;
+        /**
+         * Highlight row on hover
+         * @default true
+         */
+        hover?: boolean;
+        /**
+         * Max height of the table in pixels
+         * @default 300
+         */
+        maxHeight?: number;
+        /**
+         * Virtual scroll configuration for large datasets
+         * Enables efficient rendering by only showing visible rows
+         */
+        virtualScroll?: {
+            /**
+             * Enable virtual scrolling
+             * @default false
+             */
+            enabled?: boolean;
+            /**
+             * Row height in pixels (must be consistent for all rows)
+             * @default 48
+             */
+            itemSize?: number;
+            /**
+             * Number of buffer rows to render above/below viewport
+             * Higher values provide smoother scrolling but use more memory
+             * @default 5
+             */
+            bufferSize?: number;
+            /**
+             * Viewport height in pixels
+             * @default 600
+             */
+            viewportHeight?: number;
+        };
+    };
+    /**
+     * Initial state configuration
+     */
+    initialState?: {
+        /**
+         * Initial page number (0-indexed)
+         * @default 0
+         */
+        page?: number;
+        /**
+         * Initial sort configuration
+         */
+        sortBy?: Array<{
+            key: string;
+            direction: SortDirection;
+        }>;
+        /**
+         * Initial filter configuration
+         */
+        filters?: Array<{
+            key: string;
+            operator: FilterOperator;
+            value: any;
+        }>;
+    };
+    /**
+     * Features configuration
+     */
+    features?: {
+        /**
+         * Column management features
+         */
+        columnManagement?: {
+            /**
+             * Allow users to add new columns dynamically
+             * @default false
+             */
+            allowAdd?: boolean;
+        };
+        /**
+         * Row management features
+         * Provides a settings column with configurable actions for each row
+         */
+        rowManagement?: RowManagementConfig;
+        /**
+         * Keyboard navigation features
+         * Enables Excel-like keyboard navigation with arrow keys
+         */
+        keyboardNavigation?: {
+            /**
+             * Enable keyboard navigation
+             * @default false
+             */
+            enabled?: boolean;
+        };
+    };
+    /**
+     * Validation configuration - accumulates cell validation results
+     */
+    validation?: {
+        /**
+         * Validation trigger mode
+         * - 'lazy': Validate on cell save/blur
+         * - 'eager': Validate on every cell change
+         * @default 'lazy'
+         */
+        mode?: 'lazy' | 'eager';
+    };
+    /**
+     * Table skeleton configuration
+     * Shows a skeleton loader while data is loading
+     * @default undefined (disabled)
+     */
+    tableSkeleton?: {
+        enabled: Observable<boolean>;
+        rows: number;
+        columns: number;
+    };
+    /**
+     * Show row number in the table
+     */
+    showRowNumber?: boolean;
+}
+/**
+ * Default table configuration with sensible defaults
+ */
+export declare const DEFAULT_TABLE_CONFIG: Partial<TableConfig>;
+/**
+ * Helper function to merge user config with defaults
+ */
+export declare function mergeTableConfig(userConfig: TableConfig): TableConfig;

package/lib/models/table-validator.interface.d.ts

@@ -0,0 +1,40 @@
+import { TableConfig } from './table-config.interface';
+import { RowValidationResult } from './row-validator.interface';
+/**
+ * Table-level validation result
+ */
+export interface TableValidationResult {
+    /** Whether the entire table is valid */
+    valid: boolean;
+    /** Row-specific validation results (rowIndex -> result) */
+    rowResults?: Map<number, RowValidationResult>;
+    /** Global table-level errors */
+    globalErrors?: string[];
+    /** Global warnings */
+    globalWarnings?: string[];
+    /** Total number of invalid rows */
+    invalidRowCount?: number;
+    /** Total number of valid rows */
+    validRowCount?: number;
+}
+/**
+ * Table validator interface for validating entire table
+ */
+export interface TableValidator {
+    /**
+     * Validates the entire table
+     * @param rows Array of row data
+     * @param config Table configuration
+     * @param rowValidationResults Optional pre-computed row validation results
+     * @returns Table validation result
+     */
+    validateTable(rows: any[], config: TableConfig, rowValidationResults?: Map<number, RowValidationResult>): TableValidationResult;
+    /**
+     * Optional error message template
+     */
+    errorMessage?: string;
+    /**
+     * Optional validation ID
+     */
+    validatorId?: string;
+}

package/lib/models/workbook-action.interface.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Workbook action interfaces for configurable workbook-level features
+ */
+import { WorkbookSheetConfig } from './workbook-config.interface';
+/**
+ * Defines a workbook-level action (export all, print, etc.)
+ */
+export interface WorkbookAction {
+    /**
+     * Unique identifier for the action
+     */
+    id: string;
+    /**
+     * Display label for the action
+     */
+    label: string;
+    /**
+     * Optional icon to display (nile-icon name)
+     */
+    icon?: string;
+    /**
+     * Function to determine if action should be disabled
+     */
+    disabled?: boolean | (() => boolean);
+    /**
+     * Function to determine if action should be hidden
+     */
+    hidden?: boolean | (() => boolean);
+    /**
+     * Callback function to execute when action is clicked
+     * @param workbookId The ID of the workbook
+     */
+    action?: (workbookId: string) => void;
+}
+/**
+ * Defines a sheet tab action (rename, duplicate, delete)
+ */
+export interface SheetTabAction {
+    /**
+     * Unique identifier for the action
+     */
+    id: string;
+    /**
+     * Display label for the action
+     */
+    label: string;
+    /**
+     * Optional icon to display (nile-icon name)
+     */
+    icon?: string;
+    /**
+     * Function to determine if action should be disabled
+     */
+    disabled?: boolean | ((sheet: WorkbookSheetConfig) => boolean);
+    /**
+     * Function to determine if action should be hidden
+     */
+    hidden?: boolean | ((sheet: WorkbookSheetConfig) => boolean);
+    /**
+     * Callback function to execute when action is clicked
+     * @param sheetId The ID of the sheet
+     */
+    action?: (sheetId: string) => void;
+}
+/**
+ * Event emitted when a workbook action is clicked
+ */
+export interface WorkbookActionEvent {
+    /**
+     * The action that was clicked
+     */
+    action: WorkbookAction;
+    /**
+     * The workbook ID
+     */
+    workbookId: string;
+}
+/**
+ * Event emitted when a sheet tab action is clicked
+ */
+export interface SheetTabActionEvent {
+    /**
+     * The action that was clicked
+     */
+    action: SheetTabAction;
+    /**
+     * The sheet ID
+     */
+    sheetId: string;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Workbook configuration interface - manages multiple sheets
+ */
+import { TableConfig } from './table-config.interface';
+import { WorkbookAction, SheetTabAction } from './workbook-action.interface';
+import { AutosaveConfig } from './autosave-config.interface';
+/**
+ * Sheet configuration for workbook (simpler than standalone SheetConfig)
+ */
+export interface WorkbookSheetConfig {
+    /**
+     * Unique identifier for the sheet
+     */
+    id: string;
+    /**
+     * Display name of the sheet
+     */
+    name: string;
+    /**
+     * Table configuration for this sheet
+     */
+    tableConfig: TableConfig;
+    /**
+     * Optional per-sheet tab actions (overrides workbook defaults)
+     */
+    tabActions?: SheetTabAction[];
+}
+/**
+ * Comprehensive workbook configuration interface
+ */
+export interface WorkbookConfig {
+    /**
+     * Unique identifier for the workbook
+     */
+    id: string;
+    /**
+     * Display name of the workbook
+     */
+    name: string;
+    /**
+     * Array of sheets in the workbook
+     */
+    sheets: WorkbookSheetConfig[];
+    /**
+     * Initial active sheet index (0-based)
+     * @default 0
+     */
+    initialActiveSheetIndex?: number;
+    /**
+     * Workbook-level actions (dropdown in toolbar)
+     */
+    workbookActions?: WorkbookAction[];
+    /**
+     * Default sheet tab actions (applied to all sheets unless overridden)
+     */
+    defaultSheetTabActions?: SheetTabAction[];
+    /**
+     * Display configuration
+     */
+    display?: {
+        /**
+         * Allow adding new sheets
+         * @default true
+         */
+        allowAddSheet?: boolean;
+        /**
+         * Allow deleting sheets
+         * @default true
+         */
+        allowDeleteSheet?: boolean;
+        /**
+         * Allow fullscreen mode
+         * @default true
+         */
+        allowFullscreen?: boolean;
+        /**
+         * Maximum number of sheets allowed
+         * @default undefined (unlimited)
+         */
+        maxSheets?: number;
+        /**
+         * Minimum number of sheets required
+         * @default 1
+         */
+        minSheets?: number;
+    };
+    /**
+     * Defaults for new sheets created via "Add Sheet" button
+     */
+    newSheetDefaults?: {
+        /**
+         * Prefix for new sheet names
+         * @default 'Sheet'
+         */
+        namePrefix?: string;
+        /**
+         * Default table configuration for new sheets
+         */
+        tableConfig?: Partial<TableConfig>;
+    };
+    /**
+     * Autosave configuration
+     * Enables automatic saving of workbook config, state, and data to memory
+     * @default { enabled: true, strategy: 'lazy' }
+     */
+    autosave?: AutosaveConfig;
+}

package/lib/renderer/components/st-add-column-button/st-add-column-button.component.d.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class StAddColumnButtonComponent {
+    enabled: boolean;
+    addColumnClicked: EventEmitter<void>;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StAddColumnButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StAddColumnButtonComponent, "st-add-column-button", never, { "enabled": "enabled"; }, { "addColumnClicked": "addColumnClicked"; }, never, never>;
+}

package/lib/renderer/components/st-cell/st-cell.component.d.ts

@@ -0,0 +1,69 @@
+import { EventEmitter, OnInit, OnDestroy, ElementRef, AfterViewInit, TemplateRef } from '@angular/core';
+import { Cell } from '../../models/cell.class';
+import { CellEditEvent, CellSaveEvent, CellChangeEvent, CellCancelEvent, EditMode, NavigationDirection } from '../../../models/cell-types';
+import { TableState } from '../../models/table-state.class';
+import { TableConfig } from '../../../models/table-config.interface';
+import * as i0 from "@angular/core";
+export declare class StCellComponent implements OnInit, OnDestroy, AfterViewInit {
+    cell: Cell<any>;
+    editMode: EditMode;
+    tableState?: TableState;
+    tableConfig?: TableConfig;
+    columnIndex?: number;
+    cellChange: EventEmitter<CellChangeEvent<any>>;
+    cellEdit: EventEmitter<CellEditEvent<any>>;
+    cellSave: EventEmitter<CellSaveEvent<any>>;
+    cellCancel: EventEmitter<CellCancelEvent<any>>;
+    cellSaveAndNavigate: EventEmitter<{
+        event: KeyboardEvent;
+        direction: NavigationDirection;
+    }>;
+    editorContainer?: ElementRef;
+    private editorCleanup?;
+    private editingPositionSubscription?;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    get isEditable(): boolean;
+    get validationError(): string | undefined;
+    get hasCellTemplate(): boolean;
+    get cellTemplate(): TemplateRef<any> | null;
+    get templateContext(): any;
+    onCellKeyDown(event: KeyboardEvent): void;
+    /**
+     * Check if Enter key can trigger editing
+     * Using EditMode enum values
+     */
+    private canEditViaEnter;
+    /**
+     * Check if keyboard can trigger editing (for alphanumeric and double-click)
+     */
+    private canEditViaKeyboard;
+    /**
+     * Check if a key is alphanumeric (single character)
+     */
+    private isAlphanumericKey;
+    /**
+     * Start editing with a specific key as the initial value
+     */
+    private startEditWithKey;
+    onCellClick(): void;
+    onCellDoubleClick(): void;
+    private startEdit;
+    private renderEditor;
+    private saveEdit;
+    /**
+     * Update validation state in TableState
+     * Called on save (lazy mode) or on change (eager mode)
+     */
+    private updateValidationState;
+    /**
+     * Trigger eager validation (on every change)
+     */
+    private triggerEagerValidation;
+    private cancelEdit;
+    private cleanupEditor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StCellComponent, "st-cell", never, { "cell": "cell"; "editMode": "editMode"; "tableState": "tableState"; "tableConfig": "tableConfig"; "columnIndex": "columnIndex"; }, { "cellChange": "cellChange"; "cellEdit": "cellEdit"; "cellSave": "cellSave"; "cellCancel": "cellCancel"; "cellSaveAndNavigate": "cellSaveAndNavigate"; }, never, never>;
+}

package/lib/renderer/components/st-column-editor-modal/st-column-editor-modal.component.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { ColumnConfig } from '../../../models/column-config.interface';
+import { ColumnEditorComponent } from '../../../builder/components/column-editor/column-editor.component';
+import * as i0 from "@angular/core";
+export declare class StColumnEditorModalComponent implements OnInit, OnDestroy {
+    columnCreated: EventEmitter<ColumnConfig<any>>;
+    cancelled: EventEmitter<void>;
+    columnEditor: ColumnEditorComponent;
+    newColumn: ColumnConfig;
+    columnIndex: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Create a default column configuration
+     */
+    private createDefaultColumn;
+    /**
+     * Trigger save from external button
+     */
+    onSave(): void;
+    /**
+     * Handle column updates from the editor
+     */
+    onColumnUpdated(updates: Partial<ColumnConfig>): void;
+    /**
+     * Handle cancel from the editor
+     */
+    onCancel(): void;
+    /**
+     * Handle backdrop click to close modal
+     */
+    onBackdropClick(event: Event): void;
+    /**
+     * Prevent event propagation from modal content
+     */
+    onModalContentClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StColumnEditorModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StColumnEditorModalComponent, "st-column-editor-modal", never, {}, { "columnCreated": "columnCreated"; "cancelled": "cancelled"; }, never, never>;
+}