harmonyy 1.0.0

package/dist/youtube/index.js

@@ -0,0 +1,93 @@
+export * from './types.js';
+export default class YoutubeMusic {
+    $youtubeClientVersion;
+    $youtubeClientBuild;
+    $googVisitorId;
+    $cookieString;
+    async $getData() {
+        const dataReq = await fetch('https://music.youtube.com/sw.js_data');
+        const dataRes = await dataReq.text();
+        const dataArr = dataRes.split(',');
+        this.$youtubeClientVersion = dataArr.find(e => !isNaN(parseInt(e)));
+        this.$youtubeClientBuild = dataArr.find(e => e.startsWith('"1.')).slice(1, -1);
+        this.$googVisitorId = dataArr[15].slice(1, -1);
+    }
+    async $getCookies() {
+        const data = await fetch('https://music.youtube.com');
+        this.$cookieString = data.headers.getSetCookie().map(e => e.split(' Domain')[0]).join(' ');
+    }
+    async $getHeaders() {
+        if (!this.$youtubeClientVersion)
+            await this.$getData();
+        if (!this.$cookieString)
+            await this.$getCookies();
+        return {
+            'Accept': '*/*',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Cache-Control': 'no-cache',
+            'Content-Type': 'application/json',
+            'Cookie': this.$cookieString,
+            'Origin': 'https://music.youtube.com',
+            'Referer': 'https://music.youtube.com/',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+            'X-Goog-Visitor-Id': this.$googVisitorId,
+            'x-youtube-bootstrap-logged-in': 'false',
+            'x-youtube-client-name': this.$youtubeClientVersion,
+            'x-youtube-client-version': this.$youtubeClientBuild
+        };
+    }
+    async search(query) {
+        if (!this.$youtubeClientBuild)
+            await this.$getData();
+        const payload = {
+            context: {
+                client: {
+                    clientName: 'WEB_REMIX',
+                    clientVersion: this.$youtubeClientBuild,
+                }
+            },
+            query,
+            suggestStats: {
+                validationStatus: 'VALID',
+                parameterValidationStatus: 'VALID_PARAMETERS',
+                clientName: 'youtube-music',
+                searchMethod: 'ENTER_KEY',
+                inputMethods: ['KEYBOARD'],
+                originalQuery: query
+            }
+        };
+        const searchReq = await fetch('https://music.youtube.com/youtubei/v1/search?prettyPrint=false', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: await this.$getHeaders()
+        });
+        const searchRes = await searchReq.json();
+        return searchRes.contents.tabbedSearchResultsRenderer.tabs[0].tabRenderer.content.sectionListRenderer.contents.map((a) => a.musicCardShelfRenderer || a.musicShelfRenderer || a);
+    }
+    async #browse(browseId) {
+        if (!this.$youtubeClientBuild)
+            await this.$getData();
+        const payload = {
+            context: {
+                client: {
+                    clientName: 'WEB_REMIX',
+                    clientVersion: this.$youtubeClientBuild,
+                }
+            },
+            browseId
+        };
+        const browseReq = await fetch('https://music.youtube.com/youtubei/v1/browse?prettyPrint=false', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: await this.$getHeaders()
+        });
+        return await browseReq.json();
+    }
+    getAlbum(uri) {
+        return this.#browse(uri);
+    }
+    getArtist(uri) {
+        return this.#browse(uri);
+    }
+}

package/dist/youtube/types.d.ts

