svger-cli 2.0.1 → 2.0.3

package/src/core/performance-engine.ts

@@ -1,327 +0,0 @@
-import { logger } from '../core/logger.js';
-import { SVGProcessor, svgProcessor } from '../processors/svg-processor.js';
-import { ComponentGenerationOptions } from '../types/index.js';
-
-/**
- * Performance optimization engine for batch processing and parallel execution
- */
-export class PerformanceEngine {
-  private static instance: PerformanceEngine;
-  private processingCache: Map<string, { result: any; timestamp: number }> = new Map();
-  private readonly cacheTimeout = 5 * 60 * 1000; // 5 minutes
-
-  private constructor() {}
-
-  public static getInstance(): PerformanceEngine {
-    if (!PerformanceEngine.instance) {
-      PerformanceEngine.instance = new PerformanceEngine();
-    }
-    return PerformanceEngine.instance;
-  }
-
-  /**
-   * Process multiple SVG files in parallel with optimized batching
-   */
-  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 }>> {
-    const {
-      batchSize = 10,
-      parallel = true,
-      maxConcurrency = Math.min(4, require('os').cpus().length)
-    } = config;
-
-    logger.info(`Processing ${files.length} files with ${parallel ? 'parallel' : 'sequential'} execution`);
-    
-    const startTime = Date.now();
-    const results: Array<{ success: boolean; filePath: string; error?: Error; duration: number }> = [];
-
-    if (!parallel) {
-      // Sequential processing for stability
-      for (const file of files) {
-        const result = await this.processSingleWithCaching(file);
-        results.push(result);
-      }
-    } else {
-      // Parallel processing with controlled concurrency
-      const batches = this.createBatches(files, batchSize);
-      
-      for (const batch of batches) {
-        const semaphore = new Semaphore(maxConcurrency);
-        const batchPromises = batch.map(file => 
-          this.withSemaphore(semaphore, () => this.processSingleWithCaching(file))
-        );
-        
-        const batchResults = await Promise.all(batchPromises);
-        results.push(...batchResults);
-      }
-    }
-
-    const totalDuration = Date.now() - startTime;
-    const successful = results.filter(r => r.success).length;
-    
-    logger.info(`Batch processing complete: ${successful}/${files.length} successful in ${totalDuration}ms`);
-    
-    return results;
-  }
-
-  /**
-   * Process single file with caching support
-   */
-  private async processSingleWithCaching(
-    file: { path: string; outputDir: string; options?: Partial<ComponentGenerationOptions> }
-  ): Promise<{ success: boolean; filePath: string; error?: Error; duration: number }> {
-    const startTime = Date.now();
-    const cacheKey = this.generateCacheKey(file.path, file.options || {});
-
-    // Check cache first
-    const cached = this.getCachedResult(cacheKey);
-    if (cached) {
-      logger.debug(`Cache hit for ${file.path}`);
-      return {
-        success: true,
-        filePath: file.path,
-        duration: Date.now() - startTime
-      };
-    }
-
-    try {
-      const result = await svgProcessor.processSVGFile(
-        file.path,
-        file.outputDir,
-        file.options
-      );
-
-      // Cache successful results
-      if (result.success) {
-        this.setCachedResult(cacheKey, result);
-      }
-
-      return {
-        success: result.success,
-        filePath: file.path,
-        error: result.error,
-        duration: Date.now() - startTime
-      };
-
-    } catch (error) {
-      return {
-        success: false,
-        filePath: file.path,
-        error: error as Error,
-        duration: Date.now() - startTime
-      };
-    }
-  }
-
-  /**
-   * Optimize SVG content with performance considerations
-   */
-  public optimizeSVGContent(content: string, level: 'fast' | 'balanced' | 'maximum' = 'balanced'): string {
-    const startTime = performance.now();
-    let optimized = content;
-
-    switch (level) {
-      case 'fast':
-        // Basic optimizations only
-        optimized = this.applyFastOptimizations(content);
-        break;
-        
-      case 'balanced':
-        // Standard optimizations with good performance/quality balance
-        optimized = this.applyBalancedOptimizations(content);
-        break;
-        
-      case 'maximum':
-        // Comprehensive optimizations
-        optimized = this.applyMaximumOptimizations(content);
-        break;
-    }
-
-    const duration = performance.now() - startTime;
-    const compressionRatio = (1 - optimized.length / content.length) * 100;
-    
-    logger.debug(`SVG optimization (${level}): ${compressionRatio.toFixed(1)}% reduction in ${duration.toFixed(2)}ms`);
-    
-    return optimized;
-  }
-
-  /**
-   * Memory usage monitoring and optimization
-   */
-  public monitorMemoryUsage(): {
-    heapUsed: number;
-    heapTotal: number;
-    external: number;
-    cacheSize: number;
-    recommendations: string[];
-  } {
-    const memUsage = process.memoryUsage();
-    const cacheSize = this.processingCache.size;
-    const recommendations: string[] = [];
-
-    // Memory usage analysis
-    const heapUsedMB = memUsage.heapUsed / 1024 / 1024;
-    const heapTotalMB = memUsage.heapTotal / 1024 / 1024;
-
-    if (heapUsedMB > 500) {
-      recommendations.push('Consider reducing batch size or enabling sequential processing');
-    }
-    
-    if (cacheSize > 1000) {
-      recommendations.push('Cache size is large, consider clearing old entries');
-    }
-    
-    if (memUsage.external > 100 * 1024 * 1024) {
-      recommendations.push('High external memory usage detected');
-    }
-
-    return {
-      heapUsed: heapUsedMB,
-      heapTotal: heapTotalMB,
-      external: memUsage.external / 1024 / 1024,
-      cacheSize,
-      recommendations
-    };
-  }
-
-  /**
-   * Clear processing cache
-   */
-  public clearCache(): void {
-    this.processingCache.clear();
-    logger.debug('Processing cache cleared');
-  }
-
-  /**
-   * Get performance metrics
-   */
-  public getPerformanceMetrics(): {
-    cacheHitRate: number;
-    averageProcessingTime: number;
-    memoryUsage: any;
-  } {
-    // This would be implemented with proper metrics collection
-    return {
-      cacheHitRate: 0, // Placeholder
-      averageProcessingTime: 0, // Placeholder
-      memoryUsage: this.monitorMemoryUsage()
-    };
-  }
-
-  // Private helper methods
-
-  private createBatches<T>(items: T[], batchSize: number): T[][] {
-    const batches: T[][] = [];
-    for (let i = 0; i < items.length; i += batchSize) {
-      batches.push(items.slice(i, i + batchSize));
-    }
-    return batches;
-  }
-
-  private async withSemaphore<T>(semaphore: Semaphore, task: () => Promise<T>): Promise<T> {
-    await semaphore.acquire();
-    try {
-      return await task();
-    } finally {
-      semaphore.release();
-    }
-  }
-
-  private generateCacheKey(filePath: string, options: Partial<ComponentGenerationOptions>): string {
-    // Create a hash of file path and options for caching
-    const key = JSON.stringify({ filePath, options });
-    return Buffer.from(key).toString('base64');
-  }
-
-  private getCachedResult(key: string): any | null {
-    const cached = this.processingCache.get(key);
-    if (!cached) return null;
-    
-    // Check if cache entry is still valid
-    if (Date.now() - cached.timestamp > this.cacheTimeout) {
-      this.processingCache.delete(key);
-      return null;
-    }
-    
-    return cached.result;
-  }
-
-  private setCachedResult(key: string, result: any): void {
-    this.processingCache.set(key, {
-      result,
-      timestamp: Date.now()
-    });
-  }
-
-  private applyFastOptimizations(content: string): string {
-    return content
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .replace(/>\s+</g, '><') // Remove spaces between tags
-      .trim();
-  }
-
-  private applyBalancedOptimizations(content: string): string {
-    let optimized = this.applyFastOptimizations(content);
-    
-    // Remove unnecessary attributes
-    optimized = optimized
-      .replace(/\s+id="[^"]*"/g, '') // Remove IDs (usually not needed in components)
-      .replace(/\s+class="[^"]*"/g, '') // Remove classes
-      .replace(/<!--[\s\S]*?-->/g, '') // Remove comments
-      .replace(/\s+xmlns="[^"]*"/g, ''); // Remove xmlns (React adds it)
-    
-    return optimized;
-  }
-
-  private applyMaximumOptimizations(content: string): string {
-    let optimized = this.applyBalancedOptimizations(content);
-    
-    // Advanced optimizations
-    optimized = optimized
-      .replace(/\s+style="[^"]*"/g, '') // Remove inline styles
-      .replace(/\s+data-[^=]*="[^"]*"/g, '') // Remove data attributes
-      .replace(/fill="none"/g, '') // Remove default fill
-      .replace(/stroke="none"/g, '') // Remove default stroke
-      .replace(/\s+version="[^"]*"/g, '') // Remove version
-      .replace(/\s+baseProfile="[^"]*"/g, ''); // Remove baseProfile
-    
-    return optimized;
-  }
-}
-
-/**
- * Semaphore for controlling concurrency
- */
-class Semaphore {
-  private permits: number;
-  private waitQueue: Array<() => void> = [];
-
-  constructor(permits: number) {
-    this.permits = permits;
-  }
-
-  async acquire(): Promise<void> {
-    if (this.permits > 0) {
-      this.permits--;
-      return Promise.resolve();
-    }
-
-    return new Promise<void>((resolve) => {
-      this.waitQueue.push(resolve);
-    });
-  }
-
-  release(): void {
-    this.permits++;
-    if (this.waitQueue.length > 0) {
-      const resolve = this.waitQueue.shift()!;
-      this.permits--;
-      resolve();
-    }
-  }
-}
-
-// Export singleton instance
-export const performanceEngine = PerformanceEngine.getInstance();

