Add AVIF support, flatten recursion for image processing

src/build-shit.ts

···
 const fsp = fs.promises;
 const STYLESDIR = 'styles';
 const SCRIPTSDIR = 'scripts';
-const IMAGESDIR = path.join('assets', 'images', 'original');
+const IMAGESDIR = path.join(process.cwd(), 'assets', 'images', 'original');
 const STYLEOUTDIR = process.env.STYLEOUTDIR || path.join('assets', 'css');
 const SCRIPTSOUTDIR = process.env.SCRIPTSOUTDIR || path.join('assets', 'js');
-const IMAGESOUTDIR = process.env.IMAGESOUTDIR || path.join('assets', 'images', 'webp');
+const WEBPOUTDIR = process.env.IMAGESOUTDIR || path.join('assets', 'images', 'webp');
+const AVIFOUTDIR = process.env.IMAGESOUTDIR || path.join('assets', 'images', 'avif');
 const STYLEOUTFILE = process.env.STYLEOUTFILE || 'styles.css';
 const SQUASH = new RegExp('^[0-9]+-');
 
···
         recursive: true,
         force: true
     })));
+    return true;
 }
 
 async function mkdir(dir: string | string[]) {
···
     else {
         await Promise.all(dir.map(mkdir));
     }
+    return true;
 }
 
 function getFileExtension(filename: string) {
···
     })));
 }
 
+async function getAllFiles(fullDir: string): Promise<string[]> {
+    if (!path.isAbsolute(fullDir)) {
+        throw new Error('path must be absolute');
+    }
+    const files: string[] = [];
+    const dirs = [''];
+    for (let i = 0; i < dirs.length; i++) {
+        const parent = dirs[i];
+        const dir = path.join(fullDir, parent);
+        const dirEnts = await fsp.readdir(dir, { withFileTypes: true });
+        dirEnts.forEach(de => (de.isDirectory() ? dirs : files).push(path.join(parent, de.name)));
+    }
+    return files;
+}
+
 // Process images
