@yt-kit/core 0.3.0 → 0.5.0

package/README.md

@@ -0,0 +1,22 @@
+# YT-KIT (core)
+
+Kit de herramientas para manejar multimedia orientada a videos.
+
+## Instalación
+
+```sh
+# Con npm
+npm install @yt-kit/core
+
+# Con pnpm
+pnpm add -E @yt-kit/core
+
+# Con bun
+bun add -E @yt-kit/core
+```
+
+## Sobre la estructura de carpetas
+
+El archivo `pruebas.ts` es un archivo para probar el funcionamiento del proyecto antes de lanzar una nueva versión.
+
+`src/index.ts` es el archivo principal para las builds, no para desarrollo. En todo caso, el archivo "principal" sería `pruebas.ts`.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export * from './tasks/download/download';
 export * from './types/videoTypes';
-export * from './types/processTypes';
+export * from './types/childProcessTypes';
 export { STANDARD_RESOLUTIONS } from './lib/constants';

package/dist/index.js

@@ -2,6 +2,6 @@
 export * from './tasks/download/download';
 // Tipos
 export * from './types/videoTypes';
-export * from './types/processTypes';
+export * from './types/childProcessTypes';
 // Constantes públicas (seguras de exportar)
 export { STANDARD_RESOLUTIONS } from './lib/constants';

package/dist/interfaces/Downloader.d.ts

