feat: map all missing LAME options in library

Author: jankarres

README.md

@@ -12,6 +12,50 @@ import { LameOptions } from "./lame-options";
 
 type ProgressKind = "encode" | "decode";
 
+function parseEncodeProgressLine(content: string): {
+    progress?: number;
+    eta?: string;
+} | null {
+    const progressMatch = content.match(/\((( [0-9])|([0-9]{2})|(100))%\)\|/);
+    if (!progressMatch) {
+        return null;
+    }
+
+    const etaMatch = content.match(/[0-9]{1,2}:[0-9][0-9] /);
+
+    /* c8 ignore next */
+    const progress = Number(progressMatch[1]);
+    const eta = etaMatch ? etaMatch[0].trim() : undefined;
+
+    return { progress, eta };
+}
+
+function parseDecodeProgressLine(content: string): number | null {
+    const progressMatch = content.match(/[0-9]{1,10}\/[0-9]{1,10}/);
+    if (!progressMatch) {
+        return null;
+    }
+
+    const [current, total] = progressMatch[0].split("/").map(Number);
+    if (!Number.isFinite(current) || !Number.isFinite(total) || total === 0) {
+        return NaN;
+    }
+
+    return Math.floor((current / total) * 100);
+}
+
+function normalizeCliMessage(content: string): string | null {
+    if (
+        content.startsWith("lame: ") ||
+        content.startsWith("Warning: ") ||
+        content.includes("Error ")
+    ) {
+        return content.startsWith("lame: ") ? content : `lame: ${content}`;
+    }
+
+    return null;
+}
+
 /**
  * Thin wrapper around the LAME CLI that manages temp files, progress events,
  * and output handling while delegating the heavy lifting to the binary.
@@ -28,7 +72,8 @@ class Lame {
         new EventEmitter() as LameProgressEmitter;
 
     private readonly options: LameOptionsBag;
-    private readonly args: Array<string | number>;
+    private readonly builder: LameOptions;
+    private readonly args: string[];
 
     private filePath?: string;
     private fileBuffer?: Buffer;
@@ -43,7 +88,8 @@ class Lame {
 
     constructor(options: LameOptionsBag) {
         this.options = options;
-        this.args = new LameOptions(this.options).getArguments();
+        this.builder = new LameOptions(this.options);
+        this.args = this.builder.getArguments();
         this.lamePath = resolveLameBinary();
         this.tempPath = join(tmpdir(), "node-lame");
     }
@@ -155,16 +201,23 @@ class Lame {
      */
     private async spawnLameAndTrackProgress(
         inputFilePath: string,
-        baseArgs: Array<string | number>,
+        baseArgs: string[],
         type: ProgressKind,
     ): Promise<this> {
-        const args = [...baseArgs, "--disptime", "1"].map((value) =>
-            String(value),
-        );
+        const args = [...baseArgs];
+
+        if (
+            this.builder.shouldUseDefaultDisptime() &&
+            !args.includes("--disptime")
+        ) {
+            args.push("--disptime", "1");
+        }
+
+        const normalizedArgs = args.map((value) => String(value));
 
         const { outputPath, bufferOutput } =
             await this.prepareOutputTarget(type);
-        const spawnArgs = [inputFilePath, outputPath, ...args];
+        const spawnArgs = [inputFilePath, outputPath, ...normalizedArgs];
 
         this.status = {
             started: true,
@@ -194,68 +247,46 @@ class Lame {
                         this.status.progress,
                         this.status.eta,
                     ]);
-                } else if (
-                    type === "encode" &&
-                    /\((( [0-9])|([0-9]{2})|(100))%\)\|/.test(content)
-                ) {
-                    const progressMatch = content.match(
-                        /\((( [0-9])|([0-9]{2})|(100))%\)\|/,
-                    );
-                    const etaMatch = content.match(/[0-9]{1,2}:[0-9][0-9] /);
-
-                    const progress =
-                        progressMatch && progressMatch[1]
-                            ? Number(progressMatch[1])
-                            : undefined;
-                    const eta = etaMatch ? etaMatch[0].trim() : undefined;
-
-                    if (
-                        progress !== undefined &&
-                        progress > this.status.progress
-                    ) {
-                        this.status.progress = progress;
-                    }
-
-                    if (eta) {
-                        this.status.eta = eta;
-                    }
+                } else if (type === "encode") {
+                    const parsed = parseEncodeProgressLine(content);
+                    if (parsed) {
+                        if (
+                            parsed.progress !== undefined &&
+                            parsed.progress > this.status.progress
+                        ) {
+                            this.status.progress = parsed.progress;
+                        }
 
-                    this.emitter.emit("progress", [
-                        this.status.progress,
-                        this.status.eta,
-                    ]);
-                } else if (
-                    type === "decode" &&
-                    /[0-9]{1,10}\/[0-9]{1,10}/.test(content)
-                ) {
-                    const progressMatch = content.match(
-                        /[0-9]{1,10}\/[0-9]{1,10}/,
-                    );
+                        if (parsed.eta) {
+                            this.status.eta = parsed.eta;
+                        }
 
-                    if (progressMatch) {
-                        const [current, total] = progressMatch[0]
-                            .split("/")
-                            .map(Number);
-                        const progress = Math.floor((current / total) * 100);
+                        this.emitter.emit("progress", [
+                            this.status.progress,
+                            this.status.eta,
+                        ]);
+                        return;
+                    }
+                }
 
-                        if (!Number.isNaN(progress)) {
-                            this.status.progress = progress;
+                if (type === "decode") {
+                    const parsed = parseDecodeProgressLine(content);
+                    if (parsed !== null) {
+                        if (!Number.isNaN(parsed)) {
+                            this.status.progress = parsed;
                         }
 
                         this.emitter.emit("progress", [
                             this.status.progress,
                             this.status.eta,
                         ]);
+                        return;
                     }
-                } else if (
-                    content.startsWith("lame: ") ||
-                    content.startsWith("Warning: ") ||
-                    content.includes("Error ")
-                ) {
-                    const message = content.startsWith("lame: ")
-                        ? content
-                        : `lame: ${content}`;
-                    this.emitter.emit("error", new Error(message));
+                }
+
+                const normalized = normalizeCliMessage(content);
+                if (normalized) {
+                    this.emitter.emit("error", new Error(normalized));
                 }
             };
 
@@ -366,9 +397,11 @@ class Lame {
 
     private async ensureOutputDirectoryExists(filePath: string) {
         const dir = dirname(filePath);
-        if (dir) {
-            await mkdir(dir, { recursive: true });
+        if (!dir || dir === ".") {
+            return;
         }
+
+        await mkdir(dir, { recursive: true });
     }
 
     private async generateTempFilePath(
@@ -398,4 +431,9 @@ class Lame {
     }
 }
 
-export { Lame };
+export {
+    Lame,
+    normalizeCliMessage,
+    parseDecodeProgressLine,
+    parseEncodeProgressLine,
+};

src/core/lame-options.ts

@@ -1,36 +1,67 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import type { Platform } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 declare const __dirname: string | undefined;
 declare const __filename: string | undefined;
 
+type ImportMetaLike = { url?: string } | undefined;
+
+function deriveModuleUrl(
+    meta: ImportMetaLike,
+    filename: string | undefined,
+): string | undefined {
+    if (meta && typeof meta.url === "string") {
+        return meta.url;
+    }
+
+    if (typeof filename === "string") {
+        return pathToFileURL(filename).href;
+    }
+
+    return undefined;
+}
+
 const moduleUrl = (() => {
+    let meta: ImportMetaLike = undefined;
+
     try {
-        const meta = import.meta as { url?: string };
-        if (meta && typeof meta.url === "string") {
-            return meta.url;
-        }
+        meta = import.meta as ImportMetaLike;
     } catch {
-        // Swallow ReferenceError when import.meta is unavailable (CommonJS build).
+        // ignore when import.meta is unavailable (CommonJS build)
     }
 
-    if (typeof __filename === "string") {
-        return pathToFileURL(__filename).href;
-    }
+    const resolvedFilename = __filename;
 
-    return undefined;
+    return deriveModuleUrl(meta, resolvedFilename);
 })();
 
-const PACKAGE_ROOT =
-    typeof __dirname === "string"
-        ? join(__dirname, "..", "..", "..")
-        : moduleUrl != null
-          ? fileURLToPath(new URL("../../..", moduleUrl))
-          : process.cwd();
+function resolvePackageRoot(
+    moduleHref: string | undefined,
+    dirname: string | undefined,
+): string {
+    if (dirname) {
+        return join(dirname, "..", "..", "..");
+    }
+
+    if (moduleHref != null) {
+        return fileURLToPath(new URL("../../..", moduleHref));
+    }
+
+    return process.cwd();
+}
+
+const PACKAGE_ROOT = resolvePackageRoot(moduleUrl, __dirname);
 const CUSTOM_BINARY_ENV = "LAME_BINARY";
 
-const PLATFORM_EXECUTABLE_SUFFIX = process.platform === "win32" ? ".exe" : "";
+function getPlatformExecutableSuffix(platform: Platform): string {
+    return platform === "win32" ? ".exe" : "";
+}
+
+const PLATFORM_EXECUTABLE_SUFFIX = getPlatformExecutableSuffix(
+    process.platform,
+);
 
 /**
  * Attempt to resolve the absolute path to a bundled LAME binary.
@@ -68,4 +99,10 @@ function resolveLameBinary(): string {
     return resolved ?? "lame";
 }
 
-export { resolveBundledLameBinary, resolveLameBinary };
+export {
+    deriveModuleUrl,
+    getPlatformExecutableSuffix,
+    resolveBundledLameBinary,
+    resolveLameBinary,
+    resolvePackageRoot,
+};