@aquera/ngx-smart-table 0.0.17-alpha → 0.0.18-alpha

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

@@ -1,455 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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[];

package/lib/services/json-schema-validator.service.d.ts

@@ -1,49 +0,0 @@
-import { ValidationLoggerService } from './validation-logger.service';
-import { SchemaValidationResult } from '../models/schema-validation.interface';
-import * as i0 from "@angular/core";
-export declare class JsonSchemaValidatorService {
-    private logger;
-    private ajv;
-    private validateFn;
-    private ajvAvailable;
-    private initialized;
-    constructor(logger: ValidationLoggerService);
-    /**
-     * Ensure ajv is initialized (lazy initialization)
-     */
-    private ensureInitialized;
-    /**
-     * Initialize ajv validator
-     */
-    private initializeAjv;
-    /**
-     * Validate JSON data against TableConfig schema
-     * @param data JSON data to validate
-     * @param includeCustomRules Whether to include custom business rule validations
-     * @param enableLogging Whether to log validation errors (default: true)
-     * @returns Validation result
-     */
-    validate(data: any, includeCustomRules?: boolean, enableLogging?: boolean): SchemaValidationResult;
-    /**
-     * Validate JSON string
-     * @param jsonString JSON string to validate
-     * @param includeCustomRules Whether to include custom business rule validations
-     * @param enableLogging Whether to log validation errors (default: true)
-     * @returns Validation result
-     */
-    validateJSONString(jsonString: string, includeCustomRules?: boolean, enableLogging?: boolean): SchemaValidationResult;
-    /**
-     * Check if ajv is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Convert JSON path to user-friendly field name
-     */
-    private pathToFieldName;
-    /**
-     * Format error message from ajv error
-     */
-    private formatErrorMessage;
-    static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaValidatorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<JsonSchemaValidatorService>;
-}

package/lib/services/row-validation.service.d.ts

@@ -1,17 +0,0 @@
-import { Cell } from '../renderer/models/cell.class';
-import { RowValidator, RowValidationResult } from '../models/row-validator.interface';
-import { TableValidator, TableValidationResult } from '../models/table-validator.interface';
-import { TableConfig } from '../models/table-config.interface';
-import * as i0 from "@angular/core";
-export declare class RowValidationService {
-    /**
-     * Validate a single row
-     */
-    validateRow(rowData: any, cells: Cell[], rowIndex: number, validator: RowValidator): RowValidationResult;
-    /**
-     * Validate entire table
-     */
-    validateTable(rows: any[], config: TableConfig, validator: TableValidator, rowValidationResults?: Map<number, RowValidationResult>): TableValidationResult;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RowValidationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RowValidationService>;
-}