podcast-dl 11.7.1 → 11.7.3

package/bin/archive.js

@@ -1,7 +1,21 @@
 import dayjs from "dayjs";
 import fs from "fs";
 import path from "path";
-import { getJsonFile } from "./util.js";
+import { cwd, getJsonFile } from "./util.js";
+
+const archiveCache = new Map();
+
+const getArchiveData = (archivePath) => {
+  if (!archiveCache.has(archivePath)) {
+    const content = getJsonFile(archivePath);
+    archiveCache.set(archivePath, {
+      entries: new Set(content || []),
+      dirty: false,
+    });
+  }
+
+  return archiveCache.get(archivePath);
+};
 
 export const getArchiveKey = ({ prefix, name }) => {
   return `${prefix}-${name}`;
@@ -14,30 +28,32 @@ export const getArchiveKeys = ({ prefix, name, guid }) => {
 };
 
 export const getArchive = (archive) => {
-  const archiveContent = getJsonFile(archive);
-  return archiveContent === null ? [] : archiveContent;
+  const { entries } = getArchiveData(archive);
+  return [...entries];
 };
 
-export const writeToArchive = ({ key, archiveKeys, archive }) => {
-  const archivePath = path.resolve(process.cwd(), archive);
-  const archiveResult = getArchive(archive);
-  const keys = Array.from(
-    new Set([key, ...(archiveKeys || [])].filter(Boolean))
-  );
+export const writeToArchive = ({ archiveKeys, archive }) => {
+  const data = getArchiveData(archive);
 
-  keys.forEach((archiveKey) => {
-    if (!archiveResult.includes(archiveKey)) {
-      archiveResult.push(archiveKey);
+  archiveKeys.forEach((archiveKey) => {
+    if (!data.entries.has(archiveKey)) {
+      data.entries.add(archiveKey);
+      data.dirty = true;
     }
   });
 
-  fs.writeFileSync(archivePath, JSON.stringify(archiveResult, null, 4));
+  if (data.dirty) {
+    fs.writeFileSync(
+      path.resolve(cwd, archive),
+      JSON.stringify([...data.entries], null, 4)
+    );
+    data.dirty = false;
+  }
 };
 
-export const getIsInArchive = ({ key, archiveKeys, archive }) => {
-  const archiveResult = getArchive(archive);
-  const keys = [key, ...(archiveKeys || [])].filter(Boolean);
-  return keys.some((archiveKey) => archiveResult.includes(archiveKey));
+export const getIsInArchive = ({ archiveKeys, archive }) => {
+  const { entries } = getArchiveData(archive);
+  return archiveKeys.some((archiveKey) => entries.has(archiveKey));
 };
 
 export const getArchiveFilename = ({ pubDate, name, ext }) => {

package/bin/bin.js

@@ -19,11 +19,13 @@ import {
 import { writeFeedMeta } from "./meta.js";
 import { getFolderName, getSimpleFilename } from "./naming.js";
 import {
+  cwd,
   getFileFeed,
   getImageUrl,
   getUrlExt,
   getUrlFeed,
   logFeedInfo,
+  normalizeUrl,
 } from "./util.js";
 
 const opts = setupCommander(program);
@@ -91,7 +93,8 @@ const main = async () => {
 
   const archivePrefix = (() => {
     if (feed.feedUrl || url) {
-      const { hostname, pathname } = new URL(feed.feedUrl || url);
+      const raw = feed.feedUrl || url;
+      const { hostname, pathname } = new URL(normalizeUrl(raw) ?? raw);
       return `${hostname}${pathname}`;
     }
 
@@ -99,7 +102,7 @@ const main = async () => {
   })();
 
   const basePath = _path.resolve(
-    process.cwd(),
+    cwd,
     getFolderName({ feed, template: outDir })
   );
 
@@ -147,7 +150,7 @@ const main = async () => {
   }
 
   if (includeMeta) {
-    const podcastImageUrl = getImageUrl(feed);
+    const podcastImageUrl = normalizeUrl(getImageUrl(feed));
 
     if (podcastImageUrl) {
       const podcastImageFileExt = getUrlExt(podcastImageUrl);

package/bin/items.js

@@ -9,6 +9,7 @@ import {
   getLoopControls,
   getTranscriptUrl,
   getUrlExt,
+  normalizeUrl,
 } from "./util.js";
 
 export const ITEM_LIST_FORMATS = ["table", "json"];
@@ -46,6 +47,10 @@ export const getItemsToDownload = ({
   const items = [];
 
   const savedArchive = archive ? getArchive(archive) : [];
+  const includeRegex = episodeRegex ? new RegExp(episodeRegex) : null;
+  const excludeRegex = episodeRegexExclude
+    ? new RegExp(episodeRegexExclude)
+    : null;
 
   while (shouldGo(i)) {
     const { title, pubDate, itunes, guid } = feed.items[i];
@@ -53,18 +58,12 @@ export const getItemsToDownload = ({
     const pubDateDay = dayjs(new Date(pubDate));
     let isValid = true;
 
-    if (episodeRegex) {
-      const generatedEpisodeRegex = new RegExp(episodeRegex);
-      if (title && !generatedEpisodeRegex.test(title)) {
-        isValid = false;
-      }
+    if (includeRegex && title && !includeRegex.test(title)) {
+      isValid = false;
     }
 
-    if (episodeRegexExclude) {
-      const generatedEpisodeRegexExclude = new RegExp(episodeRegexExclude);
-      if (title && generatedEpisodeRegexExclude.test(title)) {
-        isValid = false;
-      }
+    if (excludeRegex && title && excludeRegex.test(title)) {
+      isValid = false;
     }
 
     if (before) {
@@ -115,7 +114,7 @@ export const getItemsToDownload = ({
       item._archiveKeys = archiveKeys;
 
       if (includeEpisodeImages || embedMetadataFlag) {
-        const episodeImageUrl = getImageUrl(item);
+        const episodeImageUrl = normalizeUrl(getImageUrl(item));
 
         if (episodeImageUrl) {
           const episodeImageFileExt = getUrlExt(episodeImageUrl);
@@ -150,9 +149,8 @@ export const getItemsToDownload = ({
       }
 
       if (includeEpisodeTranscripts) {
-        const episodeTranscriptUrl = getTranscriptUrl(
-          item,
-          episodeTranscriptTypes
+        const episodeTranscriptUrl = normalizeUrl(
+          getTranscriptUrl(item, episodeTranscriptTypes)
         );
 
         if (episodeTranscriptUrl) {

package/bin/meta.js

@@ -4,7 +4,7 @@ import { logMessage } from "./logger.js";
 import { getPublicObject } from "./util.js";
 
 export const writeFeedMeta = ({ outputPath, feed, key, archive, override }) => {
-  if (key && archive && getIsInArchive({ key, archive })) {
+  if (key && archive && getIsInArchive({ archiveKeys: [key], archive })) {
     logMessage("Feed metadata exists in archive. Skipping...");
     return;
   }
@@ -17,9 +17,9 @@ export const writeFeedMeta = ({ outputPath, feed, key, archive, override }) => {
       logMessage("Feed metadata exists locally. Skipping...");
     }
 
-    if (key && archive && !getIsInArchive({ key, archive })) {
+    if (key && archive && !getIsInArchive({ archiveKeys: [key], archive })) {
       try {
-        writeToArchive({ key, archive });
+        writeToArchive({ archiveKeys: [key], archive });
       } catch (error) {
         throw new Error(`Error writing to archive: ${error.toString()}`);
       }

package/bin/naming.js

@@ -33,6 +33,9 @@ const applyFilters = (value, filterStr) => {
   }, value);
 };
 
+const TEMPLATE_REGEX = /{{(\w+)(\|[^}]+)?}}/g;
+const customRegexCache = new Map();
+
 const MAX_LENGTH_FILENAME = process.env.MAX_LENGTH_FILENAME
   ? parseInt(process.env.MAX_LENGTH_FILENAME)
   : 255;
@@ -66,25 +69,17 @@ export const getItemFilename = ({
   const episodeNum = feed.items.length - item._originalIndex + offset;
   const title = item.title || "";
 
-  const releaseYear = item.pubDate
-    ? dayjs(new Date(item.pubDate)).format("YYYY")
-    : null;
-
-  const releaseMonth = item.pubDate
-    ? dayjs(new Date(item.pubDate)).format("MM")
-    : null;
-
-  const releaseDay = item.pubDate
-    ? dayjs(new Date(item.pubDate)).format("DD")
-    : null;
-
-  const releaseDate = item.pubDate
-    ? dayjs(new Date(item.pubDate)).format("YYYYMMDD")
-    : null;
+  const pubDateParsed = item.pubDate ? dayjs(new Date(item.pubDate)) : null;
+  const releaseYear = pubDateParsed?.format("YYYY") ?? null;
+  const releaseMonth = pubDateParsed?.format("MM") ?? null;
+  const releaseDay = pubDateParsed?.format("DD") ?? null;
+  const releaseDate = pubDateParsed?.format("YYYYMMDD") ?? null;
 
   const customReplacementTuples = customTemplateOptions.map((option, i) => {
-    const matchRegex = new RegExp(option);
-    const match = title.match(matchRegex);
+    if (!customRegexCache.has(option)) {
+      customRegexCache.set(option, new RegExp(option));
+    }
+    const match = title.match(customRegexCache.get(option));
 
     return match && match[0] ? [`custom_${i}`, match[0]] : [`custom_${i}`, ""];
   });
@@ -107,11 +102,13 @@ export const getItemFilename = ({
   const replacementsMap = Object.fromEntries(templateReplacementsTuples);
   const templateSegments = template.trim().split(path.sep);
   const nameSegments = templateSegments.map((segment, index) => {
-    const replaceRegex = /{{(\w+)(\|[^}]+)?}}/g;
-    const name = segment.replace(replaceRegex, (match, varName, filterStr) => {
-      const replacement = replacementsMap[varName] || "";
-      return applyFilters(replacement, filterStr);
-    });
+    const name = segment.replace(
+      TEMPLATE_REGEX,
+      (match, varName, filterStr) => {
+        const replacement = replacementsMap[varName] || "";
+        return applyFilters(replacement, filterStr);
+      }
+    );
 
     // Only truncate non-final segments here (they don't get an extension)
     // Final segment is truncated below with the extension accounted for
@@ -133,8 +130,7 @@ export const getFolderName = ({ feed, template }) => {
     podcast_link: feed.link || "",
   };
 
-  const replaceRegex = /{{(\w+)(\|[^}]+)?}}/g;
-  const name = template.replace(replaceRegex, (_, varName, filterStr) => {
+  const name = template.replace(TEMPLATE_REGEX, (_, varName, filterStr) => {
     const replacement = replacementsMap[varName] || "";
     const filtered = applyFilters(replacement, filterStr);
     return getSafeName(filtered);

package/bin/util.js

@@ -14,6 +14,7 @@ export const AUDIO_FORMATS = {
 };
 
 export const isWin = process.platform === "win32";
+export const cwd = process.cwd();
 
 export const defaultRssParserConfig = {
   defaultRSS: 2.0,
@@ -32,7 +33,7 @@ export const escapeArgForShell = (arg) => {
   let result = arg;
 
   if (/[^A-Za-z0-9_/:=-]/.test(result)) {
-    if (isWin) {
+    if (process.platform === "win32") {
       return `"${result}"`;
     } else {
       result = "'" + result.replace(/'/g, "'\\''") + "'";
@@ -72,7 +73,7 @@ export const getPublicObject = (object, exclude = []) => {
 };
 
 export const getFileString = (filePath) => {
-  const fullPath = path.resolve(process.cwd(), filePath);
+  const fullPath = path.resolve(cwd, filePath);
 
   if (!fs.existsSync(fullPath)) {
     return null;
@@ -88,7 +89,7 @@ export const getFileString = (filePath) => {
 };
 
 export const getJsonFile = (filePath) => {
-  const fullPath = path.resolve(process.cwd(), filePath);
+  const fullPath = path.resolve(cwd, filePath);
 
   if (!fs.existsSync(fullPath)) {
     return null;
@@ -135,11 +136,16 @@ export const logFeedInfo = (feed) => {
   logMessage();
 };
 
+export const normalizeUrl = (url) =>
+  url?.startsWith("//") ? "https:" + url : url;
+
 export const getUrlExt = (url) => {
   if (!url) {
     return "";
   }
 
+  url = normalizeUrl(url);
+
   const { pathname } = new URL(url);
 
   if (!pathname) {
@@ -273,10 +279,6 @@ export const correctExtensionFromMime = ({
   return basePath + mimeExt;
 };
 
-export const VALID_AUDIO_EXTS = [
-  ...new Set(Object.values(AUDIO_TYPES_TO_EXTS)),
-];
-
 export const getIsAudioUrl = (url) => {
   let ext;
   try {
@@ -289,7 +291,7 @@ export const getIsAudioUrl = (url) => {
     return false;
   }
 
-  return VALID_AUDIO_EXTS.includes(ext);
+  return VALID_AUDIO_EXTS_SET.has(ext);
 };
 
 export const AUDIO_ORDER_TYPES = {
@@ -303,16 +305,22 @@ export const getEpisodeAudioUrlAndExt = (
 ) => {
   for (const source of order) {
     if (source === AUDIO_ORDER_TYPES.link && link && getIsAudioUrl(link)) {
-      return { url: link, ext: getUrlExt(link) };
+      return { url: normalizeUrl(link), ext: getUrlExt(link) };
     }
 
     if (source === AUDIO_ORDER_TYPES.enclosure && enclosure) {
       if (getIsAudioUrl(enclosure.url)) {
-        return { url: enclosure.url, ext: getUrlExt(enclosure.url) };
+        return {
+          url: normalizeUrl(enclosure.url),
+          ext: getUrlExt(enclosure.url),
+        };
       }
 
       if (enclosure.url && AUDIO_TYPES_TO_EXTS[enclosure.type]) {
-        return { url: enclosure.url, ext: AUDIO_TYPES_TO_EXTS[enclosure.type] };
+        return {
+          url: normalizeUrl(enclosure.url),
+          ext: AUDIO_TYPES_TO_EXTS[enclosure.type],
+        };
       }
     }
   }
@@ -389,6 +397,8 @@ export const getFileFeed = async (filePath, parserConfig) => {
 };
 
 export const getUrlFeed = async (url, parserConfig) => {
+  url = normalizeUrl(url) ?? url;
+
   const config = parserConfig
     ? getJsonFile(parserConfig)
     : defaultRssParserConfig;

package/bin/util.test.js

@@ -0,0 +1,326 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  escapeArgForShell,
+  getTempPath,
+  getPublicObject,
+  getLoopControls,
+  normalizeUrl,
+  getUrlExt,
+  getExtFromMime,
+  correctExtensionFromMime,
+  getIsAudioUrl,
+  AUDIO_ORDER_TYPES,
+  getEpisodeAudioUrlAndExt,
+  getImageUrl,
+  getTranscriptUrl,
+  TRANSCRIPT_TYPES,
+} from "./util.js";
+
+describe("escapeArgForShell", () => {
+  describe("on Unix", () => {
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+      Object.defineProperty(process, "platform", {
+        value: "linux",
+        configurable: true,
+      });
+    });
+
+    afterEach(() => {
+      Object.defineProperty(process, "platform", {
+        value: originalPlatform,
+        configurable: true,
+      });
+    });
+
+    it("returns arg unchanged when only safe chars", () => {
+      expect(escapeArgForShell("foo")).toBe("foo");
+      expect(escapeArgForShell("a1_/:=-bar")).toBe("a1_/:=-bar");
+    });
+
+    it("wraps in single quotes when unsafe chars", () => {
+      expect(escapeArgForShell("foo bar")).toBe("'foo bar'");
+    });
+
+    it("escapes single quotes inside", () => {
+      expect(escapeArgForShell("it's")).toBe("'it'\\''s'");
+    });
+  });
+
+  describe("on Windows", () => {
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+      Object.defineProperty(process, "platform", {
+        value: "win32",
+        configurable: true,
+      });
+    });
+
+    afterEach(() => {
+      Object.defineProperty(process, "platform", {
+        value: originalPlatform,
+        configurable: true,
+      });
+    });
+
+    it("returns arg unchanged when only safe chars", () => {
+      expect(escapeArgForShell("foo")).toBe("foo");
+    });
+
+    it("wraps in double quotes when unsafe chars", () => {
+      expect(escapeArgForShell("foo bar")).toBe('"foo bar"');
+    });
+  });
+});
+
+describe("getTempPath", () => {
+  it("appends .tmp to path", () => {
+    expect(getTempPath("/tmp/file.mp3")).toBe("/tmp/file.mp3.tmp");
+    expect(getTempPath("out")).toBe("out.tmp");
+  });
+});
+
+describe("normalizeUrl", () => {
+  it("prepends https: for protocol-relative URL", () => {
+    expect(normalizeUrl("//example.com/foo")).toBe("https://example.com/foo");
+  });
+
+  it("returns url unchanged otherwise", () => {
+    expect(normalizeUrl("https://example.com")).toBe("https://example.com");
+    expect(normalizeUrl("http://a.b")).toBe("http://a.b");
+  });
+
+  it("returns undefined for undefined", () => {
+    expect(normalizeUrl(undefined)).toBeUndefined();
+  });
+});
+
+describe("getUrlExt", () => {
+  it("returns extension from pathname", () => {
+    expect(getUrlExt("https://example.com/episode.mp3")).toBe(".mp3");
+    expect(getUrlExt("https://example.com/path/file.m4a?q=1")).toBe(".m4a");
+  });
+
+  it("returns empty string for no url", () => {
+    expect(getUrlExt(null)).toBe("");
+    expect(getUrlExt("")).toBe("");
+  });
+
+  it("returns empty string when pathname has no ext", () => {
+    expect(getUrlExt("https://example.com/")).toBe("");
+  });
+});
+
+describe("getPublicObject", () => {
+  it("omits keys starting with _", () => {
+    expect(getPublicObject({ a: 1, _b: 2 })).toEqual({ a: 1 });
+  });
+
+  it("omits keys in exclude", () => {
+    expect(getPublicObject({ a: 1, b: 2 }, ["b"])).toEqual({ a: 1 });
+  });
+
+  it("omits falsy values", () => {
+    expect(getPublicObject({ a: 1, b: 0, c: null })).toEqual({ a: 1 });
+  });
+
+  it("returns empty object when all filtered", () => {
+    expect(getPublicObject({ _x: 1 }, [])).toEqual({});
+  });
+});
+
+describe("getLoopControls", () => {
+  describe("forward", () => {
+    it("starts at offset, goes to length", () => {
+      const c = getLoopControls({ offset: 1, length: 5, reverse: false });
+      expect(c.startIndex).toBe(1);
+      expect(c.shouldGo(0)).toBe(true);
+      expect(c.shouldGo(4)).toBe(true);
+      expect(c.shouldGo(5)).toBe(false);
+      expect(c.next(2)).toBe(3);
+    });
+  });
+
+  describe("reverse", () => {
+    it("starts at length - 1 - offset, goes down to 0", () => {
+      const c = getLoopControls({ offset: 1, length: 5, reverse: true });
+      expect(c.startIndex).toBe(3);
+      expect(c.shouldGo(3)).toBe(true);
+      expect(c.shouldGo(0)).toBe(true);
+      expect(c.shouldGo(-1)).toBe(false);
+      expect(c.next(2)).toBe(1);
+    });
+  });
+});
+
+describe("getExtFromMime", () => {
+  it("returns extension for known MIME", () => {
+    expect(getExtFromMime("audio/mpeg")).toBe(".mp3");
+    expect(getExtFromMime("text/vtt")).toBe(".vtt");
+  });
+
+  it("returns null for unknown MIME", () => {
+    expect(getExtFromMime("application/unknown")).toBeNull();
+    expect(getExtFromMime(null)).toBeNull();
+  });
+});
+
+describe("getIsAudioUrl", () => {
+  it("returns true for URL with audio extension", () => {
+    expect(getIsAudioUrl("https://example.com/ep.mp3")).toBe(true);
+    expect(getIsAudioUrl("https://example.com/ep.m4a")).toBe(true);
+  });
+
+  it("returns false for URL without audio extension", () => {
+    expect(getIsAudioUrl("https://example.com/page.html")).toBe(false);
+    expect(getIsAudioUrl("https://example.com/")).toBe(false);
+  });
+
+  it("returns false for invalid URL", () => {
+    expect(getIsAudioUrl("not-a-url")).toBe(false);
+  });
+});
+
+describe("correctExtensionFromMime", () => {
+  it("returns path unchanged when MIME ext matches current ext", () => {
+    expect(
+      correctExtensionFromMime({
+        outputPath: "/out/episode.mp3",
+        contentType: "audio/mpeg",
+      })
+    ).toBe("/out/episode.mp3");
+  });
+
+  it("replaces extension when MIME suggests different ext", () => {
+    expect(
+      correctExtensionFromMime({
+        outputPath: "/out/episode.mp3",
+        contentType: "audio/mp4",
+      })
+    ).toBe("/out/episode.m4a");
+  });
+
+  it("calls onCorrect when extension is corrected", () => {
+    const onCorrect = vi.fn();
+    correctExtensionFromMime({
+      outputPath: "/out/ep.mp3",
+      contentType: "audio/mp4",
+      onCorrect,
+    });
+    expect(onCorrect).toHaveBeenCalledWith(".mp3", ".m4a");
+  });
+
+  it("returns path unchanged when contentType has no known MIME", () => {
+    expect(
+      correctExtensionFromMime({
+        outputPath: "/out/ep.mp3",
+        contentType: "application/octet-stream",
+      })
+    ).toBe("/out/ep.mp3");
+  });
+});
+
+describe("getEpisodeAudioUrlAndExt", () => {
+  it("prefers enclosure URL when present and audio", () => {
+    const result = getEpisodeAudioUrlAndExt({
+      enclosure: { url: "https://example.com/ep.mp3" },
+      link: "https://example.com/other.mp3",
+    });
+    expect(result).toEqual({ url: "https://example.com/ep.mp3", ext: ".mp3" });
+  });
+
+  it("uses enclosure type when URL has no audio ext", () => {
+    const result = getEpisodeAudioUrlAndExt({
+      enclosure: { url: "https://example.com/ep", type: "audio/mpeg" },
+    });
+    expect(result).toEqual({ url: "https://example.com/ep", ext: ".mp3" });
+  });
+
+  it("falls back to link when enclosure not audio", () => {
+    const result = getEpisodeAudioUrlAndExt({
+      enclosure: { url: "https://example.com/page.html" },
+      link: "https://example.com/ep.mp3",
+    });
+    expect(result).toEqual({ url: "https://example.com/ep.mp3", ext: ".mp3" });
+  });
+
+  it("returns null url/ext when no audio source", () => {
+    const result = getEpisodeAudioUrlAndExt({
+      enclosure: { url: "https://example.com/page.html" },
+    });
+    expect(result).toEqual({ url: null, ext: null });
+  });
+
+  it("respects order option", () => {
+    const result = getEpisodeAudioUrlAndExt(
+      {
+        enclosure: { url: "https://example.com/ep.mp3" },
+        link: "https://example.com/alt.mp3",
+      },
+      [AUDIO_ORDER_TYPES.link, AUDIO_ORDER_TYPES.enclosure]
+    );
+    expect(result).toEqual({ url: "https://example.com/alt.mp3", ext: ".mp3" });
+  });
+});
+
+describe("getImageUrl", () => {
+  it("prefers image.url", () => {
+    expect(
+      getImageUrl({
+        image: { url: "https://a.com/img.jpg" },
+        itunes: { image: "https://b.com/img.jpg" },
+      })
+    ).toBe("https://a.com/img.jpg");
+  });
+
+  it("uses image.link when image.url missing", () => {
+    expect(
+      getImageUrl({
+        image: { link: "https://a.com/img.jpg" },
+        itunes: { image: "https://b.com/img.jpg" },
+      })
+    ).toBe("https://a.com/img.jpg");
+  });
+
+  it("uses itunes.image when image url/link missing", () => {
+    expect(getImageUrl({ itunes: { image: "https://b.com/img.jpg" } })).toBe(
+      "https://b.com/img.jpg"
+    );
+  });
+
+  it("returns null when no image", () => {
+    expect(getImageUrl({})).toBeNull();
+    expect(getImageUrl({ image: {}, itunes: {} })).toBeNull();
+  });
+});
+
+describe("getTranscriptUrl", () => {
+  it("returns null when no podcastTranscripts", () => {
+    expect(getTranscriptUrl({})).toBeNull();
+    expect(getTranscriptUrl({ podcastTranscripts: [] })).toBeNull();
+  });
+
+  it("returns URL for first matching transcript type", () => {
+    const item = {
+      podcastTranscripts: [
+        { $: { type: "text/plain", url: "https://example.com/plain.txt" } },
+        { $: { type: "text/vtt", url: "https://example.com/cc.vtt" } },
+      ],
+    };
+    expect(
+      getTranscriptUrl(item, [
+        TRANSCRIPT_TYPES["text/vtt"],
+        TRANSCRIPT_TYPES["text/plain"],
+      ])
+    ).toBe("https://example.com/cc.vtt");
+  });
+
+  it("returns null when type does not match", () => {
+    const item = {
+      podcastTranscripts: [
+        { $: { type: "text/plain", url: "https://example.com/plain.txt" } },
+      ],
+    };
+    expect(getTranscriptUrl(item, ["text/vtt"])).toBeNull();
+  });
+});

package/bin/validate.js

@@ -32,8 +32,13 @@ export const createParseNumber = ({ min, max, name, required = true }) => {
   };
 };
 
+let ffmpegExists = null;
 export const hasFfmpeg = (value) => {
-  if (!commandExistsSync("ffmpeg")) {
+  if (ffmpegExists === null) {
+    ffmpegExists = commandExistsSync("ffmpeg");
+  }
+
+  if (!ffmpegExists) {
     logErrorAndExit('option specified requires "ffmpeg" be available');
   }
 

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "podcast-dl",
-  "version": "11.7.1",
+  "version": "11.7.3",
   "description": "A CLI for downloading podcasts.",
   "type": "module",
   "bin": "./bin/bin.js",
   "scripts": {
     "build": "rimraf ./binaries && rimraf ./dist && node build.cjs",
-    "lint": "eslint ./bin"
+    "lint": "eslint ./bin",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "lint-staged": {
     "*.{js,json,md}": [
@@ -47,6 +49,7 @@
     "lint-staged": "^10.1.7",
     "prettier": "2.3.2",
     "rimraf": "^3.0.2",
+    "vitest": "^3.2.4",
     "webpack": "^5.75.0"
   },
   "dependencies": {