svger-cli 1.0.6 → 1.0.7

package/src/core/performance-engine.ts

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

@@ -0,0 +1,228 @@
+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();