-async function images(dir = '') {
-    const p = path.join(IMAGESDIR, dir);
-    await mkdir(p);
-    if (dir.length === 0) {
-        await mkdir(IMAGESOUTDIR)
-        await emptyDir(IMAGESOUTDIR);
+async function images(webp: boolean, avif: boolean, dir: string = IMAGESDIR) {
+    await mkdir(dir);
+    await mkdir(WEBPOUTDIR) && await emptyDir(WEBPOUTDIR);
+    await mkdir(AVIFOUTDIR) && await emptyDir(AVIFOUTDIR);
+    const releativeFiles = await getAllFiles(dir);
+    if (releativeFiles.length) {
+        await Promise.all(releativeFiles.map(f => processImage(dir, f, webp, avif)));
     }
-    const files = await fsp.readdir(p, {
-        withFileTypes: true
+}
+
+async function processImage(parentDir: string, relativeFile: string, webp: boolean, avif: boolean) {
+    const infile = path.join(parentDir, relativeFile);
+    const dir = path.dirname(relativeFile);
+    const outDirWebP = path.join(WEBPOUTDIR, dir);
+    const outDirAvif = path.join(AVIFOUTDIR, dir);
+    webp && await mkdir(outDirWebP);
+    avif && await mkdir(outDirAvif);
+    console.log(`Processing image ${infile}`);
+    webp && await convertWebP(infile, outDirWebP);
+    avif && await convertAvif(infile, outDirAvif);
+}
+
+function convertWebP(infile: string, outDir: string) {
+    return new Promise((resolve, reject) => {
+        const filename = path.basename(infile);
+        const extension = getFileExtension(filename);
+        const outfile = path.join(outDir, filename.substring(0, filename.lastIndexOf('.')) + '.webp');
+        const libwebpArgs = ['-mt'];
+        if (extension === 'jpeg' || extension === 'jpg') {
+            libwebpArgs.push('-q', '60');
+        }
+        else {
+            libwebpArgs.push('-near_lossless', '55');
+        }
+        libwebpArgs.push(infile, '-o', outfile);
+        const proc = spawn('cwebp', libwebpArgs);
+        const timeout = setTimeout(() => {
+            proc.kill();
+            reject(new Error(`process timed out`));
+        }, parseInt(process.env['CWEBPTIMEOUT']) || 30000);
+        proc.on('exit', async (code) => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                console.log(`Wrote ${outfile}`);
+                resolve(true);
+            }
+            else {
+                reject(new Error(`process ended with code ${code}`));
+            }
+        });
     });
-    if (files.length) {
-        await Promise.all(files.map(f => new Promise(async (res, reject) => {
-            if (f.isFile()) {
-                const outDir = path.join(IMAGESOUTDIR, dir);
-                const infile = path.join(p, f.name);
-                const extension = getFileExtension(infile);
-                const outfile = path.join(outDir, f.name.substring(0, f.name.lastIndexOf('.')) + '.webp');
-                await mkdir(outDir);
-                console.log(`Processing image ${infile}`)
-                const libwebpArgs = ['-mt'];
-                if (extension === 'jpeg' || extension === 'jpg') {
-                    libwebpArgs.push('-q', '60');
-                }
-                else {
-                    libwebpArgs.push('-near_lossless', '55');
-                }
-                libwebpArgs.push(infile, '-o', outfile);
-                const proc = spawn('cwebp', libwebpArgs);
-                const timeout = setTimeout(() => {
-                    reject('Timed out');
-                    proc.kill();
-                }, parseInt(process.env['CWEBPTIMEOUT']) || 30000);
-                proc.on('exit', async (code) => {
-                    clearTimeout(timeout);
-                    if (code === 0) {
-                        console.log(`Wrote ${outfile}`);
-                        res(null);
-                    }
-                    else {
-                        reject(code);
-                    }
-                });
+}
+
+function convertAvif(infile: string, outDir: string) {
+    return new Promise((resolve, reject) => {
+        const filename = path.basename(infile);
+        const extension = getFileExtension(filename);
+        const outfile = path.join(outDir, filename.substring(0, filename.lastIndexOf('.')) + '.avif');
+        const avifencArgs = '--speed 6 --jobs all --depth 8 --cicp 1/13/6 --codec aom'.split(' ');
+        if (extension === 'jpeg' || extension === 'jpg') {
+            avifencArgs.push('--advanced', 'cq-level=28', '-q', '40', '--yuv', '420');
+        }
+        else {
+            avifencArgs.push('--advanced', 'cq-level=30', '-q', '45', '--yuv', '444');
+        }
+        avifencArgs.push(infile, outfile);
+        console.log(`avifenc ${avifencArgs.join(' ')}`);
+        const proc = spawn('avifenc', avifencArgs);
+        const timeout = setTimeout(() => {
+            proc.kill();
+            reject(new Error(`process timed out`));
+        }, parseInt(process.env['AVIFENCTIMEOUT']) || 30000);
+        proc.on('exit', async (code) => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                console.log(`Wrote ${outfile}`);
+                resolve(true);
             }
-            else if (f.isDirectory()) {
-                images(path.join(dir, f.name)).then(res).catch(reject);
+            else {
+                reject(new Error(`process ended with code ${code}`));
             }
-        })));
-    }
+        });
+    });
+}
+
+function commandExists(cmd: string): Promise<boolean> {
+    return new Promise((resolve, _) => {
+        const proc = spawn('which', cmd.split(' '));
+        proc.on('exit', async (code) => resolve(code === 0));
+    });
 }
 
 function isAbortError(err: unknown): boolean {
···
 }
 
 (async function () {
-    await Promise.all([styles(), scripts(), images()]);
+    const webp = await commandExists('cwebp');
+    const avif = await commandExists('avifenc');
+    if (!webp && ! avif) {
+        console.error('WARNING: no image encoding software found.');
+    }
+    await Promise.all([styles(), scripts(), images(webp, avif)]);
     if (process.argv.indexOf('--watch') >= 0) {
         console.log('watching for changes...');
         (async () => {
···
                     recursive: true // no Linux ☹️
                 });
                 for await (const _ of watcher)
-                    await images();
+                    await images(webp, avif);
             } catch (err) {
                 if (isAbortError(err))
                     return;