@aquera/ngx-smart-table 0.0.2-alpha

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

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

@@ -0,0 +1,17 @@
+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>;
+}

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

@@ -0,0 +1,87 @@
+import { SchemaValidationError } from '../models/schema-validation.interface';
+import * as i0 from "@angular/core";
+/**
+ * Validation log entry interface
+ */
+export interface ValidationLogEntry {
+    /**
+     * ISO timestamp when validation failed
+     */
+    timestamp: string;
+    /**
+     * Source of validation (e.g., 'import', 'renderer', 'schema-validation')
+     */
+    source: string;
+    /**
+     * Array of validation errors
+     */
+    errors: SchemaValidationError[];
+    /**
+     * Optional context information
+     */
+    context?: {
+        fileName?: string;
+        configSnippet?: string;
+        storageKey?: string;
+    };
+}
+export declare class ValidationLoggerService {
+    private logEntries;
+    private downloadTimeoutId;
+    private readonly DOWNLOAD_DELAY_MS;
+    /**
+     * Log validation errors
+     * @param errors Array of validation errors
+     * @param source Source of validation (e.g., 'import', 'renderer', 'schema-validation')
+     * @param context Optional context information
+     * @param autoDownload Whether to automatically download log file (default: true)
+     */
+    logValidationErrors(errors: SchemaValidationError[], source: string, context?: {
+        fileName?: string;
+        configSnippet?: string;
+        storageKey?: string;
+    }, autoDownload?: boolean): void;
+    /**
+     * Schedule log file download with debounce
+     * This ensures we only download once after all errors are accumulated
+     */
+    private scheduleDownload;
+    /**
+     * Download log file with timestamped filename
+     * Called automatically when validation errors occur (after debounce delay)
+     */
+    private downloadLogFileOnError;
+    /**
+     * Get all log entries
+     * @returns Array of all log entries
+     */
+    getLogEntries(): ValidationLogEntry[];
+    /**
+     * Format all log entries as plain text
+     * @returns Formatted log text
+     */
+    formatLogAsText(): string;
+    /**
+     * Format a single log entry as plain text
+     * @param entry Log entry to format
+     * @param entryNumber Entry number (for display)
+     * @returns Formatted entry text
+     */
+    private formatLogEntry;
+    /**
+     * Download log file
+     * @param filename Optional filename (default: 'smart-table-validation-errors.log')
+     */
+    downloadLogFile(filename?: string): void;
+    /**
+     * Clear all log entries
+     */
+    clearLog(): void;
+    /**
+     * Get number of log entries
+     * @returns Number of log entries
+     */
+    getLogSize(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationLoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationLoggerService>;
+}

package/lib/services/virtual-scroll.service.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Virtual scroll state interface
+ * Contains all information needed for virtual scroll calculations
+ */
+export interface VirtualScrollState {
+    scrollTop: number;
+    viewportHeight: number;
+    totalItems: number;
+    itemSize: number;
+    bufferSize: number;
+    startIndex: number;
+    endIndex: number;
+    totalHeight: number;
+    offsetY: number;
+}
+/**
+ * Virtual Scroll Service
+ * Handles all virtual scroll calculations for efficient rendering of large datasets
+ */
+export declare class VirtualScrollService {
+    /**
+     * Calculate visible range based on scroll position
+     * @param state Current scroll state parameters
+     * @returns Complete virtual scroll state with calculated indices
+     */
+    calculateVisibleRange(state: {
+        scrollTop: number;
+        viewportHeight: number;
+        totalItems: number;
+        itemSize: number;
+        bufferSize: number;
+    }): VirtualScrollState;
+    /**
+     * Create throttled scroll observable for performance
+     * Throttles to 60fps (16ms) for smooth scrolling
+     * @param element The scrollable element to observe
+     * @returns Observable emitting scroll position
+     */
+    createScrollObservable(element: HTMLElement): Observable<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VirtualScrollService>;
+}

package/lib/shared/shared-table-components.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../builder/components/column-editor/column-editor.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+export declare class SharedTableComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedTableComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedTableComponentsModule, [typeof i1.ColumnEditorComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule], [typeof i1.ColumnEditorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedTableComponentsModule>;
+}

package/lib/smart-table.module.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./renderer/components/st-cell/st-cell.component";
+import * as i2 from "./renderer/components/st-table/st-table.component";
+import * as i3 from "./renderer/components/st-header/st-header.component";
+import * as i4 from "./renderer/components/st-column-menu/st-column-menu.component";
+import * as i5 from "./renderer/components/st-column-visibility/st-column-visibility.component";
+import * as i6 from "./renderer/components/st-column-filter/st-column-filter.component";
+import * as i7 from "./renderer/components/st-pagination/st-pagination.component";
+import * as i8 from "./renderer/components/st-add-column-button/st-add-column-button.component";
+import * as i9 from "./renderer/components/st-column-editor-modal/st-column-editor-modal.component";
+import * as i10 from "./renderer/components/st-table-actions/st-table-actions.component";
+import * as i11 from "./renderer/components/st-row-actions-dropdown/st-row-actions-dropdown.component";
+import * as i12 from "./renderer/components/st-sheet/st-sheet.component";
+import * as i13 from "./renderer/components/st-sheet-actions/st-sheet-actions.component";
+import * as i14 from "./renderer/components/st-workbook/st-workbook.component";
+import * as i15 from "./renderer/directives/click-outside.directive";
+import * as i16 from "./renderer/directives/st-column-resize.directive";
+import * as i17 from "./renderer/directives/st-keyboard-navigation.directive";
+import * as i18 from "@angular/common";
+import * as i19 from "@angular/forms";
+import * as i20 from "./shared/shared-table-components.module";
+export declare class SmartTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SmartTableModule, [typeof i1.StCellComponent, typeof i2.StTableComponent, typeof i3.StHeaderComponent, typeof i4.StColumnMenuDropdownComponent, typeof i5.StColumnVisibilityComponent, typeof i6.StColumnFilterComponent, typeof i7.StPaginationComponent, typeof i8.StAddColumnButtonComponent, typeof i9.StColumnEditorModalComponent, typeof i10.StTableActionsComponent, typeof i11.StRowActionsDropdownComponent, typeof i12.StSheetComponent, typeof i13.StSheetActionsComponent, typeof i14.StWorkbookComponent, typeof i15.ClickOutsideDirective, typeof i16.StColumnResizeDirective, typeof i17.StKeyboardNavigationDirective], [typeof i18.CommonModule, typeof i19.FormsModule, typeof i19.ReactiveFormsModule, typeof i20.SharedTableComponentsModule], [typeof i1.StCellComponent, typeof i2.StTableComponent, typeof i3.StHeaderComponent, typeof i4.StColumnMenuDropdownComponent, typeof i5.StColumnVisibilityComponent, typeof i6.StColumnFilterComponent, typeof i7.StPaginationComponent, typeof i8.StAddColumnButtonComponent, typeof i9.StColumnEditorModalComponent, typeof i10.StTableActionsComponent, typeof i11.StRowActionsDropdownComponent, typeof i12.StSheetComponent, typeof i13.StSheetActionsComponent, typeof i14.StWorkbookComponent, typeof i15.ClickOutsideDirective, typeof i16.StColumnResizeDirective, typeof i17.StKeyboardNavigationDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SmartTableModule>;
+}

package/lib/strategies/default-editors.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Default editor implementations
+ */
+import { CellEditor, CellEditorContext } from '../models/cell-strategies.interface';
+/**
+ * Text editor - basic text input
+ */
+export declare class TextEditor implements CellEditor<string> {
+    private readonly options?;
+    private input?;
+    constructor(options?: {
+        placeholder?: string | undefined;
+        maxLength?: number | undefined;
+        autoFocus?: boolean | undefined;
+        selectOnFocus?: boolean | undefined;
+    } | undefined);
+    edit(context: CellEditorContext<string>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): string;
+}
+/**
+ * Number editor - numeric input
+ */
+export declare class NumberEditor implements CellEditor<number> {
+    private readonly options?;
+    private input?;
+    constructor(options?: {
+        min?: number | undefined;
+        max?: number | undefined;
+        step?: number | undefined;
+        placeholder?: string | undefined;
+        autoFocus?: boolean | undefined;
+        selectOnFocus?: boolean | undefined;
+    } | undefined);
+    edit(context: CellEditorContext<number>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): number;
+}
+/**
+ * Date editor - date input
+ */
+export declare class DateEditor implements CellEditor<Date> {
+    private readonly options?;
+    private input?;
+    constructor(options?: {
+        min?: string | Date | undefined;
+        max?: string | Date | undefined;
+        autoFocus?: boolean | undefined;
+    } | undefined);
+    edit(context: CellEditorContext<Date>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): Date;
+}
+/**
+ * Select editor - dropdown selection
+ */
+export declare class SelectEditor<T = any> implements CellEditor<T> {
+    private readonly options;
+    private select?;
+    constructor(options: {
+        options: Array<{
+            value: T;
+            label: string;
+        }>;
+        placeholder?: string;
+        autoFocus?: boolean;
+    });
+    edit(context: CellEditorContext<T>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): T;
+}
+/**
+ * Boolean editor - checkbox
+ */
+export declare class BooleanEditor implements CellEditor<boolean> {
+    private readonly options?;
+    private checkbox?;
+    constructor(options?: {
+        autoFocus?: boolean | undefined;
+        saveOnChange?: boolean | undefined;
+    } | undefined);
+    edit(context: CellEditorContext<boolean>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): boolean;
+}
+/**
+ * Textarea editor - multi-line text input
+ */
+export declare class TextAreaEditor implements CellEditor<string> {
+    private readonly options?;
+    private textarea?;
+    constructor(options?: {
+        rows?: number | undefined;
+        cols?: number | undefined;
+        placeholder?: string | undefined;
+        maxLength?: number | undefined;
+        autoFocus?: boolean | undefined;
+        selectOnFocus?: boolean | undefined;
+    } | undefined);
+    edit(context: CellEditorContext<string>): void;
+    destroy(): void;
+    focus(): void;
+    getCurrentValue(): string;
+}

package/lib/strategies/default-formatters.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Default formatter implementations
+ */
+import { CellFormatter } from '../models/cell-strategies.interface';
+/**
+ * String formatter - default string display
+ */
+export declare class StringFormatter implements CellFormatter<string> {
+    private readonly options?;
+    constructor(options?: {
+        maxLength?: number | undefined;
+        ellipsis?: string | undefined;
+        trim?: boolean | undefined;
+        toUpperCase?: boolean | undefined;
+        toLowerCase?: boolean | undefined;
+    } | undefined);
+    format(value: string): string;
+}
+/**
+ * Number formatter - formats numbers with decimals
+ */
+export declare class NumberFormatter implements CellFormatter<number> {
+    private readonly options?;
+    constructor(options?: {
+        decimals?: number | undefined;
+        thousandsSeparator?: string | undefined;
+        decimalSeparator?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+    } | undefined);
+    format(value: number): string;
+}
+/**
+ * Currency formatter - formats currency values
+ */
+export declare class CurrencyFormatter implements CellFormatter<number> {
+    private readonly options?;
+    constructor(options?: {
+        currency?: string | undefined;
+        locale?: string | undefined;
+        decimals?: number | undefined;
+    } | undefined);
+    format(value: number): string;
+}
+/**
+ * Percentage formatter
+ */
+export declare class PercentageFormatter implements CellFormatter<number> {
+    private readonly options?;
+    constructor(options?: {
+        decimals?: number | undefined;
+        multiplier?: number | undefined;
+    } | undefined);
+    format(value: number): string;
+}
+/**
+ * Date formatter - locale-aware date formatting
+ */
+export declare class DateFormatter implements CellFormatter<Date> {
+    private readonly options?;
+    constructor(options?: {
+        locale?: string | undefined;
+        dateStyle?: "long" | "short" | "medium" | "full" | undefined;
+        timeStyle?: "long" | "short" | "medium" | "full" | undefined;
+        format?: string | undefined;
+    } | undefined);
+    format(value: Date): string;
+    private formatCustom;
+}
+/**
+ * Boolean formatter - formats boolean values
+ */
+export declare class BooleanFormatter implements CellFormatter<boolean> {
+    private readonly options?;
+    constructor(options?: {
+        trueValue?: string | undefined;
+        falseValue?: string | undefined;
+        nullValue?: string | undefined;
+    } | undefined);
+    format(value: boolean): string;
+}
+/**
+ * Array formatter - formats array values
+ */
+export declare class ArrayFormatter<T = any> implements CellFormatter<T[]> {
+    private readonly options?;
+    constructor(options?: {
+        separator?: string | undefined;
+        maxItems?: number | undefined;
+        ellipsis?: string | undefined;
+        itemFormatter?: ((item: T) => string) | undefined;
+    } | undefined);
+    format(value: T[]): string;
+}
+/**
+ * Template formatter - formats values using a template string
+ */
+export declare class TemplateFormatter implements CellFormatter<any> {
+    private readonly template;
+    constructor(template: string);
+    format(value: any): string;
+}
+/**
+ * Function formatter - formats values using a custom function
+ */
+export declare class FunctionFormatter<T = any> implements CellFormatter<T> {
+    private readonly formatFn;
+    constructor(formatFn: (value: T) => string);
+    format(value: T): string;
+}
+/**
+ * Default formatter - returns string representation
+ */
+export declare class DefaultFormatter implements CellFormatter<any> {
+    format(value: any): string;
+}

package/lib/strategies/default-validators.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Default validator implementations
+ */
+import { CellValidator, CompositeValidator } from '../models/cell-strategies.interface';
+import { ValidationResult } from '../models/cell-types';
+/**
+ * Required validator - ensures value is not empty
+ */
+export declare class RequiredValidator implements CellValidator<any> {
+    private readonly customMessage?;
+    errorMessage: string;
+    constructor(customMessage?: string | undefined);
+    validate(value: any): ValidationResult;
+}
+/**
+ * Range validator - validates numeric range
+ */
+export declare class RangeValidator implements CellValidator<number> {
+    private readonly min?;
+    private readonly max?;
+    errorMessage: string;
+    constructor(min?: number | undefined, max?: number | undefined, customMessage?: string);
+    validate(value: number): ValidationResult;
+    private buildErrorMessage;
+}
+/**
+ * String length validator
+ */
+export declare class LengthValidator implements CellValidator<string> {
+    private readonly minLength?;
+    private readonly maxLength?;
+    errorMessage: string;
+    constructor(minLength?: number | undefined, maxLength?: number | undefined, customMessage?: string);
+    validate(value: string): ValidationResult;
+    private buildErrorMessage;
+}
+/**
+ * Regex validator - validates against regular expression
+ */
+export declare class RegexValidator implements CellValidator<string> {
+    private readonly pattern;
+    errorMessage: string;
+    constructor(pattern: RegExp | string, customMessage?: string);
+    validate(value: string): ValidationResult;
+}
+/**
+ * Email validator
+ */
+export declare class EmailValidator implements CellValidator<string> {
+    errorMessage: string;
+    private readonly emailPattern;
+    constructor(customMessage?: string);
+    validate(value: string): ValidationResult;
+}
+/**
+ * URL validator
+ */
+export declare class UrlValidator implements CellValidator<string> {
+    errorMessage: string;
+    constructor(customMessage?: string);
+    validate(value: string): ValidationResult;
+}
+/**
+ * Date range validator
+ */
+export declare class DateRangeValidator implements CellValidator<Date> {
+    private readonly minDate?;
+    private readonly maxDate?;
+    errorMessage: string;
+    constructor(minDate?: Date | undefined, maxDate?: Date | undefined, customMessage?: string);
+    validate(value: Date): ValidationResult;
+    private buildErrorMessage;
+}
+/**
+ * Custom function validator
+ */
+export declare class FunctionValidator<T = any> implements CellValidator<T> {
+    private readonly validateFn;
+    errorMessage: string;
+    constructor(validateFn: (value: T) => boolean | ValidationResult, customMessage?: string);
+    validate(value: T): ValidationResult;
+}
+/**
+ * Composite validator - chains multiple validators (Chain of Responsibility)
+ */
+export declare class ChainValidator<T = any> implements CompositeValidator<T> {
+    errorMessage: string;
+    private validators;
+    constructor(validators?: CellValidator<T>[]);
+    addValidator(validator: CellValidator<T>): this;
+    getValidators(): CellValidator<T>[];
+    validate(value: T): ValidationResult;
+}
+/**
+ * Async validator interface (for future implementation)
+ */
+export interface AsyncCellValidator<T = any> {
+    validateAsync(value: T): Promise<ValidationResult>;
+}
+/**
+ * Pattern validators for common use cases
+ */
+export declare class PatternValidators {
+    static email(message?: string): EmailValidator;
+    static url(message?: string): UrlValidator;
+    static required(message?: string): RequiredValidator;
+    static range(min?: number, max?: number, message?: string): RangeValidator;
+    static stringLength(min?: number, max?: number, message?: string): LengthValidator;
+    static regex(pattern: RegExp | string, message?: string): RegexValidator;
+    static dateRange(min?: Date, max?: Date, message?: string): DateRangeValidator;
+    static custom<T>(fn: (value: T) => boolean | ValidationResult, message?: string): FunctionValidator<T>;
+    static chain<T>(...validators: CellValidator<T>[]): ChainValidator<T>;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@aquera/ngx-smart-table",
+  "version": "0.0.2-alpha",
+  "peerDependencies": {
+    "@angular/common": ">=13.0.0 <16.0.0",
+    "@angular/core": ">=13.0.0 <16.0.0",
+    "@aquera/nile": "^1.0.0",
+    "@aquera/nile-elements": "^1.4.4",
+    "rxjs": ">=6.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependenciesMeta": {
+    "ajv": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "ajv": "^8.12.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2015/aquera-ngx-smart-table.mjs",
+  "es2020": "fesm2020/aquera-ngx-smart-table.mjs",
+  "esm2020": "esm2020/aquera-ngx-smart-table.mjs",
+  "fesm2020": "fesm2020/aquera-ngx-smart-table.mjs",
+  "fesm2015": "fesm2015/aquera-ngx-smart-table.mjs",
+  "typings": "aquera-ngx-smart-table.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./aquera-ngx-smart-table.d.ts",
+      "esm2020": "./esm2020/aquera-ngx-smart-table.mjs",
+      "es2020": "./fesm2020/aquera-ngx-smart-table.mjs",
+      "es2015": "./fesm2015/aquera-ngx-smart-table.mjs",
+      "node": "./fesm2015/aquera-ngx-smart-table.mjs",
+      "default": "./fesm2020/aquera-ngx-smart-table.mjs"
+    }
+  }
+}