@adaptive-ds/assets-optimizer 0.2.0 → 0.2.1

package/dist/video/createVideoArgs.js

@@ -0,0 +1,77 @@
+import { getAvailableVideoEncoders } from "./getAvailableVideoEncoders.js";
+export async function createVideoArgs(sourcePath, outputPath, extension, cwd, logger) {
+    const commonArgs = ["-y", "-i", sourcePath, "-map", "0:v:0", "-map", "0:a?", "-map_metadata", "-1"];
+    if (extension === ".webm") {
+        return [
+            ...commonArgs,
+            "-c:v",
+            "libvpx-vp9",
+            "-row-mt",
+            "1",
+            "-crf",
+            "36",
+            "-b:v",
+            "0",
+            "-c:a",
+            "libopus",
+            "-b:a",
+            "96k",
+            outputPath,
+        ];
+    }
+    const availableEncoders = await getAvailableVideoEncoders(cwd, logger);
+    if (availableEncoders.has("libx264")) {
+        return [
+            ...commonArgs,
+            "-c:v",
+            "libx264",
+            "-preset",
+            "medium",
+            "-crf",
+            "28",
+            "-pix_fmt",
+            "yuv420p",
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            "-movflags",
+            "+faststart",
+            outputPath,
+        ];
+    }
+    if (availableEncoders.has("libopenh264")) {
+        return [
+            ...commonArgs,
+            "-c:v",
+            "libopenh264",
+            "-b:v",
+            "1000k",
+            "-pix_fmt",
+            "yuv420p",
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            "-movflags",
+            "+faststart",
+            outputPath,
+        ];
+    }
+    return [
+        ...commonArgs,
+        "-c:v",
+        "mpeg4",
+        "-q:v",
+        "5",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "128k",
+        "-movflags",
+        "+faststart",
+        outputPath,
+    ];
+}

package/dist/video/createVideoPreviewArgs.d.ts

@@ -0,0 +1,2 @@
+export declare function createVideoPreviewArgs(inputPath: string, outputPath: string, quality: number): string[];
+//# sourceMappingURL=createVideoPreviewArgs.d.ts.map

package/dist/video/createVideoPreviewArgs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVideoPreviewArgs.d.ts","sourceRoot":"","sources":["../../src/video/createVideoPreviewArgs.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAavG"}

package/dist/video/createVideoPreviewArgs.js

@@ -0,0 +1,18 @@
+export function createVideoPreviewArgs(inputPath, outputPath, quality) {
+    return [
+        "-y",
+        "-i",
+        inputPath,
+        "-vf",
+        "thumbnail",
+        "-frames:v",
+        "1",
+        "-q:v",
+        String(mapJpegQualityToQScale(quality)),
+        outputPath,
+    ];
+}
+function mapJpegQualityToQScale(quality) {
+    const normalizedQuality = Math.max(1, Math.min(100, Math.round(quality)));
+    return Math.max(2, Math.min(31, Math.round(31 - ((normalizedQuality - 1) / 99) * 29)));
+}

package/dist/video/createVideoPreviewPath.d.ts

@@ -0,0 +1,2 @@
+export declare function createVideoPreviewPath(videoPath: string): string;
+//# sourceMappingURL=createVideoPreviewPath.d.ts.map

package/dist/video/createVideoPreviewPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVideoPreviewPath.d.ts","sourceRoot":"","sources":["../../src/video/createVideoPreviewPath.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhE"}

package/dist/video/createVideoPreviewPath.js

@@ -0,0 +1,3 @@
+export function createVideoPreviewPath(videoPath) {
+    return videoPath.replace(/\.[^.]+$/, ".jpg");
+}

package/dist/video/ensureVideoPreviews.d.ts

@@ -0,0 +1,4 @@
+import type { AssetsOptimizeResult } from "../AssetsOptimizeResult.js";
+import type { Logger } from "../shared/logger.js";
+export declare function ensureVideoPreviews(videoOptimizedDir: string, videoPreviewQuality: number, cwd: string, result: AssetsOptimizeResult, logger: Logger): Promise<void>;
+//# sourceMappingURL=ensureVideoPreviews.d.ts.map

