getraw 0.1.0

package/src/core/format-sorter.ts

@@ -0,0 +1,208 @@
+import type { Format } from "./types";
+
+interface FormatSpec {
+  type: "merge" | "single";
+  video?: FormatFilter;
+  audio?: FormatFilter;
+  fallback?: FormatSpec;
+}
+
+interface FormatFilter {
+  id?: string;
+  best: boolean;
+  worst: boolean;
+  videoOnly: boolean;
+  audioOnly: boolean;
+  height?: number;
+  ext?: string;
+}
+
+function parseFilter(token: string): FormatFilter {
+  const filter: FormatFilter = {
+    best: false,
+    worst: false,
+    videoOnly: false,
+    audioOnly: false,
+  };
+
+  if (token === "best" || token === "b") {
+    filter.best = true;
+    return filter;
+  }
+  if (token === "worst" || token === "w") {
+    filter.worst = true;
+    return filter;
+  }
+  if (token === "bv" || token === "bestvideo") {
+    filter.best = true;
+    filter.videoOnly = true;
+    return filter;
+  }
+  if (token === "ba" || token === "bestaudio") {
+    filter.best = true;
+    filter.audioOnly = true;
+    return filter;
+  }
+  if (token === "wv" || token === "worstvideo") {
+    filter.worst = true;
+    filter.videoOnly = true;
+    return filter;
+  }
+  if (token === "wa" || token === "worstaudio") {
+    filter.worst = true;
+    filter.audioOnly = true;
+    return filter;
+  }
+  if (token.startsWith("bv*")) {
+    filter.best = true;
+    filter.videoOnly = false;
+    return filter;
+  }
+
+  const heightMatch = token.match(/^(\d+)p$/);
+  if (heightMatch) {
+    filter.height = parseInt(heightMatch[1], 10);
+    filter.best = true;
+    return filter;
+  }
+
+  filter.id = token;
+  return filter;
+}
+
+export function parseFormatString(formatStr: string): FormatSpec {
+  const alternatives = formatStr.split("/");
+
+  const specs: FormatSpec[] = alternatives.map((alt) => {
+    const parts = alt.split("+");
+    if (parts.length === 2) {
+      return {
+        type: "merge" as const,
+        video: parseFilter(parts[0].trim()),
+        audio: parseFilter(parts[1].trim()),
+      };
+    }
+    return {
+      type: "single" as const,
+      video: parseFilter(parts[0].trim()),
+    };
+  });
+
+  let result = specs[specs.length - 1];
+  for (let i = specs.length - 2; i >= 0; i--) {
+    specs[i].fallback = result;
+    result = specs[i];
+  }
+  return result;
+}
+
+function formatQualityScore(f: Format): number {
+  let score = 0;
+  if (f.height) score += f.height;
+  if (f.tbr) score += f.tbr / 100;
+  if (f.vbr) score += f.vbr / 200;
+  if (f.abr) score += f.abr / 200;
+  if (f.fps && f.fps > 30) score += 10;
+  if (f.source_preference) score += f.source_preference;
+  if (f.quality) score += f.quality * 100;
+  return score;
+}
+
+function hasVideo(f: Format): boolean {
+  return f.vcodec !== undefined && f.vcodec !== "none";
+}
+
+function hasAudio(f: Format): boolean {
+  return f.acodec !== undefined && f.acodec !== "none";
+}
+
+function filterMatches(f: Format, filter: FormatFilter): boolean {
+  if (filter.id && f.format_id !== filter.id) return false;
+  if (filter.videoOnly && !hasVideo(f)) return false;
+  if (filter.audioOnly && !hasAudio(f)) return false;
+  if (filter.height && f.height !== filter.height) return false;
+  if (filter.ext && f.ext !== filter.ext) return false;
+  return true;
+}
+
+function selectFromList(formats: Format[], filter: FormatFilter): Format | null {
+  const candidates = formats.filter((f) => filterMatches(f, filter));
+  if (candidates.length === 0) return null;
+
+  const sorted = [...candidates].sort(
+    (a, b) => formatQualityScore(b) - formatQualityScore(a),
+  );
+
+  return filter.worst ? sorted[sorted.length - 1] : sorted[0];
+}
+
+export function selectFormats(formats: Format[], formatStr: string): Format[] {
+  const spec = parseFormatString(formatStr);
+  return applySpec(formats, spec);
+}
+
+function applySpec(formats: Format[], spec: FormatSpec): Format[] {
+  if (spec.type === "merge" && spec.video && spec.audio) {
+    const video = selectFromList(formats, spec.video);
+    const audio = selectFromList(formats, spec.audio);
+    if (video && audio) return [video, audio];
+  }
+
+  if (spec.type === "single" && spec.video) {
+    const result = selectFromList(formats, spec.video);
+    if (result) return [result];
+  }
+
+  if (spec.fallback) {
+    return applySpec(formats, spec.fallback);
+  }
+
+  return [];
+}
+
+export function sortFormats(formats: Format[]): Format[] {
+  return [...formats].sort(
+    (a, b) => formatQualityScore(a) - formatQualityScore(b),
+  );
+}
+
+export function formatFormatTable(formats: Format[]): string {
+  const header = "ID".padEnd(12) +
+    "EXT".padEnd(6) +
+    "RESOLUTION".padEnd(14) +
+    "FPS".padEnd(6) +
+    " VCODEC".padEnd(12) +
+    "ACODEC".padEnd(12) +
+    "SIZE".padEnd(12) +
+    "NOTE";
+  const separator = "-".repeat(80);
+
+  const rows = sortFormats(formats).map((f) => {
+    const res = f.width && f.height ? `${f.width}x${f.height}` : (f.resolution ?? "audio");
+    const fps = f.fps ? String(f.fps) : "";
+    const size = f.filesize
+      ? formatSize(f.filesize)
+      : f.filesize_approx
+        ? `~${formatSize(f.filesize_approx)}`
+        : "";
+    return (
+      f.format_id.padEnd(12) +
+      (f.ext ?? "").padEnd(6) +
+      res.padEnd(14) +
+      fps.padEnd(6) +
+      (f.vcodec ?? "none").padEnd(12) +
+      (f.acodec ?? "none").padEnd(12) +
+      size.padEnd(12) +
+      (f.format_note ?? "")
+    );
+  });
+
+  return [header, separator, ...rows].join("\n");
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KiB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GiB`;
+}

package/src/core/logger.ts

@@ -0,0 +1,101 @@
+type LogLevel = "debug" | "info" | "warn" | "error";
+
+const LEVEL_ORDER: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const LEVEL_COLORS: Record<LogLevel, string> = {
+  debug: "\x1b[90m",
+  info: "\x1b[36m",
+  warn: "\x1b[33m",
+  error: "\x1b[31m",
+};
+
+const RESET = "\x1b[0m";
+
+class Logger {
+  private level: LogLevel = "info";
+  private quiet = false;
+  private progressLine = "";
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  setQuiet(quiet: boolean): void {
+    this.quiet = quiet;
+  }
+
+  debug(msg: string): void {
+    this.log("debug", msg);
+  }
+
+  info(msg: string): void {
+    this.log("info", msg);
+  }
+
+  warn(msg: string): void {
+    this.log("warn", msg);
+  }
+
+  error(msg: string): void {
+    this.log("error", msg);
+  }
+
+  progress(percent: number | null, speed: number | null, eta: number | null, filename: string): void {
+    if (this.quiet) return;
+
+    const pct = percent !== null ? `${percent.toFixed(1)}%` : "???%";
+    const spd = speed !== null ? formatBytes(speed) + "/s" : "N/A";
+    const etaStr = eta !== null ? formatEta(eta) : "N/A";
+    const bar = percent !== null ? renderBar(percent, 30) : "[" + " ".repeat(30) + "]";
+
+    this.progressLine = `\r${bar} ${pct} of ${filename} at ${spd} ETA ${etaStr}`;
+    process.stderr.write(this.progressLine);
+  }
+
+  clearProgress(): void {
+    if (this.progressLine) {
+      process.stderr.write("\r" + " ".repeat(this.progressLine.length) + "\r");
+      this.progressLine = "";
+    }
+  }
+
+  private log(level: LogLevel, msg: string): void {
+    if (this.quiet && level !== "error") return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.level]) return;
+
+    if (this.progressLine) {
+      this.clearProgress();
+    }
+
+    const color = LEVEL_COLORS[level];
+    const prefix = level === "info" ? "" : `${color}[${level}]${RESET} `;
+    process.stderr.write(`${prefix}${msg}\n`);
+  }
+}
+
+function renderBar(percent: number, width: number): string {
+  const filled = Math.round((percent / 100) * width);
+  const empty = width - filled;
+  return `[${"█".repeat(filled)}${" ".repeat(empty)}]`;
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KiB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GiB`;
+}
+
+function formatEta(seconds: number): string {
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m${Math.round(seconds % 60)}s`;
+  return `${Math.floor(seconds / 3600)}h${Math.floor((seconds % 3600) / 60)}m`;
+}
+
+export const logger = new Logger();
+export { Logger, formatBytes, formatEta };

package/src/core/orchestrator.ts

@@ -0,0 +1,140 @@
+import type { InfoDict, Options } from "./types";
+import { DownloadError } from "./types";
+import { findExtractor } from "../extractors/base";
+import { getDownloader } from "../downloaders/base";
+import { runPostProcessors } from "../postprocessors/base";
+import { selectFormats, formatFormatTable } from "./format-sorter";
+import { buildFilename } from "./output-template";
+import { logger } from "./logger";
+
+export class Orchestrator {
+  async process(url: string, options: Options): Promise<void> {
+    logger.info(`Processing: ${url}`);
+
+    const extractor = findExtractor(url);
+    if (!extractor) {
+      throw new DownloadError(`No extractor found for URL: ${url}`);
+    }
+
+    logger.debug(`Using extractor: ${extractor._NAME}`);
+    const info = await extractor.extract(url);
+
+    if (info._type === "playlist" && info.entries) {
+      logger.info(`Playlist: ${info.title} (${info.entries.length} entries)`);
+      for (let i = 0; i < info.entries.length; i++) {
+        const entry = info.entries[i];
+        entry.playlist = info.title;
+        entry.playlist_index = i + 1;
+        entry.playlist_count = info.entries.length;
+        if (entry.webpage_url) {
+          await this.processEntry(entry.webpage_url, entry, options);
+        }
+      }
+      return;
+    }
+
+    await this.processEntry(url, info, options);
+  }
+
+  private async processEntry(
+    url: string,
+    info: InfoDict,
+    options: Options,
+  ): Promise<void> {
+    if (options.dumpJson) {
+      process.stdout.write(JSON.stringify(info, null, 2) + "\n");
+      return;
+    }
+
+    if (options.listFormats) {
+      if (info.formats && info.formats.length > 0) {
+        process.stdout.write(formatFormatTable(info.formats) + "\n");
+      } else {
+        logger.warn("No formats available");
+      }
+      return;
+    }
+
+    if (!info.formats || info.formats.length === 0) {
+      if (info.url) {
+        info.formats = [
+          {
+            format_id: "direct",
+            url: info.url,
+            ext: info.ext ?? "mp4",
+          },
+        ];
+      } else {
+        throw new DownloadError("No formats found and no direct URL available");
+      }
+    }
+
+    const selectedFormats = selectFormats(info.formats, options.format);
+    if (selectedFormats.length === 0) {
+      throw new DownloadError(
+        `No matching formats for: ${options.format}`,
+      );
+    }
+
+    info.requested_formats = selectedFormats;
+    info.ext = selectedFormats[0].ext;
+
+    const filename = buildFilename(options.output, info);
+    const filepath = options.paths.home
+      ? `${options.paths.home}/${filename}`
+      : filename;
+    info.filename = filepath;
+
+    logger.info(`Downloading: ${info.title}`);
+    logger.debug(`Saving to: ${filepath}`);
+
+    for (const format of selectedFormats) {
+      const protocol = detectProtocol(format.url, format.protocol);
+      const downloader = getDownloader(protocol);
+      if (!downloader) {
+        throw new DownloadError(
+          `No downloader for protocol: ${protocol}`,
+        );
+      }
+
+      const targetPath =
+        selectedFormats.length > 1
+          ? `${filepath}.f${format.format_id}.${format.ext}`
+          : filepath;
+
+      await downloader.download(targetPath, format.url, {
+        headers: { ...info.http_headers, ...format.http_headers },
+        rateLimit: options.rateLimit,
+        retries: options.retries,
+        onProgress: options.quiet
+          ? undefined
+          : (progress) => {
+              logger.progress(
+                progress.percent,
+                progress.speed,
+                progress.eta,
+                filename,
+              );
+            },
+      });
+    }
+
+    logger.clearProgress();
+
+    if (selectedFormats.length > 1) {
+      logger.info("Merging formats requires ffmpeg (post-processor)");
+    }
+
+    await runPostProcessors(info, filepath, options);
+
+    logger.info(`Done: ${filepath}`);
+  }
+}
+
+function detectProtocol(url: string, hint?: string): string {
+  if (hint) return hint;
+  if (url.includes(".m3u8")) return "m3u8";
+  if (url.includes(".mpd")) return "dash";
+  if (url.startsWith("rtmp")) return "rtmp";
+  return "https";
+}

package/src/core/output-template.ts

@@ -0,0 +1,58 @@
+import type { InfoDict } from "./types";
+import { sanitizeFilename } from "../utils/sanitize";
+
+const TEMPLATE_RE = /%\((\w+)\)([#0\- +]*)(\d*)(?:\.(\d+))?([sdiouxXeEfFgGcr%])/g;
+
+export function renderTemplate(template: string, info: InfoDict): string {
+  return template.replace(TEMPLATE_RE, (_match, key: string, _flags: string, _width: string, _precision: string, conversion: string) => {
+    const value = getField(info, key);
+
+    if (value === undefined || value === null) {
+      return conversion === "d" ? "NA" : "NA";
+    }
+
+    if (conversion === "d" || conversion === "i") {
+      return String(Math.floor(Number(value)));
+    }
+
+    if (conversion === "f" || conversion === "F") {
+      return String(Number(value));
+    }
+
+    return String(value);
+  });
+}
+
+function getField(info: InfoDict, key: string): string | number | undefined {
+  const fieldMap: Record<string, unknown> = {
+    id: info.id,
+    title: info.title,
+    ext: info.ext ?? info.formats?.[0]?.ext ?? "unknown",
+    uploader: info.uploader,
+    uploader_id: info.uploader_id,
+    channel: info.channel,
+    channel_id: info.channel_id,
+    upload_date: info.upload_date,
+    duration: info.duration,
+    view_count: info.view_count,
+    like_count: info.like_count,
+    description: info.description,
+    webpage_url: info.webpage_url,
+    playlist: info.playlist,
+    playlist_index: info.playlist_index,
+    playlist_count: info.playlist_count,
+    timestamp: info.timestamp,
+    age_limit: info.age_limit,
+    extractor: info.extractor,
+  };
+
+  const val = fieldMap[key];
+  if (val === undefined || val === null) return undefined;
+  if (typeof val === "number") return val;
+  return String(val);
+}
+
+export function buildFilename(template: string, info: InfoDict): string {
+  const rendered = renderTemplate(template, info);
+  return sanitizeFilename(rendered);
+}