@yt-kit/core 0.4.0 → 0.5.0

package/dist/lib/compareFormats.d.ts

@@ -0,0 +1,10 @@
+import type { MediaType } from '../types/videoTypes';
+import type { YtDlpFormat } from '../types/ytDlpFormatTypes';
+export declare function getBetterFormat(a: YtDlpFormat | undefined, b: YtDlpFormat | undefined, { type, compareResolution }: {
+    type: MediaType;
+    compareResolution: boolean;
+}): YtDlpFormat | undefined;
+export declare function getWorstFormat(a: YtDlpFormat | undefined, b: YtDlpFormat | undefined, { type, compareResolution }: {
+    type: MediaType;
+    compareResolution: boolean;
+}): YtDlpFormat | undefined;

package/dist/lib/compareFormats.js

@@ -0,0 +1,52 @@
+function compareFormats({ a, b, compareResolution, type }) {
+    const canCompareQuality = (type === 'video') && compareResolution && (a.quality !== null) && (b.quality !== null);
+    const canCompareResolution = (type === 'video') && compareResolution && (a.height !== null) && (b.height !== null);
+    const canCompareFps = (type === 'video') && (a.fps !== null) && (b.fps !== null);
+    const canCompareAsr = (type === 'audio') && (a.asr !== null) && (b.asr !== null);
+    const canCompareTbr = (a.tbr !== null) && (b.tbr !== null);
+    let aScore = 0;
+    let bScore = 0;
+    if (canCompareQuality) {
+        if ((a.quality ?? 0) > (b.quality ?? 0))
+            aScore += 3;
+        else if ((a.quality ?? 0) < (b.quality ?? 0))
+            bScore += 3;
+    }
+    if (canCompareResolution) {
+        if ((a.height ?? 0) > (b.height ?? 0))
+            aScore += 3;
+        else if ((a.height ?? 0) < (b.height ?? 0))
+            bScore += 3;
+    }
+    if (canCompareFps) {
+        if ((a.fps ?? 0) > (b.fps ?? 0))
+            aScore += 2;
+        else if ((a.fps ?? 0) < (b.fps ?? 0))
+            bScore += 2;
+    }
+    if (canCompareAsr) {
+        if ((a.asr ?? 0) > (b.asr ?? 0))
+            aScore += 2;
+        else if ((a.asr ?? 0) < (b.asr ?? 0))
+            bScore += 2;
+    }
+    if (canCompareTbr) {
+        if ((a.tbr ?? 0) > (b.tbr ?? 0))
+            aScore += 1;
+        else if ((a.tbr ?? 0) < (b.tbr ?? 0))
+            bScore += 1;
+    }
+    return { aScore, bScore };
+}
+export function getBetterFormat(a, b, { type, compareResolution }) {
+    if (!a || !b)
+        return;
+    const { aScore, bScore } = compareFormats({ a, b, type, compareResolution });
+    return aScore > bScore ? a : b;
+}
+export function getWorstFormat(a, b, { type, compareResolution }) {
+    if (!a || !b)
+        return;
+    const { aScore, bScore } = compareFormats({ a, b, type, compareResolution });
+    return aScore > bScore ? b : a;
+}

package/dist/types/videoTypes.d.ts

@@ -1,3 +1,5 @@
 import type { STANDARD_RESOLUTIONS } from '../lib/constants';
 export type Height = typeof STANDARD_RESOLUTIONS[number];
 export type Resolution = `${Height}p`;
+export type FormatsToFind = Resolution | 'best-video' | 'worst-video' | 'best-audio' | 'worst-audio';
+export type MediaType = 'audio' | 'video';

package/dist/types/ytDlpFormatTypes.d.ts

@@ -0,0 +1,61 @@
+export type YtDlpFormat = {
+    format_id: string;
+    format_note: string;
+    ext: EXT;
+    protocol: Protocol;
+    acodec: Acodec;
+    vcodec: string;
+    url: string;
+    width: number | null;
+    height: number | null;
+    fps: number | null;
+    rows?: number;
+    columns?: number;
+    fragments?: Fragment[];
+    audio_ext: AudioEXT;
+    video_ext: VideoEXT;
+    vbr: number | null;
+    abr: number | null;
+    tbr: number | null;
+    resolution: string;
+    aspect_ratio: number | null;
+    filesize_approx: number | null;
+    http_headers: HTTPHeaders;
+    format: string;
+    asr?: number | null;
+    filesize?: number | null;
+    source_preference?: number;
+    audio_channels?: number | null;
+    quality?: number;
+    has_drm?: boolean;
+    language?: null | string;
+    language_preference?: number;
+    preference?: null;
+    dynamic_range?: DynamicRange | null;
+    container?: Container;
+    available_at?: number;
+    downloader_options?: DownloaderOptions;
+};
+export type Acodec = 'none' | 'mp4a.40.5' | 'opus' | 'mp4a.40.2';
+export type AudioEXT = 'none' | 'm4a' | 'webm';
+export type Container = 'm4a_dash' | 'webm_dash' | 'mp4_dash';
+export type DownloaderOptions = {
+    http_chunk_size: number;
+};
+export type DynamicRange = 'SDR';
+export type EXT = 'mhtml' | 'm4a' | 'webm' | 'mp4';
+export type Fragment = {
+    url: string;
+    duration: number;
+};
+export type HTTPHeaders = {
+    'User-Agent': string;
+    Accept: Accept;
+    'Accept-Language': AcceptLanguage;
+    'Sec-Fetch-Mode': SECFetchMode;
+};
+export type Accept = 'text/html,application/xhtml+xml,application/xmlq=0.9,*/*q=0.8';
+export type AcceptLanguage = 'en-us,enq=0.5';
+export type SECFetchMode = 'navigate';
+export type Protocol = 'mhtml' | 'https';
+export type VideoEXT = 'none' | 'mp4' | 'webm';

