podcast-dl 10.4.0 → 11.0.0

package/bin/ffmpeg.js

@@ -0,0 +1,101 @@
+import dayjs from "dayjs";
+import fs from "fs";
+import { execWithPromise } from "./exec.js";
+import { LOG_LEVELS, logMessage } from "./logger.js";
+import { escapeArgForShell } from "./util.js";
+
+export const runFfmpeg = async ({
+  feed,
+  item,
+  itemIndex,
+  outputPath,
+  episodeImageOutputPath,
+  bitrate,
+  mono,
+  addMp3Metadata,
+  ext,
+}) => {
+  if (!fs.existsSync(outputPath)) {
+    return;
+  }
+
+  const shouldEmbedImage = addMp3Metadata && episodeImageOutputPath;
+  let command = `ffmpeg -loglevel quiet -i ${escapeArgForShell(outputPath)}`;
+
+  if (shouldEmbedImage) {
+    command += ` -i ${escapeArgForShell(episodeImageOutputPath)}`;
+  }
+
+  if (bitrate) {
+    command += ` -b:a ${bitrate}`;
+  }
+
+  if (mono) {
+    command += " -ac 1";
+  }
+
+  if (addMp3Metadata) {
+    const album = feed.title || "";
+    const artist = item.itunes?.author || item.author || "";
+    const title = item.title || "";
+    const subtitle = item.itunes?.subtitle || "";
+    const comment = item.contentSnippet || item.content || "";
+    const disc = item.itunes?.season || "";
+    const track = item.itunes?.episode || `${feed.items.length - itemIndex}`;
+    const episodeType = item.itunes?.episodeType || "";
+    const date = item.pubDate
+      ? dayjs(new Date(item.pubDate)).format("YYYY-MM-DD")
+      : "";
+
+    const metaKeysToValues = {
+      album,
+      artist,
+      album_artist: artist,
+      title,
+      subtitle,
+      comment,
+      disc,
+      track,
+      "episode-type": episodeType,
+      date,
+    };
+
+    const metadataString = Object.keys(metaKeysToValues)
+      .map((key) => {
+        if (!metaKeysToValues[key]) {
+          return null;
+        }
+
+        const argValue = escapeArgForShell(metaKeysToValues[key]);
+
+        return argValue ? `-metadata ${key}=${argValue}` : null;
+      })
+      .filter((segment) => !!segment)
+      .join(" ");
+
+    command += ` -map_metadata 0 ${metadataString} -codec copy`;
+  }
+
+  if (shouldEmbedImage) {
+    command += ` -map 0 -map 1`;
+  } else {
+    command += ` -map 0`;
+  }
+
+  const tmpMp3Path = `${outputPath}.tmp${ext}`;
+  command += ` ${escapeArgForShell(tmpMp3Path)}`;
+  logMessage("Running command: " + command, LOG_LEVELS.debug);
+
+  try {
+    await execWithPromise(command, { stdio: "ignore" });
+  } catch (error) {
+    if (fs.existsSync(tmpMp3Path)) {
+      fs.unlinkSync(tmpMp3Path);
+    }
+
+    throw error;
+  }
+
+  fs.unlinkSync(outputPath);
+  fs.renameSync(tmpMp3Path, outputPath);
+};

package/bin/items.js

