svger-cli 2.0.0 → 2.0.2

package/dist/core/error-handler.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Enhanced error handling system with detailed error tracking and recovery
+ */
+export interface SVGError {
+    code: string;
+    message: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    context?: Record<string, any>;
+    timestamp: number;
+    stack?: string;
+}
+export interface ErrorRecoveryStrategy {
+    canRecover(error: SVGError): boolean;
+    recover(error: SVGError, context?: any): Promise<any>;
+}
+export declare class SVGErrorHandler {
+    private static instance;
+    private errorHistory;
+    private recoveryStrategies;
+    private readonly maxHistorySize;
+    private constructor();
+    static getInstance(): SVGErrorHandler;
+    /**
+     * Handle an error with context and attempted recovery
+     */
+    handleError(error: Error | SVGError, context?: Record<string, any>): Promise<{
+        recovered: boolean;
+        result?: any;
+    }>;
+    /**
+     * Register a custom error recovery strategy
+     */
+    registerRecoveryStrategy(errorCode: string, strategy: ErrorRecoveryStrategy): void;
+    /**
+     * Get error statistics
+     */
+    getErrorStats(): {
+        total: number;
+        bySeverity: Record<string, number>;
+        byCode: Record<string, number>;
+        recentErrors: SVGError[];
+    };
+    /**
+     * Clear error history
+     */
+    clearHistory(): void;
+    private normalizeError;
+    private categorizeError;
+    private determineSeverity;
+    private logError;
+    private addToHistory;
+    private attemptRecovery;
+    private setupDefaultStrategies;
+}
+export declare const errorHandler: SVGErrorHandler;
+/**
+ * Utility function to wrap async operations with error handling
+ */
+export declare function withErrorHandling<T>(operation: () => Promise<T>, context?: Record<string, any>): Promise<T | null>;
+/**
+ * Decorator for automatic error handling
+ */
+export declare function handleErrors(context?: Record<string, any>): (target: any, propertyName: string, descriptor: PropertyDescriptor) => void;

package/dist/core/error-handler.js