@@ -0,0 +1,418 @@
+type Run = {
+    text: string;
+    navigationEndpoint?: NavigationEndpoint;
+};
+type Runs = {
+    runs: Run[];
+};
+type Thumbnail = {
+    url: string;
+    width: number;
+    height: number;
+};
+type MusicThumbnailRenderer = {
+    musicThumbnailRenderer: {
+        thumbnail: {
+            thumbnails: Thumbnail[];
+        };
+        thumbnailCrop: string;
+        thumbnailScale: string;
+    };
+};
+type Icon = {
+    iconType: string;
+};
+type BrowseEndpoint = {
+    browseId: string;
+    params?: string;
+    browseEndpointContextSupportedConfigs?: {
+        browseEndpointContextMusicConfig: {
+            pageType: string;
+        };
+    };
+};
+type WatchEndpoint = {
+    videoId?: string;
+    playlistId?: string;
+    index?: number;
+    params?: string;
+    playerParams?: string;
+    playlistSetVideoId?: string;
+    watchEndpointMusicSupportedConfigs?: {
+        watchEndpointMusicConfig: {
+            musicVideoType: string;
+        };
+    };
+};
+type WatchPlaylistEndpoint = {
+    playlistId: string;
+    params?: string;
+};
+type ShareEntityEndpoint = {
+    serializedShareEntity: string;
+    sharePanelType: string;
+};
+type ModalEndpoint = {
+    modal: {
+        modalWithTitleAndButtonRenderer: {
+            title: Runs;
+            content: Runs;
+            button: {
+                buttonRenderer: ButtonRenderer;
+            };
+        };
+    };
+};
+type QueueAddEndpoint = {
+    queueTarget: {
+        videoId?: string;
+        playlistId?: string;
+        onEmptyQueue?: {
+            watchEndpoint: WatchEndpoint;
+        };
+    };
+    queueInsertPosition: string;
+    commands: unknown[];
+};
+type NavigationEndpoint = {
+    browseEndpoint?: BrowseEndpoint;
+    watchEndpoint?: WatchEndpoint;
+    watchPlaylistEndpoint?: WatchPlaylistEndpoint;
+    shareEntityEndpoint?: ShareEntityEndpoint;
+    modalEndpoint?: ModalEndpoint;
+};
+type ButtonRenderer = {
+    style?: string;
+    size?: string;
+    isDisabled?: boolean;
+    text?: Runs;
+    icon?: Icon;
+    command?: NavigationEndpoint;
+    navigationEndpoint?: NavigationEndpoint;
+};
+type MenuItem = {
+    menuNavigationItemRenderer?: {
+        text: Runs;
+        icon: Icon;
+        navigationEndpoint: NavigationEndpoint;
+    };
+    menuServiceItemRenderer?: {
+        text: Runs;
+        icon: Icon;
+        serviceEndpoint: {
+            queueAddEndpoint?: QueueAddEndpoint;
+        };
+    };
+    toggleMenuServiceItemRenderer?: {
+        defaultText: Runs;
+        defaultIcon: Icon;
+        defaultServiceEndpoint: {
+            modalEndpoint: ModalEndpoint;
+        };
+        toggledText: Runs;
+        toggledIcon: Icon;
+        toggledServiceEndpoint: {
+            likeEndpoint: {
+                status: string;
+                target: {
+                    videoId?: string;
+                    playlistId?: string;
+                };
+            };
+        };
+        isToggled: boolean;
+    };
+    menuServiceItemDownloadRenderer?: {
+        serviceEndpoint: {
+            offlineVideoEndpoint: {
+                videoId: string;
+                onAddCommand: unknown;
+            };
+        };
+        badgeIcon: Icon;
+    };
+};
+type MenuRenderer = {
+    menuRenderer: {
+        items: MenuItem[];
+        topLevelButtons?: {
+            likeButtonRenderer: {
+                target: {
+                    videoId: string;
+                };
+                likeStatus: string;
+                likesAllowed: boolean;
+                dislikeNavigationEndpoint: NavigationEndpoint;
+                likeCommand: NavigationEndpoint;
+            };
+        }[];
+    };
+};
+type MusicPlayButtonRenderer = {
+    playNavigationEndpoint: NavigationEndpoint;
+    playIcon: Icon;
+    pauseIcon: Icon;
+    iconColor: number;
+    backgroundColor: number;
+    activeBackgroundColor: number;
+    loadingIndicatorColor: number;
+    playingIcon: Icon;
+    iconLoadingColor: number;
+    activeScaleFactor: number;
+    buttonSize: string;
+    rippleTarget: string;
+};
+type MusicItemThumbnailOverlayRenderer = {
+    musicItemThumbnailOverlayRenderer: {
+        background: {
+            verticalGradient: {
+                gradientLayerColors: string[];
+            };
+        };
+        content: {
+            musicPlayButtonRenderer: MusicPlayButtonRenderer;
+        };
+        contentPosition: string;
+        displayStyle: string;
+    };
+};
+type MusicInlineBadge = {
+    musicInlineBadgeRenderer: {
+        icon: Icon;
+    };
+};
+type MusicResponsiveListItemRenderer = {
+    thumbnail?: MusicThumbnailRenderer;
+    overlay?: MusicItemThumbnailOverlayRenderer;
+    flexColumns: {
+        musicResponsiveListItemFlexColumnRenderer: {
+            text: Partial<Runs>;
+            displayPriority: string;
+        };
+    }[];
+    fixedColumns?: {
+        musicResponsiveListItemFixedColumnRenderer: {
+            text: Partial<Runs>;
+            displayPriority: string;
+            size: string;
+        };
+    }[];
+    menu?: MenuRenderer;
+    playlistItemData?: {
+        videoId: string;
+        playlistSetVideoId?: string;
+    };
+    flexColumnDisplayStyle?: string;
+    itemHeight?: string;
+    navigationEndpoint?: NavigationEndpoint;
+    badges?: MusicInlineBadge[];
+};
+type MusicTwoRowItemRenderer = {
+    thumbnailRenderer: MusicThumbnailRenderer;
+    aspectRatio: string;
+    title: Runs;
+    subtitle: Runs;
+    navigationEndpoint: NavigationEndpoint;
+    menu: MenuRenderer;
+    thumbnailOverlay: MusicItemThumbnailOverlayRenderer;
+    subtitleBadges?: MusicInlineBadge[];
+};
+type MusicShelfRenderer = {
+    title?: Runs;
+    contents: {
+        musicResponsiveListItemRenderer: MusicResponsiveListItemRenderer;
+    }[];
+    bottomText?: Runs;
+    bottomEndpoint?: NavigationEndpoint;
+    shelfDivider?: {
+        musicShelfDividerRenderer: {
+            hidden: boolean;
+        };
+    };
+    contentsMultiSelectable?: boolean;
+};
+type MusicCardShelfRenderer = {
+    thumbnail: MusicThumbnailRenderer;
+    title: Runs;
+    subtitle: Runs;
+    contents: {
+        musicResponsiveListItemRenderer: MusicResponsiveListItemRenderer;
+    }[];
+    buttons: {
+        buttonRenderer: ButtonRenderer;
+    }[];
+    menu: MenuRenderer;
+    onTap: NavigationEndpoint;
+    endIcon: Icon;
+    subtitleBadges?: MusicInlineBadge[];
+    thumbnailOverlay?: MusicItemThumbnailOverlayRenderer;
+};
+type MusicCarouselShelfRenderer = {
+    header: {
+        musicCarouselShelfBasicHeaderRenderer: {
+            title: Runs;
+            headerStyle: string;
+            moreContentButton?: {
+                buttonRenderer: ButtonRenderer;
+            };
+        };
+    };
+    contents: {
+        musicTwoRowItemRenderer: MusicTwoRowItemRenderer;
+    }[];
+    itemSize: string;
+};
+type MusicDescriptionShelfRenderer = {
+    header: Runs;
+    subheader?: Runs;
+    description: Runs;
+    moreButton: {
+        toggleButtonRenderer: ToggleButtonRenderer;
+    };
+};
+type ToggleButtonRenderer = {
+    isToggled: boolean;
+    isDisabled: boolean;
+    defaultIcon: Icon;
+    defaultText: Runs;
+    toggledIcon: Icon;
+    toggledText: Runs;
+};
+type MicroformatDataRenderer = {
+    urlCanonical: string;
+    title: string;
+    description: string;
+    thumbnail: {
+        thumbnails: Thumbnail[];
+    };
+    siteName: string;
+    appName: string;
+    androidPackage: string;
+    iosAppStoreId: string;
+    ogType: string;
+    urlApplinksWeb: string;
+    urlApplinksIos: string;
+    urlApplinksAndroid: string;
+    urlTwitterIos: string;
+    urlTwitterAndroid: string;
+    twitterCardType: string;
+    twitterSiteHandle: string;
+};
+type Microformat = {
+    microformatDataRenderer: MicroformatDataRenderer;
+};
+type AlbumHeaderRenderer = {
+    thumbnail: MusicThumbnailRenderer;
+    buttons: {
+        toggleButtonRenderer?: ToggleButtonRenderer;
+        musicPlayButtonRenderer?: MusicPlayButtonRenderer;
+        menuRenderer?: MenuRenderer['menuRenderer'];
+    }[];
+    title: Runs;
+    subtitle: Runs;
+    straplineTextOne: Runs;
+    straplineThumbnail: MusicThumbnailRenderer;
+    subtitleBadge?: MusicInlineBadge[];
+    description?: {
+        musicDescriptionShelfRenderer: MusicDescriptionShelfRenderer;
+    };
+    secondSubtitle: Runs;
+};
+type ArtistHeaderRenderer = {
+    title: Runs;
+    subscriptionButton: {
+        subscribeButtonRenderer: {
+            subscriberCountText: Runs;
+            subscribed: boolean;
+            enabled: boolean;
+            type: string;
+            channelId: string;
+            showPreferences: boolean;
+            subscriberCountWithSubscribeText: Runs;
+            subscribedButtonText: Runs;
+            unsubscribedButtonText: Runs;
+            unsubscribeButtonText: Runs;
+            serviceEndpoints: unknown[];
+            longSubscriberCountText: Runs;
+            shortSubscriberCountText: Runs;
+            signInEndpoint: NavigationEndpoint;
+        };
+    };
+    description?: Runs;
+    moreButton?: {
+        toggleButtonRenderer: ToggleButtonRenderer;
+    };
+    menu: MenuRenderer;
+    thumbnail: MusicThumbnailRenderer;
+    playButton: {
+        buttonRenderer: ButtonRenderer;
+    };
+    startRadioButton: {
+        buttonRenderer: ButtonRenderer;
+    };
+    shareEndpoint: NavigationEndpoint;
+    monthlyListenerCount?: Runs;
+};
+export type SearchSection = Partial<MusicCardShelfRenderer> & Partial<MusicShelfRenderer> & {
+    itemSectionRenderer?: {
+        contents: {
+            musicResponsiveListItemRenderer: MusicResponsiveListItemRenderer;
+        }[];
+    };
+};
+export type SearchResponse = SearchSection[];
+export interface AlbumResponse {
+    contents: {
+        twoColumnBrowseResultsRenderer: {
+            tabs: {
+                tabRenderer: {
+                    content: {
+                        sectionListRenderer: {
+                            contents: {
+                                musicResponsiveHeaderRenderer: AlbumHeaderRenderer;
+                            }[];
+                        };
+                    };
+                };
+            }[];
+            secondaryContents: {
+                sectionListRenderer: {
+                    contents: {
+                        musicShelfRenderer: MusicShelfRenderer;
+                    }[];
+                };
+            };
+        };
+    };
+    microformat: Microformat;
+    background: MusicThumbnailRenderer;
+}
+export interface ArtistResponse {
+    contents: {
+        singleColumnBrowseResultsRenderer: {
+            tabs: {
+                tabRenderer: {
+                    endpoint: {
+                        browseEndpoint: BrowseEndpoint;
+                    };
+                    title: string;
+                    selected: boolean;
+                    content: {
+                        sectionListRenderer: {
+                            contents: {
+                                musicShelfRenderer?: MusicShelfRenderer;
+                                musicCarouselShelfRenderer?: MusicCarouselShelfRenderer;
+                                musicDescriptionShelfRenderer?: MusicDescriptionShelfRenderer;
+                            }[];
+                        };
+                    };
+                };
+            }[];
+        };
+    };
+    header: {
+        musicImmersiveHeaderRenderer: ArtistHeaderRenderer;
+    };
+    microformat: Microformat;
+}
+export {};

