Use LRCLIB as backup server

mantou132 · mantou132 · commit 32f69a88f53a · 2024-07-28T17:29:37.000+08:00
Closed #142 #141 #140 #139
diff --git a/src/page/lrclib.ts b/src/page/lrclib.ts
@@ -0,0 +1,45 @@
+import type { SongLyricResult, Song } from './netease';
+import { request } from './request';
+
+const API_HOST = `https://lrclib.net/api`;
+
+export const LRCLIB_ID_TOKEN = 0.1;
+
+interface LrcLibLyricRes {
+  id: number;
+  trackName: string;
+  artistName: string;
+  albumName: string;
+  duration: number;
+  instrumental: boolean;
+  syncedLyrics: string;
+}
+
+export async function fetchLRCLIBSongList(s: string, fetchOptions?: RequestInit): Promise<Song[]> {
+  const searchQuery = new URLSearchParams({ q: s });
+  const fetchPromise: Promise<LrcLibLyricRes[]> = request(
+    `${API_HOST}/search?${searchQuery}`,
+    fetchOptions,
+  );
+  const list = await fetchPromise;
+  return list
+    .filter((e) => !!e.syncedLyrics)
+    .map((e) => ({
+      album: { name: e.albumName },
+      artists: e.artistName.split(',').map((name) => ({ name, alias: [] })),
+      id: e.id + LRCLIB_ID_TOKEN,
+      name: e.trackName,
+      duration: e.duration * 1000,
+    }));
+}
+
+export async function fetchLRCLIBLyric(
+  songId: number,
+  fetchOptions?: RequestInit,
+): Promise<SongLyricResult> {
+  const { syncedLyrics = '' }: LrcLibLyricRes = await request(
+    `${API_HOST}/get/${songId}`,
+    fetchOptions,
+  );
+  return { lrc: { lyric: syncedLyrics } };
+}
diff --git a/src/page/lyrics.test.ts b/src/page/lyrics.test.ts
@@ -38,12 +38,12 @@ describe('matching track', () => {
       { id: 2, artists: [{ name: '张卫健', alias: [] }], name: '夜雪', album: { name: '' } },
     ];
     let search = '';
-    const fetchData = async (s: string) => {
+    const fetchSongList = async (s: string) => {
       if (!search) search = s;
       return songs;
     };
     const fetchTransName = async () => ({});
-    const result = await matchingLyrics(query, { fetchData, fetchTransName });
+    const result = await matchingLyrics(query, { fetchSongList, fetchTransName });
     expect(search).toBe('张卫健 夜雪');
     expect(result.id).toBe(2);
   });
diff --git a/src/page/lyrics.ts b/src/page/lyrics.ts
@@ -4,52 +4,16 @@ import { Options, isProd } from '../common/constants';
 
 import { configPromise } from './config';
 import { optionsPromise } from './options';
-import { request } from './request';
-import { captureException } from './utils';
+import { fetchNetEaseChineseName, fetchNetEaseLyric, fetchNetEaseSongList, Song } from './netease';
+import { fetchLRCLIBLyric, LRCLIB_ID_TOKEN } from './lrclib';
+
+export { Song } from './netease';
 
 export interface Query {
   name: string;
   artists: string;
 }
 
-interface Artist {
-  name: string;
-  alias: string[];
-  transNames?: string[];
-}
-interface Album {
-  name: string;
-}
-export interface Song {
-  id: number;
-  name: string;
-  artists: Artist[];
-  album: Album;
-  /**ms */
-  duration?: number;
-}
-
-interface SearchSongsResult {
-  result?: {
-    songs?: Song[];
-  };
-}
-
-interface SearchArtistsResult {
-  result?: {
-    artists?: Artist[];
-  };
-}
-
-interface SongResult {
-  lrc?: {
-    lyric?: string;
-  };
-  tlyric?: {
-    lyric?: string;
-  };
-}
-
 // Convert all into English punctuation marks for processing
 const normalize = (s: string, emptySymbol = true) => {
   const result = s
@@ -121,18 +85,9 @@ const buildInSingerAliasPromise = new Promise<Record<string, string>>(async (res
 });
 
 async function fetchChineseName(s: string, fetchOptions?: RequestInit) {
-  const { API_HOST } = await configPromise;
   const singerAlias: Record<string, string> = {};
-  const searchQuery = new URLSearchParams({
-    keywords: s,
-    type: '100',
-    limit: '100',
-  });
   try {
-    const { result }: SearchArtistsResult = await request(
-      `${API_HOST}/search?${searchQuery}`,
-      fetchOptions,
-    );
+    const { result } = await fetchNetEaseChineseName(s, fetchOptions);
     const artists = result?.artists || [];
     artists.forEach((artist) => {
       const alias = [...artist.alias, ...(artist.transNames || [])].map(simplifiedText).sort();
@@ -143,39 +98,14 @@ async function fetchChineseName(s: string, fetchOptions?: RequestInit) {
         }
       });
     });
-  } catch (e) {
-    if (e.name !== 'AbortError') {
-      captureException(e);
-    }
-  }
+  } catch {}
   return singerAlias;
 }
 
