@yt-kit/core 0.4.0 → 0.5.1

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export * from './tasks/download/download';
+export { downloadAudio, downloadVideo } from './tasks/download/download';
+export { findFormatId } from './yt-dlp/findFormatId';
+export { formYoutubeUrl } from './lib/ytUtils';
 export * from './types/videoTypes';
 export * from './types/childProcessTypes';
 export { STANDARD_RESOLUTIONS } from './lib/constants';

package/dist/index.js

@@ -1,5 +1,8 @@
 // Funcionalidades del programa
-export * from './tasks/download/download';
+export { downloadAudio, downloadVideo } from './tasks/download/download';
+export { findFormatId } from './yt-dlp/findFormatId';
+// Utilidades
+export { formYoutubeUrl } from './lib/ytUtils';
 // Tipos
 export * from './types/videoTypes';
 export * from './types/childProcessTypes';

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/findFormatId.d.ts

@@ -0,0 +1,7 @@
+import type { FormatsToFind } from '../types/videoTypes';
+import type { YtDlpFormat } from '../types/ytDlpFormatTypes';
+export declare function findFormatId(url: string, formatToFind: FormatsToFind): Promise<{
+    foundSpecific: string | boolean;
+    formatId: string | undefined;
+    desiredFormat: YtDlpFormat | undefined;
+}>;

package/dist/yt-dlp/findFormatId.js

@@ -0,0 +1,61 @@
+import { getBetterFormat, getWorstFormat } from '../lib/compareFormats';
+import { spawnAsync } from '../lib/spawnAsync';
+export async function 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
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yt-kit/core",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -11,16 +11,24 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubiufboeuf/yt-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ubiufboeuf/yt-kit/issues"
+  },
+  "homepage": "https://github.com/ubiufboeuf/yt-kit#readme",
   "scripts": {
     "start": "bun pruebas.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "eslint": "9.39.1",
     "typescript": "5"
   },
   "devDependencies": {
+    "eslint": "9.39.1",
     "@eslint/js": "9.39.1",
     "@stylistic/eslint-plugin": "5.6.1",
     "globals": "16.5.0",
@@ -32,4 +40,4 @@
   "files": [
     "dist"
   ]
-}
+}

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 {};