svger-cli 1.0.6 → 1.0.8

package/src/services/config.ts

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

package/src/services/file-watcher.ts

@@ -0,0 +1,218 @@
+import fs from 'fs';
+import path from 'path';
+import { FileWatchEvent, WatchOptions } from '../types/index.js';
+import { FileSystem } from '../utils/native.js';
+import { logger } from '../core/logger.js';
+
+/**
+ * Professional file watching service with debouncing and event filtering
+ */
+export class FileWatcherService {
+  private static instance: FileWatcherService;
+  private watchers: Map<string, fs.FSWatcher> = new Map();
+  private eventHandlers: Map<string, Function[]> = new Map();
+  private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
+  private readonly debounceDelay = 300; // milliseconds
+
+  private constructor() {}
+
+  public static getInstance(): FileWatcherService {
+    if (!FileWatcherService.instance) {
+      FileWatcherService.instance = new FileWatcherService();
+    }
+    return FileWatcherService.instance;
+  }
+
+  /**
+   * Start watching a directory for SVG file changes
+   */
+  public async watchDirectory(
+    watchPath: string,
+    options: Partial<WatchOptions> = {}
+  ): Promise<string> {
+    const resolvedPath = path.resolve(watchPath);
+    
+    if (!(await FileSystem.exists(resolvedPath))) {
+      throw new Error(`Watch path does not exist: ${resolvedPath}`);
+    }
+
+    const watchId = `watch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    try {
+      const watcher = fs.watch(resolvedPath, {
+        persistent: true,
+        recursive: false
+      }, (eventType, filename) => {
+        if (filename) {
+          this.handleFileEvent(watchId, eventType, path.join(resolvedPath, filename));
+        }
+      });
+
+      this.watchers.set(watchId, watcher);
+      this.eventHandlers.set(watchId, []);
+
+      logger.info(`Started watching directory: ${resolvedPath}`);
+      return watchId;
+
+    } catch (error) {
+      logger.error(`Failed to start watching ${resolvedPath}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Handle file system events with debouncing
+   */
+  private handleFileEvent(watchId: string, eventType: string, filePath: string): void {
+    // Only process SVG files
+    if (!filePath.endsWith('.svg')) {
+      return;
+    }
+
+    const debounceKey = `${watchId}-${filePath}`;
+    
+    // Clear existing timer
+    if (this.debounceTimers.has(debounceKey)) {
+      clearTimeout(this.debounceTimers.get(debounceKey)!);
+    }
+
+    // Set new timer
+    const timer = setTimeout(async () => {
+      this.debounceTimers.delete(debounceKey);
+      await this.processFileEvent(watchId, eventType, filePath);
+    }, this.debounceDelay);
+
+    this.debounceTimers.set(debounceKey, timer);
+  }
+
+  /**
+   * Process debounced file events
+   */
+  private async processFileEvent(watchId: string, eventType: string, filePath: string): Promise<void> {
+    try {
+      const exists = await FileSystem.exists(filePath);
+      let actualEventType: FileWatchEvent['type'];
+
+      // Determine actual event type
+      if (eventType === 'rename') {
+        actualEventType = exists ? 'add' : 'unlink';
+      } else {
+        actualEventType = 'change';
+      }
+
+      const event: FileWatchEvent = {
+        type: actualEventType,
+        filePath,
+        timestamp: Date.now()
+      };
+
+      logger.debug(`File event: ${actualEventType} - ${path.basename(filePath)}`);
+      
+      // Emit event to registered handlers
+      this.emitEvent(watchId, event);
+
+    } catch (error) {
+      logger.error(`Error processing file event for ${filePath}:`, error);
+    }
+  }
+
+  /**
+   * Register an event handler for a specific watcher
+   */
+  public onFileEvent(watchId: string, handler: (event: FileWatchEvent) => void | Promise<void>): void {
+    const handlers = this.eventHandlers.get(watchId) || [];
+    handlers.push(handler);
+    this.eventHandlers.set(watchId, handlers);
+  }
+
+  /**
+   * Emit event to all registered handlers
+   */
+  private emitEvent(watchId: string, event: FileWatchEvent): void {
+    const handlers = this.eventHandlers.get(watchId) || [];
+    
+    for (const handler of handlers) {
+      try {
+        const result = handler(event);
+        // Handle async handlers
+        if (result && typeof result.then === 'function') {
+          result.catch((error: any) => {
+            logger.error(`Error in file event handler:`, error);
+          });
+        }
+      } catch (error) {
+        logger.error(`Error in file event handler:`, error);
+      }
+    }
+  }
+
+  /**
+   * Stop watching a specific directory
+   */
+  public stopWatching(watchId: string): void {
+    const watcher = this.watchers.get(watchId);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(watchId);
+      this.eventHandlers.delete(watchId);
+      
+      // Clear any pending debounce timers for this watcher
+      for (const [key, timer] of this.debounceTimers.entries()) {
+        if (key.startsWith(`${watchId}-`)) {
+          clearTimeout(timer);
+          this.debounceTimers.delete(key);
+        }
+      }
+      
+      logger.info(`Stopped watching: ${watchId}`);
+    }
+  }
+
+  /**
+   * Stop all watchers
+   */
+  public stopAllWatchers(): void {
+    for (const watchId of this.watchers.keys()) {
+      this.stopWatching(watchId);
+    }
+    logger.info('Stopped all file watchers');
+  }
+
+  /**
+   * Get active watch statistics
+   */
+  public getWatchStats(): {
+    activeWatchers: number;
+    pendingEvents: number;
+    totalHandlers: number;
+  } {
+    let totalHandlers = 0;
+    for (const handlers of this.eventHandlers.values()) {
+      totalHandlers += handlers.length;
+    }
+
+    return {
+      activeWatchers: this.watchers.size,
+      pendingEvents: this.debounceTimers.size,
+      totalHandlers
+    };
+  }
+
+  /**
+   * Cleanup on shutdown
+   */
+  public shutdown(): void {
+    this.stopAllWatchers();
+    
+    // Clear all debounce timers
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    
+    logger.info('File watcher service shutdown complete');
+  }
+}
+
+// Export singleton instance
+export const fileWatcher = FileWatcherService.getInstance();