yt-grabber 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-grabber",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Youtube Grabber",
   "main": "./dist/index.js",
   "repository": {

package/src/automations/Helpers.ts

@@ -0,0 +1,15 @@
+import {ElementHandle, Page} from "puppeteer";
+
+import puppeteerOptions from "../common/PuppeteerOptions";
+
+export const navigateToPage = async (url: string, page: Page, timeout = puppeteerOptions.timeout) => {
+    await page.goto(url, {
+        waitUntil: ["networkidle0", "domcontentloaded", "load"],
+        timeout,
+    });
+};
+
+export const clearInput = async (input: ElementHandle<Element>, page: Page) => {
+    await input.click({clickCount: 3});
+    await page.keyboard.press("Backspace");
+};

package/src/automations/Selectors.ts

@@ -5,3 +5,13 @@ export const AlbumFilterSelector = "//ytmusic-app-layout//div[@id='content']/ytm
 export const AlbumLinkSelector = "//ytmusic-app-layout//div[@id='content']/ytmusic-browse-response//ytmusic-section-list-renderer/div[@id='contents']/ytmusic-grid-renderer/div[@id='items']/*[contains(@class, 'ytmusic-grid-renderer')]//a[contains(@class, 'yt-simple-endpoint') and contains(@class, 'yt-formatted-string')]";
 
 export const AlbumsDirectLinkSelector = "//ytmusic-app-layout//div[@id='content']/ytmusic-browse-response//ytmusic-section-list-renderer//div[@id='content-group']//div[contains(@class, 'header-renderer')]/yt-formatted-string[contains(text(), 'Album')]//ancestor::div[contains(@class, 'ytmusic-shelf')]//div[@id='items-wrapper']/ul/*[contains(@class, 'ytmusic-carousel')]//a[contains(@class, 'yt-simple-endpoint') and contains(@class, 'yt-formatted-string')]";
+
+export const YtMusicSearchInputSelector = "//ytmusic-app-layout//ytmusic-search-box//input[@id='input']";
+
+export const YtMusicArtistsChipSelector = "//ytmusic-app-layout//ytmusic-search-page//div[contains(@class, 'content')]//ytmusic-section-list-renderer//ytmusic-chip-cloud-renderer//iron-selector[@id='chips']//a[contains(@class, 'ytmusic-chip-cloud-chip-renderer')]//yt-formatted-string[contains(text(), 'Wykonawcy') or contains(text(), 'Artists')]//ancestor::a";
+
+export const YtMusicAlbumsChipSelector = "//ytmusic-app-layout//ytmusic-search-page//div[contains(@class, 'content')]//ytmusic-section-list-renderer//ytmusic-chip-cloud-renderer//iron-selector[@id='chips']//a[contains(@class, 'ytmusic-chip-cloud-chip-renderer')]//yt-formatted-string[contains(text(), 'Albumy') or contains(text(), 'Albums')]//ancestor::a";
+
+export const YtMusicSongsChipSelector = "//ytmusic-app-layout//ytmusic-search-page//div[contains(@class, 'content')]//ytmusic-section-list-renderer//ytmusic-chip-cloud-renderer//iron-selector[@id='chips']//a[contains(@class, 'ytmusic-chip-cloud-chip-renderer')]//yt-formatted-string[contains(text(), 'Utwory') or contains(text(), 'Songs')]//ancestor::a";
+
+export const YtMusicSearchResultsSelector = "//ytmusic-app-layout//div[@id='content']//ytmusic-search-page//div[@id='contents']//ytmusic-shelf-renderer//div[@id='contents']//ytmusic-responsive-list-item-renderer/a";

package/src/automations/Youtube.ts

@@ -15,6 +15,7 @@ import {waitFor} from "../common/Helpers";
 import {GetYoutubeUrlParams, GetYoutubeUrlResult} from "../common/Messaging";
 import puppeteerOptions from "../common/PuppeteerOptions";
 import {IReporter, ProgressInfo, Reporter} from "../common/Reporter";
+import {navigateToPage} from "./Helpers";
 import {
     AlbumFilterSelector, AlbumLinkSelector, AlbumsDirectLinkSelector, AlbumsHrefSelector
 } from "./Selectors";
@@ -25,12 +26,7 @@ let reporter: IReporter<GetYoutubeUrlResult>;
 
 puppeteer.use(StealthPlugin());
 
-const navigateToPage = async (url: string) => {
-    await page.goto(url, {
-        waitUntil: ["networkidle0", "domcontentloaded", "load"],
-        timeout: puppeteerOptions.timeout,
-    });
-};
+
 
 export const execute = async (
     params: GetYoutubeUrlParams,
@@ -64,18 +60,18 @@ export const execute = async (
             await page.setCookie(...cachedCookies);
         }
 
-        await navigateToPage(params.url);
+        await navigateToPage(params.url, page);
         
         const process = async (urlToProcess: string) => {
             const results: string[] = [];
             
             try {                
-                await navigateToPage(urlToProcess);
+                await navigateToPage(urlToProcess, page);
 
                 const element = await page.waitForSelector(`::-p-xpath(${AlbumsHrefSelector})`, {timeout: 1000});
                 const albumsUrl = await element.evaluate((el) => el.getAttribute("href"));
 
-                await navigateToPage(`${params.url}/${albumsUrl}`);
+                await navigateToPage(`${params.url}/${albumsUrl}`, page);
                 const albumFilterButton = await page.waitForSelector(`::-p-xpath(${AlbumFilterSelector})`, {timeout: 1000});
 
                 albumFilterButton.click();
@@ -115,7 +111,11 @@ export const execute = async (
         if (error instanceof TimeoutError) {
             result.errors.push({title: i18n.t("exceptionTimeout"), description: i18n.t("exceptionTimeoutText")});
         } else {
-            result.errors.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            if (error.message === "Navigating frame was detached") {
+                result.warnings.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            } else {
+                result.errors.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            }
         }
         
         reporter.finish("done", result);
@@ -131,8 +131,8 @@ const closeResources = async () => {
 };
 
 export const cancel = async () => {
-    browser.close();
-    browser.disconnect();
+    await browser.close();
+    await browser.disconnect();
 };
 
 export default execute;

package/src/automations/YoutubeAlbums.ts

@@ -0,0 +1,128 @@
+import fs from "fs-extra";
+import {i18n as i18next} from "i18next";
+import _forEach from "lodash/forEach";
+import _includes from "lodash/includes";
+import _isEmpty from "lodash/isEmpty";
+import _map from "lodash/map";
+import _merge from "lodash/merge";
+import _replace from "lodash/replace";
+import {Browser, LaunchOptions, Page, TimeoutError} from "puppeteer";
+import puppeteer from "puppeteer-extra";
+import StealthPlugin from "puppeteer-extra-plugin-stealth";
+
+import {getProfilePath} from "../common/FileSystem";
+import {waitFor} from "../common/Helpers";
+import {GetYoutubeAlbumsParams, GetYoutubeUrlResult} from "../common/Messaging";
+import puppeteerOptions from "../common/PuppeteerOptions";
+import {IReporter, ProgressInfo, Reporter} from "../common/Reporter";
+import {clearInput, navigateToPage} from "./Helpers";
+import {
+    YtMusicAlbumsChipSelector, YtMusicSearchInputSelector, YtMusicSearchResultsSelector
+} from "./Selectors";
+
+let page: Page;
+let browser: Browser;
+let reporter: IReporter<GetYoutubeUrlResult>;
+
+puppeteer.use(StealthPlugin());
+
+export const execute = async (
+    params: GetYoutubeAlbumsParams,
+    options: LaunchOptions,
+    i18n: i18next,
+    onProgress: (data: ProgressInfo<GetYoutubeUrlResult>) => void,
+) => {
+    try {
+        const result: GetYoutubeUrlResult = {warnings: [], errors: [], urls: []};
+        const userAgent = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.3";
+        
+        await i18n.changeLanguage(params.lang);
+        
+        reporter = new Reporter(onProgress);
+        reporter.start(i18n.t("starting"));
+        browser = await puppeteer.launch(_merge(puppeteerOptions, options));
+        [page] = await browser.pages();
+        
+        await page.setUserAgent(userAgent);
+        
+        const cachedCookies = fs.readJSONSync(getProfilePath() + "/cookies.json", {throws: false});
+
+        if (_isEmpty(cachedCookies)) {
+            await waitFor(3000);
+            const pageCookies = await page.cookies();
+            
+            fs.writeJSONSync(getProfilePath() + "/cookies.json", pageCookies, {spaces: 2});
+
+            await page.setCookie(...pageCookies);
+        } else {
+            await page.setCookie(...cachedCookies);
+        }
+
+        await navigateToPage(params.url, page);
+        
+        const process = async (album: string) => {
+            const results: string[] = [];
+            
+            try {                
+                const searchInput = await page.waitForSelector(`::-p-xpath(${YtMusicSearchInputSelector})`, {timeout: 1000});
+                await clearInput(searchInput, page);
+                await searchInput.type(album);
+                page.keyboard.press("Enter");
+                await page.waitForNetworkIdle();
+
+                const albumsChip = await page.waitForSelector(`::-p-xpath(${YtMusicAlbumsChipSelector})`, {timeout: 1000});
+            
+                albumsChip.click();
+                await page.waitForNetworkIdle();
+                await page.waitForSelector(`::-p-xpath(${YtMusicSearchResultsSelector})`, {timeout: 1000});
+                
+                const albumsElements = await page.$$(`::-p-xpath(${YtMusicSearchResultsSelector})`);
+                const albumEl = albumsElements[0];
+                const albumUrl = await albumEl.evaluate((el) => el.getAttribute("href"));
+
+                results.push(`${params.url}/${albumUrl}`);
+
+                return results;
+            } catch (error) {
+                return results;
+            }
+        };
+
+        for (const a of params.albums) {
+            const data = await process(a);
+           
+            result.urls.push(...data);
+        }
+
+        reporter.finish("done", result);
+    } catch (error: any) {
+        const result: GetYoutubeUrlResult = {errors: []};
+        
+        if (error instanceof TimeoutError) {
+            result.errors.push({title: i18n.t("exceptionTimeout"), description: i18n.t("exceptionTimeoutText")});
+        } else {
+            if (error.message === "Navigating frame was detached") {
+                result.warnings.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            } else {
+                result.errors.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            }
+        }
+        
+        reporter.finish("done", result);
+        console.error("Execution failed at stage: ", error.stack);
+    } finally {
+        await closeResources();
+    }
+};
+
+const closeResources = async () => {
+    if (page) await page.close();
+    if (browser) await browser.close();
+};
+
+export const cancel = async () => {
+    await browser.close();
+    await browser.disconnect();
+};
+
+export default execute;

package/src/automations/YoutubeArtists.ts

@@ -0,0 +1,153 @@
+import fs from "fs-extra";
+import {i18n as i18next} from "i18next";
+import _forEach from "lodash/forEach";
+import _includes from "lodash/includes";
+import _isEmpty from "lodash/isEmpty";
+import _map from "lodash/map";
+import _merge from "lodash/merge";
+import _replace from "lodash/replace";
+import {Browser, LaunchOptions, Page, TimeoutError} from "puppeteer";
+import puppeteer from "puppeteer-extra";
+import StealthPlugin from "puppeteer-extra-plugin-stealth";
+
+import {getProfilePath} from "../common/FileSystem";
+import {waitFor} from "../common/Helpers";
+import {GetYoutubeArtistsParams, GetYoutubeUrlResult} from "../common/Messaging";
+import puppeteerOptions from "../common/PuppeteerOptions";
+import {IReporter, ProgressInfo, Reporter} from "../common/Reporter";
+import {clearInput, navigateToPage} from "./Helpers";
+import {
+    AlbumFilterSelector, AlbumLinkSelector, AlbumsDirectLinkSelector, AlbumsHrefSelector,
+    YtMusicArtistsChipSelector, YtMusicSearchInputSelector, YtMusicSearchResultsSelector
+} from "./Selectors";
+
+let page: Page;
+let browser: Browser;
+let reporter: IReporter<GetYoutubeUrlResult>;
+
+puppeteer.use(StealthPlugin());
+
+export const execute = async (
+    params: GetYoutubeArtistsParams,
+    options: LaunchOptions,
+    i18n: i18next,
+    onProgress: (data: ProgressInfo<GetYoutubeUrlResult>) => void,
+) => {
+    try {
+        const result: GetYoutubeUrlResult = {warnings: [], errors: [], urls: []};
+        const userAgent = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.3";
+        
+        await i18n.changeLanguage(params.lang);
+        
+        reporter = new Reporter(onProgress);
+        reporter.start(i18n.t("starting"));
+        browser = await puppeteer.launch(_merge(puppeteerOptions, options));
+        [page] = await browser.pages();
+        
+        await page.setUserAgent(userAgent);
+        
+        const cachedCookies = fs.readJSONSync(getProfilePath() + "/cookies.json", {throws: false});
+
+        if (_isEmpty(cachedCookies)) {
+            await waitFor(3000);
+            const pageCookies = await page.cookies();
+            
+            fs.writeJSONSync(getProfilePath() + "/cookies.json", pageCookies, {spaces: 2});
+
+            await page.setCookie(...pageCookies);
+        } else {
+            await page.setCookie(...cachedCookies);
+        }
+
+        await navigateToPage(params.url, page);
+        
+        const process = async (artist: string) => {
+            const results: string[] = [];
+            
+            try {                
+                const searchInput = await page.waitForSelector(`::-p-xpath(${YtMusicSearchInputSelector})`, {timeout: 1000});
+                await clearInput(searchInput, page);
+                await searchInput.type(artist);
+                page.keyboard.press("Enter");
+                await page.waitForNetworkIdle();
+
+                const artistsChip = await page.waitForSelector(`::-p-xpath(${YtMusicArtistsChipSelector})`, {timeout: 1000});
+            
+                artistsChip.click();
+                await page.waitForNetworkIdle();
+
+                await page.waitForSelector(`::-p-xpath(${YtMusicSearchResultsSelector})`, {timeout: 1000});
+                
+                const artistsElements = await page.$$(`::-p-xpath(${YtMusicSearchResultsSelector})`);
+                const artistEl = artistsElements[0];
+                const artistChannelUrl = await artistEl.evaluate((el) => el.getAttribute("href"));
+                
+                await navigateToPage(`${params.url}/${artistChannelUrl}`, page);
+                await page.waitForNetworkIdle();
+
+                const element = await page.waitForSelector(`::-p-xpath(${AlbumsHrefSelector})`, {timeout: 1000});
+                const albumsUrl = await element.evaluate((el) => el.getAttribute("href"));
+
+                await navigateToPage(`${params.url}/${albumsUrl}`, page);
+                
+                const albumFilterButton = await page.waitForSelector(`::-p-xpath(${AlbumFilterSelector})`, {timeout: 1000});
+                
+                albumFilterButton.click();
+                await page.waitForNetworkIdle();
+
+                const items = await page.$$eval(`xpath/${AlbumLinkSelector}`, (elements) => elements.map((el) => el.getAttribute("href")));
+
+                for (const item of items) {
+                    results.push(`${params.url}/${item}`);
+                }
+
+                return results;
+            } catch (error) {
+                const items = await page.$$eval(`xpath/${AlbumsDirectLinkSelector}`, (elements) => elements.map((el) => el.getAttribute("href")));
+
+                for (const item of items) {
+                    results.push(`${params.url}/${item}`);
+                }
+
+                return results;
+            }
+        };
+
+        for (const a of params.artists) {
+            const data = await process(a);
+           
+            result.urls.push(...data);
+        }
+
+        reporter.finish("done", result);
+    } catch (error: any) {
+        const result: GetYoutubeUrlResult = {errors: []};
+        
+        if (error instanceof TimeoutError) {
+            result.errors.push({title: i18n.t("exceptionTimeout"), description: i18n.t("exceptionTimeoutText")});
+        } else {
+            if (error.message === "Navigating frame was detached") {
+                result.warnings.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            } else {
+                result.errors.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            }
+        }
+        
+        reporter.finish("done", result);
+        console.error("Execution failed at stage: ", error.stack);
+    } finally {
+        await closeResources();
+    }
+};
+
+const closeResources = async () => {
+    if (page) await page.close();
+    if (browser) await browser.close();
+};
+
+export const cancel = async () => {
+    await browser.close();
+    await browser.disconnect();
+};
+
+export default execute;

package/src/automations/YoutubeSongs.ts

@@ -0,0 +1,130 @@
+import fs from "fs-extra";
+import {i18n as i18next} from "i18next";
+import _forEach from "lodash/forEach";
+import _includes from "lodash/includes";
+import _isEmpty from "lodash/isEmpty";
+import _map from "lodash/map";
+import _merge from "lodash/merge";
+import _replace from "lodash/replace";
+import {Browser, LaunchOptions, Page, TimeoutError} from "puppeteer";
+import puppeteer from "puppeteer-extra";
+import StealthPlugin from "puppeteer-extra-plugin-stealth";
+
+import {getProfilePath} from "../common/FileSystem";
+import {waitFor} from "../common/Helpers";
+import {GetYoutubeSongsParams, GetYoutubeUrlResult} from "../common/Messaging";
+import puppeteerOptions from "../common/PuppeteerOptions";
+import {IReporter, ProgressInfo, Reporter} from "../common/Reporter";
+import {clearInput, navigateToPage} from "./Helpers";
+import {
+    YtMusicSearchInputSelector, YtMusicSearchResultsSelector, YtMusicSongsChipSelector
+} from "./Selectors";
+
+let page: Page;
+let browser: Browser;
+let reporter: IReporter<GetYoutubeUrlResult>;
+
+puppeteer.use(StealthPlugin());
+
+export const execute = async (
+    params: GetYoutubeSongsParams,
+    options: LaunchOptions,
+    i18n: i18next,
+    onProgress: (data: ProgressInfo<GetYoutubeUrlResult>) => void,
+) => {
+    try {
+        const result: GetYoutubeUrlResult = {warnings: [], errors: [], urls: []};
+        const userAgent = "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.3";
+        
+        await i18n.changeLanguage(params.lang);
+        
+        reporter = new Reporter(onProgress);
+        reporter.start(i18n.t("starting"));
+        browser = await puppeteer.launch(_merge(puppeteerOptions, options));
+        [page] = await browser.pages();
+        
+        await page.setUserAgent(userAgent);
+        
+        const cachedCookies = fs.readJSONSync(getProfilePath() + "/cookies.json", {throws: false});
+
+        if (_isEmpty(cachedCookies)) {
+            await waitFor(3000);
+            const pageCookies = await page.cookies();
+            
+            fs.writeJSONSync(getProfilePath() + "/cookies.json", pageCookies, {spaces: 2});
+
+            await page.setCookie(...pageCookies);
+        } else {
+            await page.setCookie(...cachedCookies);
+        }
+
+        await navigateToPage(params.url, page);
+        
+        const process = async (song: string) => {
+            const results: string[] = [];
+            
+            try {                
+                const searchInput = await page.waitForSelector(`::-p-xpath(${YtMusicSearchInputSelector})`, {timeout: 1000});
+                await clearInput(searchInput, page);
+                await searchInput.type(song);
+                page.keyboard.press("Enter");
+                await page.waitForNetworkIdle();
+
+                const songsChip = await page.waitForSelector(`::-p-xpath(${YtMusicSongsChipSelector})`, {timeout: 1000});
+            
+                songsChip.click();
+                await page.waitForNetworkIdle();
+
+                await page.waitForSelector(`::-p-xpath(${YtMusicSearchResultsSelector})`, {timeout: 1000});
+                
+                const songsElements = await page.$$(`::-p-xpath(${YtMusicSearchResultsSelector})`);
+                const songEl = songsElements[0];
+                const songUrl = await songEl.evaluate((el) => el.getAttribute("href"));
+
+                results.push(`${params.url}/${songUrl}`);
+
+                return results;
+            } catch (error) {
+
+                return results;
+            }
+        };
+
+        for (const item of params.songs) {
+            const data = await process(item);
+           
+            result.urls.push(...data);
+        }
+
+        reporter.finish("done", result);
+    } catch (error: any) {
+        const result: GetYoutubeUrlResult = {errors: []};
+        
+        if (error instanceof TimeoutError) {
+            result.errors.push({title: i18n.t("exceptionTimeout"), description: i18n.t("exceptionTimeoutText")});
+        } else {
+            if (error.message === "Navigating frame was detached") {
+                result.warnings.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            } else {
+                result.errors.push({title: i18n.t("exceptionGetYoutubeUrls"), description: i18n.t("exceptionGetYoutubeUrlsText", {error: error.name})});
+            }
+        }
+        
+        reporter.finish("done", result);
+        console.error("Execution failed at stage: ", error.stack);
+    } finally {
+        await closeResources();
+    }
+};
+
+const closeResources = async () => {
+    if (page) await page.close();
+    if (browser) await browser.close();
+};
+
+export const cancel = async () => {
+    await browser.close();
+    await browser.disconnect();
+};
+
+export default execute;

package/src/common/Helpers.ts

@@ -42,15 +42,19 @@ export const waitFor = (miliseconds: number) => new Promise((resolve) => setTime
 export const getUrlType = (url: string) => {
     const artistRegex = /^(?:https?:\/\/)?(?:www\.)?(?:m\.)?(?:music\.)?(?:youtube\.com\/|youtu\.be\/)?(channel)/;
     const playlistRegex = /^(?:https?:\/\/)?(?:www\.)?(?:music\.)?youtube\.com\/(?:playlist\?list=|watch\?.*?\blist=)([a-zA-Z0-9_-]+)/;
+    const trackRegex = /^(?:https?:\/\/)?(?:www\.)?(?:music\.)?youtube\.com\/watch\?.*?\bv=([a-zA-Z0-9_-]+)/;
 
     const isArtist = artistRegex.test(url);
     const isPlaylist = playlistRegex.test(url);
+    const isTrack = trackRegex.test(url);
     
     if (isArtist) {
         return UrlType.Artist;
     } else if (isPlaylist) {
         return UrlType.Playlist;
+    } else if (isTrack) {
+        return UrlType.Track;
     }
 
-    return UrlType.Track;
+    return UrlType.Other;
 };

package/src/common/Media.ts

@@ -26,3 +26,10 @@ export enum FormatScope {
     Global = "global",
     Tab =  "tab"
 }
+
+export enum InputMode {
+    Auto = "auto",
+    Artists = "artists",
+    Albums = "albums",
+    Songs = "songs",
+};

package/src/common/Messaging.ts

@@ -31,6 +31,24 @@ export type GetYoutubeUrlParams = {
     artistUrls?: string[];
 };
 
+export type GetYoutubeArtistsParams = {
+    artists: string[];
+    lang: string;
+    url: string;
+};
+
+export type GetYoutubeAlbumsParams = {
+    albums: string[];
+    lang: string;
+    url: string;
+};
+
+export type GetYoutubeSongsParams = {
+    songs: string[];
+    lang: string;
+    url: string;
+};
+
 export type GetYoutubeUrlResult = {
     errors?: LogMessage[];
     warnings?: LogMessage[];

package/src/common/Store.ts

@@ -1,7 +1,7 @@
 import {Schema} from "electron-store";
 import _values from "lodash/values";
 
-import {FormatScope} from "./Media";
+import {FormatScope, InputMode} from "./Media";
 
 export type ApplicationOptions = {
     youtubeUrl?: string;
@@ -17,7 +17,8 @@ export type ApplicationOptions = {
     urls?: string[];
     language?: string;
     alwaysOverwrite?: boolean;
-    discographyDownload?: boolean;
+    enableInputMode?: boolean;
+    inputMode?: InputMode;
 };
 
 export interface IStore {
@@ -96,10 +97,15 @@ export const StoreSchema: Schema<IStore> = {
                 type: "boolean",
                 default: false
             },
-            discographyDownload: {
+            enableInputMode: {
                 type: "boolean",
-                default: true
-            }
+                default: true,
+            },
+            inputMode: {
+                type: "string",
+                default: InputMode.Auto,
+                enum: _values(InputMode),
+            },
         },
         default: {},
     },

package/src/common/Youtube.ts

@@ -107,4 +107,5 @@ export enum UrlType {
     Artist = "artist",
     Playlist = "playlist",
     Track = "track",
+    Other = "other",
 };

package/src/components/youtube/inputModePicker/InputModePicker.styl

@@ -0,0 +1,21 @@
+@import "../../../styles/mixins.styl"
+
+.input-mode-picker {
+    .button {
+        padding: 6px 0px 6px 6px;
+
+        .icon {
+            font-size: 1.7rem;
+        }
+    }
+
+    .popper {
+        z-index: 99;
+    }
+
+    .menu-item {
+        column-gap: 5px;
+        align-items: center;
+        display: flex;
+    }
+}