svger-cli 2.0.1 → 2.0.2

package/src/processors/svg-processor.ts

@@ -1,288 +0,0 @@
-import path from 'path';
-import { toPascalCase, FileSystem } from '../utils/native.js';
-import { ComponentGenerationOptions, SVGProcessorResult, ProcessingJob, ProcessingStatus } from '../types/index.js';
-import { logger } from '../core/logger.js';
-import { pluginManager } from '../core/plugin-manager.js';
-import { templateManager } from '../core/template-manager.js';
-import { performanceEngine } from '../core/performance-engine.js';
-import { frameworkTemplateEngine } from '../core/framework-templates.js';
-
-/**
- * SVG content processor and component generator
- */
-export class SVGProcessor {
-  private static instance: SVGProcessor;
-  private processingQueue: Map<string, ProcessingJob> = new Map();
-  private jobCounter = 0;
-
-  private constructor() {}
-
-  public static getInstance(): SVGProcessor {
-    if (!SVGProcessor.instance) {
-      SVGProcessor.instance = new SVGProcessor();
-    }
-    return SVGProcessor.instance;
-  }
-
-  /**
-   * Clean and optimize SVG content
-   */
-  public cleanSVGContent(svgContent: string): string {
-    logger.debug('Cleaning SVG content');
-
-    return svgContent
-      // Remove XML declaration
-      .replace(/<\?xml.*?\?>/g, '')
-      // Remove DOCTYPE declaration
-      .replace(/<!DOCTYPE.*?>/g, '')
-      // Remove comments
-      .replace(/<!--[\s\S]*?-->/g, '')
-      // Normalize whitespace
-      .replace(/\r?\n|\r/g, '')
-      .replace(/\s{2,}/g, ' ')
-      // Remove inline styles (they interfere with React styling)
-      .replace(/style="[^"]*"/g, '')
-      // Remove xmlns attributes (React will handle these)
-      .replace(/\s+xmlns(:xlink)?="[^"]*"/g, '')
-      // Convert attributes to camelCase for React
-      .replace(/fill-rule/g, 'fillRule')
-      .replace(/clip-rule/g, 'clipRule')
-      .replace(/stroke-width/g, 'strokeWidth')
-      .replace(/stroke-linecap/g, 'strokeLinecap')
-      .replace(/stroke-linejoin/g, 'strokeLinejoin')
-      .replace(/stroke-miterlimit/g, 'strokeMiterlimit')
-      .replace(/stroke-dasharray/g, 'strokeDasharray')
-      .replace(/stroke-dashoffset/g, 'strokeDashoffset')
-      .replace(/font-family/g, 'fontFamily')
-      .replace(/font-size/g, 'fontSize')
-      .replace(/font-weight/g, 'fontWeight')
-      .replace(/text-anchor/g, 'textAnchor')
-      // Remove outer SVG tag and keep inner content
-      .trim()
-      .replace(/^<svg[^>]*>([\s\S]*)<\/svg>$/i, '$1')
-      .trim();
-  }
-
-  /**
-   * Extract viewBox from SVG content
-   */
-  public extractViewBox(svgContent: string): string | null {
-    const viewBoxMatch = svgContent.match(/viewBox=["']([^"']+)["']/i);
-    return viewBoxMatch ? viewBoxMatch[1] : null;
-  }
-
-  /**
-   * Generate component name from filename
-   */
-  public generateComponentName(fileName: string): string {
-    const baseName = path.basename(fileName, '.svg');
-    const componentName = toPascalCase(baseName);
-    
-    // Ensure component name starts with uppercase letter
-    if (!/^[A-Z]/.test(componentName)) {
-      return `Svg${componentName}`;
-    }
-    
-    return componentName;
-  }
-
-  /**
-   * Generate React component from SVG content
-   */
-  public async generateComponent(
-    componentName: string,
-    svgContent: string,
-    options: Partial<ComponentGenerationOptions> = {}
-  ): Promise<string> {
-    try {
-      // Clean and optimize SVG content
-      const cleanedContent = this.cleanSVGContent(svgContent);
-      
-      // Apply plugins (no plugin configs for now, just process directly)
-      const processedContent = cleanedContent;
-      
-      // Create full options object with required fields
-      const fullOptions: ComponentGenerationOptions = {
-        componentName,
-        svgContent: processedContent,
-        framework: options.framework || 'react',
-        typescript: options.typescript !== undefined ? options.typescript : true,
-        ...options
-      };
-      
-      // Use framework template engine directly
-      const component = frameworkTemplateEngine.generateComponent(fullOptions);
-
-      logger.debug(`Generated component: ${componentName}`);
-      return component;
-
-    } catch (error) {
-      logger.error(`Failed to generate component ${componentName}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Generate framework-agnostic component from SVG content
-   */
-  public async generateFrameworkComponent(
-    componentName: string,
-    svgContent: string,
-    options: ComponentGenerationOptions
-  ): Promise<string> {
-    try {
-      // Optimize SVG content based on framework requirements
-      const optimizationLevel = options.framework === 'vanilla' ? 'maximum' : 'balanced';
-      const optimizedContent = performanceEngine.optimizeSVGContent(svgContent, optimizationLevel);
-      
-      // Generate framework-specific component
-      const component = frameworkTemplateEngine.generateComponent({
-        ...options,
-        componentName,
-        svgContent: optimizedContent
-      });
-
-      logger.debug(`Generated ${options.framework} component: ${componentName}`);
-      return component;
-
-    } catch (error) {
-      logger.error(`Failed to generate ${options.framework} component ${componentName}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Process multiple SVG files in batch with performance optimization
-   */
-  public async processBatch(
-    files: Array<{ path: string; outputDir: string; options?: Partial<ComponentGenerationOptions> }>,
-    config: { batchSize?: number; parallel?: boolean; maxConcurrency?: number } = {}
-  ): Promise<Array<{ success: boolean; filePath: string; error?: Error; duration: number }>> {
-    logger.info(`Starting batch processing of ${files.length} files`);
-    
-    try {
-      const results = await performanceEngine.processBatch(files, config);
-      
-      // Log performance metrics
-      const metrics = performanceEngine.getPerformanceMetrics();
-      if (metrics.memoryUsage.recommendations.length > 0) {
-        logger.warn('Performance recommendations:', metrics.memoryUsage.recommendations);
-      }
-      
-      return results;
-    } catch (error) {
-      logger.error('Batch processing failed:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Process a single SVG file
-   */
-  public async processSVGFile(
-    svgFilePath: string,
-    outputDir: string,
-    options: Partial<ComponentGenerationOptions> = {}
-  ): Promise<SVGProcessorResult> {
-    const jobId = `job-${++this.jobCounter}`;
-    const job: ProcessingJob = {
-      id: jobId,
-      filePath: svgFilePath,
-      status: 'processing',
-      startTime: Date.now()
-    };
-
-    this.processingQueue.set(jobId, job);
-    logger.debug(`Processing SVG file: ${svgFilePath}`);
-
-    try {
-      // Read SVG content
-      const svgContent = await FileSystem.readFile(svgFilePath, 'utf-8');
-      
-      // Generate component name
-      const componentName = this.generateComponentName(path.basename(svgFilePath));
-      
-      // Generate component code
-      const componentCode = await this.generateComponent(
-        componentName,
-        svgContent,
-        options
-      );
-
-      // Ensure output directory exists
-      await FileSystem.ensureDir(outputDir);
-
-      // Get correct file extension based on framework
-      const framework = options.framework || 'react';
-      const typescript = options.typescript !== undefined ? options.typescript : true;
-      const fileExtension = frameworkTemplateEngine.getFileExtension(framework, typescript);
-
-      // Write component file
-      const outputFilePath = path.join(outputDir, `${componentName}.${fileExtension}`);
-      await FileSystem.writeFile(outputFilePath, componentCode, 'utf-8');
-
-      // Update job status
-      job.status = 'completed';
-      job.endTime = Date.now();
-
-      const result: SVGProcessorResult = {
-        success: true,
-        componentName,
-        filePath: outputFilePath
-      };
-
-      logger.success(`Generated component: ${componentName}.${fileExtension}`);
-      return result;
-
-    } catch (error) {
-      job.status = 'failed';
-      job.endTime = Date.now();
-      job.error = error as Error;
-
-      const result: SVGProcessorResult = {
-        success: false,
-        componentName: '',
-        filePath: svgFilePath,
-        error: error as Error
-      };
-
-      logger.error(`Failed to process ${svgFilePath}:`, error);
-      return result;
-    } finally {
-      // Clean up completed jobs after some time
-      setTimeout(() => {
-        this.processingQueue.delete(jobId);
-      }, 30000); // 30 seconds
-    }
-  }
-
-  /**
-   * Get processing statistics
-   */
-  public getProcessingStats(): {
-    total: number;
-    pending: number;
-    processing: number;
-    completed: number;
-    failed: number;
-  } {
-    const jobs = Array.from(this.processingQueue.values());
-    return {
-      total: jobs.length,
-      pending: jobs.filter(j => j.status === 'pending').length,
-      processing: jobs.filter(j => j.status === 'processing').length,
-      completed: jobs.filter(j => j.status === 'completed').length,
-      failed: jobs.filter(j => j.status === 'failed').length,
-    };
-  }
-
-  /**
-   * Clear processing queue
-   */
-  public clearQueue(): void {
-    this.processingQueue.clear();
-  }
-}
-
-// Export singleton instance
-export const svgProcessor = SVGProcessor.getInstance();

package/src/services/config.ts

@@ -1,241 +0,0 @@
-import path from 'path';
-import { FileSystem } from '../utils/native.js';
-import { SVGConfig } from '../types/index.js';
-import { logger } from '../core/logger.js';
-
-/**
- * Professional configuration management service
- */
-export class ConfigService {
-  private static instance: ConfigService;
-  private static readonly CONFIG_FILE = '.svgconfig.json';
-  private cachedConfig: SVGConfig | null = null;
-
-  private constructor() {}
-
-  public static getInstance(): ConfigService {
-    if (!ConfigService.instance) {
-      ConfigService.instance = new ConfigService();
-    }
-    return ConfigService.instance;
-  }
-
-  /**
-   * Get the default configuration
-   */
-  public getDefaultConfig(): SVGConfig {
-    return {
-      source: './src/assets/svg',
-      output: './src/components/icons',
-      framework: 'react',
-      typescript: true,
-      watch: false,
-      defaultWidth: 24,
-      defaultHeight: 24,
-      defaultFill: 'currentColor',
-      exclude: [],
-      styleRules: {
-        fill: 'inherit',
-        stroke: 'none',
-      },
-      plugins: [],
-      template: {
-        type: 'default'
-      },
-      frameworkOptions: {
-        forwardRef: true,
-        memo: false,
-        scriptSetup: true,
-        standalone: true
-      },
-      errorHandling: {
-        skipOnError: false,
-        logLevel: 'info',
-        maxRetries: 3
-      },
-      performance: {
-        batchSize: 10,
-        parallel: true,
-        timeout: 30000,
-        enableCache: true
-      }
-    };
-  }
-
-  /**
-   * Get configuration file path
-   */
-  private getConfigPath(): string {
-    return path.resolve(ConfigService.CONFIG_FILE);
-  }
-
-  /**
-   * Read configuration from file with caching
-   */
-  public readConfig(): SVGConfig {
-    if (this.cachedConfig) {
-      return { ...this.cachedConfig };
-    }
-
-    try {
-      const configData = FileSystem.readJSONSync(this.getConfigPath());
-      
-      if (Object.keys(configData).length === 0) {
-        logger.debug('No configuration found, using defaults');
-        this.cachedConfig = this.getDefaultConfig();
-        return this.cachedConfig;
-      }
-
-      // Merge with defaults to ensure all required properties exist
-      this.cachedConfig = {
-        ...this.getDefaultConfig(),
-        ...configData
-      };
-
-      logger.debug('Configuration loaded successfully');
-      return this.cachedConfig!;
-    } catch (error) {
-      logger.warn('Failed to read configuration, using defaults:', error);
-      this.cachedConfig = this.getDefaultConfig();
-      return this.cachedConfig;
-    }
-  }
-
-  /**
-   * Write configuration to file
-   */
-  public writeConfig(config: SVGConfig): void {
-    try {
-      FileSystem.writeJSONSync(this.getConfigPath(), config, { spaces: 2 });
-      this.cachedConfig = config; // Update cache
-      logger.success('Configuration saved successfully');
-    } catch (error) {
-      logger.error('Failed to write configuration:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Initialize configuration with defaults
-   */
-  public async initConfig(): Promise<void> {
-    const configPath = this.getConfigPath();
-    
-    if (await FileSystem.exists(configPath)) {
-      logger.warn('Config file already exists:', configPath);
-      return;
-    }
-
-    const defaultConfig = this.getDefaultConfig();
-    this.writeConfig(defaultConfig);
-    logger.success('Configuration initialized with defaults');
-  }
-
-  /**
-   * Set a specific configuration value
-   */
-  public setConfig(key: string, value: any): void {
-    const config = this.readConfig();
-    
-    // Support nested key paths like 'styleRules.fill'
-    const keys = key.split('.');
-    let current: any = config;
-    
-    for (let i = 0; i < keys.length - 1; i++) {
-      const k = keys[i];
-      if (!(k in current)) {
-        current[k] = {};
-      }
-      current = current[k];
-    }
-    
-    const finalKey = keys[keys.length - 1];
-    current[finalKey] = value;
-    
-    this.writeConfig(config);
-    logger.success(`Configuration updated: ${key} = ${value}`);
-  }
-
-  /**
-   * Get a specific configuration value
-   */
-  public getConfig(key?: string): any {
-    const config = this.readConfig();
-    
-    if (!key) {
-      return config;
-    }
-
-    // Support nested key paths
-    const keys = key.split('.');
-    let current: any = config;
-    
-    for (const k of keys) {
-      if (!(k in current)) {
-        return undefined;
-      }
-      current = current[k];
-    }
-    
-    return current;
-  }
-
-  /**
-   * Validate configuration
-   */
-  public validateConfig(config?: SVGConfig): { valid: boolean; errors: string[] } {
-    const configToValidate = config || this.readConfig();
-    const errors: string[] = [];
-
-    // Required string fields
-    const requiredStringFields = ['source', 'output', 'defaultFill'];
-    for (const field of requiredStringFields) {
-      if (!configToValidate[field as keyof SVGConfig] || typeof configToValidate[field as keyof SVGConfig] !== 'string') {
-        errors.push(`${field} must be a non-empty string`);
-      }
-    }
-
-    // Required numeric fields
-    const requiredNumericFields = ['defaultWidth', 'defaultHeight'];
-    for (const field of requiredNumericFields) {
-      const value = configToValidate[field as keyof SVGConfig];
-      if (typeof value !== 'number' || value <= 0) {
-        errors.push(`${field} must be a positive number`);
-      }
-    }
-
-    // Validate exclude array
-    if (configToValidate.exclude && !Array.isArray(configToValidate.exclude)) {
-      errors.push('exclude must be an array');
-    }
-
-    // Validate styleRules object
-    if (configToValidate.styleRules && typeof configToValidate.styleRules !== 'object') {
-      errors.push('styleRules must be an object');
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Clear cached configuration (useful for testing)
-   */
-  public clearCache(): void {
-    this.cachedConfig = null;
-  }
-
-  /**
-   * Display current configuration
-   */
-  public showConfig(): void {
-    const config = this.readConfig();
-    console.log('📄 Current Configuration:');
-    console.log(JSON.stringify(config, null, 2));
-  }
-}
-
-// Export singleton instance
-export const configService = ConfigService.getInstance();