package/dist/yt-dlp-downloader/YtDlpDownloader.d.ts

@@ -1,5 +1,12 @@
 import type { Downloader, DownloadTasksOptions, DownloadResult } from '../interfaces/Downloader';
+import type { FormatsToFind } from '../types/videoTypes';
+import type { YtDlpFormat } from '../types/ytDlpFormatTypes';
 export declare class YtDlpDownloader implements Downloader {
     download(url: string, ytId: string, options: DownloadTasksOptions): Promise<DownloadResult>;
+    findFormatId(url: string, formatToFind: FormatsToFind): Promise<{
+        foundSpecific: string | boolean;
+        formatId: string | undefined;
+        desiredFormat: YtDlpFormat | undefined;
+    }>;
     private buildYtDlpArgs;
 }

package/dist/yt-dlp-downloader/YtDlpDownloader.js

@@ -1,5 +1,6 @@
 import { spawnAsync } from '../lib/spawnAsync';
 import { resolveFilename } from '../lib/resolveFilename';
+import { getBetterFormat, getWorstFormat } from '../lib/compareFormats';
 export class YtDlpDownloader {
     async download(url, ytId, options) {
         const args = this.buildYtDlpArgs(url, ytId, options);
@@ -10,6 +11,65 @@ export class YtDlpDownloader {
             path: 'unknown'
         };
     }
+    async findFormatId(url, formatToFind) {
+        const isSpecificResolution = Boolean(formatToFind.match(/\d/));
+        let foundSpecific = isSpecificResolution ? false : 'N/A';
+        const args = ['--print', '%(formats)j', url];
+        let output = '';
+        try {
+            output = await spawnAsync('yt-dlp', args);
+        }
+        catch (err) {
+            console.error('Error consiguiendo el ID del formato');
+            throw err;
+        }
+        let formats = [];
+        try {
+            formats = JSON.parse(output);
+        }
+        catch (err) {
+            console.error('Error convirtiendo la salida de yt-dlp a JSON');
+            throw err;
+        }
+        if (!Array.isArray(formats)) {
+            throw new Error('Se esperaba un array');
+        }
+        let bestVideo = undefined;
+        let worstVideo = undefined;
+        let bestAudio = undefined;
+        let worstAudio = undefined;
+        let desiredFormat = undefined;
+        for (const format of formats) {
+            const audioOnly = format.resolution === 'audio only';
+            if (isSpecificResolution && format.format_note === formatToFind) {
+                foundSpecific = true;
+                desiredFormat = getBetterFormat(desiredFormat, format, { compareResolution: false, type: 'video' }) ?? format;
+                continue;
+            }
+            if (audioOnly) {
+                bestAudio = getBetterFormat(bestAudio, format, { compareResolution: false, type: 'audio' }) ?? format;
+                worstAudio = getWorstFormat(worstAudio, format, { compareResolution: false, type: 'audio' }) ?? format;
+            }
+            else {
+                bestVideo = getBetterFormat(bestVideo, format, { compareResolution: true, type: 'video' }) ?? format;
+                worstVideo = getWorstFormat(worstVideo, format, { compareResolution: true, type: 'video' }) ?? format;
+            }
+        }
+        if (!isSpecificResolution) {
+            const formats = {
+                'best-video': bestVideo,
+                'worst-video': worstVideo,
+                'best-audio': bestAudio,
+                'worst-audio': worstAudio
+            };
+            desiredFormat = formats[formatToFind];
+        }
+        return {
+            foundSpecific,
+            formatId: desiredFormat?.format_id,
+            desiredFormat
+        };
+    }
     buildYtDlpArgs(url, ytId, options) {
         const { id, type } = options;
         const isVideo = type === 'video';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yt-kit/core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/lib/logs.d.ts

@@ -1 +0,0 @@
-export declare function streamLog(type: 'data' | 'err', data: any): void;

package/dist/lib/logs.js

@@ -1,8 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { stdout, stderr } from 'node:process';
-export function streamLog(type, data) {
-    const stream = type === 'data'
-        ? stdout
-        : stderr;
-    stream.write(data);
-}

package/dist/types/downloadTypes.d.ts

@@ -1 +0,0 @@
-export type DownloadType = 'video' | 'audio';

package/dist/types/processTypes.d.ts

@@ -1,3 +0,0 @@
-import type { COMMANDS } from '../lib/constants';
-export type CommandKey = keyof typeof COMMANDS;
-export type Command = typeof COMMANDS[keyof typeof COMMANDS];

package/dist/types/processTypes.js

@@ -1 +0,0 @@
-export {};