@@ -0,0 +1,224 @@
+import { logger } from '../core/logger.js';
+export class SVGErrorHandler {
+    static instance;
+    errorHistory = [];
+    recoveryStrategies = new Map();
+    maxHistorySize = 100;
+    constructor() {
+        this.setupDefaultStrategies();
+    }
+    static getInstance() {
+        if (!SVGErrorHandler.instance) {
+            SVGErrorHandler.instance = new SVGErrorHandler();
+        }
+        return SVGErrorHandler.instance;
+    }
+    /**
+     * Handle an error with context and attempted recovery
+     */
+    async handleError(error, context) {
+        const svgError = this.normalizeError(error, context);
+        // Log error based on severity
+        this.logError(svgError);
+        // Add to history
+        this.addToHistory(svgError);
+        // Attempt recovery
+        const recoveryResult = await this.attemptRecovery(svgError, context);
+        return recoveryResult;
+    }
+    /**
+     * Register a custom error recovery strategy
+     */
+    registerRecoveryStrategy(errorCode, strategy) {
+        this.recoveryStrategies.set(errorCode, strategy);
+        logger.debug(`Recovery strategy registered for error code: ${errorCode}`);
+    }
+    /**
+     * Get error statistics
+     */
+    getErrorStats() {
+        const bySeverity = {};
+        const byCode = {};
+        this.errorHistory.forEach(error => {
+            bySeverity[error.severity] = (bySeverity[error.severity] || 0) + 1;
+            byCode[error.code] = (byCode[error.code] || 0) + 1;
+        });
+        return {
+            total: this.errorHistory.length,
+            bySeverity,
+            byCode,
+            recentErrors: this.errorHistory.slice(-10)
+        };
+    }
+    /**
+     * Clear error history
+     */
+    clearHistory() {
+        this.errorHistory = [];
+        logger.debug('Error history cleared');
+    }
+    // Private methods
+    normalizeError(error, context) {
+        if ('code' in error && 'severity' in error) {
+            return error;
+        }
+        // Convert regular Error to SVGError
+        const regularError = error;
+        return {
+            code: this.categorizeError(regularError),
+            message: regularError.message,
+            severity: this.determineSeverity(regularError),
+            context: context || {},
+            timestamp: Date.now(),
+            stack: regularError.stack
+        };
+    }
+    categorizeError(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes('file not found') || message.includes('enoent')) {
+            return 'FILE_NOT_FOUND';
+        }
+        if (message.includes('permission') || message.includes('eacces')) {
+            return 'PERMISSION_DENIED';
+        }
+        if (message.includes('parse') || message.includes('syntax')) {
+            return 'PARSE_ERROR';
+        }
+        if (message.includes('timeout')) {
+            return 'TIMEOUT_ERROR';
+        }
+        if (message.includes('network') || message.includes('connection')) {
+            return 'NETWORK_ERROR';
+        }
+        if (message.includes('svg') && message.includes('invalid')) {
+            return 'INVALID_SVG';
+        }
+        return 'UNKNOWN_ERROR';
+    }
+    determineSeverity(error) {
+        const message = error.message.toLowerCase();
+        if (message.includes('critical') || message.includes('fatal')) {
+            return 'critical';
+        }
+        if (message.includes('file not found') || message.includes('permission')) {
+            return 'high';
+        }
+        if (message.includes('parse') || message.includes('invalid')) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    logError(error) {
+        const logMessage = `[${error.code}] ${error.message}`;
+        switch (error.severity) {
+            case 'critical':
+                logger.error('CRITICAL:', logMessage, error.context);
+                break;
+            case 'high':
+                logger.error('HIGH:', logMessage, error.context);
+                break;
+            case 'medium':
+                logger.warn('MEDIUM:', logMessage, error.context);
+                break;
+            case 'low':
+                logger.info('LOW:', logMessage, error.context);
+                break;
+        }
+    }
+    addToHistory(error) {
+        this.errorHistory.push(error);
+        // Maintain history size limit
+        if (this.errorHistory.length > this.maxHistorySize) {
+            this.errorHistory = this.errorHistory.slice(-this.maxHistorySize);
+        }
+    }
+    async attemptRecovery(error, context) {
+        const strategy = this.recoveryStrategies.get(error.code);
+        if (!strategy) {
+            logger.debug(`No recovery strategy found for error code: ${error.code}`);
+            return { recovered: false };
+        }
+        try {
+            if (!strategy.canRecover(error)) {
+                logger.debug(`Recovery strategy declined to handle error: ${error.code}`);
+                return { recovered: false };
+            }
+            logger.info(`Attempting recovery for error: ${error.code}`);
+            const result = await strategy.recover(error, context);
+            logger.success(`Successfully recovered from error: ${error.code}`);
+            return { recovered: true, result };
+        }
+        catch (recoveryError) {
+            logger.error(`Recovery failed for error ${error.code}:`, recoveryError);
+            return { recovered: false };
+        }
+    }
+    setupDefaultStrategies() {
+        // File not found recovery
+        this.registerRecoveryStrategy('FILE_NOT_FOUND', {
+            canRecover: (error) => error.context?.filePath && error.context?.canSkip === true,
+            recover: async (error, context) => {
+                logger.warn(`Skipping missing file: ${error.context?.filePath}`);
+                return { skipped: true, filePath: error.context?.filePath };
+            }
+        });
+        // Invalid SVG recovery
+        this.registerRecoveryStrategy('INVALID_SVG', {
+            canRecover: (error) => error.context?.svgContent,
+            recover: async (error, context) => {
+                logger.info('Attempting to clean invalid SVG content');
+                // Basic SVG cleanup
+                let cleaned = error.context?.svgContent || '';
+                // Remove potentially problematic content
+                cleaned = cleaned
+                    .replace(/<script[\s\S]*?<\/script>/gi, '') // Remove scripts
+                    .replace(/<style[\s\S]*?<\/style>/gi, '') // Remove styles
+                    .replace(/on\w+="[^"]*"/gi, '') // Remove event handlers
+                    .replace(/javascript:[^"']*/gi, ''); // Remove javascript: URLs
+                return { cleanedContent: cleaned };
+            }
+        });
+        // Permission denied recovery
+        this.registerRecoveryStrategy('PERMISSION_DENIED', {
+            canRecover: (error) => error.context?.alternative,
+            recover: async (error, context) => {
+                logger.warn(`Using alternative path due to permission issue: ${error.context?.alternative}`);
+                return { alternativePath: error.context?.alternative };
+            }
+        });
+        logger.debug('Default error recovery strategies loaded');
+    }
+}
+// Export singleton instance and utilities
+export const errorHandler = SVGErrorHandler.getInstance();
+/**
+ * Utility function to wrap async operations with error handling
+ */
+export async function withErrorHandling(operation, context) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        const result = await errorHandler.handleError(error, context);
+        if (result.recovered) {
+            return result.result;
+        }
+        // Re-throw if not recovered and severity is high
+        const svgError = error;
+        if (svgError.severity === 'high' || svgError.severity === 'critical') {
+            throw error;
+        }
+        return null;
+    }
+}
+/**
+ * Decorator for automatic error handling
+ */
+export function handleErrors(context) {
+    return function (target, propertyName, descriptor) {
+        const method = descriptor.value;
+        descriptor.value = async function (...args) {
+            return withErrorHandling(() => method.apply(this, args), { method: propertyName, ...context });
+        };
+    };
+}