package/dist/video/ensureVideoPreviews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureVideoPreviews.d.ts","sourceRoot":"","sources":["../../src/video/ensureVideoPreviews.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEtE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAOjD,wBAAsB,mBAAmB,CACvC,iBAAiB,EAAE,MAAM,EACzB,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/dist/video/ensureVideoPreviews.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { dirExists } from "../shared/dirExists.js";
+import { walkFiles } from "../shared/walkFiles.js";
+import { createVideoPreviewArgs } from "./createVideoPreviewArgs.js";
+import { createVideoPreviewPath } from "./createVideoPreviewPath.js";
+import { runFfmpeg } from "./runFfmpeg.js";
+import { supportedVideoSourceExtensions } from "./supportedVideoSourceExtensions.js";
+export async function ensureVideoPreviews(videoOptimizedDir, videoPreviewQuality, cwd, result, logger) {
+    if (!(await dirExists(videoOptimizedDir))) {
+        return;
+    }
+    for (const filePath of await walkFiles(videoOptimizedDir)) {
+        const extension = path.extname(filePath).toLowerCase();
+        if (!supportedVideoSourceExtensions.has(extension)) {
+            continue;
+        }
+        const previewPath = createVideoPreviewPath(filePath);
+        const relativePreviewPath = path.relative(videoOptimizedDir, previewPath);
+        try {
+            await fs.access(previewPath);
+            result.skippedExistingVideoPreviews.push(relativePreviewPath);
+            continue;
+        }
+        catch { }
+        await fs.mkdir(path.dirname(previewPath), { recursive: true });
+        await runFfmpeg(createVideoPreviewArgs(filePath, previewPath, videoPreviewQuality), cwd, logger);
+        result.processedVideoPreviews.push(relativePreviewPath);
+    }
+}

package/dist/video/getAvailableVideoEncoders.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../shared/logger.js";
+export declare function getAvailableVideoEncoders(cwd: string, logger?: Logger): Promise<Set<string>>;
+//# sourceMappingURL=getAvailableVideoEncoders.d.ts.map

package/dist/video/getAvailableVideoEncoders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAvailableVideoEncoders.d.ts","sourceRoot":"","sources":["../../src/video/getAvailableVideoEncoders.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAIjD,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAwClG"}

package/dist/video/getAvailableVideoEncoders.js

@@ -0,0 +1,36 @@
+import * as Bun from "bun";
+let availableEncodersPromise;
+export async function getAvailableVideoEncoders(cwd, logger) {
+    if (!availableEncodersPromise) {
+        availableEncodersPromise = (async () => {
+            const command = ["ffmpeg", "-hide_banner", "-encoders"];
+            logger?.cli(command.join(" "));
+            const process = Bun.spawn(command, {
+                cwd,
+                stdout: "pipe",
+                stderr: "pipe",
+            });
+            const [stdout, stderr, exitCode] = await Promise.all([
+                new Response(process.stdout).text(),
+                new Response(process.stderr).text(),
+                process.exited,
+            ]);
+            if (exitCode !== 0) {
+                throw new Error(`ffmpeg -encoders failed with exit code ${exitCode}\n${stderr || stdout}`.trim());
+            }
+            if (logger?.isEnabled(3)) {
+                if (stdout.trim()) {
+                    logger.verbose(stdout.trim());
+                }
+                if (stderr.trim()) {
+                    logger.verbose(stderr.trim());
+                }
+            }
+            return new Set(stdout
+                .split("\n")
+                .map((line) => line.trim().split(/\s+/)[1])
+                .filter((value) => Boolean(value)));
+        })();
+    }
+    return availableEncodersPromise;
+}

package/dist/video/processLocalVideos.d.ts

@@ -0,0 +1,4 @@
+import type { AssetsOptimizeResult } from "../AssetsOptimizeResult.js";
+import type { Logger } from "../shared/logger.js";
+export declare function processLocalVideos(videoOriginalsDir: string, videoOptimizedDir: string, cwd: string, result: AssetsOptimizeResult, logger: Logger): Promise<void>;
+//# sourceMappingURL=processLocalVideos.d.ts.map