-async function fetchSongList(s: string, fetchOptions?: RequestInit): Promise<Song[]> {
-  const { API_HOST } = await configPromise;
-  const searchQuery = new URLSearchParams({
-    keywords: s,
-    type: '1',
-    limit: '100',
-  });
-  const options = await optionsPromise;
-  const fetchPromise: Promise<SearchSongsResult> = request(
-    `${API_HOST}/search?${searchQuery}`,
-    fetchOptions,
-  );
-  try {
-    return (await fetchPromise).result?.songs || [];
-  } catch (err) {
-    if (!options['use-unreviewed-lyrics']) throw err;
-    console.error(err);
-    return [];
-  }
-}
-
 interface MatchingLyricsOptions {
   onlySearchName?: boolean;
   getDuration?: () => Promise<number>;
-  fetchData?: (s: string, fetchOptions?: RequestInit) => Promise<Song[]>;
+  fetchSongList?: (s: string, fetchOptions?: RequestInit) => Promise<Song[]>;
   fetchTransName?: (s: string, fetchOptions?: RequestInit) => Promise<Record<string, string>>;
   fetchOptions?: RequestInit;
 }
@@ -185,10 +115,10 @@ export async function matchingLyrics(
 ): Promise<{ list: Song[]; id: number; score: number }> {
   const { name = '', artists = '' } = query;
   const {
-    getDuration,
     onlySearchName = false,
-    fetchData = fetchSongList,
     fetchTransName = fetchChineseName,
+    fetchSongList = fetchNetEaseSongList,
+    getDuration,
     fetchOptions,
   } = options;
 
@@ -222,7 +152,7 @@ export async function matchingLyrics(
   const searchString = onlySearchName
     ? removeSongFeat(name)
     : `${queryArtistsArr4.join()} ${removeSongFeat(name)}`;
-  const songs = await fetchData(searchString, fetchOptions);
+  const songs = await fetchSongList(searchString, fetchOptions);
   const list: Song[] = [];
   const listIdSet = new Set<number>();
 
@@ -351,10 +281,10 @@ export async function matchingLyrics(
       list: listForMissingName,
       score: scoreForMissingName,
     } = await matchingLyrics(query, {
-      getDuration,
       onlySearchName: true,
-      fetchData,
       fetchTransName: async () => singerAlias,
+      getDuration,
+      fetchSongList,
       fetchOptions,
     });
     listForMissingName.forEach((song) => {
@@ -370,11 +300,17 @@ export async function matchingLyrics(
 }
 
 export async function fetchLyric(songId: number, fetchOptions?: RequestInit) {
-  const { API_HOST } = await configPromise;
-  const { lrc, tlyric }: SongResult = await request(
-    `${API_HOST}/lyric?${new URLSearchParams({ id: String(songId) })}`,
-    fetchOptions,
-  );
+  const id = Math.floor(songId);
+  const token = Math.round((songId % 1) * 10) / 10;
+  const get = () => {
+    switch (token) {
+      case LRCLIB_ID_TOKEN:
+        return fetchLRCLIBLyric(id, fetchOptions);
+      default:
+        return fetchNetEaseLyric(id, fetchOptions);
+    }
+  };
+  const { lrc, tlyric } = await get();
   const options = await optionsPromise;
   return (options['lyrics-transform'] === 'Simplified' && tlyric?.lyric) || lrc?.lyric || '';
 }
diff --git a/src/page/netease.ts b/src/page/netease.ts
@@ -0,0 +1,85 @@
+import { configPromise } from './config';
+import { fetchLRCLIBSongList } from './lrclib';
+import { request } from './request';
+
+interface Artist {
+  name: string;
+  alias: string[];
+  transNames?: string[];
+}
+
+interface Album {
+  name: string;
+}
+
+export interface Song {
+  id: number;
+  name: string;
+  artists: Artist[];
+  album: Album;
+  /**ms */
+  duration?: number;
+}
+
+interface SearchSongsResult {
+  result?: {
+    songs?: Song[];
+  };
+}
+
+interface SearchArtistsResult {
+  result?: {
+    artists?: Artist[];
+  };
+}
+
+export interface SongLyricResult {
+  lrc?: {
+    lyric?: string;
+  };
+  tlyric?: {
+    lyric?: string;
+  };
+}
+
+export async function fetchNetEaseChineseName(
+  s: string,
+  fetchOptions?: RequestInit,
+): Promise<SearchArtistsResult> {
+  const { API_HOST } = await configPromise;
+  const searchQuery = new URLSearchParams({
+    keywords: s,
+    type: '100',
+    limit: '100',
+  });
+  return request(`${API_HOST}/search?${searchQuery}`, fetchOptions);
+}
+
+// auto swtch to lrclib
+let down = false;
+export async function fetchNetEaseSongList(s: string, fetchOptions?: RequestInit) {
+  if (down) return fetchLRCLIBSongList(s, fetchOptions);
+
+  const { API_HOST } = await configPromise;
+  const searchQuery = new URLSearchParams({
+    keywords: s,
+    type: '1',
+    limit: '100',
+  });
+
+  try {
+    const res: SearchSongsResult = await request(`${API_HOST}/search?${searchQuery}`, fetchOptions);
+    return res.result?.songs || [];
+  } catch (err) {
+    down = true;
+    return fetchLRCLIBSongList(s, fetchOptions);
+  }
+}
+
+export async function fetchNetEaseLyric(
+  songId: number,
+  fetchOptions?: RequestInit,
+): Promise<SongLyricResult> {
+  const { API_HOST } = await configPromise;
+  return request(`${API_HOST}/lyric?${new URLSearchParams({ id: String(songId) })}`, fetchOptions);
+}
diff --git a/src/page/share-data.ts b/src/page/share-data.ts
@@ -136,7 +136,7 @@ export class SharedData {
     };
   }
 
-  private async _getLyricsFromNetEase(fetchOptions: RequestInit) {
+  private async _getLyricsFromAPI(fetchOptions: RequestInit) {
     if (this._id === 0) {
       return null;
     }
@@ -158,7 +158,7 @@ export class SharedData {
     const fetchTransName = async () => ({});
     const { id } = await matchingLyrics(this.req, {
       onlySearchName: false,
-      fetchData: fetchSongList,
+      fetchSongList,
       fetchTransName,
       fetchOptions,
     });
@@ -213,7 +213,7 @@ export class SharedData {
     else if (isSelf && remoteData?.neteaseID) {
       this._id = remoteData.neteaseID;
       this._aId = this._id;
-      this._lyrics = await this._getLyricsFromNetEase(fetchOptions);
+      this._lyrics = await this._getLyricsFromAPI(fetchOptions);
     }
 
     // 3. use other user upload lyrics
@@ -229,7 +229,7 @@ export class SharedData {
       this._aId = this._id;
       // Allow adjustment order
       const getLyricsList = [
-        this._getLyricsFromNetEase.bind(this),
+        this._getLyricsFromAPI.bind(this),
         this._getLyricsFromBuiltIn.bind(this),
       ];
       try {
@@ -282,7 +282,7 @@ export class SharedData {
         await this._matching(fetchOptions);
         this.sendToContentScript();
       } else {
-        this._lyrics = await this._getLyricsFromNetEase(fetchOptions);
+        this._lyrics = await this._getLyricsFromAPI(fetchOptions);
       }
     } catch (e) {
       if (e.name !== 'AbortError') {
