refactor: decouple lyrics providers from synced-lyrics

src/i18n/resources/en.json

@@ -381,6 +381,10 @@
         }
       }
     },
+    "better-fullscreen": {
+      "description": "Enhances the fullscreen experience with lyrics, background effects, and more",
+      "name": "Better Fullscreen"
+    },
     "blur-nav-bar": {
       "description": "Makes navigation bar transparent and blurry",
       "name": "Blur Navigation Bar"
@@ -588,6 +592,20 @@
       },
       "name": "In-App Menu"
     },
+    "lyrics-provider": {
+      "description": "Provides lyrics fetching functionality for other plugins",
+      "menu": {
+        "preferred-provider": {
+          "label": "Preferred Provider",
+          "tooltip": "Choose the default provider to use",
+          "none": {
+            "label": "None",
+            "tooltip": "No preferred provider"
+          }
+        }
+      },
+      "name": "Lyrics Provider"
+    },
     "lumiastream": {
       "description": "Adds Lumia Stream support",
       "name": "Lumia Stream [Beta]"
@@ -830,14 +848,6 @@
         "not-found": "⚠️ No lyrics found for this song."
       },
       "menu": {
-        "preferred-provider": {
-          "label": "Preferred Provider",
-          "tooltip": "Choose the default provider to use",
-          "none": {
-            "label": "None",
-            "tooltip": "No preferred provider"
-          }
-        },
         "default-text-string": {
           "label": "Default character between lyrics",
           "tooltip": "Choose the default character to use for the gap between lyrics"

src/loader/main.ts

@@ -132,14 +132,52 @@ export const forceLoadMainPlugin = async (
   }
 };
 
+const topologicalSort = (plugins: Record<string, PluginDef<unknown, unknown, unknown>>) => {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const order: string[] = [];
+
+  const visit = (id: string) => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      console.warn(`Circular dependency detected involving plugin: ${id}`);
+      return;
+    }
+
+    visiting.add(id);
+    const plugin = plugins[id];
+    if (plugin?.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (plugins[dep]) {
+          visit(dep);
+        } else {
+          console.warn(`Plugin ${id} depends on ${dep} which is not found`);
+        }
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    order.push(id);
+  };
+
+  for (const id of Object.keys(plugins)) {
+    visit(id);
+  }
+
+  return order;
+};
+
 export const loadAllMainPlugins = async (win: BrowserWindow) => {
   console.log(LoggerPrefix, t('common.console.plugins.load-all'));
   const pluginConfigs = config.plugins.getPlugins();
+  const allPluginsMap = await mainPlugins();
+  const sortedPluginIds = topologicalSort(allPluginsMap);
   const queue: Promise<void>[] = [];
 
-  for (const [plugin, pluginDef] of Object.entries(await mainPlugins())) {
-    const config = deepmerge(pluginDef.config, pluginConfigs[plugin] ?? {});
-    if (config.enabled) {
+  for (const plugin of sortedPluginIds) {
+    const pluginDef = allPluginsMap[plugin];
+    const pluginConfig = deepmerge(pluginDef.config, pluginConfigs[plugin] ?? {});
+    if (pluginConfig.enabled) {
       queue.push(forceLoadMainPlugin(plugin, win));
     } else if (loadedPluginMap[plugin]) {
       queue.push(forceUnloadMainPlugin(plugin, win));

src/loader/preload.ts

@@ -82,16 +82,54 @@ export const forceLoadPreloadPlugin = async (id: string) => {
   }
 };
 
+const topologicalSort = (plugins: Record<string, PluginDef<unknown, unknown, unknown>>) => {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const order: string[] = [];
+
+  const visit = (id: string) => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      console.warn(`Circular dependency detected involving plugin: ${id}`);
+      return;
+    }
+
+    visiting.add(id);
+    const plugin = plugins[id];
+    if (plugin?.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (plugins[dep]) {
+          visit(dep);
+        } else {
+          console.warn(`Plugin ${id} depends on ${dep} which is not found`);
+        }
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    order.push(id);
+  };
+
+  for (const id of Object.keys(plugins)) {
+    visit(id);
+  }
+
+  return order;
+};
+
 export const loadAllPreloadPlugins = async () => {
   const pluginConfigs = config.plugins.getPlugins();
+  const allPluginsMap = await preloadPlugins();
+  const sortedPluginIds = topologicalSort(allPluginsMap);
 
-  for (const [pluginId, pluginDef] of Object.entries(await preloadPlugins())) {
-    const config = deepmerge(
+  for (const pluginId of sortedPluginIds) {
+    const pluginDef = allPluginsMap[pluginId];
+    const pluginConfig = deepmerge(
       pluginDef.config ?? { enable: false },
       pluginConfigs[pluginId] ?? {},
     );
 
-    if (config.enabled) {
+    if (pluginConfig.enabled) {
       forceLoadPreloadPlugin(pluginId);
     } else {
       if (loadedPluginMap[pluginId]) {

src/loader/renderer.ts

@@ -114,10 +114,48 @@ export const forceLoadRendererPlugin = async (id: string) => {
   }
 };
 
+const topologicalSort = (plugins: Record<string, PluginDef<unknown, unknown, unknown>>) => {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const order: string[] = [];
+
+  const visit = (id: string) => {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      console.warn(`Circular dependency detected involving plugin: ${id}`);
+      return;
+    }
+
+    visiting.add(id);
+    const plugin = plugins[id];
+    if (plugin?.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (plugins[dep]) {
+          visit(dep);
+        } else {
+          console.warn(`Plugin ${id} depends on ${dep} which is not found`);
+        }
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    order.push(id);
+  };
+
+  for (const id of Object.keys(plugins)) {
+    visit(id);
+  }
+
+  return order;
+};
+
 export const loadAllRendererPlugins = async () => {
   const pluginConfigs = window.mainConfig.plugins.getPlugins();
+  const allPluginsMap = await rendererPlugins();
+  const sortedPluginIds = topologicalSort(allPluginsMap);
 
-  for (const [pluginId, pluginDef] of Object.entries(await rendererPlugins())) {
+  for (const pluginId of sortedPluginIds) {
+    const pluginDef = allPluginsMap[pluginId];
     const config = deepmerge(pluginDef.config, pluginConfigs[pluginId] ?? {});
 
     if (config.enabled) {

src/plugins/lyrics-provider/backend.ts

@@ -0,0 +1,30 @@
+import { net } from 'electron';
+
+import { createBackend } from '@/utils';
+
+const handlers = {
+  // Note: This will only be used for Forbidden headers, e.g. User-Agent, Authority, Cookie, etc.
+  // See: https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_request_header
+  async fetch(
+    url: string,
+    init: RequestInit,
+  ): Promise<[number, string, Record<string, string>]> {
+    const res = await net.fetch(url, init);
+    return [
+      res.status,
+      await res.text(),
+      Object.fromEntries(res.headers.entries()),
+    ];
+  },
+};
+
+export const backend = createBackend({
+  start(ctx) {
+    ctx.ipc.handle('lyrics-provider:fetch', (url: string, init: RequestInit) =>
+      handlers.fetch(url, init),
+    );
+  },
+  stop(ctx) {
+    ctx.ipc.removeHandler('lyrics-provider:fetch');
+  },
+});

src/plugins/lyrics-provider/index.ts

@@ -0,0 +1,20 @@
+import { createPlugin } from '@/utils';
+import { t } from '@/i18n';
+
+import { backend } from './backend';
+import { renderer } from './renderer';
+import { menu } from './menu';
+
+export default createPlugin({
+  name: () => t('plugins.lyrics-provider.name'),
+  description: () => t('plugins.lyrics-provider.description'),
+  restartNeeded: false,
+  config: {
+    enabled: true,
+    preferredProvider: null as string | null,
+  },
+
+  backend,
+  renderer,
+  menu,
+});

src/plugins/lyrics-provider/menu.ts

@@ -0,0 +1,44 @@
+import { t } from '@/i18n';
+
+import { providerNames } from './providers';
+
+import type { MenuItemConstructorOptions } from 'electron';
+import type { MenuContext } from '@/types/contexts';
+
+export const menu = async (
+  ctx: MenuContext,
+): Promise<MenuItemConstructorOptions[]> => {
+  const config = await ctx.getConfig();
+
+  return [
+    {
+      label: t('plugins.lyrics-provider.menu.preferred-provider.label'),
+      toolTip: t('plugins.lyrics-provider.menu.preferred-provider.tooltip'),
+      type: 'submenu',
+      submenu: [
+        {
+          label: t('plugins.lyrics-provider.menu.preferred-provider.none.label'),
+          toolTip: t(
+            'plugins.lyrics-provider.menu.preferred-provider.none.tooltip',
+          ),
+          type: 'radio',
+          checked: config.preferredProvider === null,
+          click() {
+            ctx.setConfig({ preferredProvider: null });
+          },
+        },
+        ...providerNames.map(
+          (provider) =>
+            ({
+              label: provider,
+              type: 'radio',
+              checked: config.preferredProvider === provider,
+              click() {
+                ctx.setConfig({ preferredProvider: provider });
+              },
+            }) as const,
+        ),
+      ],
+    },
+  ];
+};

src/plugins/synced-lyrics/providers/LRCLib.ts → src/plugins/lyrics-provider/providers/LRCLib.ts

@@ -1,6 +1,7 @@
 import { jaroWinkler } from '@skyra/jaro-winkler';
 
 import { config } from '../renderer/renderer';
+import { netFetch } from '../renderer';
 import { LRC } from '../parsers/lrc';
 
 import type { LyricProvider, LyricResult, SearchSongInfo } from '../types';
@@ -28,13 +29,13 @@ export class LRCLib implements LyricProvider {
     }
 
     let url = `${this.baseUrl}/api/search?${query.toString()}`;
-    let response = await fetch(url);
+    let [status, text] = await netFetch(url);
 
-    if (!response.ok) {
-      throw new Error(`bad HTTPStatus(${response.statusText})`);
+    if (status < 200 || status >= 300) {
+      throw new Error(`bad HTTPStatus(${status})`);
     }
 
-    let data = (await response.json()) as LRCLIBSearchResponse;
+    let data = JSON.parse(text) as LRCLIBSearchResponse;
     if (!data || !Array.isArray(data)) {
       throw new Error(`Expected an array, instead got ${typeof data}`);
     }
@@ -49,12 +50,12 @@ export class LRCLib implements LyricProvider {
       query = new URLSearchParams({ q: `${trackName}` });
       url = `${this.baseUrl}/api/search?${query.toString()}`;
 
-      response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`bad HTTPStatus(${response.statusText})`);
+      [status, text] = await netFetch(url);
+      if (status < 200 || status >= 300) {
+        throw new Error(`bad HTTPStatus(${status})`);
       }
 
-      data = (await response.json()) as LRCLIBSearchResponse;
+      data = JSON.parse(text) as LRCLIBSearchResponse;
       if (!Array.isArray(data)) {
         throw new Error(`Expected an array, instead got ${typeof data}`);
       }
@@ -64,12 +65,12 @@ export class LRCLib implements LyricProvider {
         query = new URLSearchParams({ q: title });
         url = `${this.baseUrl}/api/search?${query.toString()}`;
 
-        response = await fetch(url);
-        if (!response.ok) {
-          throw new Error(`bad HTTPStatus(${response.statusText})`);
+        [status, text] = await netFetch(url);
+        if (status < 200 || status >= 300) {
+          throw new Error(`bad HTTPStatus(${status})`);
         }
 
-        data = (await response.json()) as LRCLIBSearchResponse;
+        data = JSON.parse(text) as LRCLIBSearchResponse;
         if (!Array.isArray(data)) {
           throw new Error(`Expected an array, instead got ${typeof data}`);
         }