image-asset-manager/dist/core/ImageAssetManager.js

A comprehensive image asset management tool for frontend projects

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImageAssetManager = void 0;
const config_1 = require("../config");
const FileScanner_1 = require("./FileScanner");
class ImageAssetManager {
    constructor(configManager) {
        this.configManager = configManager || new config_1.ConfigManager();
        this.fileScanner = new FileScanner_1.FileScannerImpl();
        console.log("Image Asset Manager initialized");
    }
    formatBytes(bytes) {
        if (bytes === 0)
            return "0 B";
        const k = 1024;
        const sizes = ["B", "KB", "MB", "GB"];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
    }
    async start(options) {
        console.log(`Starting Image Asset Manager for project: ${options.projectPath}`);
        console.log(`Port: ${options.port}`);
        console.log(`Watch mode: ${options.watch}`);
        console.log(`Optimize: ${options.optimize}`);
        // This will be the main entry point that combines scan and serve
        await this.scan(options);
        if (options.watch) {
            await this.serve(options);
        }
    }
    async scan(options, scanOptions) {
        const config = this.configManager.getConfig();
        if (!scanOptions?.silent) {
            console.log(`📁 Scanning project at: ${options.projectPath}`);
            console.log(`🔍 Include patterns: ${(options.include || []).join(", ")}`);
            console.log(`🚫 Exclude patterns: ${(options.exclude || []).join(", ")}`);
            if (scanOptions?.verbose) {
                console.log(`⚙️  Max depth: ${config.scan.maxDepth}`);
                console.log(`🔗 Follow symlinks: ${config.scan.followSymlinks}`);
                console.log(`📊 Output format: ${scanOptions.outputFormat || "table"}`);
            }
        }
        // 实现基本的文件扫描功能
        try {
            const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
            const path = await Promise.resolve().then(() => __importStar(require("path")));
            // 使用配置中的包含和排除模式
            const includePatterns = options.include && options.include.length > 0
                ? options.include
                : config.scan.include;
            const excludePatterns = options.exclude && options.exclude.length > 0
                ? options.exclude
                : config.scan.exclude;
            if (!scanOptions?.silent) {
                console.log(`\n🔍 Scanning with patterns:`);
                console.log(`   Include: ${includePatterns.join(", ")}`);
                console.log(`   Exclude: ${excludePatterns.join(", ")}`);
            }
            // 扫描文件
            const allFiles = [];
            for (const pattern of includePatterns) {
                const files = await glob(pattern, {
                    cwd: options.projectPath,
                    ignore: excludePatterns,
                    absolute: true,
                });
                allFiles.push(...files);
            }
            // 去重
            const uniqueFiles = [...new Set(allFiles)];
            // 获取文件信息
            const imageFiles = [];
            let totalSize = 0;
            for (const filePath of uniqueFiles) {
                try {
                    const stats = await fs.promises.stat(filePath);
                    const relativePath = path.relative(options.projectPath, filePath);
                    const fileName = path.basename(filePath);
                    const extension = path.extname(filePath).toLowerCase().slice(1);
                    imageFiles.push({
                        path: filePath,
                        relativePath,
                        name: fileName,
                        extension,
                        size: stats.size,
                        modifiedAt: stats.mtime,
                    });
                    totalSize += stats.size;
                }
                catch (error) {
                    if (scanOptions?.verbose) {
                        console.warn(`⚠️  Could not read file: ${filePath}`);
                    }
                }
            }
            // 按扩展名分组统计
            const extensionStats = {};
            imageFiles.forEach((file) => {
                if (!extensionStats[file.extension]) {
                    extensionStats[file.extension] = { count: 0, size: 0 };
                }
                extensionStats[file.extension].count++;
                extensionStats[file.extension].size += file.size;
            });
            // 输出结果
            if (scanOptions?.outputFormat === "json") {
                console.log(JSON.stringify({
                    projectPath: options.projectPath,
                    totalFiles: imageFiles.length,
                    totalSize,
                    files: imageFiles,
                    extensionStats,
                }, null, 2));
            }
            else if (scanOptions?.outputFormat === "csv") {
                console.log("Path,RelativePath,Name,Extension,Size,ModifiedAt");
                imageFiles.forEach((file) => {
                    console.log(`"${file.path}","${file.relativePath}","${file.name}","${file.extension}",${file.size},"${file.modifiedAt.toISOString()}"`);
                });
            }
            else {
                // 表格格式输出
                if (!scanOptions?.silent) {
                    console.log(`\n📋 Found ${imageFiles.length} image files:`);
                    if (scanOptions?.verbose && imageFiles.length > 0) {
                        console.log("\n📁 Files by directory:");
                        const dirGroups = {};
                        imageFiles.forEach((file) => {
                            const dir = path.dirname(file.relativePath) || ".";
                            if (!dirGroups[dir])
                                dirGroups[dir] = [];
                            dirGroups[dir].push(file);
                        });
                        Object.entries(dirGroups).forEach(([dir, files]) => {
                            console.log(`\n  📂 ${dir}/ (${files.length} files)`);
                            files.slice(0, 10).forEach((file) => {
                                const sizeStr = this.formatBytes(file.size);
                                console.log(`    • ${file.name} (${sizeStr})`);
                            });
                            if (files.length > 10) {
                                console.log(`    ... and ${files.length - 10} more files`);
                            }
                        });
                    }
                }
            }
            if (scanOptions?.showStats && !scanOptions?.silent) {
                console.log("\n📊 Project Statistics:");
                console.log(`• Total images: ${imageFiles.length}`);
                console.log(`• Total size: ${this.formatBytes(totalSize)}`);
                console.log(`• Average size: ${imageFiles.length > 0
                    ? this.formatBytes(Math.round(totalSize / imageFiles.length))
                    : "0 B"}`);
                console.log("\n📈 By file type:");
                Object.entries(extensionStats)
                    .sort(([, a], [, b]) => b.count - a.count)
                    .forEach(([ext, stats]) => {
                    console.log(`  • ${ext.toUpperCase()}: ${stats.count} files (${this.formatBytes(stats.size)})`);
                });
            }
        }
        catch (error) {
            console.error("❌ Error during scanning:", error);
            if (scanOptions?.verbose) {
                console.error(error);
            }
        }
    }
    async serve(options, serveOptions) {
        const config = this.configManager.getConfig();
        if (!serveOptions?.silent) {
            console.log(`🌐 Starting web server on port: ${options.port}`);
            console.log(`🏠 Host: ${serveOptions?.host || config.server.host}`);
            console.log(`🔒 CORS: ${serveOptions?.cors !== false ? "✅" : "❌"}`);
            if (serveOptions?.verbose) {
                console.log(`📁 Static path: ${config.server.staticPath || "built-in"}`);
                console.log(`🔐 Authentication: ${serveOptions?.auth ? "✅" : "❌"}`);
                console.log(`🔒 SSL: ${serveOptions?.ssl ? "✅" : "❌"}`);
            }
        }
        // 首先扫描图片
        if (!serveOptions?.silent) {
            console.log("🔍 Scanning images...");
        }
        const images = await this.scanImagesForServer(options);
        console.log("images", images);
        // 启动 Web 服务器
        const { WebServer } = await Promise.resolve().then(() => __importStar(require("./WebServer")));
        const webServer = new WebServer();
        // 计算详细统计数据
        const categoryBreakdown = {};
        const sizeBreakdown = {};
        const formatBreakdown = {};
        images.forEach((img) => {
            // 分类统计
            const category = img.category || "other";
            categoryBreakdown[category] = (categoryBreakdown[category] || 0) + 1;
            // 格式统计
            const format = img.extension.toLowerCase();
            formatBreakdown[format] = (formatBreakdown[format] || 0) + 1;
            // 大小分类统计
            const sizeInKB = img.size / 1024;
            let sizeCategory;
            if (sizeInKB < 10) {
                sizeCategory = "small"; // < 10KB
            }
            else if (sizeInKB < 100) {
                sizeCategory = "medium"; // 10KB - 100KB
            }
            else if (sizeInKB < 1024) {
                sizeCategory = "large"; // 100KB - 1MB
            }
            else {
                sizeCategory = "xlarge"; // > 1MB
            }
            sizeBreakdown[sizeCategory] = (sizeBreakdown[sizeCategory] || 0) + 1;
        });
        // 简单的使用情况分析（模拟）
        const unusedFiles = [];
        const usedFiles = new Map();
        // 简单的启发式：假设某些类型的文件更可能未使用
        images.forEach((img) => {
            // 简单的启发式规则
            const isLikelyUnused = img.category === "other" ||
                img.name.includes("temp") ||
                img.name.includes("backup") ||
                img.name.includes("old") ||
                img.name.includes("unused") ||
                img.size < 1024; // 很小的文件可能是测试文件
            if (isLikelyUnused) {
                unusedFiles.push({ id: img.id, path: img.path, name: img.name });
            }
            else {
                // 模拟使用次数
                const usageCount = Math.floor(Math.random() * 5) + 1;
                usedFiles.set(img.id, {
                    references: Array(usageCount)
                        .fill(0)
                        .map((_, i) => ({
                        file: `src/component${i}.tsx`,
                        line: Math.floor(Math.random() * 100) + 1,
                        type: "import",
                    })),
                });
            }
        });
        // 准备服务器数据
        const serverData = {
            images,
            usage: { usedFiles, unusedFiles, totalReferences: usedFiles.size },
            duplicates: [],
            stats: {
                totalImages: images.length,
                totalSize: images.reduce((sum, img) => sum + img.size, 0),
                duplicateCount: 0,
                unusedCount: unusedFiles.length,
                categoryBreakdown,
                sizeBreakdown,
                formatBreakdown,
            },
            config: {
                projectPath: options.projectPath,
                excludePatterns: options.exclude || config.scan.exclude,
                includePatterns: options.include || config.scan.include,
                optimizeOptions: config.optimize,
                frameworks: config.generate.frameworks,
            },
        };
        await webServer.start(options.port, serverData);
        if (!serveOptions?.silent) {
            console.log(`✅ Server is running at http://${serveOptions?.host || "localhost"}:${options.port}`);
            console.log("Press Ctrl+C to stop the server");
        }
        // 保持服务器运行
        return new Promise((resolve) => {
            process.on("SIGINT", () => {
                console.log("\n🛑 Shutting down server...");
                webServer.stop().then(() => {
                    resolve();
                });
            });
        });
    }
    async optimize(options, optimizeOptions) {
        const config = this.configManager.getConfig();
        if (!optimizeOptions?.silent) {
            console.log(`⚡ Optimizing images in: ${options.projectPath}`);
            console.log(`📁 Output: ${optimizeOptions?.outputDir || "in-place"}`);
            console.log(`🎯 Quality: ${optimizeOptions?.quality || config.optimize.png.quality}`);
            if (optimizeOptions?.verbose) {
                console.log(`🖼️  PNG Quality: ${optimizeOptions?.pngQuality || config.optimize.png.quality}`);
                console.log(`📸 JPG Quality: ${optimizeOptions?.jpgQuality || config.optimize.jpg.quality}`);
                console.log(`🌐 WebP Quality: ${optimizeOptions?.webpQuality || config.optimize.webp.quality}`);
                console.log(`📈 Progressive: ${optimizeOptions?.progressive !== false ? "✅" : "❌"}`);
                console.log(`💾 Keep Original: ${optimizeOptions?.keepOriginal !== false ? "✅" : "❌"}`);
                console.log(`📦 Batch Size: ${optimizeOptions?.batchSize || 10}`);
                console.log(`⚡ Parallel: ${optimizeOptions?.parallel || 4}`);
                console.log(`🔍 Dry Run: ${optimizeOptions?.dryRun ? "✅" : "❌"}`);
            }
        }
        // TODO: Implement optimization logic
        console.log("Optimization functionality will be implemented in task 4");
        if (optimizeOptions?.dryRun && !optimizeOptions?.silent) {
            console.log("\n🔍 Dry run completed - no files were modified");
            console.log("• Estimated savings: 0 B (0%)");
            console.log("• Files to optimize: 0");
        }
    }
    async generate(options, generateOptions) {
        const config = this.configManager.getConfig();
        if (!generateOptions?.silent) {
            console.log(`🔧 Generating code for project: ${options.projectPath}`);
            console.log(`🎯 Framework: ${generateOptions?.framework || config.generate.frameworks[0]}`);
            console.log(`📁 Output: ${generateOptions?.outputDir || config.generate.outputDir}`);
            console.log(`📝 TypeScript: ${generateOptions?.typescript !== false ? "✅" : "❌"}`);
            if (generateOptions?.verbose) {
                console.log(`🏷️  Component Prefix: ${generateOptions?.componentPrefix || config.generate.componentPrefix}`);
                console.log(`📦 Barrel File: ${generateOptions?.barrelFile ? "✅" : "❌"}`);
                console.log(`👀 Watch Mode: ${generateOptions?.watch ? "✅" : "❌"}`);
            }
        }
        // TODO: Implement code generation logic
        console.log("Code generation functionality will be implemented in task 5");
        if (!generateOptions?.silent) {
            console.log("\n✅ Code generation completed:");
            console.log("• Type definitions: 0 files");
            console.log("• Components: 0 files");
            console.log("• Import files: 0 files");
        }
        if (generateOptions?.watch && !generateOptions?.silent) {
            console.log("\n👀 Watching for changes... Press Ctrl+C to stop");
        }
    }
    async scanImagesForServer(options) {
        try {
            const config = this.configManager.getConfig();
            const scanOptions = {
                extensions: [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".ico"],
                recursive: true,
                excludePatterns: options.exclude && options.exclude.length > 0
                    ? options.exclude
                    : config.scan.exclude,
                maxDepth: 0, // No depth limit
            };
            console.log(`🔍 Scanning images in: ${options.projectPath}`);
            // Use FileScanner to properly extract metadata
            const imageFiles = await this.fileScanner.scanDirectory(options.projectPath, scanOptions);
            // Transform to server format
            const images = imageFiles.map((file, index) => ({
                id: `img_${index}`,
                path: file.path,
                relativePath: file.relativePath,
                name: file.name + file.extension,
                extension: file.extension.slice(1), // Remove the dot
                size: file.size,
                hash: file.hash,
                dimensions: file.dimensions, // Now has actual dimensions!
                createdAt: file.createdAt,
                modifiedAt: file.modifiedAt,
                category: file.category,
                url: `/project-assets/${file.relativePath.replace(/\\/g, "/")}`,
            }));
            console.log(`✅ Found ${images.length} images`);
            return images;
        }
        catch (error) {
            console.error("❌ Error scanning images:", error);
            return [];
        }
    }
    getCategoryFromPath(filePath) {
        const lowerPath = filePath.toLowerCase();
        if (lowerPath.includes("icon"))
            return "icons";
        if (lowerPath.includes("logo"))
            return "logos";
        if (lowerPath.includes("background"))
            return "backgrounds";
        if (lowerPath.includes("avatar"))
            return "avatars";
        if (lowerPath.includes("flag"))
            return "flags";
        if (lowerPath.includes("brand"))
            return "brands";
        if (lowerPath.includes("auth"))
            return "auth";
        if (lowerPath.includes("illustration"))
            return "illustrations";
        return "other";
    }
}
exports.ImageAssetManager = ImageAssetManager;
//# sourceMappingURL=ImageAssetManager.js.map