svger-cli 4.0.1 → 4.0.3

package/dist/cli.js

@@ -1,11 +1,21 @@
 #!/usr/bin/env node
-import { CLI } from './utils/native.js';
+import { CLI, FileSystem } from './utils/native.js';
 import { svgService } from './services/svg-service.js';
 import { configService } from './services/config.js';
 import { logger } from './core/logger.js';
 import { getPluginManager } from './core/enhanced-plugin-manager.js';
+import { svgProcessor } from './processors/svg-processor.js';
 import { resolve } from 'path';
 import { pathToFileURL } from 'url';
+import path from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Read version dynamically from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const CLI_VERSION = packageJson.version;
 const program = new CLI();
 /**
  * Load a plugin from npm package or local path
@@ -80,7 +90,7 @@ function listRegisteredPlugins() {
 program
     .name('svger-cli')
     .description('Custom SVG to Angular, React, Vue, Svelte, Solid, and other component converter')
-    .version('4.0.0');
+    .version(CLI_VERSION);
 // -------- Build Command --------
 /**
  * Build all SVGs from a source folder to an output folder.
@@ -113,6 +123,39 @@ program
             }
         }
         const [src, out] = args;
+        // Validate required arguments
+        if (!src || !out) {
+            logger.error('Error: Both <src> and <out> paths are required');
+            process.exit(1);
+        }
+        // Validate framework type if provided — O(1) Set.has() instead of O(n) Array.includes()
+        const validFrameworks = new Set([
+            'react',
+            'react-native',
+            'vue',
+            'svelte',
+            'angular',
+            'solid',
+            'preact',
+            'lit',
+            'vanilla',
+        ]);
+        if (opts.framework && !validFrameworks.has(opts.framework)) {
+            logger.error(`Error: Invalid framework "${opts.framework}". Valid options: ${[...validFrameworks].join(', ')}`);
+            process.exit(1);
+        }
+        // Validate optimization level if provided — O(1) Set.has()
+        const validOptLevels = new Set([
+            'none',
+            'basic',
+            'balanced',
+            'aggressive',
+            'maximum',
+        ]);
+        if (opts.optimize && !validOptLevels.has(opts.optimize)) {
+            logger.error(`Error: Invalid optimization level "${opts.optimize}". Valid options: ${[...validOptLevels].join(', ')}`);
+            process.exit(1);
+        }
         // Build config from CLI options
         const buildConfig = { src, out };
         if (opts.framework) {
@@ -155,6 +198,11 @@ program
     .action(async (args) => {
     try {
         const [src, out] = args;
+        // Validate required arguments
+        if (!src || !out) {
+            logger.error('Error: Both <src> and <out> paths are required');
+            process.exit(1);
+        }
         await svgService.startWatching({ src, out });
         // Keep the process running
         process.on('SIGINT', () => {
@@ -262,12 +310,27 @@ program
                 logger.error('Invalid format. Use key=value');
                 process.exit(1);
             }
-            const parsedValue = !isNaN(Number(value)) ? Number(value) : value;
+            // Parse value with O(1) lookup for known literals, then type detection
+            const literalValues = {
+                true: true,
+                false: false,
+            };
+            let parsedValue;
+            if (value in literalValues) {
+                parsedValue = literalValues[value];
+            }
+            else if (!isNaN(Number(value)) && value.trim() !== '') {
+                parsedValue = Number(value);
+            }
+            else {
+                parsedValue = value;
+            }
             return configService.setConfig(key, parsedValue);
         }
         if (opts.show)
             return configService.showConfig();
         logger.error('No option provided. Use --init, --set, or --show');
+        process.exit(1);
     }
     catch (error) {
         logger.error('Config operation failed:', error);
@@ -311,16 +374,65 @@ program
     .option('--in-place', 'Optimize files in-place (overwrite originals)')
     .action(async (args, opts) => {
     try {
-        const [input, output = input] = args;
+        const [input, output = opts.inPlace ? input : args[1] || input] = args;
+        if (!input) {
+            logger.error('Error: Input path is required');
+            process.exit(1);
+        }
+        // Validate optimization level if provided — O(1) Set.has()
+        const validOptLevels = new Set([
+            'basic',
+            'balanced',
+            'aggressive',
+            'maximum',
+        ]);
         const level = opts.level || 'balanced';
+        if (!validOptLevels.has(level)) {
+            logger.error(`Error: Invalid optimization level "${level}". Valid options: ${[...validOptLevels].join(', ')}`);
+            process.exit(1);
+        }
+        const inputDir = path.resolve(input);
+        const outputDir = opts.inPlace ? inputDir : path.resolve(output);
+        // Validate input directory
+        if (!(await FileSystem.exists(inputDir))) {
+            logger.error(`Error: Input directory not found: ${inputDir}`);
+            process.exit(1);
+        }
+        // Set optimization level
+        svgService.setOptimizerLevel(level);
         logger.info(`Optimizing SVG files at ${level.toUpperCase()} level...`);
-        logger.info(`Input: ${input}, Output: ${output}`);
-        // Implementation would go through svg-processor
-        // For now, show success message
-        logger.success(`Optimization complete!`);
+        logger.info(`Input: ${inputDir}`);
+        logger.info(`Output: ${outputDir}`);
+        // Ensure output directory exists
+        await FileSystem.ensureDir(outputDir);
+        // Read all SVG files
+        const files = await FileSystem.readDir(inputDir);
+        const svgFiles = files.filter((file) => file.endsWith('.svg'));
+        if (svgFiles.length === 0) {
+            logger.warn('No SVG files found in input directory');
+            return;
+        }
+        let optimized = 0;
+        let failed = 0;
+        // Process each SVG file
+        for (const file of svgFiles) {
+            try {
+                const inputPath = path.join(inputDir, file);
+                const outputPath = path.join(outputDir, file);
+                const content = await FileSystem.readFile(inputPath, 'utf-8');
+                const optimizedContent = await svgProcessor.cleanSVGContent(content);
+                await FileSystem.writeFile(outputPath, optimizedContent, 'utf-8');
+                optimized++;
+                logger.info(`✓ Optimized: ${file}`);
+            }
+            catch (error) {
+                failed++;
+                logger.error(`✗ Failed: ${file} - ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        logger.success(`Optimization complete! ${optimized} optimized, ${failed} failed`);
         if (opts.validate) {
-            logger.info('Running visual validation...');
-            logger.success('Visual validation passed! ✅');
+            logger.warn('Visual validation not yet implemented for optimize command');
         }
     }
     catch (error) {

package/dist/config.d.ts

@@ -1,28 +1,34 @@
 /**
  * Read the current svger-cli configuration.
  *
- * @returns {Record<string, any>} Configuration object. Returns an empty object if no config file exists.
+ * @deprecated Use `configService.readConfig()` instead.
+ * @returns {Record<string, any>} Configuration object.
  */
 export declare function readConfig(): Record<string, any>;
 /**
  * Write a configuration object to the config file.
  *
+ * @deprecated Use `configService.writeConfig(config)` instead.
  * @param {Record<string, any>} config - Configuration object to write.
  */
 export declare function writeConfig(config: Record<string, any>): void;
 /**
  * Initialize the svger-cli configuration with default values.
- * If a config file already exists, this function will not overwrite it.
+ *
+ * @deprecated Use `configService.initConfig()` instead.
  */
 export declare function initConfig(): Promise<void>;
 /**
  * Set a specific configuration key to a new value.
  *
+ * @deprecated Use `configService.setConfig(key, value)` instead.
  * @param {string} key - The config key to set.
  * @param {any} value - The value to assign to the key.
  */
 export declare function setConfig(key: string, value: any): void;
 /**
  * Display the current configuration in the console.
+ *
+ * @deprecated Use `configService.showConfig()` instead.
  */
 export declare function showConfig(): void;