@@ -1,15 +1,15 @@
 export interface Downloader {
-    download(url: string, options: DownloadTasksOptions): Promise<DownloadResult>;
+    download(url: string, ytId: string, options: DownloadTasksOptions): Promise<DownloadResult>;
 }
 export interface DownloadOptions {
     id: string;
-    outputFolder?: string;
+    outputPath?: string;
     filename?: string;
 }
 export interface DownloadTasksOptions {
     id: string;
     type: 'video' | 'audio';
-    outputFolder: string;
+    outputPath: string;
     filename: string;
 }
 export interface DownloadResult {

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

@@ -2,4 +2,8 @@ export declare const STANDARD_RESOLUTIONS: readonly [18, 144, 240, 360, 480, 720
 export declare const COMMANDS: {
     readonly 'yt-dlp': "yt-dlp-linux";
 };
-export declare const DEFAULT_FILENAME = "%(id)s.%(ext)s";
+export declare const DEFAULT_FILENAME = "%(ytId)s.%(ext)s";
+export declare const PATTERNS: {
+    readonly ID: "%(id)s";
+    readonly YT_ID: "%(ytId)s";
+};

package/dist/lib/constants.js

@@ -2,4 +2,8 @@ export const STANDARD_RESOLUTIONS = [18, 144, 240, 360, 480, 720, 1080, 1440, 21
 export const COMMANDS = {
     'yt-dlp': 'yt-dlp-linux'
 };
-export const DEFAULT_FILENAME = '%(id)s.%(ext)s';
+export const DEFAULT_FILENAME = '%(ytId)s.%(ext)s';
+export const PATTERNS = {
+    ID: '%(id)s',
+    YT_ID: '%(ytId)s'
+};

package/dist/lib/expandPattern.d.ts

@@ -0,0 +1,4 @@
+import type { PATTERNS } from './constants';
+export type Pattern = typeof PATTERNS[keyof typeof PATTERNS];
+export type PatternData = string;
+export declare function expandPattern(pattern: string, patternMap: Map<Pattern, PatternData>): string;

package/dist/lib/expandPattern.js

@@ -0,0 +1,7 @@
+export function expandPattern(pattern, patternMap) {
+    let resolvedPattern = pattern;
+    for (const [key, value] of patternMap) {
+        resolvedPattern = resolvedPattern.replaceAll(key, value);
+    }
+    return resolvedPattern;
+}

package/dist/lib/resolveFilename.d.ts

@@ -0,0 +1,7 @@
+interface ResolverProps {
+    filename: string;
+    id: string;
+    ytId: string;
+}
+export declare function resolveFilename({ filename, id, ytId }: ResolverProps): string;
+export {};

package/dist/lib/resolveFilename.js

@@ -0,0 +1,11 @@
+import { PATTERNS } from './constants';
+import { expandPattern } from './expandPattern';
+import { sanitizeFilename } from './sanitizeFilename';
+export function resolveFilename({ filename, id, ytId }) {
+    const map = new Map([
+        [PATTERNS.ID, id],
+        [PATTERNS.YT_ID, ytId]
+    ]);
+    const raw = expandPattern(filename, map);
+    return sanitizeFilename(raw);
+}

package/dist/lib/sanitizeFilename.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeFilename(raw: string): string;

package/dist/lib/sanitizeFilename.js

@@ -0,0 +1,6 @@
+// Por ahora esto está enfocado solo para Linux,
+// pero en un futuro sería ideal que soporte más sistemas operativos
+export function sanitizeFilename(raw) {
+    return raw
+        .replaceAll('/', '⁄');
+}

package/dist/lib/spawnAsync.d.ts

@@ -1,2 +1,2 @@
-import type { CommandKey } from '../types/processTypes';
+import type { CommandKey } from '../types/childProcessTypes';
 export declare function spawnAsync(command: CommandKey, args: string[], showOutput?: boolean): Promise<unknown>;

package/dist/lib/spawnAsync.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { COMMANDS } from '../lib/constants';
-import { streamLog } from './logs';
+import { streamLog } from './logger';
 export function spawnAsync(command, args, showOutput) {
     const _command = COMMANDS[command];
     return new Promise((resolve, reject) => {

package/dist/tasks/download/download.js

@@ -1,6 +1,6 @@
 // import { spawnAsync } from 'src/core/lib/spawnAsync'
 // import type { DownloadOptions } from './interfaces/Downloader'
-import { DEFAULT_FILENAME } from 'src/lib/constants';
+import { DEFAULT_FILENAME } from '../../lib/constants';
 import { formYoutubeUrl } from '../../lib/ytUtils';
 import { YtDlpDownloader } from '../../yt-dlp-downloader/YtDlpDownloader';
 export async function downloadVideo(ytId, options) {
@@ -8,20 +8,20 @@ export async function downloadVideo(ytId, options) {
         return;
     const url = formYoutubeUrl(ytId);
     const taskOptions = formDownloadTaskOptions('video', options);
-    return new YtDlpDownloader().download(url, taskOptions);
+    return new YtDlpDownloader().download(url, ytId, taskOptions);
 }
 export async function downloadAudio(ytId, options) {
     if (!ytId || !options.id)
         return;
     const url = formYoutubeUrl(ytId);
     const taskOptions = formDownloadTaskOptions('audio', options);
-    return new YtDlpDownloader().download(url, taskOptions);
+    return new YtDlpDownloader().download(url, ytId, taskOptions);
 }
 function formDownloadTaskOptions(type, options) {
     const taskOptions = {
         id: options.id,
         type,
-        outputFolder: options.outputFolder ?? '.',
+        outputPath: options.outputPath ?? '.',
         filename: options.filename ?? DEFAULT_FILENAME
     };
     return taskOptions;

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/types/ytDlpFormatTypes.js

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

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, options: DownloadTasksOptions): Promise<DownloadResult>;
+    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,7 +1,9 @@
 import { spawnAsync } from '../lib/spawnAsync';
+import { resolveFilename } from '../lib/resolveFilename';
+import { getBetterFormat, getWorstFormat } from '../lib/compareFormats';
 export class YtDlpDownloader {
-    async download(url, options) {
-        const args = this.buildYtDlpArgs(url, options);
+    async download(url, ytId, options) {
+        const args = this.buildYtDlpArgs(url, ytId, options);
         // const result = await spawnAsync('yt-dlp', args, true)
         await spawnAsync('yt-dlp', args, true);
         return {
@@ -9,11 +11,70 @@ export class YtDlpDownloader {
             path: 'unknown'
         };
     }
-    buildYtDlpArgs(url, options) {
+    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';
-        const exportRoute = options.outputFolder;
-        const exportName = options.filename;
+        const exportRoute = options.outputPath;
+        const exportName = resolveFilename({ filename: options.filename, id: options.id, ytId });
         const audioFormat = 'aac';
         const audioFormatPreferences = isVideo
             ? []

package/package.json

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