@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/builder/services/definition-export.service.mjs

@@ -0,0 +1,167 @@
+/**
+ * Definition export service
+ * Handles exporting TableConfig to JSON or TypeScript
+ */
+import { Injectable } from '@angular/core';
+import { generateTypeScriptCode } from '../utils/typescript-generator.util';
+import * as i0 from "@angular/core";
+export class DefinitionExportService {
+    /**
+     * Export TableConfig to JSON string
+     * @param config Table configuration
+     * @param pretty Whether to format JSON with indentation
+     * @returns JSON string
+     */
+    exportToJSON(config, pretty = true) {
+        // Create a serializable version (remove functions, circular refs)
+        const serializable = this.sanitizeForJSON(config);
+        if (pretty) {
+            return JSON.stringify(serializable, null, 2);
+        }
+        else {
+            return JSON.stringify(serializable);
+        }
+    }
+    /**
+     * Export TableConfig to TypeScript code
+     * @param config Table configuration
+     * @param options Generation options
+     * @returns TypeScript code string
+     */
+    exportToTypeScript(config, options = {}) {
+        return generateTypeScriptCode(config, options);
+    }
+    /**
+     * Download configuration as JSON file
+     * @param config Table configuration
+     * @param fileName File name (without extension)
+     */
+    downloadAsJSON(config, fileName = 'table-config') {
+        const json = this.exportToJSON(config);
+        this.downloadFile(json, `${fileName}.json`, 'application/json');
+    }
+    /**
+     * Download configuration as TypeScript file
+     * @param config Table configuration
+     * @param fileName File name (without extension)
+     * @param options Generation options
+     */
+    downloadAsTypeScript(config, fileName = 'table-config', options = {}) {
+        const code = this.exportToTypeScript(config, options);
+        this.downloadFile(code, `${fileName}.ts`, 'text/typescript');
+    }
+    /**
+     * Save configuration to localStorage
+     * @param config Table configuration
+     * @param key Storage key
+     */
+    saveToLocalStorage(config, key = 'smart-table-definition') {
+        try {
+            const json = this.exportToJSON(config, false);
+            localStorage.setItem(key, json);
+        }
+        catch (error) {
+            console.error('Failed to save to localStorage:', error);
+            throw error;
+        }
+    }
+    /**
+     * Load configuration from localStorage
+     * @param key Storage key
+     * @returns TableConfig or null if not found
+     */
+    loadFromLocalStorage(key = 'smart-table-definition') {
+        try {
+            const stored = localStorage.getItem(key);
+            if (!stored) {
+                return null;
+            }
+            return JSON.parse(stored);
+        }
+        catch (error) {
+            console.error('Failed to load from localStorage:', error);
+            return null;
+        }
+    }
+    /**
+     * Sanitize config for JSON serialization
+     * Removes functions, circular references, and other non-serializable values
+     */
+    sanitizeForJSON(config) {
+        const sanitized = {
+            columns: config.columns.map(col => this.sanitizeColumn(col)),
+            pagination: config.pagination,
+            sorting: config.sorting,
+            filtering: config.filtering,
+            display: config.display,
+            initialState: config.initialState
+        };
+        // Remove undefined values
+        Object.keys(sanitized).forEach(key => {
+            if (sanitized[key] === undefined) {
+                delete sanitized[key];
+            }
+        });
+        return sanitized;
+    }
+    /**
+     * Sanitize column config for JSON serialization
+     */
+    sanitizeColumn(column) {
+        const sanitized = {
+            key: column.key,
+            header: column.header,
+            dataType: column.dataType,
+            editable: column.editable,
+            sortable: column.sortable,
+            filterable: column.filterable,
+            resizable: column.resizable,
+            width: column.width,
+            minWidth: column.minWidth,
+            maxWidth: column.maxWidth,
+            sticky: column.sticky,
+            alignment: column.alignment,
+            verticalAlignment: column.verticalAlignment,
+            className: column.className,
+            style: column.style,
+            tooltip: column.tooltip,
+            visible: column.visible,
+            pinned: column.pinned,
+            sortPriority: column.sortPriority,
+            metadata: column.metadata
+        };
+        // Remove undefined values
+        Object.keys(sanitized).forEach(key => {
+            if (sanitized[key] === undefined) {
+                delete sanitized[key];
+            }
+        });
+        // Note: formatter, validator, editor, parser, hooks are functions
+        // and cannot be serialized to JSON. They will need to be recreated
+        // when importing, or stored separately as metadata.
+        return sanitized;
+    }
+    /**
+     * Download file helper
+     */
+    downloadFile(content, fileName, mimeType) {
+        const blob = new Blob([content], { type: mimeType });
+        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);
+    }
+}
+DefinitionExportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionExportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DefinitionExportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionExportService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition-export.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-table/src/lib/builder/services/definition-export.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Definition export service\n * Handles exporting TableConfig to JSON or TypeScript\n */\n\nimport { Injectable } from '@angular/core';\nimport { TableConfig } from '../../models/table-config.interface';\nimport { ExportOptions } from '../models/builder-state.interface';\nimport { generateTypeScriptCode, TypeScriptGeneratorOptions } from '../utils/typescript-generator.util';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefinitionExportService {\n  /**\n   * Export TableConfig to JSON string\n   * @param config Table configuration\n   * @param pretty Whether to format JSON with indentation\n   * @returns JSON string\n   */\n  exportToJSON(config: TableConfig, pretty: boolean = true): string {\n    // Create a serializable version (remove functions, circular refs)\n    const serializable = this.sanitizeForJSON(config);\n\n    if (pretty) {\n      return JSON.stringify(serializable, null, 2);\n    } else {\n      return JSON.stringify(serializable);\n    }\n  }\n\n  /**\n   * Export TableConfig to TypeScript code\n   * @param config Table configuration\n   * @param options Generation options\n   * @returns TypeScript code string\n   */\n  exportToTypeScript(config: TableConfig, options: TypeScriptGeneratorOptions = {}): string {\n    return generateTypeScriptCode(config, options);\n  }\n\n  /**\n   * Download configuration as JSON file\n   * @param config Table configuration\n   * @param fileName File name (without extension)\n   */\n  downloadAsJSON(config: TableConfig, fileName: string = 'table-config'): void {\n    const json = this.exportToJSON(config);\n    this.downloadFile(json, `${fileName}.json`, 'application/json');\n  }\n\n  /**\n   * Download configuration as TypeScript file\n   * @param config Table configuration\n   * @param fileName File name (without extension)\n   * @param options Generation options\n   */\n  downloadAsTypeScript(\n    config: TableConfig,\n    fileName: string = 'table-config',\n    options: TypeScriptGeneratorOptions = {}\n  ): void {\n    const code = this.exportToTypeScript(config, options);\n    this.downloadFile(code, `${fileName}.ts`, 'text/typescript');\n  }\n\n  /**\n   * Save configuration to localStorage\n   * @param config Table configuration\n   * @param key Storage key\n   */\n  saveToLocalStorage(config: TableConfig, key: string = 'smart-table-definition'): void {\n    try {\n      const json = this.exportToJSON(config, false);\n      localStorage.setItem(key, json);\n    } catch (error) {\n      console.error('Failed to save to localStorage:', error);\n      throw error;\n    }\n  }\n\n  /**\n   * Load configuration from localStorage\n   * @param key Storage key\n   * @returns TableConfig or null if not found\n   */\n  loadFromLocalStorage(key: string = 'smart-table-definition'): TableConfig | null {\n    try {\n      const stored = localStorage.getItem(key);\n      if (!stored) {\n        return null;\n      }\n\n      return JSON.parse(stored) as TableConfig;\n    } catch (error) {\n      console.error('Failed to load from localStorage:', error);\n      return null;\n    }\n  }\n\n  /**\n   * Sanitize config for JSON serialization\n   * Removes functions, circular references, and other non-serializable values\n   */\n  private sanitizeForJSON(config: TableConfig): any {\n    const sanitized: any = {\n      columns: config.columns.map(col => this.sanitizeColumn(col)),\n      pagination: config.pagination,\n      sorting: config.sorting,\n      filtering: config.filtering,\n      display: config.display,\n      initialState: config.initialState\n    };\n\n    // Remove undefined values\n    Object.keys(sanitized).forEach(key => {\n      if (sanitized[key] === undefined) {\n        delete sanitized[key];\n      }\n    });\n\n    return sanitized;\n  }\n\n  /**\n   * Sanitize column config for JSON serialization\n   */\n  private sanitizeColumn(column: any): any {\n    const sanitized: any = {\n      key: column.key,\n      header: column.header,\n      dataType: column.dataType,\n      editable: column.editable,\n      sortable: column.sortable,\n      filterable: column.filterable,\n      resizable: column.resizable,\n      width: column.width,\n      minWidth: column.minWidth,\n      maxWidth: column.maxWidth,\n      sticky: column.sticky,\n      alignment: column.alignment,\n      verticalAlignment: column.verticalAlignment,\n      className: column.className,\n      style: column.style,\n      tooltip: column.tooltip,\n      visible: column.visible,\n      pinned: column.pinned,\n      sortPriority: column.sortPriority,\n      metadata: column.metadata\n    };\n\n    // Remove undefined values\n    Object.keys(sanitized).forEach(key => {\n      if (sanitized[key] === undefined) {\n        delete sanitized[key];\n      }\n    });\n\n    // Note: formatter, validator, editor, parser, hooks are functions\n    // and cannot be serialized to JSON. They will need to be recreated\n    // when importing, or stored separately as metadata.\n\n    return sanitized;\n  }\n\n  /**\n   * Download file helper\n   */\n  private downloadFile(content: string, fileName: string, mimeType: string): void {\n    const blob = new Blob([content], { type: mimeType });\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"]}

package/esm2020/lib/builder/services/definition-import.service.mjs

@@ -0,0 +1,193 @@
+/**
+ * Definition import service
+ * Handles importing TableConfig from JSON with validation
+ */
+import { Injectable } from '@angular/core';
+import { mergeTableConfig } from '../../models/table-config.interface';
+import { validateTableConfig } from '../utils/config-validator.util';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/json-schema-validator.service";
+import * as i2 from "../../services/validation-logger.service";
+export class DefinitionImportService {
+    constructor(schemaValidator, logger) {
+        this.schemaValidator = schemaValidator;
+        this.logger = logger;
+    }
+    /**
+     * Import TableConfig from JSON string
+     * @param jsonString JSON string to parse
+     * @param skipSchemaValidation Skip JSON schema validation (use custom validation only)
+     * @param fileName Optional filename for logging context
+     * @returns Import result with success status and config or errors
+     */
+    importFromJSON(jsonString, skipSchemaValidation = false, fileName) {
+        try {
+            // Parse JSON
+            const parsed = JSON.parse(jsonString);
+            // Validate structure
+            if (!parsed || typeof parsed !== 'object') {
+                return {
+                    success: false,
+                    error: 'Invalid JSON: root must be an object',
+                    validationErrors: ['Root must be an object']
+                };
+            }
+            // JSON Schema validation (if enabled and available)
+            let schemaErrors = [];
+            if (!skipSchemaValidation && this.schemaValidator.isAvailable()) {
+                const schemaResult = this.schemaValidator.validateJSONString(jsonString, true);
+                if (!schemaResult.valid) {
+                    schemaErrors = schemaResult.errors;
+                }
+            }
+            // Check for columns array (basic validation)
+            if (!parsed.columns || !Array.isArray(parsed.columns)) {
+                return {
+                    success: false,
+                    error: 'Invalid configuration: columns array is required',
+                    validationErrors: [
+                        'Columns array is required',
+                        ...schemaErrors.map(err => `${err.field || err.path}: ${err.message}`)
+                    ]
+                };
+            }
+            // Create TableConfig object
+            const tableConfig = {
+                columns: parsed.columns,
+                pagination: parsed.pagination,
+                sorting: parsed.sorting,
+                filtering: parsed.filtering,
+                display: parsed.display,
+                initialState: parsed.initialState
+            };
+            // Merge with defaults
+            const mergedConfig = mergeTableConfig(tableConfig);
+            // Custom validation (for additional business rules)
+            const customValidationErrors = validateTableConfig(mergedConfig);
+            // Combine all validation errors
+            const allErrors = [
+                ...schemaErrors.map(err => `${err.field || err.path}: ${err.message}`),
+                ...customValidationErrors.map(err => `${err.field}: ${err.message}`)
+            ];
+            if (allErrors.length > 0) {
+                // Log validation errors
+                const allSchemaErrors = [
+                    ...schemaErrors,
+                    ...customValidationErrors.map(err => ({
+                        path: err.field || '',
+                        message: err.message,
+                        code: err.code || 'VALIDATION_ERROR',
+                        field: err.field
+                    }))
+                ];
+                this.logger.logValidationErrors(allSchemaErrors, 'import', {
+                    fileName: fileName,
+                    configSnippet: jsonString.substring(0, 500) // Include first 500 chars as context
+                });
+                return {
+                    success: false,
+                    error: 'Configuration validation failed',
+                    validationErrors: allErrors
+                };
+            }
+            return {
+                success: true,
+                tableConfig: mergedConfig
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to parse JSON: ${error.message}`,
+                validationErrors: [error.message]
+            };
+        }
+    }
+    /**
+     * Import TableConfig from File object
+     * @param file File to read
+     * @returns Promise with import result
+     */
+    async importFromFile(file) {
+        return new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onload = (event) => {
+                const content = event.target?.result;
+                const result = this.importFromJSON(content, true, file.name);
+                resolve(result);
+            };
+            reader.onerror = () => {
+                const errorResult = {
+                    success: false,
+                    error: 'Failed to read file',
+                    validationErrors: ['File read error']
+                };
+                // Log file read error
+                this.logger.logValidationErrors([{
+                        path: '',
+                        message: 'Failed to read file',
+                        code: 'FILE_READ_ERROR',
+                        field: 'root'
+                    }], 'import', {
+                    fileName: file.name
+                });
+                resolve(errorResult);
+            };
+            reader.readAsText(file);
+        });
+    }
+    /**
+     * Import TableConfig from localStorage
+     * @param key Storage key
+     * @returns Import result
+     */
+    importFromLocalStorage(key = 'smart-table-definition') {
+        try {
+            const stored = localStorage.getItem(key);
+            if (!stored) {
+                const errorResult = {
+                    success: false,
+                    error: 'No data found in localStorage',
+                    validationErrors: ['No data found']
+                };
+                // Log localStorage read error
+                this.logger.logValidationErrors([{
+                        path: '',
+                        message: 'No data found in localStorage',
+                        code: 'STORAGE_NOT_FOUND',
+                        field: 'root'
+                    }], 'import', {
+                    storageKey: key
+                });
+                return errorResult;
+            }
+            return this.importFromJSON(stored, true, undefined);
+        }
+        catch (error) {
+            const errorResult = {
+                success: false,
+                error: `Failed to read from localStorage: ${error.message}`,
+                validationErrors: [error.message]
+            };
+            // Log localStorage error
+            this.logger.logValidationErrors([{
+                    path: '',
+                    message: `Failed to read from localStorage: ${error.message}`,
+                    code: 'STORAGE_READ_ERROR',
+                    field: 'root'
+                }], 'import', {
+                storageKey: key
+            });
+            return errorResult;
+        }
+    }
+}
+DefinitionImportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionImportService, deps: [{ token: i1.JsonSchemaValidatorService }, { token: i2.ValidationLoggerService }], target: i0.ɵɵFactoryTarget.Injectable });
+DefinitionImportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionImportService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DefinitionImportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.JsonSchemaValidatorService }, { type: i2.ValidationLoggerService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition-import.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-table/src/lib/builder/services/definition-import.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Definition import service\n * Handles importing TableConfig from JSON with validation\n */\n\nimport { Injectable } from '@angular/core';\nimport { TableConfig, mergeTableConfig } from '../../models/table-config.interface';\nimport { ImportResult, ValidationError } from '../models/builder-state.interface';\nimport { validateTableConfig } from '../utils/config-validator.util';\nimport { JsonSchemaValidatorService } from '../../services/json-schema-validator.service';\nimport { SchemaValidationError } from '../../models/schema-validation.interface';\nimport { ValidationLoggerService } from '../../services/validation-logger.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DefinitionImportService {\n  constructor(\n    private schemaValidator: JsonSchemaValidatorService,\n    private logger: ValidationLoggerService\n  ) {}\n  /**\n   * Import TableConfig from JSON string\n   * @param jsonString JSON string to parse\n   * @param skipSchemaValidation Skip JSON schema validation (use custom validation only)\n   * @param fileName Optional filename for logging context\n   * @returns Import result with success status and config or errors\n   */\n  importFromJSON(jsonString: string, skipSchemaValidation: boolean = false, fileName?: string): ImportResult {\n    try {\n      // Parse JSON\n      const parsed = JSON.parse(jsonString);\n\n      // Validate structure\n      if (!parsed || typeof parsed !== 'object') {\n        return {\n          success: false,\n          error: 'Invalid JSON: root must be an object',\n          validationErrors: ['Root must be an object']\n        };\n      }\n\n      // JSON Schema validation (if enabled and available)\n      let schemaErrors: SchemaValidationError[] = [];\n      if (!skipSchemaValidation && this.schemaValidator.isAvailable()) {\n        const schemaResult = this.schemaValidator.validateJSONString(jsonString, true);\n        if (!schemaResult.valid) {\n          schemaErrors = schemaResult.errors;\n        }\n      }\n\n      // Check for columns array (basic validation)\n      if (!parsed.columns || !Array.isArray(parsed.columns)) {\n        return {\n          success: false,\n          error: 'Invalid configuration: columns array is required',\n          validationErrors: [\n            'Columns array is required',\n            ...schemaErrors.map(err => `${err.field || err.path}: ${err.message}`)\n          ]\n        };\n      }\n\n      // Create TableConfig object\n      const tableConfig: TableConfig = {\n        columns: parsed.columns,\n        pagination: parsed.pagination,\n        sorting: parsed.sorting,\n        filtering: parsed.filtering,\n        display: parsed.display,\n        initialState: parsed.initialState\n      };\n\n      // Merge with defaults\n      const mergedConfig = mergeTableConfig(tableConfig);\n\n      // Custom validation (for additional business rules)\n      const customValidationErrors = validateTableConfig(mergedConfig);\n      \n      // Combine all validation errors\n      const allErrors = [\n        ...schemaErrors.map(err => `${err.field || err.path}: ${err.message}`),\n        ...customValidationErrors.map(err => `${err.field}: ${err.message}`)\n      ];\n\n      if (allErrors.length > 0) {\n        // Log validation errors\n        const allSchemaErrors: SchemaValidationError[] = [\n          ...schemaErrors,\n          ...customValidationErrors.map(err => ({\n            path: err.field || '',\n            message: err.message,\n            code: err.code || 'VALIDATION_ERROR',\n            field: err.field\n          }))\n        ];\n        \n        this.logger.logValidationErrors(allSchemaErrors, 'import', {\n          fileName: fileName,\n          configSnippet: jsonString.substring(0, 500) // Include first 500 chars as context\n        });\n\n        return {\n          success: false,\n          error: 'Configuration validation failed',\n          validationErrors: allErrors\n        };\n      }\n\n      return {\n        success: true,\n        tableConfig: mergedConfig\n      };\n    } catch (error: any) {\n      return {\n        success: false,\n        error: `Failed to parse JSON: ${error.message}`,\n        validationErrors: [error.message]\n      };\n    }\n  }\n\n  /**\n   * Import TableConfig from File object\n   * @param file File to read\n   * @returns Promise with import result\n   */\n  async importFromFile(file: File): Promise<ImportResult> {\n    return new Promise((resolve) => {\n      const reader = new FileReader();\n\n      reader.onload = (event) => {\n        const content = event.target?.result as string;\n        const result = this.importFromJSON(content, true, file.name);\n        resolve(result);\n      };\n\n      reader.onerror = () => {\n        const errorResult = {\n          success: false,\n          error: 'Failed to read file',\n          validationErrors: ['File read error']\n        };\n        \n        // Log file read error\n        this.logger.logValidationErrors([{\n          path: '',\n          message: 'Failed to read file',\n          code: 'FILE_READ_ERROR',\n          field: 'root'\n        }], 'import', {\n          fileName: file.name\n        });\n        \n        resolve(errorResult);\n      };\n\n      reader.readAsText(file);\n    });\n  }\n\n  /**\n   * Import TableConfig from localStorage\n   * @param key Storage key\n   * @returns Import result\n   */\n  importFromLocalStorage(key: string = 'smart-table-definition'): ImportResult {\n    try {\n      const stored = localStorage.getItem(key);\n      if (!stored) {\n        const errorResult = {\n          success: false,\n          error: 'No data found in localStorage',\n          validationErrors: ['No data found']\n        };\n        \n        // Log localStorage read error\n        this.logger.logValidationErrors([{\n          path: '',\n          message: 'No data found in localStorage',\n          code: 'STORAGE_NOT_FOUND',\n          field: 'root'\n        }], 'import', {\n          storageKey: key\n        });\n        \n        return errorResult;\n      }\n\n      return this.importFromJSON(stored, true, undefined);\n    } catch (error: any) {\n      const errorResult = {\n        success: false,\n        error: `Failed to read from localStorage: ${error.message}`,\n        validationErrors: [error.message]\n      };\n      \n      // Log localStorage error\n      this.logger.logValidationErrors([{\n        path: '',\n        message: `Failed to read from localStorage: ${error.message}`,\n        code: 'STORAGE_READ_ERROR',\n        field: 'root'\n      }], 'import', {\n        storageKey: key\n      });\n      \n      return errorResult;\n    }\n  }\n}\n\n"]}

package/esm2020/lib/builder/services/sample-data-generator.service.mjs

@@ -0,0 +1,126 @@
+/**
+ * Sample data generator service
+ * Generates sample data for preview based on column configurations
+ */
+import { Injectable } from '@angular/core';
+import { CellDataType } from '../../models/cell-types';
+import * as i0 from "@angular/core";
+export class SampleDataGeneratorService {
+    /**
+     * Generate sample data based on column configurations
+     * @param columns Column configurations
+     * @param rowCount Number of rows to generate
+     * @returns Array of sample data objects
+     */
+    generateSampleData(columns, rowCount = 5) {
+        return Array.from({ length: rowCount }, (_, index) => {
+            const row = {};
+            columns.forEach(column => {
+                row[column.key] = this.generateValueForColumn(column, index, columns);
+            });
+            return row;
+        });
+    }
+    /**
+     * Generate a sample value for a specific column
+     * @param column Column configuration
+     * @param rowIndex Row index (for variation)
+     * @param allColumns All columns (for valueGetter context)
+     * @returns Sample value
+     */
+    generateValueForColumn(column, rowIndex, allColumns) {
+        // Use valueGetter if provided
+        if (column.valueGetter && allColumns) {
+            // For preview, we'll generate a simple object
+            const sampleRow = this.generateBasicSampleRow(allColumns);
+            return column.valueGetter(sampleRow);
+        }
+        // Generate based on dataType
+        switch (column.dataType) {
+            case CellDataType.STRING:
+                return this.generateStringValue(column, rowIndex);
+            case CellDataType.NUMBER:
+                return this.generateNumberValue(column, rowIndex);
+            case CellDataType.DATE:
+                return this.generateDateValue(rowIndex);
+            case CellDataType.BOOLEAN:
+                return this.generateBooleanValue(rowIndex);
+            default:
+                return this.generateStringValue(column, rowIndex);
+        }
+    }
+    /**
+     * Generate a basic sample row for valueGetter
+     */
+    generateBasicSampleRow(columns) {
+        const row = {};
+        columns.forEach(col => {
+            row[col.key] = `Sample ${col.key}`;
+        });
+        return row;
+    }
+    /**
+     * Generate string value
+     */
+    generateStringValue(column, rowIndex) {
+        const key = column.key;
+        const samples = {
+            name: ['John Doe', 'Jane Smith', 'Bob Johnson', 'Alice Williams', 'Charlie Brown'],
+            email: ['john@example.com', 'jane@example.com', 'bob@example.com', 'alice@example.com', 'charlie@example.com'],
+            title: ['Manager', 'Developer', 'Designer', 'Analyst', 'Director'],
+            status: ['Active', 'Inactive', 'Pending', 'Approved', 'Rejected'],
+            city: ['New York', 'London', 'Tokyo', 'Paris', 'Sydney'],
+            country: ['USA', 'UK', 'Japan', 'France', 'Australia']
+        };
+        // Check if we have predefined samples for this key
+        if (samples[key]) {
+            return samples[key][rowIndex % samples[key].length];
+        }
+        // Generate generic string
+        return `${key.charAt(0).toUpperCase() + key.slice(1)} ${rowIndex + 1}`;
+    }
+    /**
+     * Generate number value
+     */
+    generateNumberValue(column, rowIndex) {
+        const key = column.key.toLowerCase();
+        // Special handling for common numeric fields
+        if (key.includes('age')) {
+            return 20 + (rowIndex * 5) + Math.floor(Math.random() * 10);
+        }
+        if (key.includes('price') || key.includes('cost') || key.includes('amount') || key.includes('salary')) {
+            return (rowIndex + 1) * 1000 + Math.floor(Math.random() * 500);
+        }
+        if (key.includes('quantity') || key.includes('count')) {
+            return (rowIndex + 1) * 10;
+        }
+        if (key.includes('id')) {
+            return rowIndex + 1;
+        }
+        // Generic number
+        return (rowIndex + 1) * 100;
+    }
+    /**
+     * Generate date value
+     */
+    generateDateValue(rowIndex) {
+        const baseDate = new Date(2024, 0, 1);
+        baseDate.setDate(baseDate.getDate() + rowIndex * 7); // Increment by weeks
+        return baseDate;
+    }
+    /**
+     * Generate boolean value
+     */
+    generateBooleanValue(rowIndex) {
+        return rowIndex % 2 === 0;
+    }
+}
+SampleDataGeneratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SampleDataGeneratorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SampleDataGeneratorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SampleDataGeneratorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SampleDataGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sample-data-generator.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-table/src/lib/builder/services/sample-data-generator.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Sample data generator service\n * Generates sample data for preview based on column configurations\n */\n\nimport { Injectable } from '@angular/core';\nimport { ColumnConfig } from '../../models/column-config.interface';\nimport { CellDataType } from '../../models/cell-types';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SampleDataGeneratorService {\n  /**\n   * Generate sample data based on column configurations\n   * @param columns Column configurations\n   * @param rowCount Number of rows to generate\n   * @returns Array of sample data objects\n   */\n  generateSampleData(columns: ColumnConfig[], rowCount: number = 5): any[] {\n    return Array.from({ length: rowCount }, (_, index) => {\n      const row: any = {};\n      columns.forEach(column => {\n        row[column.key] = this.generateValueForColumn(column, index, columns);\n      });\n      return row;\n    });\n  }\n\n  /**\n   * Generate a sample value for a specific column\n   * @param column Column configuration\n   * @param rowIndex Row index (for variation)\n   * @param allColumns All columns (for valueGetter context)\n   * @returns Sample value\n   */\n  private generateValueForColumn(column: ColumnConfig, rowIndex: number, allColumns?: ColumnConfig[]): any {\n    // Use valueGetter if provided\n    if (column.valueGetter && allColumns) {\n      // For preview, we'll generate a simple object\n      const sampleRow = this.generateBasicSampleRow(allColumns);\n      return column.valueGetter(sampleRow);\n    }\n\n    // Generate based on dataType\n    switch (column.dataType) {\n      case CellDataType.STRING:\n        return this.generateStringValue(column, rowIndex);\n      case CellDataType.NUMBER:\n        return this.generateNumberValue(column, rowIndex);\n      case CellDataType.DATE:\n        return this.generateDateValue(rowIndex);\n      case CellDataType.BOOLEAN:\n        return this.generateBooleanValue(rowIndex);\n      default:\n        return this.generateStringValue(column, rowIndex);\n    }\n  }\n\n  /**\n   * Generate a basic sample row for valueGetter\n   */\n  private generateBasicSampleRow(columns: ColumnConfig[]): any {\n    const row: any = {};\n    columns.forEach(col => {\n      row[col.key] = `Sample ${col.key}`;\n    });\n    return row;\n  }\n\n  /**\n   * Generate string value\n   */\n  private generateStringValue(column: ColumnConfig, rowIndex: number): string {\n    const key = column.key;\n    const samples: Record<string, string[]> = {\n      name: ['John Doe', 'Jane Smith', 'Bob Johnson', 'Alice Williams', 'Charlie Brown'],\n      email: ['john@example.com', 'jane@example.com', 'bob@example.com', 'alice@example.com', 'charlie@example.com'],\n      title: ['Manager', 'Developer', 'Designer', 'Analyst', 'Director'],\n      status: ['Active', 'Inactive', 'Pending', 'Approved', 'Rejected'],\n      city: ['New York', 'London', 'Tokyo', 'Paris', 'Sydney'],\n      country: ['USA', 'UK', 'Japan', 'France', 'Australia']\n    };\n\n    // Check if we have predefined samples for this key\n    if (samples[key]) {\n      return samples[key][rowIndex % samples[key].length];\n    }\n\n    // Generate generic string\n    return `${key.charAt(0).toUpperCase() + key.slice(1)} ${rowIndex + 1}`;\n  }\n\n  /**\n   * Generate number value\n   */\n  private generateNumberValue(column: ColumnConfig, rowIndex: number): number {\n    const key = column.key.toLowerCase();\n    \n    // Special handling for common numeric fields\n    if (key.includes('age')) {\n      return 20 + (rowIndex * 5) + Math.floor(Math.random() * 10);\n    }\n    if (key.includes('price') || key.includes('cost') || key.includes('amount') || key.includes('salary')) {\n      return (rowIndex + 1) * 1000 + Math.floor(Math.random() * 500);\n    }\n    if (key.includes('quantity') || key.includes('count')) {\n      return (rowIndex + 1) * 10;\n    }\n    if (key.includes('id')) {\n      return rowIndex + 1;\n    }\n\n    // Generic number\n    return (rowIndex + 1) * 100;\n  }\n\n  /**\n   * Generate date value\n   */\n  private generateDateValue(rowIndex: number): Date {\n    const baseDate = new Date(2024, 0, 1);\n    baseDate.setDate(baseDate.getDate() + rowIndex * 7); // Increment by weeks\n    return baseDate;\n  }\n\n  /**\n   * Generate boolean value\n   */\n  private generateBooleanValue(rowIndex: number): boolean {\n    return rowIndex % 2 === 0;\n  }\n}\n\n"]}