package/dist/config.js

@@ -1,158 +1,51 @@
-import path from 'path';
-import { FileSystem } from './utils/native.js';
-const CONFIG_FILE = '.svgconfig.json';
 /**
- * Get the absolute path to the configuration file.
+ * Legacy configuration module - delegates to ConfigService.
  *
- * @returns {string} Absolute path to .svgconfig.json
+ * @deprecated Use `configService` from `./services/config.js` instead.
+ * This module exists only for backward compatibility and will be removed in v5.0.0.
  */
-function getConfigPath() {
-    return path.resolve(CONFIG_FILE);
-}
+import { configService } from './services/config.js';
 /**
  * Read the current svger-cli configuration.
  *
- * @returns {Record<string, any>} Configuration object. Returns an empty object if no config file exists.
+ * @deprecated Use `configService.readConfig()` instead.
+ * @returns {Record<string, any>} Configuration object.
  */
 export function readConfig() {
-    return FileSystem.readJSONSync(getConfigPath());
+    return configService.readConfig();
 }
 /**
  * Write a configuration object to the config file.
  *
+ * @deprecated Use `configService.writeConfig(config)` instead.
  * @param {Record<string, any>} config - Configuration object to write.
  */
 export function writeConfig(config) {
-    FileSystem.writeJSONSync(getConfigPath(), config, { spaces: 2 });
+    configService.writeConfig(config);
 }
 /**
  * Initialize the svger-cli configuration with default values.
- * If a config file already exists, this function will not overwrite it.
+ *
+ * @deprecated Use `configService.initConfig()` instead.
  */
 export async function initConfig() {
-    if (await FileSystem.exists(getConfigPath())) {
-        console.log('⚠️  Config file already exists:', getConfigPath());
-        return;
-    }
-    const defaultConfig = {
-        // Configuration Version (for migration compatibility)
-        version: '4.0.0',
-        // Source & Output
-        source: './src/assets/svg',
-        output: './src/components/icons',
-        // Framework Configuration
-        framework: 'react',
-        typescript: true,
-        componentType: 'functional',
-        // Processing Options
-        watch: false,
-        parallel: true,
-        batchSize: 10,
-        maxConcurrency: 4,
-        cache: true,
-        // Default Properties
-        defaultWidth: 24,
-        defaultHeight: 24,
-        defaultFill: 'currentColor',
-        defaultStroke: 'none',
-        defaultStrokeWidth: 1,
-        // Styling Configuration
-        styleRules: {
-            fill: 'inherit',
-            stroke: 'none',
-        },
-        responsive: {
-            breakpoints: ['sm', 'md', 'lg', 'xl'],
-            values: {
-                width: ['16px', '20px', '24px', '32px'],
-                height: ['16px', '20px', '24px', '32px'],
-            },
-        },
-        theme: {
-            mode: 'auto',
-            variables: {
-                primary: 'currentColor',
-                secondary: '#6b7280',
-                accent: '#3b82f6',
-            },
-        },
-        animations: [],
-        // v4.0.0: Plugin System
-        plugins: [],
-        // Advanced Options
-        exclude: [],
-        include: [],
-        // Error Handling
-        errorHandling: {
-            strategy: 'continue',
-            maxRetries: 3,
-            timeout: 30000,
-        },
-        // Performance Settings
-        performance: {
-            optimization: 'balanced',
-            memoryLimit: 512,
-            cacheTimeout: 3600000,
-        },
-        // Output Customization
-        outputConfig: {
-            naming: 'pascal',
-            extension: 'tsx',
-            directory: './src/components/icons',
-        },
-        // Framework-specific configurations
-        react: {
-            componentType: 'functional',
-            forwardRef: true,
-            memo: false,
-            propsInterface: 'SVGProps',
-            styledComponents: false,
-            cssModules: false,
-        },
-        vue: {
-            api: 'composition',
-            setup: true,
-            typescript: true,
-            scoped: true,
-            cssVariables: true,
-        },
-        angular: {
-            standalone: true,
-            signals: true,
-            changeDetection: 'OnPush',
-            encapsulation: 'Emulated',
-        },
-        // Legacy support (deprecated)
-        template: {
-            type: 'default',
-        },
-        frameworkOptions: {
-            forwardRef: true,
-            memo: false,
-            scriptSetup: true,
-            standalone: true,
-        },
-    };
-    writeConfig(defaultConfig);
-    console.log('✅ Config file created:', getConfigPath());
+    return configService.initConfig();
 }
 /**
  * Set a specific configuration key to a new value.
  *
+ * @deprecated Use `configService.setConfig(key, value)` instead.
  * @param {string} key - The config key to set.
  * @param {any} value - The value to assign to the key.
  */
 export function setConfig(key, value) {
-    const config = readConfig();
-    config[key] = value;
-    writeConfig(config);
-    console.log(`✅ Set config ${key}=${value}`);
+    configService.setConfig(key, value);
 }
 /**
  * Display the current configuration in the console.
+ *
+ * @deprecated Use `configService.showConfig()` instead.
  */
 export function showConfig() {
-    const config = readConfig();
-    console.log('📄 Current Config:');
-    console.log(JSON.stringify(config, null, 2));
+    configService.showConfig();
 }