package/dist/video/processLocalVideos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processLocalVideos.d.ts","sourceRoot":"","sources":["../../src/video/processLocalVideos.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAMjD,wBAAsB,kBAAkB,CACtC,iBAAiB,EAAE,MAAM,EACzB,iBAAiB,EAAE,MAAM,EACzB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/video/processLocalVideos.js

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { walkFiles } from "../shared/walkFiles.js";
+import { createVideoArgs } from "./createVideoArgs.js";
+import { runFfmpeg } from "./runFfmpeg.js";
+import { supportedVideoSourceExtensions } from "./supportedVideoSourceExtensions.js";
+export async function processLocalVideos(videoOriginalsDir, videoOptimizedDir, cwd, result, logger) {
+    for (const sourceFile of await walkFiles(videoOriginalsDir)) {
+        const extension = path.extname(sourceFile).toLowerCase();
+        const relativePath = path.relative(videoOriginalsDir, sourceFile);
+        if (!supportedVideoSourceExtensions.has(extension)) {
+            result.warnings.push(`Skipped unsupported video source file: ${relativePath}`);
+            continue;
+        }
+        const outputPath = path.join(videoOptimizedDir, relativePath);
+        try {
+            await fs.access(outputPath);
+            result.skippedExistingVideos.push(relativePath);
+            continue;
+        }
+        catch { }
+        await fs.mkdir(path.dirname(outputPath), { recursive: true });
+        await runFfmpeg(await createVideoArgs(sourceFile, outputPath, extension, cwd, logger), cwd, logger);
+        result.processedVideos.push(relativePath);
+    }
+}

package/dist/video/processVideos.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessVideosOptions } from "./ProcessVideosOptions.js";
+export declare function processVideos(options: ProcessVideosOptions): Promise<void>;
+//# sourceMappingURL=processVideos.d.ts.map

package/dist/video/processVideos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processVideos.d.ts","sourceRoot":"","sources":["../../src/video/processVideos.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAGrE,wBAAsB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhF"}

package/dist/video/processVideos.js

@@ -0,0 +1,10 @@
+import { dirExists } from "../shared/dirExists.js";
+import { ensureVideoPreviews } from "./ensureVideoPreviews.js";
+import { processLocalVideos } from "./processLocalVideos.js";
+export async function processVideos(options) {
+    const { cwd, logger, result, videoOptimizedDir, videoPreviewQuality, videoOriginalsDir } = options;
+    if (await dirExists(videoOriginalsDir)) {
+        await processLocalVideos(videoOriginalsDir, videoOptimizedDir, cwd, result, logger);
+    }
+    await ensureVideoPreviews(videoOptimizedDir, videoPreviewQuality, cwd, result, logger);
+}

package/dist/video/runFfmpeg.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "../shared/logger.js";
+export declare function runFfmpeg(args: string[], cwd: string, logger?: Logger): Promise<void>;
+//# sourceMappingURL=runFfmpeg.d.ts.map

package/dist/video/runFfmpeg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runFfmpeg.d.ts","sourceRoot":"","sources":["../../src/video/runFfmpeg.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4B3F"}

package/dist/video/runFfmpeg.js

@@ -0,0 +1,26 @@
+import * as Bun from "bun";
+export async function runFfmpeg(args, cwd, logger) {
+    const command = ["ffmpeg", ...args];
+    logger?.cli(command.join(" "));
+    const process = Bun.spawn(command, {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(process.stdout).text(),
+        new Response(process.stderr).text(),
+        process.exited,
+    ]);
+    if (exitCode !== 0) {
+        throw new Error(`ffmpeg ${args.join(" ")} failed with exit code ${exitCode}\n${stderr || stdout}`.trim());
+    }
+    if (logger?.isEnabled(3)) {
+        if (stdout.trim()) {
+            logger.verbose(stdout.trim());
+        }
+        if (stderr.trim()) {
+            logger.verbose(stderr.trim());
+        }
+    }
+}

package/dist/video/supportedVideoSourceExtensions.d.ts

@@ -0,0 +1,2 @@
+export declare const supportedVideoSourceExtensions: Set<string>;
+//# sourceMappingURL=supportedVideoSourceExtensions.d.ts.map

package/dist/video/supportedVideoSourceExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supportedVideoSourceExtensions.d.ts","sourceRoot":"","sources":["../../src/video/supportedVideoSourceExtensions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,aAA6D,CAAA"}

package/dist/video/supportedVideoSourceExtensions.js

@@ -0,0 +1 @@
+export const supportedVideoSourceExtensions = new Set([".mp4", ".mov", ".m4v", ".webm", ".avi", ".mkv"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptive-ds/assets-optimizer",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "main": "./dist/index.js",
   "dependencies": {
     "image-size": "^2.0.2",