@aquera/ngx-smart-table 0.0.2-alpha

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

@@ -0,0 +1,71 @@
+/**
+ * Workbook state interfaces for state management
+ */
+import { TableStateSnapshot } from './table-types';
+/**
+ * Configuration options for initializing WorkbookState
+ */
+export interface WorkbookStateConfig {
+    /**
+     * Workbook ID
+     */
+    id: string;
+    /**
+     * Initial workbook name
+     */
+    name: string;
+    /**
+     * Initial active sheet index
+     */
+    initialActiveSheetIndex?: number;
+}
+/**
+ * Workbook metadata tracking
+ */
+export interface WorkbookMetadata {
+    /**
+     * When the workbook was created
+     */
+    createdAt: Date;
+    /**
+     * When the workbook was last modified
+     */
+    lastModified: Date;
+    /**
+     * When the workbook was last accessed
+     */
+    lastAccessed: Date;
+    /**
+     * Number of sheets in workbook
+     */
+    sheetCount: number;
+}
+/**
+ * Complete snapshot of workbook state
+ */
+export interface WorkbookStateSnapshot {
+    /**
+     * Workbook ID
+     */
+    id: string;
+    /**
+     * Workbook name
+     */
+    name: string;
+    /**
+     * Active sheet index
+     */
+    activeSheetIndex: number;
+    /**
+     * Fullscreen state
+     */
+    isFullscreen: boolean;
+    /**
+     * Map of sheet ID to TableStateSnapshot
+     */
+    sheetTableStates: Map<string, TableStateSnapshot>;
+    /**
+     * Workbook metadata
+     */
+    metadata: WorkbookMetadata;
+}

package/lib/renderer/models/z-index.enum.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Z-Index values for table layering
+ *
+ * Range Groups:
+ * - Table layers: -1 to 10
+ * - Dropdowns/Popups: 100-1001
+ * - Overlays/Modals: 2000-9999
+ */
+export declare enum TableZIndex {
+    /** Hidden scroll spacer element (below everything) */
+    SCROLL_SPACER = -1,
+    /** Base table body layer */
+    BODY = 1,
+    /** Sticky columns in body (left/right) */
+    STICKY_COLUMN = 2,
+    /** Virtual scroll sticky header */
+    VIRTUAL_SCROLL_HEADER = 3,
+    /** Column resize handles */
+    RESIZE_HANDLE = 4,
+    /** Sticky body cells (inline styled) */
+    STICKY_BODY_CELL = 5,
+    /** Sticky header cells (inline styled) */
+    STICKY_HEADER_CELL = 7,
+    /** Standard table sticky header container */
+    STICKY_HEADER_CONTAINER = 8,
+    /** Focused cell (keyboard navigation - highest in table) */
+    FOCUSED_CELL = 10,
+    /** Table actions dropdown menu */
+    DROPDOWN = 100,
+    /** Add column button and similar UI elements */
+    FLOATING_BUTTON = 1000,
+    /** Column filter popup */
+    POPUP = 1001,
+    /** Modal backdrop/overlay */
+    MODAL_OVERLAY = 2000,
+    /** Table actions dropdown backdrop */
+    TABLE_ACTIONS_BACKDROP = 9996,
+    /** Table actions dropdown menu */
+    TABLE_ACTIONS_DROPDOWN = 9997,
+    /** Row actions dropdown backdrop */
+    ROW_ACTIONS_BACKDROP = 9998,
+    /** Row actions dropdown menu */
+    ROW_ACTIONS_DROPDOWN = 9999
+}

package/lib/schemas/table-config.schema.d.ts

