@aquera/ngx-smart-table 0.0.2-alpha

package/lib/renderer/directives/st-column-resize.directive.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Column Resize Directive
+ * Handles column resizing when applied to th/td elements
+ */
+import { ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { ColumnConfig } from '../../models/column-config.interface';
+import { ColumnResizeEvent } from '../models/table-types';
+import * as i0 from "@angular/core";
+export declare class StColumnResizeDirective implements OnDestroy {
+    private el;
+    /**
+     * Column configuration
+     */
+    column: ColumnConfig<any>;
+    /**
+     * Emits when column is resized
+     */
+    columnResized: EventEmitter<ColumnResizeEvent>;
+    /**
+     * Resize state
+     */
+    private isResizing;
+    private startX;
+    private startWidth;
+    constructor(el: ElementRef<HTMLElement>);
+    /**
+     * Start resize on mousedown
+     */
+    onResizeStart(event: MouseEvent): void;
+    /**
+     * Track mouse movement during resize
+     */
+    private onResizeMove;
+    /**
+     * End resize on mouseup
+     */
+    private onResizeEnd;
+    /**
+     * Cleanup on destroy
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StColumnResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StColumnResizeDirective, "[stColumnResize]", never, { "column": "column"; }, { "columnResized": "columnResized"; }, never>;
+}

package/lib/renderer/directives/st-keyboard-navigation.directive.d.ts

@@ -0,0 +1,15 @@
+import { TableState } from '../models/table-state.class';
+import * as i0 from "@angular/core";
+/**
+ * Directive to handle keyboard navigation in table cells
+ */
+export declare class StKeyboardNavigationDirective {
+    tableState: TableState;
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Convert navigation key to direction using enums
+     */
+    private getDirection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StKeyboardNavigationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StKeyboardNavigationDirective, "[stKeyboardNavigation]", never, { "tableState": "tableState"; }, {}, never>;
+}

package/lib/renderer/models/cell-state.interface.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Cell state interface - represents unique state per cell instance
+ * This is the "Context" in the Flyweight pattern
+ */
+import { CellLifecycleState } from '../../models/cell-types';
+/**
+ * Cell state containing all unique state per cell instance
+ * This is stored individually per cell, while ColumnConfig is shared (Flyweight)
+ */
+export interface CellState<T = any> {
+    /**
+     * Current cell value
+     */
+    value: T;
+    /**
+     * Whether the cell is currently in edit mode
+     */
+    isEditing: boolean;
+    /**
+     * Whether the cell value has been modified
+     */
+    isDirty: boolean;
+    /**
+     * Previous value before current edit (for undo/cancel)
+     */
+    previousValue?: T;
+    /**
+     * Original value when cell was initialized (for reset)
+     */
+    originalValue?: T;
+    /**
+     * Validation error message if validation failed
+     */
+    error?: string;
+    /**
+     * Multiple validation errors (field-specific)
+     */
+    errors?: Record<string, string>;
+    /**
+     * Warning messages (non-blocking)
+     */
+    warnings?: string[];
+    /**
+     * Current lifecycle state of the cell
+     */
+    lifecycleState: CellLifecycleState;
+    /**
+     * Whether the cell is currently loading (async operations)
+     */
+    isLoading?: boolean;
+    /**
+     * Whether the cell is disabled
+     */
+    isDisabled?: boolean;
+    /**
+     * Whether the cell is readonly
+     */
+    isReadonly?: boolean;
+    /**
+     * Whether the cell is selected
+     */
+    isSelected?: boolean;
+    /**
+     * Whether the cell is focused
+     */
+    isFocused?: boolean;
+    /**
+     * Whether the cell is hovered
+     */
+    isHovered?: boolean;
+    /**
+     * Custom metadata for cell-specific data
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Timestamp of last modification
+     */
+    lastModified?: Date;
+    /**
+     * Timestamp of last validation
+     */
+    lastValidated?: Date;
+}
+/**
+ * Factory function to create initial cell state with defaults
+ */
+export declare function createCellState<T>(value: T, overrides?: Partial<CellState<T>>): CellState<T>;
+/**
+ * Cell state memento for save/restore operations (Memento pattern)
+ * Contains minimal state needed for undo/redo
+ */
+export interface CellStateMemento<T = any> {
+    value: T;
+    isDirty: boolean;
+    error?: string;
+    metadata?: Record<string, any>;
+    timestamp: Date;
+}
+/**
+ * Create a memento snapshot of cell state
+ */
+export declare function createMemento<T>(state: CellState<T>): CellStateMemento<T>;
+/**
+ * Restore cell state from memento
+ */
+export declare function restoreFromMemento<T>(currentState: CellState<T>, memento: CellStateMemento<T>): CellState<T>;
+/**
+ * Helper to check if cell is in valid state
+ */
+export declare function isCellValid<T>(state: CellState<T>): boolean;
+/**
+ * Helper to check if cell can be edited
+ */
+export declare function canEdit<T>(state: CellState<T>): boolean;
+/**
+ * Helper to check if cell is in display mode
+ */
+export declare function isDisplayMode<T>(state: CellState<T>): boolean;

package/lib/renderer/models/cell.class.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Cell class - represents individual cell instances
+ * Combines ColumnConfig (Flyweight) with CellState (unique per instance)
+ */
+import { ColumnConfig } from '../../models/column-config.interface';
+import { CellState } from './cell-state.interface';
+import { ValidationResult } from '../../models/cell-types';
+/**
+ * Cell class implementing the Flyweight pattern
+ * - References shared ColumnConfig (Flyweight)
+ * - Owns unique CellState (Flyweight Context)
+ */
+export declare class Cell<T = any> {
+    /**
+     * Shared column configuration (Flyweight - reference only, not owned)
+     */
+    private readonly columnConfig;
+    /**
+     * Unique cell state (owned by this instance)
+     */
+    private state;
+    /**
+     * Row data context (reference to parent row data)
+     */
+    private rowData?;
+    /**
+     * Row index in table
+     */
+    private rowIndex?;
+    /**
+     * History of state mementos for undo/redo
+     */
+    private history;
+    /**
+     * Current position in history
+     */
+    private historyIndex;
+    /**
+     * Maximum history size
+     */
+    private readonly maxHistorySize;
+    constructor(columnConfig: ColumnConfig<T>, initialValue: T, rowData?: any, rowIndex?: number);
+    /**
+     * Get current cell value
+     */
+    getValue(): T;
+    /**
+     * Set cell value
+     * @param value New value
+     * @param skipValidation Skip validation (useful for programmatic sets)
+     */
+    setValue(value: T, skipValidation?: boolean): boolean;
+    /**
+     * Render cell value as formatted string (delegates to formatter strategy)
+     */
+    render(): string;
+    /**
+     * Validate cell value (delegates to validator strategy)
+     */
+    validate(): ValidationResult;
+    /**
+     * Start edit mode
+     */
+    startEdit(): boolean;
+    /**
+     * Save edited value
+     * @param newValue The new value from editor
+     */
+    saveEdit(newValue: T): boolean;
+    /**
+     * Cancel edit and revert to previous value
+     */
+    cancelEdit(): void;
+    /**
+     * Reset cell to original value
+     */
+    reset(): void;
+    /**
+     * Check if cell can be edited
+     */
+    canEdit(): boolean;
+    /**
+     * Check if cell is valid
+     */
+    isValid(): boolean;
+    /**
+     * Check if cell is dirty (modified)
+     */
+    isDirty(): boolean;
+    /**
+     * Check if cell is in edit mode
+     */
+    isEditing(): boolean;
+    /**
+     * Set focus state on this cell
+     */
+    focus(): void;
+    /**
+     * Remove focus from this cell
+     */
+    blur(): void;
+    /**
+     * Check if this cell is focused
+     */
+    isFocused(): boolean;
+    /**
+     * Get current cell state (Memento pattern)
+     */
+    getState(): CellState<T>;
+    /**
+     * Restore cell state from snapshot (Memento pattern)
+     */
+    restoreState(state: CellState<T>): void;
+    /**
+     * Get column configuration (readonly access)
+     */
+    getColumnConfig(): Readonly<ColumnConfig<T>>;
+    /**
+     * Get row data context
+     */
+    getRowData(): any;
+    /**
+     * Get row index
+     */
+    getRowIndex(): number | undefined;
+    /**
+     * Set loading state
+     */
+    setLoading(isLoading: boolean): void;
+    /**
+     * Set disabled state
+     */
+    setDisabled(isDisabled: boolean): void;
+    /**
+     * Set readonly state
+     */
+    setReadonly(isReadonly: boolean): void;
+    /**
+     * Save current state to history
+     */
+    private saveToHistory;
+    /**
+     * Undo last change
+     */
+    undo(): boolean;
+    /**
+     * Redo last undone change
+     */
+    redo(): boolean;
+    /**
+     * Check if undo is available
+     */
+    canUndo(): boolean;
+    /**
+     * Check if redo is available
+     */
+    canRedo(): boolean;
+    /**
+     * Create cell event for hooks
+     */
+    private createEvent;
+    /**
+     * Get cell metadata
+     */
+    getMetadata(key: string): any;
+    /**
+     * Set cell metadata
+     */
+    setMetadata(key: string, value: any): void;
+    /**
+     * Clear all metadata
+     */
+    clearMetadata(): void;
+}

package/lib/renderer/models/row-validation-state.interface.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Row validation state interface
+ * Represents an INVALID row with accumulated cell errors
+ * Note: Valid rows are not stored - absence of a row state means the row is valid
+ */
+export interface RowValidationState {
+    /**
+     * Index of the row in the table
+     */
+    rowIndex: number;
+    /**
+     * Always false for stored states (only invalid rows are stored)
+     */
+    isValid: false;
+    /**
+     * Number of invalid cells in the row
+     */
+    invalidCellCount: number;
+    /**
+     * Map of column keys to validation error messages
+     */
+    cellErrors: Map<string, string>;
+    /**
+     * Timestamp of the last validation
+     */
+    lastValidated: Date;
+}

package/lib/renderer/models/sheet-state.class.d.ts

@@ -0,0 +1,67 @@
+/**
+ * SheetState - Reactive state management for sheet operations
+ * Wraps TableState and adds sheet-level state tracking
+ */
+import { BehaviorSubject, Observable } from 'rxjs';
+import { TableState } from './table-state.class';
+import { SheetStateConfig, SheetMetadata, SheetStateSnapshot } from './sheet-state.interface';
+import { ColumnConfig } from '../../models/column-config.interface';
+import { TableStateConfig } from './table-state.interface';
+/**
+ * SheetState class - Manages sheet-level state and delegates table operations
+ */
+export declare class SheetState {
+    /**
+     * Sheet identity
+     */
+    readonly id: string;
+    /**
+     * Observable sheet name
+     */
+    readonly name$: BehaviorSubject<string>;
+    /**
+     * Table state instance (delegates table operations)
+     */
+    readonly tableState: TableState;
+    /**
+     * Sheet metadata
+     */
+    private _metadata$;
+    readonly metadata$: Observable<SheetMetadata>;
+    /**
+     * Constructor
+     * @param config Sheet state configuration
+     * @param columns Reference to columns array for table state
+     * @param tableStateConfig Optional table state configuration
+     */
+    constructor(config: SheetStateConfig, columns: ColumnConfig<any>[], tableStateConfig?: TableStateConfig);
+    /**
+     * Update sheet name
+     * @param name New sheet name
+     */
+    updateName(name: string): void;
+    /**
+     * Get current sheet name
+     */
+    getName(): string;
+    /**
+     * Get complete state snapshot
+     */
+    getSnapshot(): SheetStateSnapshot;
+    /**
+     * Reset sheet state
+     */
+    reset(): void;
+    /**
+     * Update last accessed timestamp
+     */
+    updateLastAccessed(): void;
+    /**
+     * Update last modified timestamp
+     */
+    private updateLastModified;
+    /**
+     * Get current metadata
+     */
+    getMetadata(): SheetMetadata;
+}

package/lib/renderer/models/sheet-state.interface.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Sheet state interfaces for state management
+ */
+import { TableStateSnapshot } from './table-types';
+/**
+ * Configuration options for initializing SheetState
+ */
+export interface SheetStateConfig {
+    /**
+     * Sheet ID
+     */
+    id: string;
+    /**
+     * Initial sheet name
+     */
+    name: string;
+}
+/**
+ * Sheet metadata tracking
+ */
+export interface SheetMetadata {
+    /**
+     * When the sheet was created
+     */
+    createdAt: Date;
+    /**
+     * When the sheet was last modified
+     */
+    lastModified: Date;
+    /**
+     * When the sheet was last accessed
+     */
+    lastAccessed: Date;
+}
+/**
+ * Complete snapshot of sheet state
+ */
+export interface SheetStateSnapshot {
+    /**
+     * Sheet ID
+     */
+    id: string;
+    /**
+     * Sheet name
+     */
+    name: string;
+    /**
+     * Table state snapshot
+     */
+    tableStateSnapshot: TableStateSnapshot;
+    /**
+     * Sheet metadata
+     */
+    metadata: SheetMetadata;
+}