@@ -0,0 +1,203 @@
+import dayjs from "dayjs";
+import path from "path";
+import { getItemFilename } from "./naming.js";
+import {
+  getEpisodeAudioUrlAndExt,
+  getImageUrl,
+  getLoopControls,
+  getTranscriptUrl,
+  getUrlExt,
+} from "./util.js";
+import { logErrorAndExit } from "./logger.js";
+
+export const ITEM_LIST_FORMATS = ["table", "json"];
+
+export const getItemsToDownload = ({
+  addMp3MetadataFlag,
+  basePath,
+  feed,
+  limit,
+  offset,
+  reverse,
+  before,
+  after,
+  episodeDigits,
+  episodeNumOffset,
+  episodeRegex,
+  episodeRegexExclude,
+  episodeSourceOrder,
+  episodeTemplate,
+  episodeCustomTemplateOptions,
+  includeEpisodeImages,
+  includeEpisodeTranscripts,
+  episodeTranscriptTypes,
+}) => {
+  const { startIndex, shouldGo, next } = getLoopControls({
+    offset,
+    reverse,
+    length: feed.items.length,
+  });
+
+  let i = startIndex;
+  const items = [];
+
+  while (shouldGo(i)) {
+    const { title, pubDate } = feed.items[i];
+    const pubDateDay = dayjs(new Date(pubDate));
+    let isValid = true;
+
+    if (episodeRegex) {
+      const generatedEpisodeRegex = new RegExp(episodeRegex);
+      if (title && !generatedEpisodeRegex.test(title)) {
+        isValid = false;
+      }
+    }
+
+    if (episodeRegexExclude) {
+      const generatedEpisodeRegexExclude = new RegExp(episodeRegexExclude);
+      if (title && generatedEpisodeRegexExclude.test(title)) {
+        isValid = false;
+      }
+    }
+
+    if (before) {
+      const beforeDateDay = dayjs(new Date(before));
+      if (
+        !pubDateDay.isSame(beforeDateDay, "day") &&
+        !pubDateDay.isBefore(beforeDateDay, "day")
+      ) {
+        isValid = false;
+      }
+    }
+
+    if (after) {
+      const afterDateDay = dayjs(new Date(after));
+      if (
+        !pubDateDay.isSame(afterDateDay, "day") &&
+        !pubDateDay.isAfter(afterDateDay, "day")
+      ) {
+        isValid = false;
+      }
+    }
+
+    const { url: episodeAudioUrl } = getEpisodeAudioUrlAndExt(
+      feed.items[i],
+      episodeSourceOrder
+    );
+
+    if (isValid) {
+      const item = feed.items[i];
+      item._originalIndex = i;
+
+      if (includeEpisodeImages || addMp3MetadataFlag) {
+        const episodeImageUrl = getImageUrl(item);
+
+        if (episodeImageUrl) {
+          const episodeImageFileExt = getUrlExt(episodeImageUrl);
+
+          const episodeImageName = getItemFilename({
+            item,
+            feed,
+            url: episodeAudioUrl,
+            ext: episodeImageFileExt,
+            template: episodeTemplate,
+            customTemplateOptions: episodeCustomTemplateOptions,
+            width: episodeDigits,
+            offset: episodeNumOffset,
+          });
+
+          const outputImagePath = path.resolve(basePath, episodeImageName);
+          item._episodeImage = {
+            url: episodeImageUrl,
+            outputPath: outputImagePath,
+          };
+        }
+      }
+
+      if (includeEpisodeTranscripts) {
+        const episodeTranscriptUrl = getTranscriptUrl(
+          item,
+          episodeTranscriptTypes
+        );
+
+        if (episodeTranscriptUrl) {
+          const episodeTranscriptFileExt = getUrlExt(episodeTranscriptUrl);
+
+          const episodeTranscriptName = getItemFilename({
+            item,
+            feed,
+            url: episodeAudioUrl,
+            ext: episodeTranscriptFileExt,
+            template: episodeTemplate,
+            width: episodeDigits,
+            offset: episodeNumOffset,
+          });
+
+          const outputTranscriptPath = path.resolve(
+            basePath,
+            episodeTranscriptName
+          );
+
+          item._episodeTranscript = {
+            url: episodeTranscriptUrl,
+            outputPath: outputTranscriptPath,
+          };
+        }
+      }
+
+      items.push(item);
+    }
+
+    i = next(i);
+  }
+
+  return limit ? items.slice(0, limit) : items;
+};
+
+export const logItemsList = ({
+  type,
+  feed,
+  limit,
+  offset,
+  reverse,
+  before,
+  after,
+  episodeRegex,
+  episodeRegexExclude,
+}) => {
+  const items = getItemsToDownload({
+    feed,
+    limit,
+    offset,
+    reverse,
+    before,
+    after,
+    episodeRegex,
+    episodeRegexExclude,
+  });
+
+  if (!items.length) {
+    logErrorAndExit("No episodes found with provided criteria to list");
+  }
+
+  const isJson = type === "json";
+
+  const output = items.map((item) => {
+    const data = {
+      episodeNum: feed.items.length - item._originalIndex,
+      title: item.title,
+      pubDate: item.pubDate,
+    };
+
+    return data;
+  });
+
+  if (isJson) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(output));
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.table(output);
+};

package/bin/logger.js

@@ -1,25 +1,25 @@
 /* eslint-disable no-console */
 