@@ -0,0 +1,455 @@
+/**
+ * TableConfig JSON Schema
+ * Exported as TypeScript constant for use in validation service
+ */
+export declare const tableConfigSchema: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "https://ngx-smart-table.schema/table-config.json";
+    readonly title: "Smart Table Configuration Schema";
+    readonly description: "JSON Schema for Smart Table TableConfig";
+    readonly type: "object";
+    readonly required: readonly ["columns"];
+    readonly properties: {
+        readonly columns: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly description: "Array of column definitions";
+            readonly items: {
+                readonly $ref: "#/definitions/ColumnConfig";
+            };
+        };
+        readonly pagination: {
+            readonly $ref: "#/definitions/PaginationConfig";
+        };
+        readonly sorting: {
+            readonly $ref: "#/definitions/SortingConfig";
+        };
+        readonly filtering: {
+            readonly $ref: "#/definitions/FilteringConfig";
+        };
+        readonly selection: {
+            readonly $ref: "#/definitions/SelectionConfig";
+        };
+        readonly display: {
+            readonly $ref: "#/definitions/DisplayConfig";
+        };
+        readonly initialState: {
+            readonly $ref: "#/definitions/InitialStateConfig";
+        };
+        readonly features: {
+            readonly $ref: "#/definitions/FeaturesConfig";
+        };
+    };
+    readonly definitions: {
+        readonly ColumnConfig: {
+            readonly type: "object";
+            readonly required: readonly ["key", "header", "dataType"];
+            readonly properties: {
+                readonly key: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-zA-Z_$][a-zA-Z0-9_$]*$";
+                    readonly description: "Unique identifier for the column (must be a valid identifier)";
+                };
+                readonly header: {
+                    readonly type: "string";
+                    readonly description: "Display header text for the column";
+                };
+                readonly dataType: {
+                    readonly type: "string";
+                    readonly enum: readonly ["string", "number", "boolean", "date", "custom"];
+                    readonly description: "Data type of the column values";
+                };
+                readonly editable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether cells in this column are editable";
+                };
+                readonly editMode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["click", "manual", "none"];
+                    readonly description: "Edit mode trigger";
+                };
+                readonly sortable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column is sortable";
+                };
+                readonly filterable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column is filterable";
+                };
+                readonly hideable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column's visibility can be toggled by users";
+                };
+                readonly movable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column can be moved left/right by users";
+                };
+                readonly pinnable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column can be pinned/unpinned by users";
+                };
+                readonly enableMenu: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to show the column menu dropdown for this column";
+                };
+                readonly resizable: {
+                    readonly type: "boolean";
+                    readonly description: "Whether this column is resizable";
+                };
+                readonly width: {
+                    readonly oneOf: readonly [{
+                        readonly type: "number";
+                        readonly minimum: 1;
+                    }, {
+                        readonly type: "string";
+                        readonly enum: readonly ["auto"];
+                    }];
+                    readonly description: "Column width (px, %, or 'auto')";
+                };
+                readonly minWidth: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly description: "Minimum column width (px)";
+                };
+                readonly maxWidth: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly description: "Maximum column width (px)";
+                };
+                readonly sticky: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly enum: readonly ["left", "right"];
+                    }, {
+                        readonly type: "boolean";
+                        readonly const: false;
+                    }];
+                    readonly description: "Whether this column is sticky (left or right)";
+                };
+                readonly showStickyShadow: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to show shadow indicator on sticky columns";
+                };
+                readonly alignment: {
+                    readonly type: "string";
+                    readonly enum: readonly ["left", "center", "right"];
+                    readonly description: "Cell content horizontal alignment";
+                };
+                readonly verticalAlignment: {
+                    readonly type: "string";
+                    readonly enum: readonly ["top", "middle", "bottom"];
+                    readonly description: "Cell content vertical alignment";
+                };
+                readonly truncate: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to truncate overflowing text";
+                };
+                readonly tooltip: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "null";
+                    }];
+                    readonly description: "Tooltip configuration (string or function - functions not serializable)";
+                };
+                readonly className: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                    }, {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    }, {
+                        readonly type: "null";
+                    }];
+                    readonly description: "CSS class name(s) for cells in this column";
+                };
+                readonly style: {
+                    readonly type: "object";
+                    readonly description: "Inline styles for cells in this column (object or function - functions not serializable)";
+                };
+                readonly visible: {
+                    readonly type: "boolean";
+                    readonly description: "Whether column is visible";
+                };
+                readonly pinned: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly enum: readonly ["left", "right"];
+                    }, {
+                        readonly type: "boolean";
+                        readonly const: false;
+                    }];
+                    readonly description: "Whether column is pinned (left, right, or none)";
+                };
+                readonly sortPriority: {
+                    readonly type: "number";
+                    readonly description: "Sort order priority (for multi-column sort)";
+                };
+                readonly metadata: {
+                    readonly type: "object";
+                    readonly description: "Custom metadata for column";
+                };
+                readonly showLoadingIndicator: {
+                    readonly type: "boolean";
+                    readonly description: "Whether cells should show loading indicator during async operations";
+                };
+                readonly sortDirection: {
+                    readonly type: "string";
+                    readonly enum: readonly ["none", "asc", "desc"];
+                    readonly description: "Current sort direction (runtime state)";
+                };
+                readonly sortEnabled: {
+                    readonly type: "boolean";
+                    readonly description: "Whether sorting is currently active/enabled (runtime state)";
+                };
+                readonly filterConfig: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly operator: {
+                            readonly type: "string";
+                            readonly enum: readonly ["equals", "contains", "startsWith", "endsWith", "gt", "lt", "gte", "lte", "between", "in"];
+                            readonly description: "Filter operator";
+                        };
+                        readonly value: {
+                            readonly description: "Current filter value (any type)";
+                        };
+                        readonly enabled: {
+                            readonly type: "boolean";
+                            readonly description: "Whether filtering is currently active/enabled";
+                        };
+                        readonly options: {
+                            readonly $ref: "#/definitions/FilterOptions";
+                            readonly description: "Custom filter options for dropdown-based filtering";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                    readonly description: "Filter configuration for this column";
+                };
+                readonly stickyOffset: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Calculated offset for sticky positioning (runtime state, auto-calculated)";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly PaginationConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly description: "Enable pagination";
+                };
+                readonly pageSize: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                    readonly description: "Number of items per page";
+                };
+                readonly pageSizeOptions: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly minimum: 1;
+                    };
+                    readonly minItems: 1;
+                    readonly description: "Available page size options for user selection";
+                };
+                readonly showPagination: {
+                    readonly type: "boolean";
+                    readonly description: "Show pagination UI controls";
+                };
+                readonly showTopControls: {
+                    readonly type: "boolean";
+                    readonly description: "Show pagination controls at the top of the table";
+                };
+                readonly showBottomControls: {
+                    readonly type: "boolean";
+                    readonly description: "Show pagination controls at the bottom of the table";
+                };
+                readonly totalItems: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Total number of items available (for server-side pagination)";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly SortingConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly description: "Enable sorting";
+                };
+                readonly multiColumn: {
+                    readonly type: "boolean";
+                    readonly description: "Allow sorting by multiple columns simultaneously";
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["local", "server"];
+                    readonly description: "Sorting mode - local (client-side) or server (API-based)";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly FilteringConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly description: "Enable filtering";
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["local", "server"];
+                    readonly description: "Filtering mode - local (client-side) or server (API-based)";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly SelectionConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly enabled: {
+                    readonly type: "boolean";
+                    readonly description: "Enable row selection";
+                };
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["single", "multiple"];
+                    readonly description: "Selection mode - single row or multiple rows";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly DisplayConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly stickyHeader: {
+                    readonly type: "boolean";
+                    readonly description: "Make table header sticky on scroll";
+                };
+                readonly maxHeight: {
+                    readonly type: "number";
+                    readonly description: "Maximum height of the table in pixels";
+                };
+                readonly virtualScroll: {
+                    readonly $ref: "#/definitions/VirtualScrollConfig";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly InitialStateConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly page: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Initial page number (0-indexed)";
+                };
+                readonly sortBy: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["key"];
+                        readonly properties: {
+                            readonly key: {
+                                readonly type: "string";
+                                readonly description: "Column key to sort by";
+                            };
+                            readonly direction: {
+                                readonly type: "string";
+                                readonly enum: readonly ["none", "asc", "desc"];
+                                readonly description: "Sort direction";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "Initial sort configuration";
+                };
+                readonly filters: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["key", "operator"];
+                        readonly properties: {
+                            readonly key: {
+                                readonly type: "string";
+                                readonly description: "Column key to filter";
+                            };
+                            readonly operator: {
+                                readonly type: "string";
+                                readonly enum: readonly ["equals", "contains", "startsWith", "endsWith", "gt", "lt", "gte", "lte", "between", "in"];
+                                readonly description: "Filter operator";
+                            };
+                            readonly value: {
+                                readonly description: "Filter value (any type)";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly description: "Initial filter configuration";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly FeaturesConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly columnManagement: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allowAdd: {
+                            readonly type: "boolean";
+                            readonly description: "Allow users to add new columns dynamically";
+                            readonly default: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                    readonly description: "Column management features";
+                };
+                readonly keyboardNavigation: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly enabled: {
+                            readonly type: "boolean";
+                            readonly description: "Enable Excel-like keyboard navigation with arrow keys";
+                            readonly default: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                    readonly description: "Keyboard navigation features";
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Features configuration for table capabilities";
+        };
+        readonly FilterOptions: {
+            readonly type: "object";
+            readonly required: readonly ["data", "handler"];
+            readonly properties: {
+                readonly data: {
+                    readonly type: "array";
+                    readonly description: "Array of data items to display in the dropdown";
+                    readonly items: {
+                        readonly description: "Data item of any type";
+                    };
+                };
+                readonly handler: {
+                    readonly description: "Handler function to transform data items into {label, value} pairs. Type: (item: any) => {label: string, value: any}";
+                };
+                readonly multiselect: {
+                    readonly type: "boolean";
+                    readonly description: "Whether to allow multiple selections (default: false)";
+                    readonly default: false;
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Filter options configuration for custom dropdown filters";
+        };
+    };
+    readonly additionalProperties: false;
+};

package/lib/services/autosave.service.d.ts

@@ -0,0 +1,73 @@
+import { WorkbookConfig } from '../models/workbook-config.interface';
+import { WorkbookStateSnapshot } from '../renderer/models/workbook-state.interface';
+import * as i0 from "@angular/core";
+/**
+ * Autosave data structure
+ */
+export interface AutosaveData {
+    workbookConfig: WorkbookConfig;
+    workbookState: WorkbookStateSnapshot;
+    sheetsData: Map<string, any[]>;
+    timestamp: Date;
+}
+/**
+ * AutosaveService - In-memory autosave storage
+ *
+ * Stores autosave data in memory for workbooks.
+ * Data is automatically cleared when the component is destroyed or tab is closed.
+ */
+export declare class AutosaveService {
+    /**
+     * In-memory storage for autosaved data
+     */
+    private autosaveStore;
+    /**
+     * Track dirty state per workbook
+     */
+    private dirtyState;
+    /**
+     * Track last save timestamp per workbook
+     */
+    private lastSaveTime;
+    /**
+     * Save workbook data to memory
+     * @param workbookId Unique workbook identifier
+     * @param data Autosave data to store
+     */
+    save(workbookId: string, data: AutosaveData): void;
+    /**
+     * Retrieve autosaved data for a workbook
+     * @param workbookId Unique workbook identifier
+     * @returns Autosaved data or null if not found
+     */
+    get(workbookId: string): AutosaveData | null;
+    /**
+     * Check if workbook has unsaved changes
+     * @param workbookId Unique workbook identifier
+     * @returns True if workbook has unsaved changes
+     */
+    isDirty(workbookId: string): boolean;
+    /**
+     * Mark workbook as dirty or clean
+     * @param workbookId Unique workbook identifier
+     * @param dirty Dirty state
+     */
+    setDirty(workbookId: string, dirty: boolean): void;
+    /**
+     * Get last save timestamp for a workbook
+     * @param workbookId Unique workbook identifier
+     * @returns Last save timestamp or null
+     */
+    getLastSaveTime(workbookId: string): Date | null;
+    /**
+     * Clear autosave data for a specific workbook
+     * @param workbookId Unique workbook identifier
+     */
+    clear(workbookId: string): void;
+    /**
+     * Clear all autosave data
+     */
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutosaveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AutosaveService>;
+}

package/lib/services/custom-validation-rules.util.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom validation rules utility
+ * Implements business logic validations that can't be expressed in JSON Schema
+ */
+import { TableConfig } from '../models/table-config.interface';
+import { SchemaValidationError } from '../models/schema-validation.interface';
+/**
+ * Validate custom business rules
+ * @param config Table configuration
+ * @returns Array of validation errors
+ */
+export declare function validateCustomRules(config: TableConfig): SchemaValidationError[];