package/dist/core/enhanced-plugin-manager.d.ts

@@ -21,6 +21,7 @@ interface PluginMetrics {
 export declare class EnhancedPluginManager {
     private plugins;
     private executionMetrics;
+    private readonly MAX_METRICS_SIZE;
     private enableVisualValidation;
     constructor();
     /**

package/dist/core/enhanced-plugin-manager.js

@@ -11,6 +11,7 @@ import { compareVisually } from '../utils/visual-diff.js';
 export class EnhancedPluginManager {
     plugins = new Map();
     executionMetrics = [];
+    MAX_METRICS_SIZE = 1000; // Cap at 1000 entries to prevent memory leak
     enableVisualValidation = true;
     constructor() {
         logger.debug('EnhancedPluginManager initialized');
@@ -20,13 +21,15 @@ export class EnhancedPluginManager {
      */
     registerPlugin(plugin) {
         if (this.plugins.has(plugin.name)) {
-            logger.warn(`Plugin "${plugin.name}" is already registered. Skipping duplicate.`);
-            return;
+            const errorMsg = `Plugin "${plugin.name}" is already registered. Cannot register duplicate plugins with the same name.`;
+            logger.error(errorMsg);
+            throw new Error(errorMsg);
         }
         // Validate plugin structure
         if (!this.validatePlugin(plugin)) {
-            logger.error(`Plugin "${plugin.name}" failed validation. Skipping.`);
-            return;
+            const errorMsg = `Plugin "${plugin.name}" failed validation. Cannot register invalid plugin.`;
+            logger.error(errorMsg);
+            throw new Error(errorMsg);
         }
         // Initialize plugin if it has init method
         if (plugin.init) {
@@ -134,11 +137,20 @@ export class EnhancedPluginManager {
                 const maxDiff = plugin.validation.maxDiffPercent ?? 5;
                 validationPassed = visualDiff <= maxDiff;
                 if (!validationPassed) {
-                    logger.warn(`Plugin "${plugin.name}" exceeded visual diff threshold: ${visualDiff.toFixed(4)}% > ${maxDiff}%`);
-                }
-                else {
-                    logger.debug(`Plugin "${plugin.name}" visual validation passed: ${visualDiff.toFixed(4)}% <= ${maxDiff}%`);
+                    const errorMsg = `Plugin "${plugin.name}" exceeded visual diff threshold: ${visualDiff.toFixed(4)}% > ${maxDiff}%`;
+                    logger.error(errorMsg);
+                    // Return original content and stop execution on validation failure
+                    return {
+                        content: originalContent,
+                        skipRemaining: true,
+                        metadata: {
+                            visualDiff,
+                            validationPassed: false,
+                            error: errorMsg,
+                        },
+                    };
                 }
+                logger.debug(`Plugin "${plugin.name}" visual validation passed: ${visualDiff.toFixed(4)}% <= ${maxDiff}%`);
             }
             catch (error) {
                 logger.warn(`Plugin "${plugin.name}" visual validation failed:`, error.message);
@@ -153,6 +165,10 @@ export class EnhancedPluginManager {
             visualDiff: visualDiff > 0 ? visualDiff : undefined,
             validationPassed,
         });
+        // Implement circular buffer to prevent memory leak in long-running watch mode
+        if (this.executionMetrics.length > this.MAX_METRICS_SIZE) {
+            this.executionMetrics.shift(); // Remove oldest entry
+        }
         logger.debug(`Plugin "${plugin.name}" completed in ${executionTime.toFixed(2)}ms` +
             (visualDiff > 0 ? ` (visual diff: ${visualDiff.toFixed(4)}%)` : ''));
         return result;
@@ -224,10 +240,20 @@ export class EnhancedPluginManager {
      * Get summary of execution metrics
      */
     getMetricsSummary() {
+        // Single pass through metrics instead of multiple filters
+        let totalExecutionTime = 0;
+        let validationsPassed = 0;
+        let validationsFailed = 0;
+        for (const metric of this.executionMetrics) {
+            totalExecutionTime += metric.executionTime;
+            if (metric.validationPassed) {
+                validationsPassed++;
+            }
+            else {
+                validationsFailed++;
+            }
+        }
         const totalExecutions = this.executionMetrics.length;
-        const totalExecutionTime = this.executionMetrics.reduce((sum, m) => sum + m.executionTime, 0);
-        const validationsPassed = this.executionMetrics.filter(m => m.validationPassed).length;
-        const validationsFailed = this.executionMetrics.filter(m => !m.validationPassed).length;
         return {
             totalPlugins: this.plugins.size,
             totalExecutions,

package/dist/core/framework-templates.js

@@ -46,6 +46,10 @@ export class FrameworkTemplateEngine {
         const attrRegex = /(\w+(?:-\w+)*)="([^"]*)"/g;
         let match;
         while ((match = attrRegex.exec(attributesString)) !== null) {
+            // Prevent infinite loop if regex doesn't advance
+            if (match.index === attrRegex.lastIndex) {
+                attrRegex.lastIndex++;
+            }
             attributes[match[1]] = match[2];
         }
         return { attributes, innerContent };

package/dist/core/logger.js

@@ -19,10 +19,14 @@ export class LoggerService {
         this.enableColors = enabled;
     }
     shouldLog(level) {
-        const levels = ['debug', 'info', 'warn', 'error'];
-        const currentIndex = levels.indexOf(this.logLevel);
-        const messageIndex = levels.indexOf(level);
-        return messageIndex >= currentIndex;
+        // O(1) Map lookup instead of O(n) indexOf on array
+        const levelPriority = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3,
+        };
+        return (levelPriority[level] ?? 0) >= (levelPriority[this.logLevel] ?? 0);
     }
     formatMessage(level, message) {
         const timestamp = new Date().toISOString();

package/dist/core/performance-engine.js

@@ -1,4 +1,5 @@
 import os from 'os';
+import fs from 'fs';
 import { logger } from '../core/logger.js';
 import { svgProcessor } from '../processors/svg-processor.js';
 /**
@@ -41,7 +42,12 @@ export class PerformanceEngine {
             }
         }
         const totalDuration = Date.now() - startTime;
-        const successful = results.filter(r => r.success).length;
+        // Single-pass counter instead of results.filter().length — O(n) → O(n) but avoids intermediate array allocation
+        let successful = 0;
+        for (let i = 0; i < results.length; i++) {
+            if (results[i].success)
+                successful++;
+        }
         logger.info(`Batch processing complete: ${successful}/${files.length} successful in ${totalDuration}ms`);
         return results;
     }
@@ -166,8 +172,15 @@ export class PerformanceEngine {
         }
     }
     generateCacheKey(filePath, options) {
-        // Create a hash of file path and options for caching
-        const key = JSON.stringify({ filePath, options });
+        // Include file modification time to invalidate cache when file changes
+        let mtimeMs = 0;
+        try {
+            mtimeMs = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            // File may not exist yet; use 0 so caching still works
+        }
+        const key = JSON.stringify({ filePath, mtimeMs, options });
         return Buffer.from(key).toString('base64');
     }
     getCachedResult(key) {

package/dist/core/style-compiler.js

@@ -217,13 +217,12 @@ function getAnimationStyles(animationType: string): React.CSSProperties {
 }
 
 function getThemeStyles(theme: _theme): React.CSSProperties {
-  if (theme === 'dark') {
-    return { filter: 'invert(1) hue-rotate(180deg)' };
-  }
-  if (theme === 'auto') {
-    return { filter: 'var(--svger-theme-filter, none)' };
-  }
-  return {};
+  // O(1) object lookup instead of if-else chain
+  const themeStyleMap: Record<string, React.CSSProperties> = {
+    dark: { filter: 'invert(1) hue-rotate(180deg)' },
+    auto: { filter: 'var(--svger-theme-filter, none)' },
+  };
+  return themeStyleMap[theme as string] || {};
 }
 
 ${componentName}.displayName = "${componentName}";

package/dist/core/template-manager.js

@@ -424,23 +424,27 @@ const ${componentName} = React.forwardRef<SVGSVGElement, ${componentName}Props>(
         baseStyles.color = colorMap[variant];
       }
       
-      // Apply theme
-      if (theme === 'dark') {
-        baseStyles.filter = 'invert(1)';
-      } else if (theme === 'auto') {
-        baseStyles.filter = 'var(--svger-theme-filter, none)';
+      // Apply theme — O(1) object lookup instead of if-else chain
+      const themeFilters: Record<string, string> = {
+        dark: 'invert(1)',
+        auto: 'var(--svger-theme-filter, none)',
+      };
+      if (theme && themeFilters[theme]) {
+        baseStyles.filter = themeFilters[theme];
       }
       
-      // Apply animation
+      // Apply animation — O(1) object lookup instead of if-else chain
       if (animate) {
-        if (animate === true || animate === 'spin') {
-          baseStyles.animation = 'svger-spin 2s linear infinite';
-        } else if (animate === 'pulse') {
-          baseStyles.animation = 'svger-pulse 2s ease-in-out infinite';
-        } else if (animate === 'bounce') {
-          baseStyles.animation = 'svger-bounce 1s infinite';
-        } else if (animate === 'fade') {
-          baseStyles.animation = 'svger-fade 2s ease-in-out infinite alternate';
+        const animationMap: Record<string, string> = {
+          spin: 'svger-spin 2s linear infinite',
+          pulse: 'svger-pulse 2s ease-in-out infinite',
+          bounce: 'svger-bounce 1s infinite',
+          fade: 'svger-fade 2s ease-in-out infinite alternate',
+        };
+        const animKey = animate === true ? 'spin' : animate;
+        const anim = animationMap[animKey as string];
+        if (anim) {
+          baseStyles.animation = anim;
         }
       }
       

package/dist/index.d.ts

@@ -4,7 +4,6 @@
  * A high-performance, framework-agnostic SVG processing toolkit with enterprise-grade
  * architecture and comprehensive styling capabilities.
  *
- * @version 2.0.0
  * @author SVGER-CLI Development Team
  * @license MIT
  */
@@ -148,7 +147,7 @@ export declare const SVGER: {
 /**
  * Package Version Information
  */
-export declare const VERSION = "2.0.0";
+export declare const VERSION: string;
 export declare const PACKAGE_NAME = "svger-cli";
 /**
  * Webpack Plugin - Official webpack integration for SVGER-CLI