package/src/core/plugin-manager.ts

@@ -1,228 +0,0 @@
-import { Plugin, PluginConfig } from '../types/index.js';
-import { logger } from '../core/logger.js';
-
-/**
- * Plugin management system for extending SVG processing capabilities
- */
-export class PluginManager {
-  private static instance: PluginManager;
-  private plugins: Map<string, Plugin> = new Map();
-  private activePlugins: Set<string> = new Set();
-
-  private constructor() {
-    this.loadBuiltinPlugins();
-  }
-
-  public static getInstance(): PluginManager {
-    if (!PluginManager.instance) {
-      PluginManager.instance = new PluginManager();
-    }
-    return PluginManager.instance;
-  }
-
-  /**
-   * Load built-in plugins
-   */
-  private loadBuiltinPlugins(): void {
-    // SVG Optimizer Plugin
-    this.registerPlugin({
-      name: 'svg-optimizer',
-      version: '1.0.0',
-      process: async (content: string, options?: any) => {
-        return this.optimizeSVG(content, options);
-      },
-      validate: (options?: any) => true
-    });
-
-    // Color Theme Plugin
-    this.registerPlugin({
-      name: 'color-theme',
-      version: '1.0.0',
-      process: async (content: string, options?: any) => {
-        return this.applyColorTheme(content, options);
-      },
-      validate: (options?: any) => {
-        return options && typeof options.theme === 'object';
-      }
-    });
-
-    // Size Normalizer Plugin
-    this.registerPlugin({
-      name: 'size-normalizer',
-      version: '1.0.0',
-      process: async (content: string, options?: any) => {
-        return this.normalizeSizes(content, options);
-      }
-    });
-
-    logger.debug('Built-in plugins loaded');
-  }
-
-  /**
-   * Register a new plugin
-   */
-  public registerPlugin(plugin: Plugin): void {
-    if (this.plugins.has(plugin.name)) {
-      logger.warn(`Plugin ${plugin.name} is already registered, overwriting`);
-    }
-    
-    this.plugins.set(plugin.name, plugin);
-    logger.debug(`Plugin registered: ${plugin.name} v${plugin.version}`);
-  }
-
-  /**
-   * Enable a plugin
-   */
-  public enablePlugin(name: string, config?: PluginConfig): void {
-    const plugin = this.plugins.get(name);
-    if (!plugin) {
-      throw new Error(`Plugin not found: ${name}`);
-    }
-
-    if (plugin.validate && config?.options && !plugin.validate(config.options)) {
-      throw new Error(`Invalid options for plugin: ${name}`);
-    }
-
-    this.activePlugins.add(name);
-    logger.info(`Plugin enabled: ${name}`);
-  }
-
-  /**
-   * Disable a plugin
-   */
-  public disablePlugin(name: string): void {
-    this.activePlugins.delete(name);
-    logger.info(`Plugin disabled: ${name}`);
-  }
-
-  /**
-   * Process content through all active plugins
-   */
-  public async processContent(
-    content: string, 
-    pluginConfigs: PluginConfig[] = []
-  ): Promise<string> {
-    let processedContent = content;
-
-    for (const config of pluginConfigs) {
-      const plugin = this.plugins.get(config.name);
-      
-      if (!plugin) {
-        logger.warn(`Plugin not found: ${config.name}, skipping`);
-        continue;
-      }
-
-      if (!this.activePlugins.has(config.name)) {
-        logger.debug(`Plugin ${config.name} is disabled, skipping`);
-        continue;
-      }
-
-      try {
-        logger.debug(`Processing with plugin: ${config.name}`);
-        processedContent = await plugin.process(processedContent, config.options);
-      } catch (error) {
-        logger.error(`Plugin ${config.name} failed:`, error);
-        // Continue processing with other plugins
-      }
-    }
-
-    return processedContent;
-  }
-
-  /**
-   * Get list of available plugins
-   */
-  public getAvailablePlugins(): Array<{ name: string; version: string; enabled: boolean }> {
-    return Array.from(this.plugins.entries()).map(([name, plugin]) => ({
-      name,
-      version: plugin.version,
-      enabled: this.activePlugins.has(name)
-    }));
-  }
-
-  /**
-   * Built-in SVG optimizer
-   */
-  private optimizeSVG(content: string, options: any = {}): string {
-    let optimized = content;
-
-    // Remove unnecessary whitespace
-    if (options.removeWhitespace !== false) {
-      optimized = optimized.replace(/>\s+</g, '><');
-    }
-
-    // Remove empty groups
-    if (options.removeEmptyGroups !== false) {
-      optimized = optimized.replace(/<g[^>]*>\s*<\/g>/g, '');
-    }
-
-    // Merge similar paths (basic implementation)
-    if (options.mergePaths === true) {
-      // This would require more sophisticated path parsing
-      logger.debug('Path merging not implemented yet');
-    }
-
-    // Remove comments
-    if (options.removeComments !== false) {
-      optimized = optimized.replace(/<!--[\s\S]*?-->/g, '');
-    }
-
-    return optimized;
-  }
-
-  /**
-   * Built-in color theme applier
-   */
-  private applyColorTheme(content: string, options: any = {}): string {
-    if (!options.theme) {
-      return content;
-    }
-
-    let themed = content;
-    const theme = options.theme;
-
-    // Replace colors according to theme
-    for (const [originalColor, newColor] of Object.entries(theme)) {
-      const colorRegex = new RegExp(`(fill|stroke)=["']${originalColor}["']`, 'g');
-      themed = themed.replace(colorRegex, `$1="${newColor}"`);
-    }
-
-    return themed;
-  }
-
-  /**
-   * Built-in size normalizer
-   */
-  private normalizeSizes(content: string, options: any = {}): string {
-    const targetSize = options.size || 24;
-    
-    // This is a basic implementation - would need more sophisticated sizing logic
-    let normalized = content;
-    
-    // Normalize stroke-width relative to size
-    if (options.normalizeStrokes !== false) {
-      const strokeRegex = /stroke-width=["']([^"']+)["']/g;
-      normalized = normalized.replace(strokeRegex, (match, width) => {
-        const numericWidth = parseFloat(width);
-        if (!isNaN(numericWidth)) {
-          const normalizedWidth = (numericWidth / 24) * targetSize;
-          return `stroke-width="${normalizedWidth}"`;
-        }
-        return match;
-      });
-    }
-
-    return normalized;
-  }
-
-  /**
-   * Clear all plugins (useful for testing)
-   */
-  public clear(): void {
-    this.plugins.clear();
-    this.activePlugins.clear();
-  }
-}
-
-// Export singleton instance
-export const pluginManager = PluginManager.getInstance();