package/dist/core/framework-templates.d.ts

@@ -0,0 +1,17 @@
+import { ComponentGenerationOptions, FrameworkType } from '../types/index.js';
+export type { FrameworkType, FrameworkOptions } from '../types/index.js';
+export declare class FrameworkTemplateEngine {
+    generateComponent(options: ComponentGenerationOptions): string;
+    getFileExtension(framework: FrameworkType, typescript?: boolean): string;
+    private parseSVG;
+    private generateReactComponent;
+    private generateVueComponent;
+    private generateSvelteComponent;
+    private generateAngularComponent;
+    private generateSolidComponent;
+    private generatePreactComponent;
+    private generateLitComponent;
+    private generateVanillaComponent;
+    private toKebabCase;
+}
+export declare const frameworkTemplateEngine: FrameworkTemplateEngine;

package/{src/core/framework-templates.ts → dist/core/framework-templates.js}

@@ -1,89 +1,65 @@
-import { ComponentGenerationOptions, FrameworkType, FrameworkOptions } from '../types/index.js';
-
-// Re-export types for convenience
-export type { FrameworkType, FrameworkOptions } from '../types/index.js';
-
-interface SVGAttributes {
-  viewBox?: string;
-  width?: string;
-  height?: string;
-  fill?: string;
-  stroke?: string;
-  xmlns?: string;
-  [key: string]: string | undefined;
-}
-
 export class FrameworkTemplateEngine {
-  
-  public generateComponent(options: ComponentGenerationOptions): string {
-    const { framework, componentName, svgContent, typescript = true, frameworkOptions = {} } = options;
-
-    switch (framework) {
-      case 'react':
-        return this.generateReactComponent(componentName, svgContent, typescript, frameworkOptions);
-      case 'vue':
-        return this.generateVueComponent(componentName, svgContent, typescript, frameworkOptions);
-      case 'svelte':
-        return this.generateSvelteComponent(componentName, svgContent, typescript);
-      case 'angular':
-        return this.generateAngularComponent(componentName, svgContent, typescript, frameworkOptions);
-      case 'solid':
-        return this.generateSolidComponent(componentName, svgContent, typescript);
-      case 'preact':
-        return this.generatePreactComponent(componentName, svgContent, typescript);
-      case 'lit':
-        return this.generateLitComponent(componentName, svgContent, typescript);
-      case 'vanilla':
-        return this.generateVanillaComponent(componentName, svgContent, typescript);
-      default:
-        throw new Error(`Unsupported framework: ${framework}`);
+    generateComponent(options) {
+        const { framework, componentName, svgContent, typescript = true, frameworkOptions = {} } = options;
+        switch (framework) {
+            case 'react':
+                return this.generateReactComponent(componentName, svgContent, typescript, frameworkOptions);
+            case 'vue':
+                return this.generateVueComponent(componentName, svgContent, typescript, frameworkOptions);
+            case 'svelte':
+                return this.generateSvelteComponent(componentName, svgContent, typescript);
+            case 'angular':
+                return this.generateAngularComponent(componentName, svgContent, typescript, frameworkOptions);
+            case 'solid':
+                return this.generateSolidComponent(componentName, svgContent, typescript);
+            case 'preact':
+                return this.generatePreactComponent(componentName, svgContent, typescript);
+            case 'lit':
+                return this.generateLitComponent(componentName, svgContent, typescript);
+            case 'vanilla':
+                return this.generateVanillaComponent(componentName, svgContent, typescript);
+            default:
+                throw new Error(`Unsupported framework: ${framework}`);
+        }
     }
-  }
-
-  public getFileExtension(framework: FrameworkType, typescript: boolean = true): string {
-    const tsExt = typescript ? 'ts' : 'js';
-    
-    switch (framework) {
-      case 'react':
-      case 'preact':
-      case 'solid':
-        return typescript ? 'tsx' : 'jsx';
-      case 'vue':
-        return 'vue';
-      case 'svelte':
-        return 'svelte';
-      case 'angular':
-        return `component.${tsExt}`;
-      case 'lit':
-      case 'vanilla':
-        return `${tsExt}`;
-      default:
-        return `${tsExt}`;
+    getFileExtension(framework, typescript = true) {
+        const tsExt = typescript ? 'ts' : 'js';
+        switch (framework) {
+            case 'react':
+            case 'preact':
+            case 'solid':
+                return typescript ? 'tsx' : 'jsx';
+            case 'vue':
+                return 'vue';
+            case 'svelte':
+                return 'svelte';
+            case 'angular':
+                return `component.${tsExt}`;
+            case 'lit':
+            case 'vanilla':
+                return `${tsExt}`;
+            default:
+                return `${tsExt}`;
+        }
     }
-  }
-
-  private parseSVG(svgContent: string): { attributes: SVGAttributes; innerContent: string } {
-    const svgMatch = svgContent.match(/<svg([^>]*)>([\s\S]*?)<\/svg>/);
-    if (!svgMatch) {
-      return { attributes: {}, innerContent: svgContent };
+    parseSVG(svgContent) {
+        const svgMatch = svgContent.match(/<svg([^>]*)>([\s\S]*?)<\/svg>/);
+        if (!svgMatch) {
+            return { attributes: {}, innerContent: svgContent };
+        }
+        const attributesString = svgMatch[1];
+        const innerContent = svgMatch[2].trim();
+        const attributes = {};
+        const attrRegex = /(\w+(?:-\w+)*)="([^"]*)"/g;
+        let match;
+        while ((match = attrRegex.exec(attributesString)) !== null) {
+            attributes[match[1]] = match[2];
+        }
+        return { attributes, innerContent };
     }
-
-    const attributesString = svgMatch[1];
-    const innerContent = svgMatch[2].trim();
-    const attributes: SVGAttributes = {};
-
-    const attrRegex = /(\w+(?:-\w+)*)="([^"]*)"/g;
-    let match;
-    while ((match = attrRegex.exec(attributesString)) !== null) {
-      attributes[match[1]] = match[2];
-    }
-
-    return { attributes, innerContent };
-  }
-
-  private generateReactComponent(componentName: string, svgContent: string, typescript: boolean, options: FrameworkOptions): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    return `import React from "react";
+    generateReactComponent(componentName, svgContent, typescript, options) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        return `import React from "react";
 import type { SVGProps } from "react";
 
 export interface ${componentName}Props extends SVGProps<SVGSVGElement> {
@@ -119,14 +95,12 @@ ${componentName}.displayName = "${componentName}";
 
 export default ${componentName};
 `;
-  }
-
-  private generateVueComponent(componentName: string, svgContent: string, typescript: boolean, options: FrameworkOptions): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    const { scriptSetup = true } = options;
-
-    if (scriptSetup && typescript) {
-      return `<template>
+    }
+    generateVueComponent(componentName, svgContent, typescript, options) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        const { scriptSetup = true } = options;
+        if (scriptSetup && typescript) {
+            return `<template>
   <svg
     :class="className"
     :style="style"
@@ -160,9 +134,8 @@ withDefaults(defineProps<Props>(), {
 });
 </script>
 `;
-    }
-
-    return `<template>
+        }
+        return `<template>
   <svg
     :class="className"
     :style="style"
