@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/services/custom-validation-rules.util.mjs

@@ -0,0 +1,124 @@
+/**
+ * Custom validation rules utility
+ * Implements business logic validations that can't be expressed in JSON Schema
+ */
+/**
+ * Validate custom business rules
+ * @param config Table configuration
+ * @returns Array of validation errors
+ */
+export function validateCustomRules(config) {
+    const errors = [];
+    if (!config.columns || !Array.isArray(config.columns)) {
+        return errors; // Let schema validation handle this
+    }
+    // 1. Check for duplicate column keys
+    const keys = config.columns.map(col => col.key);
+    const keyCounts = new Map();
+    keys.forEach((key, index) => {
+        const count = keyCounts.get(key) || 0;
+        keyCounts.set(key, count + 1);
+        if (count > 0) {
+            errors.push({
+                path: `/columns/${index}/key`,
+                message: `Duplicate column key: "${key}". Column keys must be unique.`,
+                code: 'DUPLICATE_KEY',
+                value: key,
+                field: `columns[${index}].key`
+            });
+        }
+    });
+    // 2. Validate width constraints for each column
+    config.columns.forEach((column, index) => {
+        const prefix = `/columns/${index}`;
+        // Width constraint: minWidth <= width <= maxWidth
+        if (typeof column.width === 'number' &&
+            column.minWidth !== undefined &&
+            column.width < column.minWidth) {
+            errors.push({
+                path: `${prefix}/width`,
+                message: `Width (${column.width}) must be greater than or equal to minWidth (${column.minWidth})`,
+                code: 'WIDTH_CONSTRAINT_VIOLATION',
+                value: column.width,
+                field: `columns[${index}].width`
+            });
+        }
+        if (typeof column.width === 'number' &&
+            column.maxWidth !== undefined &&
+            column.width > column.maxWidth) {
+            errors.push({
+                path: `${prefix}/width`,
+                message: `Width (${column.width}) must be less than or equal to maxWidth (${column.maxWidth})`,
+                code: 'WIDTH_CONSTRAINT_VIOLATION',
+                value: column.width,
+                field: `columns[${index}].width`
+            });
+        }
+        // 3. Sticky columns must have defined width (not 'auto')
+        if (column.sticky && (column.sticky === 'left' || column.sticky === 'right')) {
+            if (column.width === undefined || column.width === 'auto') {
+                errors.push({
+                    path: `${prefix}/width`,
+                    message: `Sticky columns must have a defined width (not 'auto'). Column "${column.key}" is sticky but has no width.`,
+                    code: 'STICKY_WIDTH_REQUIRED',
+                    value: column.width,
+                    field: `columns[${index}].width`
+                });
+            }
+        }
+        // 4. Column key format validation (should be valid identifier)
+        if (column.key && !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(column.key)) {
+            errors.push({
+                path: `${prefix}/key`,
+                message: `Column key "${column.key}" must be a valid identifier (letters, numbers, underscore, dollar sign, starting with letter/underscore/dollar)`,
+                code: 'INVALID_KEY_FORMAT',
+                value: column.key,
+                field: `columns[${index}].key`
+            });
+        }
+    });
+    // 5. Validate pagination pageSize is in pageSizeOptions (if both provided)
+    if (config.pagination?.pageSize && config.pagination?.pageSizeOptions) {
+        if (!config.pagination.pageSizeOptions.includes(config.pagination.pageSize)) {
+            errors.push({
+                path: '/pagination/pageSize',
+                message: `pageSize (${config.pagination.pageSize}) must be one of the pageSizeOptions: [${config.pagination.pageSizeOptions.join(', ')}]`,
+                code: 'PAGE_SIZE_NOT_IN_OPTIONS',
+                value: config.pagination.pageSize,
+                field: 'pagination.pageSize'
+            });
+        }
+    }
+    // 6. Validate initial state sortBy keys exist in columns
+    if (config.initialState?.sortBy) {
+        const columnKeys = new Set(config.columns.map(col => col.key));
+        config.initialState.sortBy.forEach((sort, index) => {
+            if (!columnKeys.has(sort.key)) {
+                errors.push({
+                    path: `/initialState/sortBy/${index}/key`,
+                    message: `Sort key "${sort.key}" does not exist in columns`,
+                    code: 'INVALID_SORT_KEY',
+                    value: sort.key,
+                    field: `initialState.sortBy[${index}].key`
+                });
+            }
+        });
+    }
+    // 7. Validate initial state filter keys exist in columns
+    if (config.initialState?.filters) {
+        const columnKeys = new Set(config.columns.map(col => col.key));
+        config.initialState.filters.forEach((filter, index) => {
+            if (!columnKeys.has(filter.key)) {
+                errors.push({
+                    path: `/initialState/filters/${index}/key`,
+                    message: `Filter key "${filter.key}" does not exist in columns`,
+                    code: 'INVALID_FILTER_KEY',
+                    value: filter.key,
+                    field: `initialState.filters[${index}].key`
+                });
+            }
+        });
+    }
+    return errors;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-validation-rules.util.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/services/custom-validation-rules.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Custom validation rules utility\n * Implements business logic validations that can't be expressed in JSON Schema\n */\n\nimport { TableConfig } from '../models/table-config.interface';\nimport { SchemaValidationError } from '../models/schema-validation.interface';\n\n/**\n * Validate custom business rules\n * @param config Table configuration\n * @returns Array of validation errors\n */\nexport function validateCustomRules(config: TableConfig): SchemaValidationError[] {\n  const errors: SchemaValidationError[] = [];\n\n  if (!config.columns || !Array.isArray(config.columns)) {\n    return errors; // Let schema validation handle this\n  }\n\n  // 1. Check for duplicate column keys\n  const keys = config.columns.map(col => col.key);\n  const keyCounts = new Map<string, number>();\n  keys.forEach((key, index) => {\n    const count = keyCounts.get(key) || 0;\n    keyCounts.set(key, count + 1);\n    if (count > 0) {\n      errors.push({\n        path: `/columns/${index}/key`,\n        message: `Duplicate column key: \"${key}\". Column keys must be unique.`,\n        code: 'DUPLICATE_KEY',\n        value: key,\n        field: `columns[${index}].key`\n      });\n    }\n  });\n\n  // 2. Validate width constraints for each column\n  config.columns.forEach((column, index) => {\n    const prefix = `/columns/${index}`;\n    \n    // Width constraint: minWidth <= width <= maxWidth\n    if (\n      typeof column.width === 'number' &&\n      column.minWidth !== undefined &&\n      column.width < column.minWidth\n    ) {\n      errors.push({\n        path: `${prefix}/width`,\n        message: `Width (${column.width}) must be greater than or equal to minWidth (${column.minWidth})`,\n        code: 'WIDTH_CONSTRAINT_VIOLATION',\n        value: column.width,\n        field: `columns[${index}].width`\n      });\n    }\n\n    if (\n      typeof column.width === 'number' &&\n      column.maxWidth !== undefined &&\n      column.width > column.maxWidth\n    ) {\n      errors.push({\n        path: `${prefix}/width`,\n        message: `Width (${column.width}) must be less than or equal to maxWidth (${column.maxWidth})`,\n        code: 'WIDTH_CONSTRAINT_VIOLATION',\n        value: column.width,\n        field: `columns[${index}].width`\n      });\n    }\n\n    // 3. Sticky columns must have defined width (not 'auto')\n    if (column.sticky && (column.sticky === 'left' || column.sticky === 'right')) {\n      if (column.width === undefined || column.width === 'auto') {\n        errors.push({\n          path: `${prefix}/width`,\n          message: `Sticky columns must have a defined width (not 'auto'). Column \"${column.key}\" is sticky but has no width.`,\n          code: 'STICKY_WIDTH_REQUIRED',\n          value: column.width,\n          field: `columns[${index}].width`\n        });\n      }\n    }\n\n    // 4. Column key format validation (should be valid identifier)\n    if (column.key && !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(column.key)) {\n      errors.push({\n        path: `${prefix}/key`,\n        message: `Column key \"${column.key}\" must be a valid identifier (letters, numbers, underscore, dollar sign, starting with letter/underscore/dollar)`,\n        code: 'INVALID_KEY_FORMAT',\n        value: column.key,\n        field: `columns[${index}].key`\n      });\n    }\n  });\n\n  // 5. Validate pagination pageSize is in pageSizeOptions (if both provided)\n  if (config.pagination?.pageSize && config.pagination?.pageSizeOptions) {\n    if (!config.pagination.pageSizeOptions.includes(config.pagination.pageSize)) {\n      errors.push({\n        path: '/pagination/pageSize',\n        message: `pageSize (${config.pagination.pageSize}) must be one of the pageSizeOptions: [${config.pagination.pageSizeOptions.join(', ')}]`,\n        code: 'PAGE_SIZE_NOT_IN_OPTIONS',\n        value: config.pagination.pageSize,\n        field: 'pagination.pageSize'\n      });\n    }\n  }\n\n  // 6. Validate initial state sortBy keys exist in columns\n  if (config.initialState?.sortBy) {\n    const columnKeys = new Set(config.columns.map(col => col.key));\n    config.initialState.sortBy.forEach((sort, index) => {\n      if (!columnKeys.has(sort.key)) {\n        errors.push({\n          path: `/initialState/sortBy/${index}/key`,\n          message: `Sort key \"${sort.key}\" does not exist in columns`,\n          code: 'INVALID_SORT_KEY',\n          value: sort.key,\n          field: `initialState.sortBy[${index}].key`\n        });\n      }\n    });\n  }\n\n  // 7. Validate initial state filter keys exist in columns\n  if (config.initialState?.filters) {\n    const columnKeys = new Set(config.columns.map(col => col.key));\n    config.initialState.filters.forEach((filter, index) => {\n      if (!columnKeys.has(filter.key)) {\n        errors.push({\n          path: `/initialState/filters/${index}/key`,\n          message: `Filter key \"${filter.key}\" does not exist in columns`,\n          code: 'INVALID_FILTER_KEY',\n          value: filter.key,\n          field: `initialState.filters[${index}].key`\n        });\n      }\n    });\n  }\n\n  return errors;\n}\n\n"]}

package/esm2020/lib/services/json-schema-validator.service.mjs

@@ -0,0 +1,216 @@
+/**
+ * JSON Schema Validation Service
+ * Validates TableConfig JSON against JSON Schema using ajv
+ *
+ */
+import { Injectable } from '@angular/core';
+import { tableConfigSchema } from '../schemas/table-config.schema';
+import { validateCustomRules } from './custom-validation-rules.util';
+import Ajv from 'ajv';
+import * as i0 from "@angular/core";
+import * as i1 from "./validation-logger.service";
+export class JsonSchemaValidatorService {
+    constructor(logger) {
+        this.logger = logger;
+        this.ajv = null;
+        this.validateFn = null;
+        this.ajvAvailable = false;
+        this.initialized = false;
+    }
+    /**
+     * Ensure ajv is initialized (lazy initialization)
+     */
+    ensureInitialized() {
+        if (!this.initialized) {
+            this.initializeAjv();
+            this.initialized = true;
+        }
+    }
+    /**
+     * Initialize ajv validator
+     */
+    initializeAjv() {
+        try {
+            // Try to load ajv - use require for compatibility with Angular build system
+            // eslint-disable-next-line @typescript-eslint/no-require-imports      
+            this.ajv = new Ajv({
+                allErrors: true,
+                verbose: true,
+                strict: false,
+                validateSchema: false // Don't validate the schema itself
+            });
+            // Compile schema (convert const to regular object for ajv)
+            const schema = JSON.parse(JSON.stringify(tableConfigSchema));
+            this.validateFn = this.ajv.compile(schema);
+            this.ajvAvailable = true;
+        }
+        catch (error) {
+            // ajv is optional - if not installed, validation will use custom rules only
+            console.warn('ajv library not found. JSON schema validation will be disabled. Install with: npm install ajv');
+            this.ajvAvailable = false;
+        }
+    }
+    /**
+     * 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, includeCustomRules = true, enableLogging = true) {
+        // Ensure ajv is initialized before validation
+        this.ensureInitialized();
+        const allErrors = [];
+        // 1. JSON Schema validation (if ajv is available)
+        if (this.ajvAvailable) {
+            const isValid = this.validateFn(data);
+            if (!isValid) {
+                // Convert ajv errors to our format
+                const schemaErrors = (this.validateFn.errors || []).map((error) => {
+                    const path = error.instancePath || error.schemaPath || '';
+                    const field = this.pathToFieldName(path);
+                    return {
+                        path: path,
+                        message: this.formatErrorMessage(error, field),
+                        code: error.keyword || 'VALIDATION_ERROR',
+                        value: error.data,
+                        field: field
+                    };
+                });
+                allErrors.push(...schemaErrors);
+            }
+        }
+        else {
+            // If ajv is not available, add a warning but continue with custom rules
+            allErrors.push({
+                path: '',
+                message: 'JSON schema validation is not available. Please install ajv: npm install ajv',
+                code: 'AJV_NOT_AVAILABLE',
+                field: 'root'
+            });
+        }
+        // 2. Custom business rule validation
+        if (includeCustomRules && data && typeof data === 'object') {
+            try {
+                const customErrors = validateCustomRules(data);
+                allErrors.push(...customErrors);
+            }
+            catch (error) {
+                allErrors.push({
+                    path: '',
+                    message: `Custom validation failed: ${error.message}`,
+                    code: 'CUSTOM_VALIDATION_ERROR',
+                    field: 'root'
+                });
+            }
+        }
+        const result = {
+            valid: allErrors.length === 0,
+            errors: allErrors,
+            ajvAvailable: this.ajvAvailable
+        };
+        // Log validation errors if validation failed and logging is enabled
+        if (!result.valid && enableLogging) {
+            this.logger.logValidationErrors(allErrors, 'schema-validation');
+        }
+        return result;
+    }
+    /**
+     * 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, includeCustomRules = true, enableLogging = true) {
+        try {
+            const data = JSON.parse(jsonString);
+            return this.validate(data, includeCustomRules, enableLogging);
+        }
+        catch (error) {
+            const result = {
+                valid: false,
+                errors: [{
+                        path: '',
+                        message: `Invalid JSON: ${error.message}`,
+                        code: 'JSON_PARSE_ERROR',
+                        value: jsonString,
+                        field: 'root'
+                    }],
+                ajvAvailable: this.ajvAvailable
+            };
+            // Log JSON parse errors if logging is enabled
+            if (enableLogging) {
+                this.logger.logValidationErrors(result.errors, 'schema-validation', {
+                    configSnippet: jsonString.substring(0, 200) // Include first 200 chars as context
+                });
+            }
+            return result;
+        }
+    }
+    /**
+     * Check if ajv is available
+     */
+    isAvailable() {
+        this.ensureInitialized();
+        return this.ajvAvailable;
+    }
+    /**
+     * Convert JSON path to user-friendly field name
+     */
+    pathToFieldName(path) {
+        if (!path)
+            return 'root';
+        // Remove leading slash
+        let field = path.replace(/^\//, '');
+        // Replace array indices with brackets
+        field = field.replace(/\/(\d+)/g, '[$1]');
+        // Replace slashes with dots
+        field = field.replace(/\//g, '.');
+        return field || 'root';
+    }
+    /**
+     * Format error message from ajv error
+     */
+    formatErrorMessage(error, field) {
+        const keyword = error.keyword;
+        const params = error.params || {};
+        switch (keyword) {
+            case 'required':
+                return `Field '${field}' is required but missing`;
+            case 'type':
+                return `Field '${field}' must be of type ${params.type}, but got ${typeof error.data}`;
+            case 'enum':
+                return `Field '${field}' must be one of: ${params.allowedValues?.join(', ') || 'allowed values'}`;
+            case 'pattern':
+                return `Field '${field}' does not match required pattern: ${params.pattern}`;
+            case 'minimum':
+                return `Field '${field}' must be at least ${params.limit}`;
+            case 'maximum':
+                return `Field '${field}' must be at most ${params.limit}`;
+            case 'minLength':
+                return `Field '${field}' must have at least ${params.limit} items`;
+            case 'maxLength':
+                return `Field '${field}' must have at most ${params.limit} items`;
+            case 'minItems':
+                return `Array '${field}' must have at least ${params.limit} items`;
+            case 'maxItems':
+                return `Array '${field}' must have at most ${params.limit} items`;
+            case 'additionalProperties':
+                return `Field '${field}' contains unknown property: ${params.additionalProperty}`;
+            case 'oneOf':
+                return `Field '${field}' does not match any of the allowed types`;
+            default:
+                return error.message || `Field '${field}' is invalid`;
+        }
+    }
+}
+JsonSchemaValidatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: JsonSchemaValidatorService, deps: [{ token: i1.ValidationLoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
+JsonSchemaValidatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: JsonSchemaValidatorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: JsonSchemaValidatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ValidationLoggerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema-validator.service.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/services/json-schema-validator.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * JSON Schema Validation Service\n * Validates TableConfig JSON against JSON Schema using ajv\n * \n */\n\nimport { Injectable } from '@angular/core';\nimport { tableConfigSchema } from '../schemas/table-config.schema';\nimport { validateCustomRules } from './custom-validation-rules.util';\nimport { ValidationLoggerService } from './validation-logger.service';\nimport { SchemaValidationError, SchemaValidationResult } from '../models/schema-validation.interface';\nimport Ajv from 'ajv';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class JsonSchemaValidatorService {\n  private ajv: any = null;\n  private validateFn: any = null;\n  private ajvAvailable: boolean = false;\n  private initialized: boolean = false;\n\n  constructor(private logger: ValidationLoggerService) {\n  }\n\n  /**\n   * Ensure ajv is initialized (lazy initialization)\n   */\n  private ensureInitialized(): void {\n    if (!this.initialized) {\n      this.initializeAjv();\n      this.initialized = true;\n    }\n  }\n\n  /**\n   * Initialize ajv validator\n   */\n  private initializeAjv(): void {\n    try {\n      // Try to load ajv - use require for compatibility with Angular build system\n      // eslint-disable-next-line @typescript-eslint/no-require-imports      \n      this.ajv = new Ajv({\n        allErrors: true,\n        verbose: true,\n        strict: false,\n        validateSchema: false // Don't validate the schema itself\n      });\n\n      // Compile schema (convert const to regular object for ajv)\n      const schema = JSON.parse(JSON.stringify(tableConfigSchema));\n      this.validateFn = this.ajv.compile(schema);\n      this.ajvAvailable = true;\n    } catch (error) {\n      // ajv is optional - if not installed, validation will use custom rules only\n      console.warn('ajv library not found. JSON schema validation will be disabled. Install with: npm install ajv');\n      this.ajvAvailable = false;\n    }\n  }\n\n  /**\n   * Validate JSON data against TableConfig schema\n   * @param data JSON data to validate\n   * @param includeCustomRules Whether to include custom business rule validations\n   * @param enableLogging Whether to log validation errors (default: true)\n   * @returns Validation result\n   */\n  validate(data: any, includeCustomRules: boolean = true, enableLogging: boolean = true): SchemaValidationResult {\n    // Ensure ajv is initialized before validation\n    this.ensureInitialized();\n    \n    const allErrors: SchemaValidationError[] = [];\n\n    // 1. JSON Schema validation (if ajv is available)\n    if (this.ajvAvailable) {\n      const isValid = this.validateFn(data);\n\n      if (!isValid) {\n        // Convert ajv errors to our format\n        const schemaErrors: SchemaValidationError[] = (this.validateFn.errors || []).map((error: any) => {\n          const path = error.instancePath || error.schemaPath || '';\n          const field = this.pathToFieldName(path);\n          \n          return {\n            path: path,\n            message: this.formatErrorMessage(error, field),\n            code: error.keyword || 'VALIDATION_ERROR',\n            value: error.data,\n            field: field\n          };\n        });\n\n        allErrors.push(...schemaErrors);\n      }\n    } else {\n      // If ajv is not available, add a warning but continue with custom rules\n      allErrors.push({\n        path: '',\n        message: 'JSON schema validation is not available. Please install ajv: npm install ajv',\n        code: 'AJV_NOT_AVAILABLE',\n        field: 'root'\n      });\n    }\n\n    // 2. Custom business rule validation\n    if (includeCustomRules && data && typeof data === 'object') {\n      try {\n        const customErrors = validateCustomRules(data as any);\n        allErrors.push(...customErrors);\n      } catch (error: any) {\n        allErrors.push({\n          path: '',\n          message: `Custom validation failed: ${error.message}`,\n          code: 'CUSTOM_VALIDATION_ERROR',\n          field: 'root'\n        });\n      }\n    }\n\n    const result = {\n      valid: allErrors.length === 0,\n      errors: allErrors,\n      ajvAvailable: this.ajvAvailable\n    };\n\n    // Log validation errors if validation failed and logging is enabled\n    if (!result.valid && enableLogging) {\n      this.logger.logValidationErrors(allErrors, 'schema-validation');\n    }\n\n    return result;\n  }\n\n  /**\n   * Validate JSON string\n   * @param jsonString JSON string to validate\n   * @param includeCustomRules Whether to include custom business rule validations\n   * @param enableLogging Whether to log validation errors (default: true)\n   * @returns Validation result\n   */\n  validateJSONString(jsonString: string, includeCustomRules: boolean = true, enableLogging: boolean = true): SchemaValidationResult {\n    try {\n      const data = JSON.parse(jsonString);\n      return this.validate(data, includeCustomRules, enableLogging);\n    } catch (error: any) {\n      const result = {\n        valid: false,\n        errors: [{\n          path: '',\n          message: `Invalid JSON: ${error.message}`,\n          code: 'JSON_PARSE_ERROR',\n          value: jsonString,\n          field: 'root'\n        }],\n        ajvAvailable: this.ajvAvailable\n      };\n\n      // Log JSON parse errors if logging is enabled\n      if (enableLogging) {\n        this.logger.logValidationErrors(result.errors, 'schema-validation', {\n          configSnippet: jsonString.substring(0, 200) // Include first 200 chars as context\n        });\n      }\n\n      return result;\n    }\n  }\n\n  /**\n   * Check if ajv is available\n   */\n  isAvailable(): boolean {\n    this.ensureInitialized();\n    return this.ajvAvailable;\n  }\n\n  /**\n   * Convert JSON path to user-friendly field name\n   */\n  private pathToFieldName(path: string): string {\n    if (!path) return 'root';\n    \n    // Remove leading slash\n    let field = path.replace(/^\\//, '');\n    \n    // Replace array indices with brackets\n    field = field.replace(/\\/(\\d+)/g, '[$1]');\n    \n    // Replace slashes with dots\n    field = field.replace(/\\//g, '.');\n    \n    return field || 'root';\n  }\n\n  /**\n   * Format error message from ajv error\n   */\n  private formatErrorMessage(error: any, field: string): string {\n    const keyword = error.keyword;\n    const params = error.params || {};\n    \n    switch (keyword) {\n      case 'required':\n        return `Field '${field}' is required but missing`;\n      \n      case 'type':\n        return `Field '${field}' must be of type ${params.type}, but got ${typeof error.data}`;\n      \n      case 'enum':\n        return `Field '${field}' must be one of: ${params.allowedValues?.join(', ') || 'allowed values'}`;\n      \n      case 'pattern':\n        return `Field '${field}' does not match required pattern: ${params.pattern}`;\n      \n      case 'minimum':\n        return `Field '${field}' must be at least ${params.limit}`;\n      \n      case 'maximum':\n        return `Field '${field}' must be at most ${params.limit}`;\n      \n      case 'minLength':\n        return `Field '${field}' must have at least ${params.limit} items`;\n      \n      case 'maxLength':\n        return `Field '${field}' must have at most ${params.limit} items`;\n      \n      case 'minItems':\n        return `Array '${field}' must have at least ${params.limit} items`;\n      \n      case 'maxItems':\n        return `Array '${field}' must have at most ${params.limit} items`;\n      \n      case 'additionalProperties':\n        return `Field '${field}' contains unknown property: ${params.additionalProperty}`;\n      \n      case 'oneOf':\n        return `Field '${field}' does not match any of the allowed types`;\n      \n      default:\n        return error.message || `Field '${field}' is invalid`;\n    }\n  }\n}\n\n"]}

package/esm2020/lib/services/row-validation.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RowValidationService {
+    /**
+     * Validate a single row
+     */
+    validateRow(rowData, cells, rowIndex, validator) {
+        try {
+            return validator.validateRow(rowData, cells, rowIndex);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: `Validation error: ${error.message}`,
+                errors: [error.message]
+            };
+        }
+    }
+    /**
+     * Validate entire table
+     */
+    validateTable(rows, config, validator, rowValidationResults) {
+        try {
+            return validator.validateTable(rows, config, rowValidationResults);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                globalErrors: [`Table validation error: ${error.message}`]
+            };
+        }
+    }
+}
+RowValidationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: RowValidationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RowValidationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: RowValidationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: RowValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/validation-logger.service.mjs

@@ -0,0 +1,177 @@
+/**
+ * Validation Logger Service
+ * Automatically logs validation errors and provides functionality to download them as a log file
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ValidationLoggerService {
+    constructor() {
+        this.logEntries = [];
+        this.downloadTimeoutId = null;
+        this.DOWNLOAD_DELAY_MS = 500; // Wait 500ms after last error before downloading
+    }
+    /**
+     * 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, source, context, autoDownload = true) {
+        if (errors.length === 0) {
+            return; // Don't log if there are no errors
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            source: source,
+            errors: errors,
+            context: context
+        };
+        this.logEntries.push(entry);
+        // Schedule automatic download after errors accumulate (debounced)
+        if (autoDownload) {
+            this.scheduleDownload();
+        }
+    }
+    /**
+     * Schedule log file download with debounce
+     * This ensures we only download once after all errors are accumulated
+     */
+    scheduleDownload() {
+        // Clear any existing timeout
+        if (this.downloadTimeoutId !== null) {
+            clearTimeout(this.downloadTimeoutId);
+        }
+        // Schedule download after delay
+        // If more errors come in before timeout fires, this will be cancelled and rescheduled
+        this.downloadTimeoutId = setTimeout(() => {
+            this.downloadLogFileOnError();
+            this.downloadTimeoutId = null;
+        }, this.DOWNLOAD_DELAY_MS);
+    }
+    /**
+     * Download log file with timestamped filename
+     * Called automatically when validation errors occur (after debounce delay)
+     */
+    downloadLogFileOnError() {
+        // Generate filename with timestamp to avoid overwriting
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5); // Format: 2024-01-15T10-30-45
+        const filename = `smart-table-validation-errors-${timestamp}.log`;
+        this.downloadLogFile(filename);
+    }
+    /**
+     * Get all log entries
+     * @returns Array of all log entries
+     */
+    getLogEntries() {
+        return [...this.logEntries];
+    }
+    /**
+     * Format all log entries as plain text
+     * @returns Formatted log text
+     */
+    formatLogAsText() {
+        if (this.logEntries.length === 0) {
+            return 'No validation errors logged.\n';
+        }
+        let logText = `Smart Table Validation Error Log\n`;
+        logText += `Generated: ${new Date().toISOString()}\n`;
+        logText += `Total Validation Failures: ${this.logEntries.length}\n`;
+        logText += `${'='.repeat(80)}\n\n`;
+        this.logEntries.forEach((entry, index) => {
+            logText += this.formatLogEntry(entry, index + 1);
+            logText += '\n';
+        });
+        return logText;
+    }
+    /**
+     * Format a single log entry as plain text
+     * @param entry Log entry to format
+     * @param entryNumber Entry number (for display)
+     * @returns Formatted entry text
+     */
+    formatLogEntry(entry, entryNumber) {
+        let text = `[${entry.timestamp}] Validation Failed - Source: ${entry.source}\n`;
+        // Add context information if available
+        if (entry.context) {
+            if (entry.context.fileName) {
+                text += `File: ${entry.context.fileName}\n`;
+            }
+            if (entry.context.storageKey) {
+                text += `Storage Key: ${entry.context.storageKey}\n`;
+            }
+            if (entry.context.configSnippet) {
+                text += `Config Snippet: ${entry.context.configSnippet}\n`;
+            }
+        }
+        text += `${'━'.repeat(80)}\n`;
+        // Format each error
+        entry.errors.forEach((error, errorIndex) => {
+            text += `Error ${errorIndex + 1}:\n`;
+            if (error.field) {
+                text += `  Field: ${error.field}\n`;
+            }
+            if (error.path) {
+                text += `  Path: ${error.path}\n`;
+            }
+            if (error.code) {
+                text += `  Code: ${error.code}\n`;
+            }
+            if (error.message) {
+                text += `  Message: ${error.message}\n`;
+            }
+            if (error.value !== undefined && error.value !== null) {
+                const valueStr = typeof error.value === 'object'
+                    ? JSON.stringify(error.value, null, 2).split('\n').map(line => `    ${line}`).join('\n')
+                    : String(error.value);
+                text += `  Value: ${valueStr}\n`;
+            }
+            text += '\n';
+        });
+        text += `${'━'.repeat(80)}\n`;
+        return text;
+    }
+    /**
+     * Download log file
+     * @param filename Optional filename (default: 'smart-table-validation-errors.log')
+     */
+    downloadLogFile(filename = 'smart-table-validation-errors.log') {
+        const logText = this.formatLogAsText();
+        const blob = new Blob([logText], { type: 'text/plain' });
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = filename;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Clear all log entries
+     */
+    clearLog() {
+        // Cancel any pending download
+        if (this.downloadTimeoutId !== null) {
+            clearTimeout(this.downloadTimeoutId);
+            this.downloadTimeoutId = null;
+        }
+        this.logEntries = [];
+    }
+    /**
+     * Get number of log entries
+     * @returns Number of log entries
+     */
+    getLogSize() {
+        return this.logEntries.length;
+    }
+}
+ValidationLoggerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ValidationLoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ValidationLoggerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ValidationLoggerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ValidationLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation-logger.service.js","sourceRoot":"","sources":["../../../../../projects/smart-table/src/lib/services/validation-logger.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Validation Logger Service\n * Automatically logs validation errors and provides functionality to download them as a log file\n */\n\nimport { Injectable } from '@angular/core';\nimport { SchemaValidationError } from '../models/schema-validation.interface';\n\n/**\n * Validation log entry interface\n */\nexport interface ValidationLogEntry {\n  /**\n   * ISO timestamp when validation failed\n   */\n  timestamp: string;\n\n  /**\n   * Source of validation (e.g., 'import', 'renderer', 'schema-validation')\n   */\n  source: string;\n\n  /**\n   * Array of validation errors\n   */\n  errors: SchemaValidationError[];\n\n  /**\n   * Optional context information\n   */\n  context?: {\n    fileName?: string;\n    configSnippet?: string;\n    storageKey?: string;\n  };\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ValidationLoggerService {\n  private logEntries: ValidationLogEntry[] = [];\n  private downloadTimeoutId: any = null;\n  private readonly DOWNLOAD_DELAY_MS = 500; // Wait 500ms after last error before downloading\n\n  /**\n   * Log validation errors\n   * @param errors Array of validation errors\n   * @param source Source of validation (e.g., 'import', 'renderer', 'schema-validation')\n   * @param context Optional context information\n   * @param autoDownload Whether to automatically download log file (default: true)\n   */\n  logValidationErrors(\n    errors: SchemaValidationError[],\n    source: string,\n    context?: {\n      fileName?: string;\n      configSnippet?: string;\n      storageKey?: string;\n    },\n    autoDownload: boolean = true\n  ): void {\n    if (errors.length === 0) {\n      return; // Don't log if there are no errors\n    }\n\n    const entry: ValidationLogEntry = {\n      timestamp: new Date().toISOString(),\n      source: source,\n      errors: errors,\n      context: context\n    };\n\n    this.logEntries.push(entry);\n\n    // Schedule automatic download after errors accumulate (debounced)\n    if (autoDownload) {\n      this.scheduleDownload();\n    }\n  }\n\n  /**\n   * Schedule log file download with debounce\n   * This ensures we only download once after all errors are accumulated\n   */\n  private scheduleDownload(): void {\n    // Clear any existing timeout\n    if (this.downloadTimeoutId !== null) {\n      clearTimeout(this.downloadTimeoutId);\n    }\n\n    // Schedule download after delay\n    // If more errors come in before timeout fires, this will be cancelled and rescheduled\n    this.downloadTimeoutId = setTimeout(() => {\n      this.downloadLogFileOnError();\n      this.downloadTimeoutId = null;\n    }, this.DOWNLOAD_DELAY_MS);\n  }\n\n  /**\n   * Download log file with timestamped filename\n   * Called automatically when validation errors occur (after debounce delay)\n   */\n  private downloadLogFileOnError(): void {\n    // Generate filename with timestamp to avoid overwriting\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5); // Format: 2024-01-15T10-30-45\n    const filename = `smart-table-validation-errors-${timestamp}.log`;\n    this.downloadLogFile(filename);\n  }\n\n  /**\n   * Get all log entries\n   * @returns Array of all log entries\n   */\n  getLogEntries(): ValidationLogEntry[] {\n    return [...this.logEntries];\n  }\n\n  /**\n   * Format all log entries as plain text\n   * @returns Formatted log text\n   */\n  formatLogAsText(): string {\n    if (this.logEntries.length === 0) {\n      return 'No validation errors logged.\\n';\n    }\n\n    let logText = `Smart Table Validation Error Log\\n`;\n    logText += `Generated: ${new Date().toISOString()}\\n`;\n    logText += `Total Validation Failures: ${this.logEntries.length}\\n`;\n    logText += `${'='.repeat(80)}\\n\\n`;\n\n    this.logEntries.forEach((entry, index) => {\n      logText += this.formatLogEntry(entry, index + 1);\n      logText += '\\n';\n    });\n\n    return logText;\n  }\n\n  /**\n   * Format a single log entry as plain text\n   * @param entry Log entry to format\n   * @param entryNumber Entry number (for display)\n   * @returns Formatted entry text\n   */\n  private formatLogEntry(entry: ValidationLogEntry, entryNumber: number): string {\n    let text = `[${entry.timestamp}] Validation Failed - Source: ${entry.source}\\n`;\n    \n    // Add context information if available\n    if (entry.context) {\n      if (entry.context.fileName) {\n        text += `File: ${entry.context.fileName}\\n`;\n      }\n      if (entry.context.storageKey) {\n        text += `Storage Key: ${entry.context.storageKey}\\n`;\n      }\n      if (entry.context.configSnippet) {\n        text += `Config Snippet: ${entry.context.configSnippet}\\n`;\n      }\n    }\n\n    text += `${'━'.repeat(80)}\\n`;\n\n    // Format each error\n    entry.errors.forEach((error, errorIndex) => {\n      text += `Error ${errorIndex + 1}:\\n`;\n      \n      if (error.field) {\n        text += `  Field: ${error.field}\\n`;\n      }\n      \n      if (error.path) {\n        text += `  Path: ${error.path}\\n`;\n      }\n      \n      if (error.code) {\n        text += `  Code: ${error.code}\\n`;\n      }\n      \n      if (error.message) {\n        text += `  Message: ${error.message}\\n`;\n      }\n      \n      if (error.value !== undefined && error.value !== null) {\n        const valueStr = typeof error.value === 'object' \n          ? JSON.stringify(error.value, null, 2).split('\\n').map(line => `    ${line}`).join('\\n')\n          : String(error.value);\n        text += `  Value: ${valueStr}\\n`;\n      }\n      \n      text += '\\n';\n    });\n\n    text += `${'━'.repeat(80)}\\n`;\n\n    return text;\n  }\n\n  /**\n   * Download log file\n   * @param filename Optional filename (default: 'smart-table-validation-errors.log')\n   */\n  downloadLogFile(filename: string = 'smart-table-validation-errors.log'): void {\n    const logText = this.formatLogAsText();\n    const blob = new Blob([logText], { type: 'text/plain' });\n    const url = URL.createObjectURL(blob);\n    const link = document.createElement('a');\n    link.href = url;\n    link.download = filename;\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n  }\n\n  /**\n   * Clear all log entries\n   */\n  clearLog(): void {\n    // Cancel any pending download\n    if (this.downloadTimeoutId !== null) {\n      clearTimeout(this.downloadTimeoutId);\n      this.downloadTimeoutId = null;\n    }\n    this.logEntries = [];\n  }\n\n  /**\n   * Get number of log entries\n   * @returns Number of log entries\n   */\n  getLogSize(): number {\n    return this.logEntries.length;\n  }\n}\n\n"]}