{"version":3,"sources":["../src/index.ts","../src/core/optimizer.ts","../src/core/texture-config.ts","../src/core/batch-processor.ts"],"sourcesContent":["// Main library exports\nexport { TextureOptimizer } from './core/optimizer.js';\nexport type { OptimizationResult } from './core/optimizer.js';\n\nexport { TextureConfigManager } from './core/texture-config.js';\nexport type { TextureSettings, TextureEntry, TextureConfig } from './core/texture-config.js';\n\nexport { BatchProcessor } from './core/batch-processor.js';\nexport type { BatchProcessorOptions } from './core/batch-processor.js';\n\n// Re-export for convenience\nexport * from './core/optimizer.js';\nexport * from './core/texture-config.js';\nexport * from './core/batch-processor.js';","import sharp from 'sharp'; // Sharp is the main dependency!\nimport fs from 'fs/promises';\nimport path from 'path';\nimport type { TextureSettings as ConfigSettings } from './texture-config';\n\n// These settings are passed from the BatchProcessor\nexport type OptimizerSettings = ConfigSettings & {\n    format: 'png' | 'jpg' | 'webp';\n};\n\nexport interface OptimizationResult {\n    success: boolean;\n    inputPath: string;\n    outputPath?: string;\n    originalSize: { width: number; height: number; bytes: number };\n    optimizedSize: { width: number; height: number; bytes: number };\n    reductionPercent: number;\n    settings: OptimizerSettings; // Use OptimizerSettings\n    processingTime: number;\n    error?: string;\n}\n\n/**\n * TextureOptimizer uses Sharp to process and optimize textures\n * Handles resizing, compression, and format conversion\n */\nexport class TextureOptimizer {\n    constructor(private settings: OptimizerSettings) { } // Use OptimizerSettings\n\n    /**\n     * Optimize a single texture using Sharp\n     * Applies maxSize constraint, power-of-2 resizing, and compression\n     */\n    async optimize(inputPath: string, outputPath: string): Promise<OptimizationResult> {\n        const startTime = Date.now();\n\n        try {\n            // Read original file\n            const originalBuffer = await fs.readFile(inputPath);\n            const metadata = await sharp(originalBuffer).metadata();\n\n            const originalSize = {\n                width: metadata.width!,\n                height: metadata.height!,\n                bytes: originalBuffer.length\n            };\n\n            // Calculate target dimensions based on maxSize setting\n            // powerOf2 is now always true\n            const targetDims = this.calculateTargetDimensions(\n                originalSize.width,\n                originalSize.height,\n                this.settings.maxSize!\n            );\n\n            // Create Sharp processing pipeline\n            let pipeline = sharp(originalBuffer)\n                .resize(targetDims.width, targetDims.height, {\n                    fit: 'inside', // Hardcoded maintainAspectRatio: true\n                    kernel: sharp.kernel.lanczos3, // Best quality resizing algorithm\n                    withoutEnlargement: true // Never upscale beyond original\n                });\n\n            // Apply format-specific compression\n            pipeline = this.applyCompression(pipeline);\n\n            // Generate output buffer\n            const outputBuffer = await pipeline.toBuffer();\n\n            // Write optimized texture to disk\n            await fs.mkdir(path.dirname(outputPath), { recursive: true });\n            await fs.writeFile(outputPath, outputBuffer);\n\n            const processingTime = Date.now() - startTime;\n            const reductionPercent = ((originalSize.bytes - outputBuffer.length) / originalSize.bytes) * 100;\n\n            return {\n                success: true,\n                inputPath,\n                outputPath,\n                originalSize,\n                optimizedSize: {\n                    width: targetDims.width,\n                    height: targetDims.height,\n                    bytes: outputBuffer.length\n                },\n                reductionPercent,\n                settings: this.settings,\n                processingTime\n            };\n\n        } catch (error) {\n            return {\n                success: false,\n                inputPath,\n                originalSize: { width: 0, height: 0, bytes: 0 },\n                optimizedSize: { width: 0, height: 0, bytes: 0 },\n                reductionPercent: 0,\n                settings: this.settings,\n                processingTime: Date.now() - startTime,\n                error: (error as Error).message\n            };\n        }\n    }\n\n    /**\n     * Calculate target dimensions based on maxSize and power-of-2 settings\n     * Luna Labs recommendation: Never exceed 1024x1024 for playable ads\n     */\n    private calculateTargetDimensions(\n        width: number,\n        height: number,\n        maxSize: number\n    ): { width: number; height: number } {\n\n        // Power-of-2 calculation is now the default\n        const toPowerOf2 = (val: number): number => {\n            return Math.pow(2, Math.floor(Math.log2(val)));\n        };\n\n        let targetWidth = toPowerOf2(width);\n        let targetHeight = toPowerOf2(height);\n\n        // Apply maxSize constraint to each dimension\n        targetWidth = Math.min(targetWidth, maxSize);\n        targetHeight = Math.min(targetHeight, maxSize);\n\n        // Ensure we don't exceed maxSize on either dimension\n        if (targetWidth > maxSize || targetHeight > maxSize) {\n            const aspectRatio = width / height;\n            if (width > height) {\n                targetWidth = maxSize;\n                targetHeight = toPowerOf2(maxSize / aspectRatio);\n            } else {\n                targetHeight = maxSize;\n                targetWidth = toPowerOf2(maxSize * aspectRatio);\n            }\n        }\n\n        // Clamp to valid range\n        targetWidth = Math.max(32, Math.min(targetWidth, maxSize));\n        targetHeight = Math.max(32, Math.min(targetHeight, maxSize));\n\n        return { width: targetWidth, height: targetHeight };\n    }\n\n    /**\n     * Apply format-specific compression using Sharp\n     * Different formats require different optimization strategies\n     */\n    private applyCompression(pipeline: sharp.Sharp): sharp.Sharp {\n        switch (this.settings.format) {\n            case 'jpg': // Handles 'jpeg' via format detection in batch-processor\n                return pipeline.jpeg({\n                    quality: this.settings.quality,\n                    mozjpeg: true, // Use mozjpeg for better compression\n                    progressive: true\n                });\n\n            case 'png':\n                return pipeline.png({\n                    quality: this.settings.quality,\n                    compressionLevel: 9, // Maximum compression\n                    effort: 7 // High effort for better results\n                });\n\n            case 'webp':\n                return pipeline.webp({\n                    quality: this.settings.quality,\n                    effort: 6 // Good balance of speed and quality\n                });\n\n            default:\n                return pipeline;\n        }\n    }\n}","import fs from 'fs/promises';\nimport path from 'path';\nimport { z } from 'zod';\n\n// Zod schema for validation\nconst textureSettingsSchema = z.object({\n    maxSize: z.union([z.literal(32), z.literal(64), z.literal(128), z.literal(256), z.literal(512), z.literal(1024), z.literal(2048), z.literal(4096)]).optional(),\n    quality: z.number().min(1).max(100).optional(),\n});\n\nconst textureEntrySchema = z.object({\n    name: z.string(),\n    useDefault: z.boolean(),\n    maxSize: z.union([z.literal(32), z.literal(64), z.literal(128), z.literal(256), z.literal(512), z.literal(1024), z.literal(2048), z.literal(4096)]).optional(),\n    quality: z.number().min(1).max(100).optional(),\n});\n\nconst textureConfigSchema = z.object({\n    defaultSettings: textureSettingsSchema,\n    textures: z.array(textureEntrySchema)\n});\n\nexport type TextureSettings = z.infer<typeof textureSettingsSchema>;\nexport type TextureEntry = z.infer<typeof textureEntrySchema>;\nexport type TextureConfig = z.infer<typeof textureConfigSchema>;\n\n/**\n * Manages per-texture configuration based on texture names\n * Loads settings from texture-optimize-pro.json and matches by filename\n */\nexport class TextureConfigManager {\n    private config: TextureConfig;\n    private textureMap: Map<string, TextureEntry>;\n\n    constructor(config: TextureConfig) {\n        this.config = config;\n        this.textureMap = new Map();\n\n        // Build lookup map for fast access by texture name\n        for (const texture of config.textures) {\n            this.textureMap.set(texture.name.toLowerCase(), texture);\n        }\n    }\n\n    /**\n     * Load texture configuration from JSON file\n     */\n    static async loadFromFile(configPath: string): Promise<TextureConfigManager> {\n        try {\n            const content = await fs.readFile(configPath, 'utf-8');\n            const rawConfig = JSON.parse(content);\n            const config = textureConfigSchema.parse(rawConfig);\n            return new TextureConfigManager(config);\n        } catch (error) {\n            throw new Error(`Failed to load texture config from ${configPath}: ${(error as Error).message}`);\n        }\n    }\n\n    /**\n     * Get settings for a specific texture by matching its filename\n     * Example: \"player-sprite.png\" matches texture name \"player-sprite\"\n     */\n    getSettingsForTexture(texturePath: string): TextureSettings {\n        // Extract filename without extension\n        const basename = path.basename(texturePath, path.extname(texturePath));\n        const normalizedName = basename.toLowerCase();\n\n        // Try exact match\n        const textureEntry = this.textureMap.get(normalizedName);\n\n        if (!textureEntry) {\n            // No specific config found, use defaults\n            return { ...this.config.defaultSettings };\n        }\n\n        if (textureEntry.useDefault) {\n            // Texture is configured but set to use default settings\n            return { ...this.config.defaultSettings };\n        }\n\n        // Merge texture-specific settings with defaults (texture settings override defaults)\n        return {\n            maxSize: textureEntry.maxSize ?? this.config.defaultSettings.maxSize,\n            quality: textureEntry.quality ?? this.config.defaultSettings.quality,\n        };\n    }\n\n    /**\n     * Check if a texture has custom settings (not using defaults)\n     */\n    hasCustomSettings(texturePath: string): boolean {\n        const basename = path.basename(texturePath, path.extname(texturePath));\n        const normalizedName = basename.toLowerCase();\n        const entry = this.textureMap.get(normalizedName);\n        return entry !== undefined && !entry.useDefault;\n    }\n\n    /**\n     * Get all texture names that have configurations\n     */\n    getConfiguredTextures(): string[] {\n        return Array.from(this.textureMap.keys());\n    }\n\n    /**\n     * Get default settings\n     */\n    getDefaultSettings(): TextureSettings {\n        return { ...this.config.defaultSettings };\n    }\n}","import { glob } from 'glob';\nimport path from 'path';\nimport { TextureOptimizer, type OptimizationResult, type OptimizerSettings } from './optimizer';\nimport { TextureConfigManager } from './texture-config';\nimport chalk from 'chalk';\nimport fs from 'fs/promises';\n\nexport interface BatchProcessorOptions {\n    basePath: string;\n    outputDir?: string;\n    textureConfigPath: string; // Path to texture-optimize-pro.json\n    patterns?: string[];\n    exclude?: string[];\n    concurrency?: number;\n    verbose?: boolean;\n    inPlaceMode?: boolean; // New option for in-place optimization\n}\n\n// Supported formats\nconst SUPPORTED_FORMATS = ['png', 'jpg', 'jpeg', 'webp'];\ntype SupportedFormat = 'png' | 'jpg' | 'webp';\n\n/**\n * BatchProcessor scans directories for textures and processes them\n * based on per-texture configuration from textures.json\n */\nexport class BatchProcessor {\n    private configManager!: TextureConfigManager;\n    private options: Required<Omit<BatchProcessorOptions, 'outputDir' | 'inPlaceMode'>> & {\n        outputDir?: string;\n        inPlaceMode: boolean;\n    };\n\n    constructor(options: BatchProcessorOptions) {\n        this.options = {\n            patterns: [`**/*.{${SUPPORTED_FORMATS.join(',')}}`], // Use supported formats\n            exclude: ['**/node_modules/**', '**/_originalTexture/**'], // Exclude backup folder\n            concurrency: 10,\n            verbose: false,\n            inPlaceMode: !options.outputDir,\n            ...options\n        };\n    }\n\n    /**\n     * Initialize and process all textures\n     * Matches texture filenames to configuration entries\n     */\n    async processAll(): Promise<OptimizationResult[]> {\n        // Load texture configuration from texture-optimize-pro.json\n        console.log(chalk.blue(`📋 Loading texture configuration from: ${this.options.textureConfigPath}`));\n        this.configManager = await TextureConfigManager.loadFromFile(this.options.textureConfigPath);\n\n        const configuredTextures = this.configManager.getConfiguredTextures();\n        console.log(chalk.blue(`   Found ${configuredTextures.length} configured textures in config`));\n\n        // Find all texture files in base path\n        const files = await this.findTextures();\n        console.log(chalk.blue(`📁 Found ${files.length} texture files to process\\n`));\n\n        // Process in chunks for memory efficiency (Sharp can use a lot of memory)\n        const results: OptimizationResult[] = [];\n        const chunkSize = this.options.concurrency;\n\n        for (let i = 0; i < files.length; i += chunkSize) {\n            const chunk = files.slice(i, i + chunkSize);\n            const chunkResults = await Promise.all(\n                chunk.map(filePath => this.processTexture(filePath))\n            );\n\n            results.push(...chunkResults);\n\n            if (this.options.verbose) {\n                console.log(chalk.gray(`⏳ Progress: ${Math.min(i + chunkSize, files.length)}/${files.length}`));\n            }\n        }\n\n        this.printSummary(results);\n        return results;\n    }\n\n    /**\n * Process a single texture based on its name configuration\n * The texture name is matched against entries in texture-optimize-pro.json\n */\n    private async processTexture(inputPath: string): Promise<OptimizationResult> {\n        // Get settings for this specific texture by matching its filename\n        const settings = this.configManager.getSettingsForTexture(inputPath);\n\n        // Auto-detect format from input file extension\n        let ext = path.extname(inputPath).substring(1).toLowerCase();\n        if (ext === 'jpeg') {\n            ext = 'jpg';\n        }\n        const format = ext as SupportedFormat;\n\n        // Combine config settings with auto-detected format\n        const optimizerSettings: OptimizerSettings = {\n            ...settings,\n            format: format,\n            quality: settings.quality ?? 80,\n            maxSize: settings.maxSize ?? 512,\n        };\n\n        // Check if inputPath is from _originalTexture folder\n        const isFromBackupFolder = inputPath.includes('_originalTexture');\n\n        // Determine source, output path, and backup path based on mode\n        let sourcePath: string;\n        let outputPath: string;\n        let backupPath: string | undefined;\n        let isReoptimization = false;\n\n        if (isFromBackupFolder) {\n            // File is from _originalTexture, output to parent directory\n            sourcePath = inputPath;\n            const parentDir = path.dirname(path.dirname(inputPath)); // Go up two levels\n            const filename = path.basename(inputPath);\n            outputPath = path.join(parentDir, filename);\n            isReoptimization = true;\n\n            if (this.options.verbose) {\n                console.log(chalk.gray(`   📦 Using texture from _originalTexture folder: ${filename}`));\n            }\n        } else if (this.options.inPlaceMode) {\n            const inputDir = path.dirname(inputPath);\n            const inputFilename = path.basename(inputPath);\n            const backupDir = path.join(inputDir, '_originalTexture');\n\n            backupPath = path.join(backupDir, inputFilename);\n            outputPath = inputPath;\n\n            // Check if backup already exists\n            try {\n                await fs.access(backupPath);\n                // Backup exists, use it as source (re-optimization scenario)\n                sourcePath = backupPath;\n                isReoptimization = true;\n\n                if (this.options.verbose) {\n                    console.log(chalk.gray(`   📦 Using original from backup: ${path.basename(backupPath)}`));\n                }\n            } catch {\n                // Backup doesn't exist - BACKUP FIRST, then use current as source\n                sourcePath = inputPath;\n                // Create backup BEFORE optimization\n                await this.backupOriginal(inputPath, backupPath);\n            }\n        } else {\n            // Normal mode: output to specified directory\n            const relativePath = path.relative(this.options.basePath, inputPath);\n            const outputName = path.basename(relativePath);\n            outputPath = path.join(this.options.outputDir!, path.dirname(relativePath), outputName);\n\n            // Check if there's a backup in the source location\n            const inputDir = path.dirname(inputPath);\n            const inputFilename = path.basename(inputPath);\n            const potentialBackupPath = path.join(inputDir, '_originalTexture', inputFilename);\n\n            try {\n                await fs.access(potentialBackupPath);\n                sourcePath = potentialBackupPath;\n                isReoptimization = true;\n\n                if (this.options.verbose) {\n                    console.log(chalk.gray(`   📦 Using original from backup: ${path.basename(potentialBackupPath)}`));\n                }\n            } catch {\n                sourcePath = inputPath;\n            }\n        }\n\n        // Create optimizer with texture-specific settings\n        const optimizer = new TextureOptimizer(optimizerSettings);\n\n        try {\n            // Process using Sharp (from sourcePath, not inputPath)\n            const result = await optimizer.optimize(sourcePath, outputPath);\n\n            // Log result with color coding\n            if (result.success) {\n                const hasCustom = this.configManager.hasCustomSettings(inputPath);\n                const configType = hasCustom ? chalk.yellow('[CUSTOM]') : chalk.gray('[DEFAULT]');\n                const reduction = result.reductionPercent.toFixed(1);\n                const sizeMB = (result.optimizedSize.bytes / 1024 / 1024).toFixed(2);\n                const mode = this.options.inPlaceMode ? chalk.cyan('[IN-PLACE]') : '';\n                const reoptimizationTag = isReoptimization ? chalk.magenta('[RE-OPT]') : '';\n\n                console.log(\n                    `${chalk.green('✓')} ${mode} ${reoptimizationTag} ${configType} ${path.basename(inputPath)} → ${path.basename(outputPath)} ` +\n                    `(${reduction}% smaller, ${sizeMB} MB, ${result.optimizedSize.width}x${result.optimizedSize.height}, maxSize: ${optimizerSettings.maxSize}px)`\n                );\n            } else {\n                console.log(`${chalk.red('✗')} ${path.basename(inputPath)} - ${result.error}`);\n            }\n\n            return result;\n        } catch (error) {\n            console.log(`${chalk.red('✗')} ${path.basename(inputPath)} - ${(error as Error).message}`);\n            throw error;\n        }\n    }\n\n    /**\n     * Backup original texture to _originalTexture folder\n     */\n    private async backupOriginal(originalPath: string, backupPath: string): Promise<void> {\n        try {\n            // Create backup directory if it doesn't exist\n            await fs.mkdir(path.dirname(backupPath), { recursive: true });\n\n            // Copy original to backup location\n            await fs.copyFile(originalPath, backupPath);\n\n            if (this.options.verbose) {\n                console.log(chalk.gray(`   📦 Backed up: ${path.basename(originalPath)} → _originalTexture/`));\n            }\n        } catch (error) {\n            console.error(chalk.red(`   ⚠️  Failed to backup ${path.basename(originalPath)}: ${(error as Error).message}`));\n            throw error;\n        }\n    }\n\n    /**\n * Find all texture files matching patterns in the base path\n */\n    private async findTextures(): Promise<string[]> {\n        const allFiles: string[] = [];\n\n        for (const pattern of this.options.patterns) {\n            const files = await glob(pattern, {\n                cwd: this.options.basePath,\n                absolute: true,\n                ignore: this.options.exclude\n            });\n            allFiles.push(...files);\n        }\n\n        // Remove duplicates and sort\n        const uniqueFiles = [...new Set(allFiles)].sort();\n\n        // If no files found, check if there are files in _originalTexture folders\n        if (uniqueFiles.length === 0) {\n            console.log(chalk.yellow('⚠️  No textures found outside _originalTexture folders'));\n            console.log(chalk.blue('🔍 Searching for textures in _originalTexture folders...'));\n\n            for (const pattern of this.options.patterns) {\n                const backupFiles = await glob(`**/_originalTexture/${pattern}`, {\n                    cwd: this.options.basePath,\n                    absolute: true\n                });\n                allFiles.push(...backupFiles);\n            }\n\n            if (allFiles.length > 0) {\n                console.log(chalk.green(`✓ Found ${allFiles.length} textures in _originalTexture folders\\n`));\n            }\n        }\n\n        return [...new Set(allFiles)].sort();\n    }\n\n    /**\n     * Print comprehensive processing summary\n     */\n    private printSummary(results: OptimizationResult[]): void {\n        console.log('\\n' + chalk.bold.cyan('═'.repeat(50)));\n        console.log(chalk.bold.cyan('Processing Summary'));\n        console.log(chalk.bold.cyan('═'.repeat(50)));\n\n        const successful = results.filter(r => r.success);\n        const failed = results.filter(r => !r.success);\n        const withCustomSettings = results.filter(r => r.success && this.configManager.hasCustomSettings(r.inputPath));\n\n        console.log(chalk.green(`✓ Successful: ${successful.length}/${results.length}`));\n        console.log(chalk.yellow(`⚙ Custom settings applied: ${withCustomSettings.length}`));\n        console.log(chalk.gray(`📋 Default settings used: ${successful.length - withCustomSettings.length}`));\n\n        if (this.options.inPlaceMode) {\n            console.log(chalk.cyan(`📦 Originals backed up to: _originalTexture/ folders`));\n        }\n\n        if (failed.length > 0) {\n            console.log(chalk.red(`✗ Failed: ${failed.length}`));\n        }\n\n        // Calculate statistics\n        const totalOriginalBytes = successful.reduce((sum, r) => sum + r.originalSize.bytes, 0);\n        const totalOptimizedBytes = successful.reduce((sum, r) => sum + r.optimizedSize.bytes, 0);\n\n        // Avoid division by zero if totalOriginalBytes is 0\n        const totalReduction = totalOriginalBytes > 0\n            ? ((totalOriginalBytes - totalOptimizedBytes) / totalOriginalBytes) * 100\n            : 0;\n\n        const savedMB = (totalOriginalBytes - totalOptimizedBytes) / 1024 / 1024;\n\n        // Avoid division by zero if successful.length is 0\n        const avgProcessingTime = successful.length > 0\n            ? successful.reduce((sum, r) => sum + r.processingTime, 0) / successful.length\n            : 0;\n\n        console.log(chalk.bold('\\n📊 Size Statistics:'));\n        console.log(chalk.blue(`   Original size:  ${(totalOriginalBytes / 1024 / 1024).toFixed(2)} MB`));\n        console.log(chalk.blue(`   Optimized size: ${(totalOptimizedBytes / 1024 / 1024).toFixed(2)} MB`));\n        console.log(chalk.green(`   💾 Saved: ${savedMB.toFixed(2)} MB (${totalReduction.toFixed(1)}% reduction)`));\n        console.log(chalk.gray(`   ⚡ Avg processing time: ${avgProcessingTime.toFixed(0)}ms per texture`));\n\n        // Per-format breakdown\n        const formatStats = new Map<string, { count: number; bytes: number }>();\n        for (const result of successful) {\n            const format = result.settings.format!;\n            const existing = formatStats.get(format) || { count: 0, bytes: 0 };\n            formatStats.set(format, {\n                count: existing.count + 1,\n                bytes: existing.bytes + result.optimizedSize.bytes\n            });\n        }\n\n        console.log(chalk.bold('\\n📦 Format Breakdown:'));\n        for (const [format, stats] of formatStats) {\n            const sizeMB = (stats.bytes / 1024 / 1024).toFixed(2);\n            console.log(`   ${format.toUpperCase()}: ${stats.count} files (${sizeMB} MB)`);\n        }\n\n        // MaxSize distribution\n        const sizeDistribution = new Map<number, number>();\n        for (const result of successful) {\n            const maxSize = result.settings.maxSize!;\n            sizeDistribution.set(maxSize, (sizeDistribution.get(maxSize) || 0) + 1);\n        }\n\n        console.log(chalk.bold('\\n📏 MaxSize Distribution:'));\n        const sortedSizes = Array.from(sizeDistribution.entries()).sort((a, b) => a[0] - b[0]);\n        for (const [size, count] of sortedSizes) {\n            console.log(`   ${size}px: ${count} textures`);\n        }\n\n        console.log(chalk.bold.cyan('\\n' + '═'.repeat(50) + '\\n'));\n    }\n}"],"mappings":"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","names":["fs","sharp","path","import_promises","import_path","fs","path","import_path","import_promises","chalk","path","fs"]}