-const ERROR_STATUSES = {
+export const ERROR_STATUSES = {
   general: 1,
   nothingDownloaded: 2,
   completedWithErrors: 3,
 };
 
-const LOG_LEVEL_TYPES = {
+export const LOG_LEVEL_TYPES = {
   debug: "debug",
   quiet: "quiet",
   silent: "silent",
   static: "static",
 };
 
-const LOG_LEVELS = {
+export const LOG_LEVELS = {
   debug: 0,
   info: 1,
   important: 2,
 };
 
-const getShouldOutputProgressIndicator = () => {
+export const getShouldOutputProgressIndicator = () => {
   return (
     process.stdout.isTTY &&
     process.env.LOG_LEVEL !== LOG_LEVEL_TYPES.static &&
@@ -28,7 +28,7 @@ const getShouldOutputProgressIndicator = () => {
   );
 };
 
-const logMessage = (message = "", logLevel = 1) => {
+export const logMessage = (message = "", logLevel = 1) => {
   if (
     !process.env.LOG_LEVEL ||
     process.env.LOG_LEVEL === LOG_LEVEL_TYPES.debug ||
@@ -51,7 +51,7 @@ const logMessage = (message = "", logLevel = 1) => {
   }
 };
 
-const getLogMessageWithMarker = (marker) => {
+export const getLogMessageWithMarker = (marker) => {
   return (message, logLevel) => {
     if (marker) {
       logMessage(`${marker} | ${message}`, logLevel);
@@ -61,7 +61,7 @@ const getLogMessageWithMarker = (marker) => {
   };
 };
 
-const logError = (msg, error) => {
+export const logError = (msg, error) => {
   if (process.env.LOG_LEVEL === LOG_LEVEL_TYPES.silent) {
     return;
   }
@@ -73,7 +73,7 @@ const logError = (msg, error) => {
   }
 };
 
-const logErrorAndExit = (msg, error) => {
+export const logErrorAndExit = (msg, error) => {
   console.error(msg);
 
   if (error) {
@@ -82,13 +82,3 @@ const logErrorAndExit = (msg, error) => {
 
   process.exit(ERROR_STATUSES.general);
 };
-
-export {
-  ERROR_STATUSES,
-  getShouldOutputProgressIndicator,
-  getLogMessageWithMarker,
-  LOG_LEVELS,
-  logMessage,
-  logError,
-  logErrorAndExit,
-};

package/bin/meta.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+import { logMessage } from "./logger.js";
+import { getPublicObject } from "./util.js";
+
+export const writeFeedMeta = ({ outputPath, feed, override }) => {
+  const output = getPublicObject(feed, ["items"]);
+
+  try {
+    if (override || !fs.existsSync(outputPath)) {
+      fs.writeFileSync(outputPath, JSON.stringify(output, null, 4));
+    } else {
+      logMessage("Feed metadata exists locally. Skipping...");
+    }
+  } catch (error) {
+    throw new Error(
+      `Unable to save metadata file for feed: ${error.toString()}`
+    );
+  }
+};
+
+export const writeItemMeta = ({ marker, outputPath, item, override }) => {
+  const output = getPublicObject(item);
+
+  try {
+    if (override || !fs.existsSync(outputPath)) {
+      fs.writeFileSync(outputPath, JSON.stringify(output, null, 4));
+    } else {
+      logMessage(`${marker} | Episode metadata exists locally. Skipping...`);
+    }
+  } catch (error) {
+    throw new Error("Unable to save meta file for episode", error);
+  }
+};

package/bin/naming.js

@@ -1,24 +1,24 @@
-import path from "path";
-import filenamify from "filenamify";
 import dayjs from "dayjs";
+import filenamify from "filenamify";
+import path from "path";
 
 const INVALID_CHAR_REPLACE = "_";
 const MAX_LENGTH_FILENAME = process.env.MAX_LENGTH_FILENAME
   ? parseInt(process.env.MAX_LENGTH_FILENAME)
   : 255;
 
-const getSafeName = (name, maxLength = MAX_LENGTH_FILENAME) => {
+export const getSafeName = (name, maxLength = MAX_LENGTH_FILENAME) => {
   return filenamify(name, {
     replacement: INVALID_CHAR_REPLACE,
     maxLength,
   });
 };
 
-const getSimpleFilename = (name, ext = "") => {
+export const getSimpleFilename = (name, ext = "") => {
   return `${getSafeName(name, MAX_LENGTH_FILENAME - (ext?.length ?? 0))}${ext}`;
 };
 
-const getItemFilename = ({
+export const getItemFilename = ({
   item,
   ext,
   url,
@@ -92,7 +92,7 @@ const getItemFilename = ({
   return nameSegments.join(path.sep);
 };
 
-const getFolderName = ({ feed, template }) => {
+export const getFolderName = ({ feed, template }) => {
   const templateReplacementsTuples = [
     ["podcast_title", feed.title || ""],
     ["podcast_link", feed.link || ""],
@@ -110,21 +110,3 @@ const getFolderName = ({ feed, template }) => {
 
   return name;
 };
-
-const getArchiveFilename = ({ pubDate, name, ext }) => {
-  const formattedPubDate = pubDate
-    ? dayjs(new Date(pubDate)).format("YYYYMMDD")
-    : null;
-
-  const baseName = formattedPubDate ? `${formattedPubDate}-${name}` : name;
-
-  return `${baseName}${ext}`;
-};
-
-export {
-  getArchiveFilename,
-  getFolderName,
-  getItemFilename,
-  getSafeName,
-  getSimpleFilename,
-};