package/dist/youtube/types.js

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

package/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "harmonyy",
+    "description": "a keyless search tool for music streaming services",
+    "type": "module",
+    "version": "1.0.0",
+    "homepage": "https://github.com/VillainsRule/harmony",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/VillainsRule/harmony.git"
+    },
+    "bugs": {
+        "url": "https://github.com/VillainsRule/harmony/issues"
+    },
+    "keywords": [
+        "spotify",
+        "apple music",
+        "youtube music"
+    ],
+    "exports": {
+        "./package.json": "./package.json",
+        "./apple": {
+            "import": "./dist/apple/index.js",
+            "types": "./dist/apple/index.d.ts"
+        },
+        "./spotify": {
+            "import": "./dist/spotify/index.js",
+            "types": "./dist/spotify/index.d.ts"
+        },
+        "./youtube": {
+            "import": "./dist/youtube/index.js",
+            "types": "./dist/youtube/index.d.ts"
+        }
+    },
+    "typesVersions": {
+        "*": {
+            "apple": [
+                "dist/apple/index.d.ts"
+            ],
+            "spotify": [
+                "dist/spotify/index.d.ts"
+            ],
+            "youtube": [
+                "dist/youtube/index.d.ts"
+            ]
+        }
+    },
+    "files": [
+        "dist/**/*.js",
+        "dist/**/*.d.ts",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "bunx --bun tsc -P tsconfig.build.json",
+        "prod": "bun run build && npm publish"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.4.2",
+        "typescript": "^7.0.2"
+    }
+}