podcast-dl 11.7.3 → 11.7.4

package/bin/archive.js

@@ -43,10 +43,7 @@ export const writeToArchive = ({ archiveKeys, archive }) => {
   });
 
   if (data.dirty) {
-    fs.writeFileSync(
-      path.resolve(cwd, archive),
-      JSON.stringify([...data.entries], null, 4)
-    );
+    fs.writeFileSync(path.resolve(cwd, archive), JSON.stringify([...data.entries], null, 4));
     data.dirty = false;
   }
 };
@@ -57,9 +54,7 @@ export const getIsInArchive = ({ archiveKeys, archive }) => {
 };
 
 export const getArchiveFilename = ({ pubDate, name, ext }) => {
-  const formattedPubDate = pubDate
-    ? dayjs(new Date(pubDate)).format("YYYYMMDD")
-    : null;
+  const formattedPubDate = pubDate ? dayjs(new Date(pubDate)).format("YYYYMMDD") : null;
 
   const baseName = formattedPubDate ? `${formattedPubDate}-${name}` : name;
 

package/bin/async.js

@@ -5,12 +5,7 @@ import _path from "path";
 import stream from "stream";
 import { throttle } from "throttle-debounce";
 import { promisify } from "util";
-import {
-  getArchiveFilename,
-  getArchiveKeys,
-  getIsInArchive,
-  writeToArchive,
-} from "./archive.js";
+import { getArchiveFilename, getArchiveKeys, getIsInArchive, writeToArchive } from "./archive.js";
 import { runExec } from "./exec.js";
 import { runFfmpeg } from "./ffmpeg.js";
 import {
@@ -61,11 +56,7 @@ export const download = async (options) => {
     return outputPath;
   }
 
-  if (
-    archive &&
-    archiveKeys.length &&
-    getIsInArchive({ archiveKeys, archive })
-  ) {
+  if (archive && archiveKeys.length && getIsInArchive({ archiveKeys, archive })) {
     logMessage("Download exists in archive. Skipping...");
     return null;
   }
@@ -98,23 +89,17 @@ export const download = async (options) => {
 
   logMessage(
     `Starting download${
-      expectedSize
-        ? ` of ${(expectedSize / BYTES_IN_MB).toFixed(2)} MB...`
-        : "..."
-    }`
+      expectedSize ? ` of ${(expectedSize / BYTES_IN_MB).toFixed(2)} MB...` : "..."
+    }`,
   );
 
   try {
     const onDownloadProgress = throttle(3000, (progress) => {
-      if (
-        getShouldOutputProgressIndicator() &&
-        progress.transferred > 0 &&
-        progress.percent < 1
-      ) {
+      if (getShouldOutputProgressIndicator() && progress.transferred > 0 && progress.percent < 1) {
         logMessage(
-          `${(progress.percent * 100).toFixed(0)}% of ${(
-            progress.total / BYTES_IN_MB
-          ).toFixed(2)} MB...`
+          `${(progress.percent * 100).toFixed(0)}% of ${(progress.total / BYTES_IN_MB).toFixed(
+            2,
+          )} MB...`,
         );
       }
     });
@@ -123,7 +108,7 @@ export const download = async (options) => {
       got
         .stream(url, { headers: { "user-agent": userAgent } })
         .on("downloadProgress", onDownloadProgress),
-      fs.createWriteStream(tempOutputPath)
+      fs.createWriteStream(tempOutputPath),
     );
   } catch (error) {
     removeFile();
@@ -145,10 +130,7 @@ export const download = async (options) => {
   if (fileSize === 0) {
     removeFile();
 
-    logMessage(
-      "Unable to write to file. Suggestion: verify permissions",
-      LOG_LEVELS.important
-    );
+    logMessage("Unable to write to file. Suggestion: verify permissions", LOG_LEVELS.important);
 
     return null;
   }
@@ -159,10 +141,7 @@ export const download = async (options) => {
         outputPath,
         contentType: headResponse?.headers?.["content-type"],
         onCorrect: (from, to) =>
-          logMessage(
-            `Correcting extension: ${from} --> ${to}`,
-            LOG_LEVELS.important
-          ),
+          logMessage(`Correcting extension: ${from} --> ${to}`, LOG_LEVELS.important),
       });
 
   fs.renameSync(tempOutputPath, finalOutputPath);
@@ -217,8 +196,10 @@ export const downloadItemsAsync = async ({
     const threadIndex = index % threads;
     const marker = threads > 1 ? `[${threadIndex}] ${item.title}` : item.title;
     const logMessage = getLogMessageWithMarker(marker);
-    const { url: episodeAudioUrl, ext: audioFileExt } =
-      getEpisodeAudioUrlAndExt(item, episodeSourceOrder);
+    const { url: episodeAudioUrl, ext: audioFileExt } = getEpisodeAudioUrlAndExt(
+      item,
+      episodeSourceOrder,
+    );
 
     if (!episodeAudioUrl) {
       hasErrors = true;
@@ -273,9 +254,7 @@ export const downloadItemsAsync = async ({
             } catch (error) {
               hasErrors = true;
               logError(
-                `${marker} | Error downloading ${
-                  item._episodeImage.url
-                }: ${error.toString()}`
+                `${marker} | Error downloading ${item._episodeImage.url}: ${error.toString()}`,
               );
             }
           }
@@ -300,9 +279,7 @@ export const downloadItemsAsync = async ({
             } catch (error) {
               hasErrors = true;
               logError(
-                `${marker} | Error downloading ${
-                  item._episodeTranscript.url
-                }: ${error.toString()}`
+                `${marker} | Error downloading ${item._episodeTranscript.url}: ${error.toString()}`,
               );
             }
           }
@@ -316,9 +293,7 @@ export const downloadItemsAsync = async ({
               audioFormat,
               bitrate,
               embedMetadata: embedMetadataFlag,
-              episodeImageOutputPath: hasEpisodeImage
-                ? item._episodeImage.outputPath
-                : undefined,
+              episodeImageOutputPath: hasEpisodeImage ? item._episodeImage.outputPath : undefined,
               ext: audioFileExt,
               feed,
               item,
@@ -355,10 +330,7 @@ export const downloadItemsAsync = async ({
               width: episodeDigits,
               offset: episodeNumOffset,
             });
-            const outputEpisodeMetaPath = _path.resolve(
-              basePath,
-              episodeMetaName
-            );
+            const outputEpisodeMetaPath = _path.resolve(basePath, episodeMetaName);
 
             try {
               logMessage("Saving episode metadata...");
@@ -393,9 +365,7 @@ export const downloadItemsAsync = async ({
     }
   };
 
-  const itemPromises = targetItems.map((item, index) =>
-    limit(() => downloadItem(item, index))
-  );
+  const itemPromises = targetItems.map((item, index) => limit(() => downloadItem(item, index)));
 
   await Promise.all(itemPromises);
 

package/bin/bin.js

@@ -9,13 +9,7 @@ import { getArchiveKey } from "./archive.js";
 import { download, downloadItemsAsync } from "./async.js";
 import { setupCommander } from "./commander.js";
 import { getItemsToDownload, logItemsList } from "./items.js";
-import {
-  ERROR_STATUSES,
-  LOG_LEVELS,
-  logError,
-  logErrorAndExit,
-  logMessage,
-} from "./logger.js";
+import { ERROR_STATUSES, LOG_LEVELS, logError, logErrorAndExit, logMessage } from "./logger.js";
 import { writeFeedMeta } from "./meta.js";
 import { getFolderName, getSimpleFilename } from "./naming.js";
 import {
@@ -87,9 +81,7 @@ const main = async () => {
     bootstrapProxy();
   }
 
-  const feed = url
-    ? await getUrlFeed(url, parserConfig)
-    : await getFileFeed(file, parserConfig);
+  const feed = url ? await getUrlFeed(url, parserConfig) : await getFileFeed(file, parserConfig);
 
   const archivePrefix = (() => {
     if (feed.feedUrl || url) {
@@ -101,10 +93,7 @@ const main = async () => {
     return feed.title || file;
   })();
 
-  const basePath = _path.resolve(
-    cwd,
-    getFolderName({ feed, template: outDir })
-  );
+  const basePath = _path.resolve(cwd, getFolderName({ feed, template: outDir }));
 
   if (info) {
     logFeedInfo(feed);
@@ -142,10 +131,7 @@ const main = async () => {
   }
 
   if (archive) {
-    archive =
-      typeof archive === "boolean"
-        ? "./{{podcast_title}}/archive.json"
-        : archive;
+    archive = typeof archive === "boolean" ? "./{{podcast_title}}/archive.json" : archive;
     archive = getFolderName({ feed, template: archive });
   }
 
@@ -156,7 +142,7 @@ const main = async () => {
       const podcastImageFileExt = getUrlExt(podcastImageUrl);
       const outputImagePath = _path.resolve(
         basePath,
-        getSimpleFilename(feed.title || "image", podcastImageFileExt)
+        getSimpleFilename(feed.title || "image", podcastImageFileExt),
       );
 
       try {
@@ -184,10 +170,7 @@ const main = async () => {
 
     const outputMetaPath = _path.resolve(
       basePath,
-      getSimpleFilename(
-        feed.title ? feed.title : "meta",
-        feed.title ? ".meta.json" : ".json"
-      )
+      getSimpleFilename(feed.title ? feed.title : "meta", feed.title ? ".meta.json" : ".json"),
     );
 
     try {
@@ -243,9 +226,7 @@ const main = async () => {
     logErrorAndExit("No episodes found with provided criteria to download");
   }
 
-  logMessage(
-    `\nStarting download of ${pluralize("episode", targetItems.length, true)}\n`
-  );
+  logMessage(`\nStarting download of ${pluralize("episode", targetItems.length, true)}\n`);
 
   const { numEpisodesDownloaded, hasErrors } = await downloadItemsAsync({
     archive,
@@ -278,17 +259,11 @@ const main = async () => {
       `\n${numEpisodesDownloaded} of ${pluralize(
         "episode",
         targetItems.length,
-        true
-      )} downloaded\n`
+        true,
+      )} downloaded\n`,
     );
   } else if (numEpisodesDownloaded > 0) {
-    logMessage(
-      `\nSuccessfully downloaded ${pluralize(
-        "episode",
-        numEpisodesDownloaded,
-        true
-      )}\n`
-    );
+    logMessage(`\nSuccessfully downloaded ${pluralize("episode", numEpisodesDownloaded, true)}\n`);
   }
 
   if (numEpisodesDownloaded === 0) {

package/bin/commander.js

@@ -7,29 +7,22 @@ export const setupCommander = (program) => {
   program
     .option("--url <string>", "url to podcast rss feed")
     .option("--file <path>", "local path to podcast rss feed")
-    .option(
-      "--out-dir <path>",
-      "specify output directory",
-      "./{{podcast_title}}"
-    )
-    .option(
-      "--archive [path]",
-      "download or write only items not listed in archive file"
-    )
+    .option("--out-dir <path>", "specify output directory", "./{{podcast_title}}")
+    .option("--archive [path]", "download or write only items not listed in archive file")
     .option(
       "--episode-template <string>",
       "template for generating episode related filenames",
-      "{{release_date}}-{{title}}"
+      "{{release_date}}-{{title}}",
     )
     .option(
       "--episode-custom-template-options <patterns...>",
-      "create custom options for the episode template"
+      "create custom options for the episode template",
     )
     .option(
       "--episode-digits <number>",
       "minimum number of digits to use for episode numbering (leading zeros)",
       createParseNumber({ min: 0, name: "--episode-digits" }),
-      1
+      1,
     )
     .option(
       "--episode-num-offset <number>",
@@ -39,7 +32,7 @@ export const setupCommander = (program) => {
         max: Number.MAX_SAFE_INTEGER,
         name: "--episode-num-offset",
       }),
-      0
+      0,
     )
     .option(
       "--episode-source-order <string>",
@@ -49,24 +42,16 @@ export const setupCommander = (program) => {
         const isValid = parsed.every((type) => !!AUDIO_ORDER_TYPES[type]);
 
         if (!isValid) {
-          logErrorAndExit(
-            `Invalid type found in --episode-source-order: ${value}\n`
-          );
+          logErrorAndExit(`Invalid type found in --episode-source-order: ${value}\n`);
         }
 
         return parsed;
       },
-      [AUDIO_ORDER_TYPES.enclosure, AUDIO_ORDER_TYPES.link]
-    )
-    .option("--include-meta", "write out podcast metadata to json")
-    .option(
-      "--include-episode-meta",
-      "write out individual episode metadata to json"
-    )
-    .option(
-      "--include-episode-transcripts",
-      "download found episode transcripts"
+      [AUDIO_ORDER_TYPES.enclosure, AUDIO_ORDER_TYPES.link],
     )
+    .option("--include-meta", "write out podcast metadata to json", false)
+    .option("--include-episode-meta", "write out individual episode metadata to json", false)
+    .option("--include-episode-transcripts", "download found episode transcripts", false)
     .option(
       "--episode-transcript-types <string>",
       "list of allowed transcript types in preferred order",
@@ -75,9 +60,7 @@ export const setupCommander = (program) => {
         const isValid = parsed.every((type) => !!TRANSCRIPT_TYPES[type]);
 
         if (!isValid) {
-          logErrorAndExit(
-            `Invalid type found in --transcript-types: ${value}\n`
-          );
+          logErrorAndExit(`Invalid type found in --transcript-types: ${value}\n`);
         }
 
         return parsed;
@@ -90,98 +73,68 @@ export const setupCommander = (program) => {
         TRANSCRIPT_TYPES["text/vtt"],
         TRANSCRIPT_TYPES["text/html"],
         TRANSCRIPT_TYPES["text/plain"],
-      ]
+      ],
     )
-    .option("--include-episode-images", "download found episode images")
+    .option("--include-episode-images", "download found episode images", false)
     .option(
       "--offset <number>",
       "offset episode to start downloading from (most recent = 0)",
       createParseNumber({ min: 0, name: "--offset" }),
-      0
+      0,
     )
     .option(
       "--limit <number>",
       "max amount of episodes to download",
-      createParseNumber({ min: 1, name: "--limit", require: false })
-    )
-    .option(
-      "--episode-regex <string>",
-      "match episode title against regex before downloading"
-    )
-    .option(
-      "--episode-regex-exclude <string>",
-      "episode titles matching regex will be excluded"
+      createParseNumber({ min: 1, name: "--limit", required: false }),
     )
+    .option("--episode-regex <string>", "match episode title against regex before downloading")
+    .option("--episode-regex-exclude <string>", "episode titles matching regex will be excluded")
     .option(
       "--season <number>",
       "download only episodes from this season",
-      createParseNumber({ min: 0, name: "--season" })
-    )
-    .option(
-      "--after <string>",
-      "download episodes only after this date (inclusive)"
-    )
-    .option(
-      "--before <string>",
-      "download episodes only before this date (inclusive)"
-    )
-    .option(
-      "--embed-metadata",
-      "add metadata to episode files using ffmpeg",
-      hasFfmpeg
-    )
-    .option(
-      "--add-mp3-metadata",
-      "deprecated: use --embed-metadata instead",
-      hasFfmpeg
+      createParseNumber({ min: 0, name: "--season" }),
     )
+    .option("--after <string>", "download episodes only after this date (inclusive)")
+    .option("--before <string>", "download episodes only before this date (inclusive)")
+    .option("--embed-metadata", "add metadata to episode files using ffmpeg", hasFfmpeg, false)
+    .option("--add-mp3-metadata", "deprecated: use --embed-metadata instead", hasFfmpeg, false)
     .option(
       "--audio-format <string>",
       "convert audio to format (mp3, m4a, aac, opus, ogg, flac, wav)",
       (value) => {
         if (!AUDIO_FORMATS[value]) {
           logErrorAndExit(
-            `Invalid audio format: ${value}\nSupported formats: ${Object.keys(
-              AUDIO_FORMATS
-            ).join(", ")}`
+            `Invalid audio format: ${value}\nSupported formats: ${Object.keys(AUDIO_FORMATS).join(
+              ", ",
+            )}`,
           );
         }
 
         return hasFfmpeg(value);
-      }
-    )
-    .option(
-      "--adjust-bitrate <string>",
-      "adjust bitrate of episode files using ffmpeg",
-      hasFfmpeg
+      },
     )
-    .option("--mono", "force episode files into mono using ffmpeg", hasFfmpeg)
-    .option("--override", "override local files on collision")
+    .option("--adjust-bitrate <string>", "adjust bitrate of episode files using ffmpeg", hasFfmpeg)
+    .option("--mono", "force episode files into mono using ffmpeg", hasFfmpeg, false)
+    .option("--override", "override local files on collision", false)
     .option(
       "--always-postprocess",
-      "always run additional tasks on the file regardless of whether the file already exists"
-    )
-    .option("--reverse", "download episodes in reverse order")
-    .option("--info", "print retrieved podcast info instead of downloading")
-    .option(
-      "--list [table|json]",
-      "print episode info instead of downloading",
-      (value) => {
-        if (!ITEM_LIST_FORMATS.includes(value)) {
-          logErrorAndExit(
-            `${value} is an invalid format for --list\nUse one of the following: ${ITEM_LIST_FORMATS.join(
-              ", "
-            )}`
-          );
-        }
-
-        return value;
+      "always run additional tasks on the file regardless of whether the file already exists",
+      false,
+    )
+    .option("--reverse", "download episodes in reverse order", false)
+    .option("--info", "print retrieved podcast info instead of downloading", false)
+    .option("--list [table|json]", "print episode info instead of downloading", (value) => {
+      if (!ITEM_LIST_FORMATS.includes(value)) {
+        logErrorAndExit(
+          `${value} is an invalid format for --list\nUse one of the following: ${ITEM_LIST_FORMATS.join(
+            ", ",
+          )}`,
+        );
       }
-    )
-    .option(
-      "--exec <string>",
-      "execute a command after each episode is downloaded"
-    )
+
+      return value;
+    })
+    .option("--exec <string>", "execute a command after each episode is downloaded")
     .option(
       "--threads <number>",
       "the number of downloads that can happen concurrently",
@@ -190,7 +143,7 @@ export const setupCommander = (program) => {
         max: Number.MAX_SAFE_INTEGER,
         name: "threads",
       }),
-      1
+      1,
     )
     .option(
       "--attempts <number>",
@@ -200,15 +153,12 @@ export const setupCommander = (program) => {
         max: Number.MAX_SAFE_INTEGER,
         name: "attempts",
       }),
-      3
-    )
-    .option(
-      "--parser-config <string>",
-      "path to JSON config to override RSS parser"
+      3,
     )
-    .option("--proxy", "enable proxy support via global-agent")
+    .option("--parser-config <string>", "path to JSON config to override RSS parser")
+    .option("--proxy", "enable proxy support via global-agent", false)
     .option("--user-agent <string>", "specify custom user agent string")
-    .option("--trust-ext", "trust file extension, skip MIME-based correction");
+    .option("--trust-ext", "trust file extension, skip MIME-based correction", false);
 
   program.parse();