qasai 0.0.1

package/src/utils/compressor.ts

@@ -0,0 +1,437 @@
+import sharp from 'sharp';
+import { optimize } from 'svgo';
+import { readFile, writeFile, stat, mkdir, copyFile } from 'fs/promises';
+import { dirname, extname, basename, join } from 'path';
+import type { CompressOptions, CompressionResult, ImageFormat } from './types.js';
+import {
+	compressWithMozjpeg,
+	compressWithJpegtran,
+	compressWithPngquant,
+	compressWithOptipng,
+	compressWithGifsicle
+} from './engines.js';
+
+const SUPPORTED_FORMATS = ['.jpg', '.jpeg', '.png', '.webp', '.avif', '.gif', '.tiff', '.svg'];
+
+export function isSupportedFormat(file: string): boolean {
+	const ext = extname(file).toLowerCase();
+	return SUPPORTED_FORMATS.includes(ext);
+}
+
+export function getFormat(file: string): ImageFormat {
+	const ext = extname(file).toLowerCase().slice(1);
+	return ext as ImageFormat;
+}
+
+function parseResize(resize: string): { width?: number; height?: number; percent?: number } {
+	if (resize.endsWith('%')) {
+		return { percent: parseInt(resize) / 100 };
+	}
+	const [w, h] = resize.split('x').map(Number);
+	return { width: w || undefined, height: h || undefined };
+}
+
+async function compressSvg(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalContent = await readFile(inputPath, 'utf-8');
+	const originalSize = Buffer.byteLength(originalContent, 'utf-8');
+
+	const result = optimize(originalContent, {
+		multipass: true,
+		plugins: [
+			'preset-default',
+			'removeDimensions',
+			{
+				name: 'removeAttrs',
+				params: {
+					attrs: options.keepMetadata ? [] : ['data-.*']
+				}
+			}
+		]
+	});
+
+	await mkdir(dirname(outputPath), { recursive: true });
+	await writeFile(outputPath, result.data);
+
+	const compressedSize = Buffer.byteLength(result.data, 'utf-8');
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+async function needsResize(options: CompressOptions): Promise<boolean> {
+	return !!(options.resize || options.maxWidth || options.maxHeight);
+}
+
+async function resizeWithSharp(inputPath: string, options: CompressOptions): Promise<Buffer> {
+	let image = sharp(inputPath);
+	const metadata = await image.metadata();
+
+	if (options.resize) {
+		const { width, height, percent } = parseResize(options.resize);
+		if (percent && metadata.width && metadata.height) {
+			image = image.resize(
+				Math.round(metadata.width * percent),
+				Math.round(metadata.height * percent)
+			);
+		} else if (width || height) {
+			image = image.resize(width, height, { fit: 'inside', withoutEnlargement: true });
+		}
+	}
+
+	if (options.maxWidth || options.maxHeight) {
+		const maxW = options.maxWidth ? parseInt(options.maxWidth) : undefined;
+		const maxH = options.maxHeight ? parseInt(options.maxHeight) : undefined;
+		image = image.resize(maxW, maxH, { fit: 'inside', withoutEnlargement: true });
+	}
+
+	return image.toBuffer();
+}
+
+async function compressJpeg(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const engine = options.jpegEngine || 'mozjpeg';
+	let actualInput = inputPath;
+
+	if (await needsResize(options)) {
+		const buffer = await resizeWithSharp(inputPath, options);
+		const tempPath = outputPath + '.tmp.jpg';
+		await mkdir(dirname(tempPath), { recursive: true });
+		await sharp(buffer).jpeg({ quality: 100 }).toFile(tempPath);
+		actualInput = tempPath;
+	}
+
+	let result: CompressionResult;
+
+	switch (engine) {
+		case 'mozjpeg':
+			result = await compressWithMozjpeg(actualInput, outputPath, options);
+			break;
+		case 'jpegtran':
+			result = await compressWithJpegtran(actualInput, outputPath, options);
+			break;
+		case 'sharp':
+		default:
+			result = await compressWithSharpJpeg(actualInput, outputPath, options);
+			break;
+	}
+
+	if (actualInput !== inputPath) {
+		await import('fs/promises').then(fs => fs.unlink(actualInput).catch(() => {}));
+	}
+
+	result.file = inputPath;
+	return result;
+}
+
+async function compressWithSharpJpeg(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const quality = parseInt(options.quality || '80');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	let image = sharp(inputPath);
+
+	if (!options.keepMetadata) {
+		image = image.rotate();
+	}
+
+	await image
+		.jpeg({
+			quality: options.lossless ? 100 : quality,
+			progressive: options.progressive !== false,
+			mozjpeg: true
+		})
+		.toFile(outputPath);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+async function compressPng(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const engine = options.pngEngine || 'pngquant';
+	let actualInput = inputPath;
+
+	if (await needsResize(options)) {
+		const buffer = await resizeWithSharp(inputPath, options);
+		const tempPath = outputPath + '.tmp.png';
+		await mkdir(dirname(tempPath), { recursive: true });
+		await sharp(buffer).png().toFile(tempPath);
+		actualInput = tempPath;
+	}
+
+	let result: CompressionResult;
+
+	switch (engine) {
+		case 'pngquant':
+			result = await compressWithPngquant(actualInput, outputPath, options);
+			break;
+		case 'optipng':
+			result = await compressWithOptipng(actualInput, outputPath, options);
+			break;
+		case 'sharp':
+		default:
+			result = await compressWithSharpPng(actualInput, outputPath, options);
+			break;
+	}
+
+	if (actualInput !== inputPath) {
+		await import('fs/promises').then(fs => fs.unlink(actualInput).catch(() => {}));
+	}
+
+	result.file = inputPath;
+	return result;
+}
+
+async function compressWithSharpPng(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const quality = parseInt(options.quality || '80');
+	const effort = parseInt(options.effort || '6');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	let image = sharp(inputPath);
+
+	if (!options.keepMetadata) {
+		image = image.rotate();
+	}
+
+	await image
+		.png({
+			compressionLevel: Math.min(9, Math.round(effort * 0.9)),
+			palette: !options.lossless,
+			quality: options.lossless ? 100 : quality,
+			effort
+		})
+		.toFile(outputPath);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+async function compressGif(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const engine = options.gifEngine || 'gifsicle';
+
+	if (engine === 'gifsicle') {
+		return compressWithGifsicle(inputPath, outputPath, options);
+	}
+
+	return compressWithSharpGif(inputPath, outputPath, options);
+}
+
+async function compressWithSharpGif(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const effort = parseInt(options.effort || '6');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	await sharp(inputPath, { animated: true })
+		.gif({ effort })
+		.toFile(outputPath);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+async function compressRaster(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	let image = sharp(inputPath);
+	const metadata = await image.metadata();
+
+	const quality = parseInt(options.quality || '80');
+	const effort = parseInt(options.effort || '6');
+
+	if (options.resize) {
+		const { width, height, percent } = parseResize(options.resize);
+		if (percent && metadata.width && metadata.height) {
+			image = image.resize(
+				Math.round(metadata.width * percent),
+				Math.round(metadata.height * percent)
+			);
+		} else if (width || height) {
+			image = image.resize(width, height, { fit: 'inside', withoutEnlargement: true });
+		}
+	}
+
+	if (options.maxWidth || options.maxHeight) {
+		const maxW = options.maxWidth ? parseInt(options.maxWidth) : undefined;
+		const maxH = options.maxHeight ? parseInt(options.maxHeight) : undefined;
+		image = image.resize(maxW, maxH, { fit: 'inside', withoutEnlargement: true });
+	}
+
+	if (!options.keepMetadata) {
+		image = image.rotate();
+	}
+
+	const inputFormat = getFormat(inputPath);
+	const outputFormat = options.format || (inputFormat === 'jpeg' ? 'jpg' : inputFormat as string);
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	switch (outputFormat as string) {
+		case 'webp':
+			await image
+				.webp({
+					quality: options.lossless ? 100 : quality,
+					lossless: options.lossless || false,
+					effort
+				})
+				.toFile(outputPath);
+			break;
+
+		case 'avif':
+			await image
+				.avif({
+					quality: options.lossless ? 100 : quality,
+					lossless: options.lossless || false,
+					effort
+				})
+				.toFile(outputPath);
+			break;
+
+		case 'tiff':
+			await image
+				.tiff({
+					quality: options.lossless ? 100 : quality,
+					compression: options.lossless ? 'lzw' : 'jpeg'
+				})
+				.toFile(outputPath);
+			break;
+
+		default:
+			await copyFile(inputPath, outputPath);
+	}
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+export async function compressImage(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const format = getFormat(inputPath);
+
+	let finalOutputPath = outputPath;
+	if (options.format && options.format !== format) {
+		const dir = dirname(outputPath);
+		const name = basename(outputPath, extname(outputPath));
+		finalOutputPath = join(dir, `${name}.${options.format}`);
+	}
+
+	switch (format) {
+		case 'svg':
+			return compressSvg(inputPath, finalOutputPath, options);
+
+		case 'jpg':
+		case 'jpeg':
+			if (!options.format || options.format === 'jpg') {
+				return compressJpeg(inputPath, finalOutputPath, options);
+			}
+			return compressRaster(inputPath, finalOutputPath, options);
+
+		case 'png':
+			if (!options.format || options.format === 'png') {
+				return compressPng(inputPath, finalOutputPath, options);
+			}
+			return compressRaster(inputPath, finalOutputPath, options);
+
+		case 'gif':
+			if (!options.format) {
+				return compressGif(inputPath, finalOutputPath, options);
+			}
+			return compressRaster(inputPath, finalOutputPath, options);
+
+		default:
+			return compressRaster(inputPath, finalOutputPath, options);
+	}
+}
+
+export function formatBytes(bytes: number): string {
+	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]}`;
+}

package/src/utils/engines.ts

@@ -0,0 +1,220 @@
+import { execa } from 'execa';
+import { stat, copyFile, mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import type { CompressOptions, CompressionResult } from './types.js';
+
+async function getTempPath(ext: string): Promise<string> {
+	const tempDir = join(tmpdir(), 'qasai');
+	await mkdir(tempDir, { recursive: true });
+	return join(tempDir, `${randomUUID()}${ext}`);
+}
+
+export async function compressWithMozjpeg(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const mozjpeg = await import('mozjpeg');
+	const quality = parseInt(options.quality || '80');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	const args = [
+		'-quality', options.lossless ? '100' : String(quality),
+		'-outfile', outputPath,
+		inputPath
+	];
+
+	if (options.progressive !== false) {
+		args.unshift('-progressive');
+	}
+
+	await execa(mozjpeg.default, args);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+export async function compressWithJpegtran(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const jpegtran = await import('jpegtran-bin');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	const args = [
+		'-optimize',
+		'-outfile', outputPath
+	];
+
+	if (options.progressive !== false) {
+		args.push('-progressive');
+	}
+
+	if (!options.keepMetadata) {
+		args.push('-copy', 'none');
+	} else {
+		args.push('-copy', 'all');
+	}
+
+	args.push(inputPath);
+
+	await execa(jpegtran.default, args);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+export async function compressWithPngquant(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const pngquant = await import('pngquant-bin');
+	const quality = options.pngQuality || options.quality || '65-80';
+	const colors = parseInt(options.colors || '256');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	const args = [
+		'--quality', quality.includes('-') ? quality : `0-${quality}`,
+		'--speed', '1',
+		'--force',
+		colors.toString(),
+		'--output', outputPath,
+		inputPath
+	];
+
+	try {
+		await execa(pngquant.default, args);
+	} catch (error: unknown) {
+		const execaError = error as { exitCode?: number };
+		if (execaError.exitCode === 99) {
+			await copyFile(inputPath, outputPath);
+		} else {
+			throw error;
+		}
+	}
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+export async function compressWithOptipng(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const optipng = await import('optipng-bin');
+	const effort = parseInt(options.effort || '2');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+	await copyFile(inputPath, outputPath);
+
+	const args = [
+		`-o${Math.min(7, effort)}`,
+		'-silent',
+		outputPath
+	];
+
+	if (!options.keepMetadata) {
+		args.push('-strip', 'all');
+	}
+
+	await execa(optipng.default, args);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}
+
+export async function compressWithGifsicle(
+	inputPath: string,
+	outputPath: string,
+	options: CompressOptions
+): Promise<CompressionResult> {
+	const originalStats = await stat(inputPath);
+	const originalSize = originalStats.size;
+
+	const gifsicle = await import('gifsicle');
+	const colors = parseInt(options.colors || '256');
+	const effort = parseInt(options.effort || '3');
+
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	const args = [
+		`-O${Math.min(3, effort)}`,
+		'--colors', String(colors),
+		'-o', outputPath,
+		inputPath
+	];
+
+	if (options.lossless) {
+		args.splice(args.indexOf('--colors'), 2);
+	}
+
+	await execa(gifsicle.default, args);
+
+	const compressedStats = await stat(outputPath);
+	const compressedSize = compressedStats.size;
+	const saved = originalSize - compressedSize;
+
+	return {
+		file: inputPath,
+		originalSize,
+		compressedSize,
+		saved,
+		savedPercent: (saved / originalSize) * 100
+	};
+}

package/src/utils/types.ts

@@ -0,0 +1,35 @@
+export type JpegEngine = 'mozjpeg' | 'jpegtran' | 'sharp';
+export type PngEngine = 'pngquant' | 'optipng' | 'sharp';
+export type GifEngine = 'gifsicle' | 'sharp';
+export type SvgEngine = 'svgo';
+
+export interface CompressOptions {
+	output?: string;
+	inPlace?: boolean;
+	quality?: string;
+	lossless?: boolean;
+	resize?: string;
+	maxWidth?: string;
+	maxHeight?: string;
+	format?: 'jpg' | 'png' | 'webp' | 'avif';
+	recursive?: boolean;
+	keepMetadata?: boolean;
+	progressive?: boolean;
+	effort?: string;
+	jpegEngine?: JpegEngine;
+	pngEngine?: PngEngine;
+	gifEngine?: GifEngine;
+	pngQuality?: string;
+	colors?: string;
+}
+
+export interface CompressionResult {
+	file: string;
+	originalSize: number;
+	compressedSize: number;
+	saved: number;
+	savedPercent: number;
+}
+
+export type ImageFormat = 'jpg' | 'jpeg' | 'png' | 'webp' | 'avif' | 'gif' | 'svg' | 'tiff';
+export type OutputFormat = 'jpg' | 'png' | 'webp' | 'avif' | 'gif' | 'tiff';

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}