@webstir-io/webstir-frontend 0.1.40

package/src/assets/imageOptimizer.ts

@@ -0,0 +1,112 @@
+import path from 'node:path';
+import sharp from 'sharp';
+import { glob } from 'glob';
+import { copy, ensureDir, emptyDir, pathExists, remove } from '../utils/fs.js';
+import { EXTENSIONS } from '../core/constants.js';
+
+const TRANSCODABLE_EXTENSIONS = new Set<string>([
+    EXTENSIONS.png,
+    EXTENSIONS.jpg,
+    EXTENSIONS.jpeg
+]);
+
+export interface ImageDimensions
+{
+    width: number;
+    height: number;
+}
+
+export async function optimizeImages(sourceDir: string, destinationDir: string, files?: string[]): Promise<void> {
+    if (!(await pathExists(sourceDir))) {
+        await emptyDir(destinationDir);
+        return;
+    }
+
+    if (!files || files.length === 0) {
+        await emptyDir(destinationDir);
+        const allFiles = await glob('**/*', { cwd: sourceDir, nodir: true });
+        await Promise.all(allFiles.map(async (relative) => processImage(sourceDir, destinationDir, relative)));
+        return;
+    }
+
+    await ensureDir(destinationDir);
+    await Promise.all(files.map(async (relative) => processImage(sourceDir, destinationDir, relative, true)));
+}
+
+export async function getImageDimensions(filePath: string): Promise<ImageDimensions | null> {
+    try {
+        const metadata = await sharp(filePath).metadata();
+        if (typeof metadata.width === 'number' && typeof metadata.height === 'number') {
+            return { width: metadata.width, height: metadata.height };
+        }
+    } catch {
+        // Ignore errors – the caller can continue without dimensions.
+    }
+    return null;
+}
+
+function replaceExtension(filePath: string, extension: string): string {
+    const parsed = path.parse(filePath);
+    return path.join(parsed.dir, `${parsed.name}${extension}`);
+}
+
+async function createWebpVariant(sourcePath: string, destinationPath: string): Promise<void> {
+    try {
+        await sharp(sourcePath)
+            .webp({ quality: 75 })
+            .toFile(destinationPath);
+    } catch {
+        // Ignore failures; fall back to original image only.
+    }
+}
+
+async function createAvifVariant(sourcePath: string, destinationPath: string): Promise<void> {
+    try {
+        await sharp(sourcePath)
+            .avif({ quality: 45 })
+            .toFile(destinationPath);
+    } catch {
+        // Ignore failures; fall back to original image only.
+    }
+}
+
+async function processImage(sourceDir: string, destinationDir: string, relative: string, incremental = false): Promise<void> {
+    const sourcePath = path.join(sourceDir, relative);
+    const destinationPath = path.join(destinationDir, relative);
+
+    if (!(await pathExists(sourcePath))) {
+        await removeVariants(destinationPath, true);
+        return;
+    }
+
+    await ensureDir(path.dirname(destinationPath));
+    await copy(sourcePath, destinationPath);
+
+    const extension = path.extname(sourcePath).toLowerCase();
+    if (!TRANSCODABLE_EXTENSIONS.has(extension)) {
+        if (incremental) {
+            await removeVariants(destinationPath, false);
+        }
+        return;
+    }
+
+    if (incremental) {
+        await removeVariants(destinationPath, false);
+    }
+
+    await Promise.all([
+        createWebpVariant(sourcePath, replaceExtension(destinationPath, EXTENSIONS.webp)),
+        createAvifVariant(sourcePath, replaceExtension(destinationPath, EXTENSIONS.avif))
+    ]);
+}
+
+async function removeVariants(destinationPath: string, includeBase: boolean): Promise<void> {
+    const targets = [replaceExtension(destinationPath, EXTENSIONS.webp), replaceExtension(destinationPath, EXTENSIONS.avif)];
+    if (includeBase) {
+        targets.push(destinationPath);
+    }
+
+    await Promise.all(targets.map(async (target) => {
+        await remove(target).catch(() => undefined);
+    }));
+}

package/src/assets/precompression.ts

@@ -0,0 +1,25 @@
+import { createReadStream, createWriteStream } from 'node:fs';
+import { constants as zlibConstants, createBrotliCompress, createGzip } from 'node:zlib';
+
+export async function createCompressedVariants(filePath: string): Promise<void> {
+    await Promise.all([
+        compress(filePath, '.br', () => createBrotliCompress({ params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 11 } })),
+        compress(filePath, '.gz', () => createGzip({ level: zlibConstants.Z_BEST_COMPRESSION }))
+    ]);
+}
+
+async function compress(source: string, extension: string, factory: () => NodeJS.ReadWriteStream): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const destination = `${source}${extension}`;
+        const readStream = createReadStream(source);
+        const writeStream = createWriteStream(destination);
+        const compressor = factory();
+
+        readStream.on('error', reject);
+        writeStream.on('error', reject);
+        compressor.on('error', reject);
+        writeStream.on('close', resolve);
+
+        readStream.pipe(compressor).pipe(writeStream);
+    });
+}