add abstraction layer for lyrics provider

Closes: gh-18

Author: therepanic

src/extension.ts

@@ -8,13 +8,13 @@ import { SpotifyPreAuthState } from './SpotifyPreAuthState';
 import { SpotifyAuthState } from './SpotifyAuthState';
 import { clearTimeout } from 'node:timers';
 import { SpotifyCurrentPlayingState } from './SpotifyCurrentPlayingState';
-import { LRCLibSearchResponse } from './api/response/LRCLibGetResponse';
-import { LRCLibApi } from './api/LRCLibApi';
 import TreeMap from 'ts-treemap';
 import { LyricsEntry } from './LyricsEntry';
 import { generateTextColor, getAccentColorFromUrl } from './ColorUtil';
 import path from 'node:path';
 import LRUCache from 'lru-cache';
+import { LRCLibLyricsProvider } from './provider/LRCLibLyricsProvider';
+import { LyricsProvider } from './provider/LyricsProvider';
 
 let panel: WebviewPanel | undefined;
 
@@ -26,6 +26,8 @@ let tracksCache: LRUCache<string, SpotifyCurrentPlayingState>;
 let server: http.Server | null;
 let pollingTimeout: NodeJS.Timeout | null;
 
+const provider: LyricsProvider = new LRCLibLyricsProvider();
+
 export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(
         vscode.commands.registerCommand('spotilyrics.lyrics', async () => {
@@ -352,16 +354,16 @@ async function updateLyrics() {
             currentPlayingState.authors !== artists ||
             currentPlayingState.name !== trackName
         ) {
-            const getLyricsResponse: LRCLibSearchResponse = await LRCLibApi.get(
+            const lyricsResult = await provider.getLyrics(
                 trackName,
                 artists,
                 albumName,
                 durationInS
             );
-            if (!getLyricsResponse.statusCode && !getLyricsResponse.instrumental) {
+            if (lyricsResult && !lyricsResult.instrumental) {
                 const currentlyPlayingPoll = new SpotifyCurrentPlayingState(trackName, artists);
-                if (getLyricsResponse.plainLyrics) {
-                    const plainLyricsStrs: string[] = getLyricsResponse.plainLyrics
+                if (lyricsResult.plainLyrics) {
+                    const plainLyricsStrs: string[] = lyricsResult.plainLyrics
                         .split(/\n/)
                         .map((s) => s.trim())
                         .filter((s) => s !== '')
@@ -370,9 +372,9 @@ async function updateLyrics() {
                     currentlyPlayingPoll.plainLyricsStrs = plainLyricsStrs;
                 }
                 // load synchronized lyrics in treemap
-                if (getLyricsResponse.syncedLyrics) {
+                if (lyricsResult.syncedLyrics) {
                     const synchronizedLyricsMap = new TreeMap<number, LyricsEntry>();
-                    const synchronizedLyricsStrs: string[] = getLyricsResponse.syncedLyrics
+                    const synchronizedLyricsStrs: string[] = lyricsResult.syncedLyrics
                         .split(/(?=\[\d{2}:\d{2}\.\d{2}\])/)
                         .filter((s) => s.trim() !== '');
                     let id: number = 0;

src/provider/LRCLibLyricsProvider.ts

@@ -0,0 +1,26 @@
+import { LyricsProvider } from './LyricsProvider';
+import { LyricsResult } from './LyricsResult';
+import { LRCLibApi } from '../api/LRCLibApi';
+
+export class LRCLibLyricsProvider implements LyricsProvider {
+    async getLyrics(
+        track_name?: string,
+        artist_name?: string,
+        album_name?: string,
+        duration?: number
+    ): Promise<LyricsResult | null> {
+        const result = await LRCLibApi.get(track_name, artist_name, album_name, duration);
+        if (result.statusCode) {
+            return null;
+        }
+        return {
+            name: result.name,
+            trackName: result.trackName,
+            artistName: result.artistName,
+            albumName: result.albumName,
+            plainLyrics: result.plainLyrics,
+            syncedLyrics: result.syncedLyrics,
+            instrumental: result.instrumental,
+        };
+    }
+}

src/provider/LyricsProvider.ts

@@ -0,0 +1,10 @@
+import { LyricsResult } from './LyricsResult';
+
+export interface LyricsProvider {
+    getLyrics(
+        track_name?: string,
+        artist_name?: string,
+        album_name?: string,
+        duration?: number
+    ): Promise<LyricsResult | null>;
+}

src/provider/LyricsResult.ts

@@ -0,0 +1,9 @@
+export interface LyricsResult {
+    name: string;
+    trackName: string;
+    artistName: string;
+    albumName: string;
+    plainLyrics?: string;
+    syncedLyrics?: string;
+    instrumental?: boolean;
+}