svger-cli 2.0.1 → 2.0.2

package/dist/services/config.js

@@ -0,0 +1,209 @@
+import path from 'path';
+import { FileSystem } from '../utils/native.js';
+import { logger } from '../core/logger.js';
+/**
+ * Professional configuration management service
+ */
+export class ConfigService {
+    static instance;
+    static CONFIG_FILE = '.svgconfig.json';
+    cachedConfig = null;
+    constructor() { }
+    static getInstance() {
+        if (!ConfigService.instance) {
+            ConfigService.instance = new ConfigService();
+        }
+        return ConfigService.instance;
+    }
+    /**
+     * Get the default configuration
+     */
+    getDefaultConfig() {
+        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
+     */
+    getConfigPath() {
+        return path.resolve(ConfigService.CONFIG_FILE);
+    }
+    /**
+     * Read configuration from file with caching
+     */
+    readConfig() {
+        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
+     */
+    writeConfig(config) {
+        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
+     */
+    async initConfig() {
+        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
+     */
+    setConfig(key, value) {
+        const config = this.readConfig();
+        // Support nested key paths like 'styleRules.fill'
+        const keys = key.split('.');
+        let current = 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
+     */
+    getConfig(key) {
+        const config = this.readConfig();
+        if (!key) {
+            return config;
+        }
+        // Support nested key paths
+        const keys = key.split('.');
+        let current = config;
+        for (const k of keys) {
+            if (!(k in current)) {
+                return undefined;
+            }
+            current = current[k];
+        }
+        return current;
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        const configToValidate = config || this.readConfig();
+        const errors = [];
+        // Required string fields
+        const requiredStringFields = ['source', 'output', 'defaultFill'];
+        for (const field of requiredStringFields) {
+            if (!configToValidate[field] || typeof configToValidate[field] !== '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];
+            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)
+     */
+    clearCache() {
+        this.cachedConfig = null;
+    }
+    /**
+     * Display current configuration
+     */
+    showConfig() {
+        const config = this.readConfig();
+        console.log('📄 Current Configuration:');
+        console.log(JSON.stringify(config, null, 2));
+    }
+}
+// Export singleton instance
+export const configService = ConfigService.getInstance();

package/dist/services/file-watcher.d.ts

@@ -0,0 +1,54 @@
+import { FileWatchEvent, WatchOptions } from '../types/index.js';
+/**
+ * Professional file watching service with debouncing and event filtering
+ */
+export declare class FileWatcherService {
+    private static instance;
+    private watchers;
+    private eventHandlers;
+    private debounceTimers;
+    private readonly debounceDelay;
+    private constructor();
+    static getInstance(): FileWatcherService;
+    /**
+     * Start watching a directory for SVG file changes
+     */
+    watchDirectory(watchPath: string, options?: Partial<WatchOptions>): Promise<string>;
+    /**
+     * Handle file system events with debouncing
+     */
+    private handleFileEvent;
+    /**
+     * Process debounced file events
+     */
+    private processFileEvent;
+    /**
+     * Register an event handler for a specific watcher
+     */
+    onFileEvent(watchId: string, handler: (event: FileWatchEvent) => void | Promise<void>): void;
+    /**
+     * Emit event to all registered handlers
+     */
+    private emitEvent;
+    /**
+     * Stop watching a specific directory
+     */
+    stopWatching(watchId: string): void;
+    /**
+     * Stop all watchers
+     */
+    stopAllWatchers(): void;
+    /**
+     * Get active watch statistics
+     */
+    getWatchStats(): {
+        activeWatchers: number;
+        pendingEvents: number;
+        totalHandlers: number;
+    };
+    /**
+     * Cleanup on shutdown
+     */
+    shutdown(): void;
+}
+export declare const fileWatcher: FileWatcherService;

package/dist/services/file-watcher.js

@@ -0,0 +1,180 @@
+import fs from 'fs';
+import path from 'path';
+import { FileSystem } from '../utils/native.js';
+import { logger } from '../core/logger.js';
+/**
+ * Professional file watching service with debouncing and event filtering
+ */
+export class FileWatcherService {
+    static instance;
+    watchers = new Map();
+    eventHandlers = new Map();
+    debounceTimers = new Map();
+    debounceDelay = 300; // milliseconds
+    constructor() { }
+    static getInstance() {
+        if (!FileWatcherService.instance) {
+            FileWatcherService.instance = new FileWatcherService();
+        }
+        return FileWatcherService.instance;
+    }
+    /**
+     * Start watching a directory for SVG file changes
+     */
+    async watchDirectory(watchPath, options = {}) {
+        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
+     */
+    handleFileEvent(watchId, eventType, filePath) {
+        // 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
+     */
+    async processFileEvent(watchId, eventType, filePath) {
+        try {
+            const exists = await FileSystem.exists(filePath);
+            let actualEventType;
+            // Determine actual event type
+            if (eventType === 'rename') {
+                actualEventType = exists ? 'add' : 'unlink';
+            }
+            else {
+                actualEventType = 'change';
+            }
+            const event = {
+                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
+     */
+    onFileEvent(watchId, handler) {
+        const handlers = this.eventHandlers.get(watchId) || [];
+        handlers.push(handler);
+        this.eventHandlers.set(watchId, handlers);
+    }
+    /**
+     * Emit event to all registered handlers
+     */
+    emitEvent(watchId, event) {
+        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) => {
+                        logger.error(`Error in file event handler:`, error);
+                    });
+                }
+            }
+            catch (error) {
+                logger.error(`Error in file event handler:`, error);
+            }
+        }
+    }
+    /**
+     * Stop watching a specific directory
+     */
+    stopWatching(watchId) {
+        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
+     */
+    stopAllWatchers() {
+        for (const watchId of this.watchers.keys()) {
+            this.stopWatching(watchId);
+        }
+        logger.info('Stopped all file watchers');
+    }
+    /**
+     * Get active watch statistics
+     */
+    getWatchStats() {
+        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
+     */
+    shutdown() {
+        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();

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

@@ -0,0 +1,81 @@
+import { BuildOptions, GenerateOptions, WatchOptions } from '../types/index.js';
+/**
+ * Main SVG service that orchestrates all SVG processing operations
+ */
+export declare class SVGService {
+    private static instance;
+    private activeWatchers;
+    lockService: LockService;
+    private constructor();
+    static getInstance(): SVGService;
+    /**
+     * Build all SVG files from source to output directory
+     */
+    buildAll(options: BuildOptions): Promise<void>;
+    /**
+     * Generate a React component from a single SVG file
+     */
+    generateSingle(options: GenerateOptions): Promise<void>;
+    /**
+     * Start watching SVG files for changes
+     */
+    startWatching(options: WatchOptions): Promise<string>;
+    /**
+     * Handle file watch events
+     */
+    private handleWatchEvent;
+    /**
+     * Process a watched file
+     */
+    private processWatchedFile;
+    /**
+     * Handle file removal in watch mode
+     */
+    private handleFileRemoval;
+    /**
+     * Stop watching files
+     */
+    stopWatching(watchId?: string): void;
+    /**
+     * Clean output directory
+     */
+    clean(outDir: string): Promise<void>;
+    /**
+     * Generate index.ts file with all component exports
+     */
+    private generateIndexFile;
+    /**
+     * Generate the content for index.ts file
+     */
+    private generateIndexContent;
+    /**
+     * Get service statistics
+     */
+    getStats(): {
+        activeWatchers: number;
+        processingQueue: any;
+        watcherStats: any;
+    };
+    /**
+     * Shutdown service
+     */
+    shutdown(): void;
+}
+/**
+ * Simple file locking service
+ */
+export declare class LockService {
+    private static instance;
+    private static readonly LOCK_FILE;
+    private cachedLocks;
+    private constructor();
+    static getInstance(): LockService;
+    private getLockFilePath;
+    private readLockFile;
+    private writeLockFile;
+    lockFiles(files: string[]): void;
+    unlockFiles(files: string[]): void;
+    isLocked(file: string): boolean;
+    clearCache(): void;
+}
+export declare const svgService: SVGService;