svger-cli 4.0.1 → 4.0.3

package/dist/optimizers/shape-conversion.js

@@ -144,8 +144,9 @@ function shouldConvert(element, pathData, threshold) {
 function convertShapeToPath(node, threshold) {
     const tag = node.tag;
     let pathData = null;
-    switch (tag) {
-        case 'rect': {
+    // O(1) object lookup for shape tag → path converter
+    const shapeConverters = {
+        rect: () => {
             const x = parseFloat(node.attrs.get('x') || '0');
             const y = parseFloat(node.attrs.get('y') || '0');
             const width = parseFloat(node.attrs.get('width') || '0');
@@ -156,41 +157,35 @@ function convertShapeToPath(node, threshold) {
             const ry = node.attrs.has('ry')
                 ? parseFloat(node.attrs.get('ry'))
                 : undefined;
-            pathData = rectToPath(x, y, width, height, rx, ry);
-            break;
-        }
-        case 'circle': {
+            return rectToPath(x, y, width, height, rx, ry);
+        },
+        circle: () => {
             const cx = parseFloat(node.attrs.get('cx') || '0');
             const cy = parseFloat(node.attrs.get('cy') || '0');
             const r = parseFloat(node.attrs.get('r') || '0');
-            pathData = circleToPath(cx, cy, r);
-            break;
-        }
-        case 'ellipse': {
+            return circleToPath(cx, cy, r);
+        },
+        ellipse: () => {
             const cx = parseFloat(node.attrs.get('cx') || '0');
             const cy = parseFloat(node.attrs.get('cy') || '0');
             const rx = parseFloat(node.attrs.get('rx') || '0');
             const ry = parseFloat(node.attrs.get('ry') || '0');
-            pathData = ellipseToPath(cx, cy, rx, ry);
-            break;
-        }
-        case 'polygon': {
+            return ellipseToPath(cx, cy, rx, ry);
+        },
+        polygon: () => {
             const points = node.attrs.get('points');
-            if (points) {
-                pathData = polygonToPath(points);
-            }
-            break;
-        }
-        case 'polyline': {
+            return points ? polygonToPath(points) : null;
+        },
+        polyline: () => {
             const points = node.attrs.get('points');
-            if (points) {
-                pathData = polylineToPath(points);
-            }
-            break;
-        }
-        default:
-            return { converted: false, savings: 0 };
+            return points ? polylineToPath(points) : null;
+        },
+    };
+    const converter = shapeConverters[tag];
+    if (!converter) {
+        return { converted: false, savings: 0 };
     }
+    pathData = converter();
     // Check if conversion was possible
     if (!pathData) {
         return { converted: false, savings: 0 };

package/dist/optimizers/style-optimizer.js

@@ -45,6 +45,11 @@ function parseCSSRules(cssText: string): Map<string, Map<string, string>> {
   let match;
 
   while ((match = ruleRegex.exec(cleaned)) !== null) {
+    // Prevent infinite loop if regex doesn't advance
+    if (match.index === ruleRegex.lastIndex) {
+      ruleRegex.lastIndex++;
+    }
+    
     const selector = match[1].trim();
     const declarationsText = match[2].trim();
 

package/dist/optimizers/svg-tree-parser.js

@@ -60,6 +60,10 @@ function parseAttributes(attrString) {
     const attrRegex = /([a-zA-Z][a-zA-Z0-9-:]*)=["']([^"']*)["']/g;
     let match;
     while ((match = attrRegex.exec(attrString)) !== null) {
+        // Prevent infinite loop if regex doesn't advance
+        if (match.index === attrRegex.lastIndex) {
+            attrRegex.lastIndex++;
+        }
         const [, name, value] = match;
         attrs.set(name, value);
     }

package/dist/optimizers/transform-collapsing.js

@@ -220,21 +220,17 @@ function applyTransformToPath(node, matrix) {
  * Apply transform to shape coordinates
  */
 function applyTransformToShape(node, matrix) {
-    switch (node.tag) {
-        case 'rect':
-            return applyTransformToRect(node, matrix);
-        case 'circle':
-            return applyTransformToCircle(node, matrix);
-        case 'line':
-            return applyTransformToLine(node, matrix);
-        case 'polygon':
-        case 'polyline':
-            return applyTransformToPoints(node, matrix);
-        case 'path':
-            return applyTransformToPath(node, matrix);
-        default:
-            return false;
-    }
+    // O(1) object lookup for shape tag → transform handler
+    const shapeHandlers = {
+        rect: applyTransformToRect,
+        circle: applyTransformToCircle,
+        line: applyTransformToLine,
+        polygon: applyTransformToPoints,
+        polyline: applyTransformToPoints,
+        path: applyTransformToPath,
+    };
+    const handler = shapeHandlers[node.tag];
+    return handler ? handler(node, matrix) : false;
 }
 /**
  * Collapse transforms by propagating down the tree

package/dist/optimizers/transform-optimizer.js

@@ -36,6 +36,10 @@ export function parseTransformList(transformStr) {
     const regex = /(\w+)\s*\([^)]+\)/g;
     let match;
     while ((match = regex.exec(transformStr)) !== null) {
+        // Prevent infinite loop if regex doesn't advance
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
         const cmd = parseTransformCommand(match[0]);
         if (cmd) {
             transforms.push(cmd);
@@ -63,32 +67,27 @@ function multiplyMatrices(m1, m2) {
  */
 function transformToMatrix(transform) {
     const { type, values } = transform;
-    switch (type) {
-        case 'matrix':
-            if (values.length === 6) {
-                return values;
-            }
-            return IDENTITY_MATRIX;
-        case 'translate': {
+    // O(1) object lookup for transform type → matrix factory
+    const matrixFactories = {
+        matrix: () => (values.length === 6 ? values : IDENTITY_MATRIX),
+        translate: () => {
             const tx = values[0] || 0;
             const ty = values[1] || 0;
             return [1, 0, 0, 1, tx, ty];
-        }
-        case 'scale': {
+        },
+        scale: () => {
             const sx = values[0] || 1;
             const sy = values[1] !== undefined ? values[1] : sx;
             return [sx, 0, 0, sy, 0, 0];
-        }
-        case 'rotate': {
+        },
+        rotate: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const cos = Math.cos(rad);
             const sin = Math.sin(rad);
-            // Rotate around point (cx, cy) if provided
             if (values.length === 3) {
                 const cx = values[1];
                 const cy = values[2];
-                // translate(-cx, -cy) × rotate(angle) × translate(cx, cy)
                 return [
                     cos,
                     sin,
@@ -99,22 +98,22 @@ function transformToMatrix(transform) {
                 ];
             }
             return [cos, sin, -sin, cos, 0, 0];
-        }
-        case 'skewX': {
+        },
+        skewX: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const tan = Math.tan(rad);
             return [1, 0, tan, 1, 0, 0];
-        }
-        case 'skewY': {
+        },
+        skewY: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const tan = Math.tan(rad);
             return [1, tan, 0, 1, 0, 0];
-        }
-        default:
-            return IDENTITY_MATRIX;
-    }
+        },
+    };
+    const factory = matrixFactories[type];
+    return factory ? factory() : IDENTITY_MATRIX;
 }
 /**
  * Consolidate transform list into single matrix

package/dist/optimizers/types.js

@@ -45,78 +45,68 @@ export function getDefaultOptConfig(level) {
         shapeConversionThreshold: 5,
         optimizationLevel: level,
     };
-    switch (level) {
-        case OptLevel.NONE:
-            return {
-                ...baseConfig,
-                removeMetadata: false,
-                removeComments: false,
-                normalizeWhitespace: false,
-                removeUnnecessaryAttrs: false,
-                shortenColors: false,
-                removeEmptyContainers: false,
-                removeDoctype: false,
-                removeXMLProcInst: false,
-                enableNumericOptimization: false,
-                enableStyleOptimization: false,
-                enableTransformOptimization: false,
-                enableTransformCollapsing: false,
-                enablePathOptimization: false,
-                enablePathSimplification: false,
-            };
-        case OptLevel.BASIC:
-            return baseConfig;
-        case OptLevel.BALANCED:
-            return {
-                ...baseConfig,
-                removeHiddenElements: true,
-                floatPrecision: 3,
-                enableNumericOptimization: true,
-                enableStyleOptimization: true,
-                enableTransformOptimization: false,
-                enableTransformCollapsing: false,
-                enablePathOptimization: false,
-            };
-        case OptLevel.AGGRESSIVE:
-            return {
-                ...baseConfig,
-                removeHiddenElements: true,
-                mergePaths: true,
-                collapseGroups: true,
-                floatPrecision: 2,
-                pathTolerance: 0.7,
-                sortAttrs: true,
-                enableNumericOptimization: true,
-                enableStyleOptimization: true,
-                enableTransformOptimization: true,
-                enableTransformCollapsing: true,
-                enablePathOptimization: true,
-                // DISABLED: Shape conversion conflicts with floatPrecision=2
-                // Causes visual regressions (coordinates get rounded before conversion)
-                shapeConversion: false,
-                shapeConversionThreshold: 5,
-            };
-        case OptLevel.MAXIMUM:
-            return {
-                ...baseConfig,
-                removeHiddenElements: true,
-                mergePaths: true,
-                collapseGroups: true,
-                inlineStyles: true,
-                floatPrecision: 1,
-                pathTolerance: 0.9,
-                sortAttrs: true,
-                removeViewBox: false, // Keep viewBox even at maximum for compatibility
-                enableNumericOptimization: true,
-                enableStyleOptimization: true,
-                enableTransformOptimization: true,
-                enableTransformCollapsing: true,
-                enablePathOptimization: true,
-                enablePathSimplification: true,
-                shapeConversion: true,
-                shapeConversionThreshold: 0, // Convert even 1-byte savings
-            };
-        default:
-            return baseConfig;
-    }
+    // O(1) object lookup for optimization level → config overrides
+    const levelOverrides = {
+        [OptLevel.NONE]: {
+            removeMetadata: false,
+            removeComments: false,
+            normalizeWhitespace: false,
+            removeUnnecessaryAttrs: false,
+            shortenColors: false,
+            removeEmptyContainers: false,
+            removeDoctype: false,
+            removeXMLProcInst: false,
+            enableNumericOptimization: false,
+            enableStyleOptimization: false,
+            enableTransformOptimization: false,
+            enableTransformCollapsing: false,
+            enablePathOptimization: false,
+            enablePathSimplification: false,
+        },
+        [OptLevel.BASIC]: {},
+        [OptLevel.BALANCED]: {
+            removeHiddenElements: true,
+            floatPrecision: 3,
+            enableNumericOptimization: true,
+            enableStyleOptimization: true,
+            enableTransformOptimization: false,
+            enableTransformCollapsing: false,
+            enablePathOptimization: false,
+        },
+        [OptLevel.AGGRESSIVE]: {
+            removeHiddenElements: true,
+            mergePaths: true,
+            collapseGroups: true,
+            floatPrecision: 2,
+            pathTolerance: 0.7,
+            sortAttrs: true,
+            enableNumericOptimization: true,
+            enableStyleOptimization: true,
+            enableTransformOptimization: true,
+            enableTransformCollapsing: true,
+            enablePathOptimization: true,
+            shapeConversion: false,
+            shapeConversionThreshold: 5,
+        },
+        [OptLevel.MAXIMUM]: {
+            removeHiddenElements: true,
+            mergePaths: true,
+            collapseGroups: true,
+            inlineStyles: true,
+            floatPrecision: 1,
+            pathTolerance: 0.9,
+            sortAttrs: true,
+            removeViewBox: false,
+            enableNumericOptimization: true,
+            enableStyleOptimization: true,
+            enableTransformOptimization: true,
+            enableTransformCollapsing: true,
+            enablePathOptimization: true,
+            enablePathSimplification: true,
+            shapeConversion: true,
+            shapeConversionThreshold: 0,
+        },
+    };
+    const overrides = levelOverrides[level] ?? {};
+    return { ...baseConfig, ...overrides };
 }

package/dist/plugins/gradient-optimizer.js

@@ -44,6 +44,10 @@ function removeDuplicateStops(gradientContent) {
     const seen = new Set();
     let match;
     while ((match = stopRegex.exec(gradientContent)) !== null) {
+        // Prevent infinite loop if regex doesn't advance
+        if (match.index === stopRegex.lastIndex) {
+            stopRegex.lastIndex++;
+        }
         const stopTag = match[0];
         const normalized = stopTag.replace(/\s+/g, ' ').trim();
         if (!seen.has(normalized)) {

package/dist/processors/svg-processor.js

@@ -187,7 +187,7 @@ export class SVGProcessor {
         const baseName = path.basename(fileName, '.svg');
         // Object lookup map for naming conventions - O(1) performance
         const namingHandlers = {
-            kebab: () => toPascalCase(baseName),
+            kebab: () => toKebabCase(baseName),
             camel: () => {
                 const pascalName = toPascalCase(baseName);
                 return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
@@ -340,13 +340,26 @@ export class SVGProcessor {
                 error: error,
             };
             logger.error(`Failed to process ${svgFilePath}:`, error);
+            // Immediately remove failed jobs to prevent memory leaks
+            this.processingQueue.delete(jobId);
             return result;
         }
         finally {
-            // Clean up completed jobs after some time
-            setTimeout(() => {
-                this.processingQueue.delete(jobId);
-            }, 30000); // 30 seconds
+            // Clean up completed jobs after a short delay (allows stats queries)
+            if (job.status === 'completed') {
+                setTimeout(() => {
+                    this.processingQueue.delete(jobId);
+                }, 30000); // 30 seconds
+            }
+            // Cap queue size as a safety net to prevent unbounded growth
+            if (this.processingQueue.size > 10000) {
+                const oldestEntries = Array.from(this.processingQueue.entries())
+                    .filter(([, j]) => j.status === 'completed' || j.status === 'failed')
+                    .slice(0, this.processingQueue.size - 5000);
+                for (const [key] of oldestEntries) {
+                    this.processingQueue.delete(key);
+                }
+            }
         }
     }
     /**
@@ -354,13 +367,18 @@ export class SVGProcessor {
      */
     getProcessingStats() {
         const jobs = Array.from(this.processingQueue.values());
-        return {
+        // Direct property increment via object key — O(1) per job, avoids switch branching
+        const stats = {
             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,
+            pending: 0,
+            processing: 0,
+            completed: 0,
+            failed: 0,
         };
+        for (const job of jobs) {
+            stats[job.status]++;
+        }
+        return stats;
     }
     /**
      * Clear processing queue

package/dist/services/config.js

@@ -1,6 +1,14 @@
 import path from 'path';
 import { FileSystem } from '../utils/native.js';
 import { logger } from '../core/logger.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Get package version dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf-8'));
+const CURRENT_VERSION = packageJson.version;
 /**
  * Professional configuration management service
  */
@@ -21,7 +29,7 @@ export class ConfigService {
     getDefaultConfig() {
         return {
             // Configuration Version (for migration compatibility)
-            version: '4.0.0',
+            version: CURRENT_VERSION,
             // Source & Output
             source: './src/assets/svg',
             output: './src/components/icons',
@@ -130,7 +138,7 @@ export class ConfigService {
                 return this.cachedConfig;
             }
             // Check if migration is needed
-            if (!configData.version || configData.version !== '4.0.0') {
+            if (!configData.version || configData.version !== CURRENT_VERSION) {
                 logger.info('Detected older configuration version, migrating...');
                 const migratedConfig = this.migrateConfig(configData);
                 this.cachedConfig = migratedConfig;
@@ -220,16 +228,21 @@ export class ConfigService {
      * Migrate configuration from older versions to v4.0.0
      */
     migrateConfig(config) {
+        // Validate config is not null/undefined
+        if (!config || typeof config !== 'object') {
+            logger.warn('Invalid config provided for migration, using defaults');
+            return this.getDefaultConfig();
+        }
         const currentVersion = config.version || '3.0.0';
-        // No migration needed if already v4.0.0
-        if (currentVersion === '4.0.0') {
-            return config;
+        // No migration needed if already current version
+        if (currentVersion === CURRENT_VERSION) {
+            return { ...this.getDefaultConfig(), ...config };
         }
-        logger.info(`Migrating configuration from ${currentVersion} to 4.0.0...`);
+        logger.info(`Migrating configuration from ${currentVersion} to ${CURRENT_VERSION}...`);
         // Migration from v3.x to v4.0.0
         const migratedConfig = { ...config };
         // Add version field
-        migratedConfig.version = '4.0.0';
+        migratedConfig.version = CURRENT_VERSION;
         // Ensure plugins array exists (new in v4.0.0)
         if (!migratedConfig.plugins) {
             migratedConfig.plugins = [];
@@ -262,10 +275,14 @@ export class ConfigService {
                 logger.info(`Migrated optimization level: ${oldOptimization} → ${migratedConfig.performance.optimization}`);
             }
         }
-        // Save migrated config
-        this.writeConfig(migratedConfig);
-        logger.success('Configuration migrated to v4.0.0');
-        return migratedConfig;
+        // Save migrated config merged with defaults to ensure all new keys exist
+        const mergedMigratedConfig = {
+            ...this.getDefaultConfig(),
+            ...migratedConfig,
+        };
+        this.writeConfig(mergedMigratedConfig);
+        logger.success(`Configuration migrated from ${currentVersion} to ${CURRENT_VERSION}`);
+        return mergedMigratedConfig;
     }
     /**
      * Validate configuration

package/dist/services/file-watcher.js

@@ -59,10 +59,15 @@ export class FileWatcherService {
         if (this.debounceTimers.has(debounceKey)) {
             clearTimeout(this.debounceTimers.get(debounceKey));
         }
-        // Set new timer
+        // Set new timer with error handling
         const timer = setTimeout(async () => {
             this.debounceTimers.delete(debounceKey);
-            await this.processFileEvent(watchId, eventType, filePath);
+            try {
+                await this.processFileEvent(watchId, eventType, filePath);
+            }
+            catch (error) {
+                logger.error(`Failed to process file event for ${filePath}:`, error);
+            }
         }, this.debounceDelay);
         this.debounceTimers.set(debounceKey, timer);
     }
@@ -130,7 +135,7 @@ export class FileWatcherService {
             watcher.close();
             this.watchers.delete(watchId);
             this.eventHandlers.delete(watchId);
-            // Clear any pending debounce timers for this watcher
+            // Clear all pending debounce timers for this watcher to prevent orphaned timers
             for (const [key, timer] of this.debounceTimers.entries()) {
                 if (key.startsWith(`${watchId}-`)) {
                     clearTimeout(timer);

package/dist/services/svg-service.d.ts

@@ -11,7 +11,7 @@ export declare class SVGService {
     /**
      * Set optimizer level for SVG processing
      */
-    private setOptimizerLevel;
+    setOptimizerLevel(level: string): void;
     /**
      * Build all SVG files from source to output directory
      */

package/dist/services/svg-service.js

@@ -25,8 +25,15 @@ export class SVGService {
      * Set optimizer level for SVG processing
      */
     setOptimizerLevel(level) {
-        const validLevels = ['none', 'basic', 'balanced', 'aggressive', 'maximum'];
-        if (!validLevels.includes(level.toLowerCase())) {
+        // O(1) Set lookup instead of O(n) Array.includes()
+        const validLevels = new Set([
+            'none',
+            'basic',
+            'balanced',
+            'aggressive',
+            'maximum',
+        ]);
+        if (!validLevels.has(level.toLowerCase())) {
             logger.warn(`Invalid optimization level "${level}". Using "basic" instead.`);
             svgProcessor.setOptimizationLevel(OptLevel.BASIC);
             return;
@@ -117,15 +124,21 @@ export class SVGService {
                 });
             }
         }
-        // Log summary
-        const successful = results.filter(r => r.success).length;
-        const failed = results.filter(r => !r.success).length;
-        logger.info(`Build complete: ${successful} successful, ${failed} failed`);
-        if (failed > 0) {
+        // Log summary - single pass through results
+        const successfulResults = [];
+        const failedResults = [];
+        for (const result of results) {
+            if (result.success) {
+                successfulResults.push(result);
+            }
+            else {
+                failedResults.push(result);
+            }
+        }
+        logger.info(`Build complete: ${successfulResults.length} successful, ${failedResults.length} failed`);
+        if (failedResults.length > 0) {
             logger.warn('Some files failed to process:');
-            results
-                .filter(r => !r.success)
-                .forEach(r => {
+            failedResults.forEach(r => {
                 logger.warn(`  - ${r.file}: ${r.error?.message}`);
             });
         }
@@ -210,7 +223,7 @@ export class SVGService {
             },
             unlink: async () => {
                 logger.info(`SVG removed: ${fileName}`);
-                await this.handleFileRemoval(event.filePath, outDir);
+                await this.handleFileRemoval(event.filePath, outDir, config);
             },
         };
         const handler = eventHandlers[event.type];

package/dist/utils/native.d.ts

@@ -45,7 +45,6 @@ export declare class FileSystem {
     private static _readdir;
     private static _stat;
     private static _mkdir;
-    private static _rmdir;
     private static _unlink;
     static exists(path: string): Promise<boolean>;
     static readFile(path: string, encoding?: BufferEncoding): Promise<string>;