@@ -194,11 +167,10 @@ export default defineComponent({
 });
 </script>
 `;
-  }
-
-  private generateSvelteComponent(componentName: string, svgContent: string, typescript: boolean): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    return `<script${typescript ? ' lang="ts"' : ''}>
+    }
+    generateSvelteComponent(componentName, svgContent, typescript) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        return `<script${typescript ? ' lang="ts"' : ''}>
   export let className${typescript ? ': string' : ''} = '';
   export let style${typescript ? ': string' : ''} = '';
   export let width${typescript ? ': string | number' : ''} = ${attributes.width || 24};
@@ -221,14 +193,12 @@ export default defineComponent({
   ${innerContent}
 </svg>
 `;
-  }
-
-  private generateAngularComponent(componentName: string, svgContent: string, typescript: boolean, options: FrameworkOptions): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    const { standalone = true } = options;
-    const kebabName = this.toKebabCase(componentName);
-
-    return `import { Component, Input${standalone ? ', ChangeDetectionStrategy' : ''} } from '@angular/core';
+    }
+    generateAngularComponent(componentName, svgContent, typescript, options) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        const { standalone = true } = options;
+        const kebabName = this.toKebabCase(componentName);
+        return `import { Component, Input${standalone ? ', ChangeDetectionStrategy' : ''} } from '@angular/core';
 
 @Component({
   selector: '${kebabName}',
@@ -256,11 +226,10 @@ export class ${componentName}Component {
   @Input() stroke: string = '';
 }
 `;
-  }
-
-  private generateSolidComponent(componentName: string, svgContent: string, typescript: boolean): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    return `import { Component, JSX } from 'solid-js';
+    }
+    generateSolidComponent(componentName, svgContent, typescript) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        return `import { Component, JSX } from 'solid-js';
 
 export interface ${componentName}Props extends JSX.SvgSVGAttributes<SVGSVGElement> {
   className?: string;
@@ -288,11 +257,10 @@ const ${componentName}: Component<${componentName}Props> = (props) => (
 
 export default ${componentName};
 `;
-  }
-
-  private generatePreactComponent(componentName: string, svgContent: string, typescript: boolean): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    return `import { h, FunctionComponent } from 'preact';
+    }
+    generatePreactComponent(componentName, svgContent, typescript) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        return `import { h, FunctionComponent } from 'preact';
 import { JSX } from 'preact/jsx-runtime';
 
 export interface ${componentName}Props extends JSX.SVGAttributes<SVGSVGElement> {
@@ -331,13 +299,11 @@ const ${componentName}: FunctionComponent<${componentName}Props> = ({
 
 export default ${componentName};
 `;
-  }
-
-  private generateLitComponent(componentName: string, svgContent: string, typescript: boolean): string {
-    const { attributes, innerContent } = this.parseSVG(svgContent);
-    const kebabName = this.toKebabCase(componentName);
-
-    return `import { LitElement, html, css, svg } from 'lit';
+    }
+    generateLitComponent(componentName, svgContent, typescript) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        const kebabName = this.toKebabCase(componentName);
+        return `import { LitElement, html, css, svg } from 'lit';
 import { customElement, property } from 'lit/decorators.js';
 
 @customElement('${kebabName}')
@@ -373,11 +339,10 @@ declare global {
   }
 }
 `;
-  }
-
-  private generateVanillaComponent(componentName: string, svgContent: string, typescript: boolean): string {
-    const { attributes, innerContent} = this.parseSVG(svgContent);
-    return `export interface ${componentName}Options {
+    }
+    generateVanillaComponent(componentName, svgContent, typescript) {
+        const { attributes, innerContent } = this.parseSVG(svgContent);
+        return `export interface ${componentName}Options {
   className?: string;
   width?: string | number;
   height?: string | number;
@@ -415,14 +380,12 @@ export function ${componentName}(options: ${componentName}Options = {}): SVGSVGE
   return svg;
 }
 `;
-  }
-
-  private toKebabCase(str: string): string {
-    return str
-      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-      .replace(/([A-Z])([A-Z])([a-z])/g, '$1-$2$3')
-      .toLowerCase();
-  }
+    }
+    toKebabCase(str) {
+        return str
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/([A-Z])([A-Z])([a-z])/g, '$1-$2$3')
+            .toLowerCase();
+    }
 }
-
 export const frameworkTemplateEngine = new FrameworkTemplateEngine();

package/dist/core/logger.d.ts

@@ -0,0 +1,22 @@
+import { Logger, LogLevel } from '../types/index.js';
+/**
+ * Professional logging service with configurable levels and formatted output
+ */
+export declare class LoggerService implements Logger {
+    private static instance;
+    private logLevel;
+    private enableColors;
+    private constructor();
+    static getInstance(): LoggerService;
+    setLogLevel(level: LogLevel): void;
+    setColors(enabled: boolean): void;
+    private shouldLog;
+    private formatMessage;
+    private getPrefix;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+}
+export declare const logger: LoggerService;