Add missing sidebar configuration

- Fix add next behavior when shuffle is enabled
- Fix shuffled queue when songs are removed from queue
- Fix queue indices when currently playing song is removed
- Re-shuffle queue after queue is finished when shuffle is enabled

.github/FUNDING.yml

@@ -1 +1,3 @@
 # These are supported funding model platforms
+
+ko_fi: jeffvli

.github/ISSUE_TEMPLATE/1-Bug_report.md

@@ -4,18 +4,6 @@ about: You're having technical issues. 🐞
 labels: 'bug'
 ---
 
-<!-- Please use the following issue template or your issue will be closed -->
-
-## Prerequisites
-
-<!-- If the following boxes are not ALL checked, your issue is likely to be closed -->
-
-- [ ] Using npm
-- [ ] Using an up-to-date [`main` branch](https://github.com/electron-react-boilerplate/electron-react-boilerplate/tree/main)
-- [ ] Using latest version of devtools. [Check the docs for how to update](https://electron-react-boilerplate.js.org/docs/dev-tools/)
-- [ ] Tried solutions mentioned in [#400](https://github.com/electron-react-boilerplate/electron-react-boilerplate/issues/400)
-- [ ] For issue in production release, add devtools output of `DEBUG_PROD=true npm run build && npm start`
-
 ## Expected Behavior
 
 <!--- What should have happened? -->
@@ -23,6 +11,8 @@ labels: 'bug'
 ## Current Behavior
 
 <!--- What went wrong? -->
+<!-- Add screenshots to help explain your problem -->
+<!-- (Open the browser dev tools in the menu or using CTRL + SHIFT + I) -->
 
 ## Steps to Reproduce
 
@@ -44,24 +34,12 @@ labels: 'bug'
 ## Context
 
 <!--- How has this issue affected you? What are you trying to accomplish? -->
-<!--- Did you make any changes to the boilerplate after cloning it? -->
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
 
 ## Your Environment
 
 <!--- Include as many relevant details about the environment you experienced the bug in -->
 
-- Node version :
-- electron-react-boilerplate version or branch :
-- Operating System and version :
-- Link to your project :
-
-<!---
-❗️❗️ Also, please consider donating (https://opencollective.com/electron-react-boilerplate-594) ❗️❗️
-
-Donations will ensure the following:
-
-🔨 Long term maintenance of the project
-🛣 Progress on the roadmap
-🐛 Quick responses to bug reports and help requests
- -->
+- Application version (e.g. v0.1.0) :
+- Operating System and version (e.g. Windows 10) :
+- Server and version (e.g. Navidrome v0.48.0) :
+- Node version (if developing locally) :

.github/ISSUE_TEMPLATE/2-Question.md

@@ -4,16 +4,6 @@ about: Ask a question.❓
 labels: 'question'
 ---
 
-## Summary
-
-<!-- What do you need help with? -->
-
-<!---
-❗️❗️ Also, please consider donating (https://opencollective.com/electron-react-boilerplate-594) ❗️❗️
-
-Donations will ensure the following:
-
-🔨 Long term maintenance of the project
-🛣 Progress on the roadmap
-🐛 Quick responses to bug reports and help requests
- -->
+<!-- Question issues will be closed. -->
+<!-- Ask questions in the discussions tab: Please use discussions https://github.com/jeffvli/feishin/discussions -->
+<!-- Or join the Discord/Matrix servers: https://discord.gg/FVKpcMDy5f https://matrix.to/#/#sonixd:matrix.org -->

.github/ISSUE_TEMPLATE/3-Feature_request.md

@@ -1,15 +1,11 @@
 ---
 name: Feature request
-about: You want something added to the boilerplate. 🎉
+about: Request a feature to be added to Feishin 🎉
 labels: 'enhancement'
 ---
 
-<!---
-❗️❗️ Also, please consider donating (https://opencollective.com/electron-react-boilerplate-594) ❗️❗️
+## What do you want to be added?
 
-Donations will ensure the following:
+## Additional context
 
-🔨 Long term maintenance of the project
-🛣 Progress on the roadmap
-🐛 Quick responses to bug reports and help requests
- -->
+<!-- Is this a server-specific feature? (e.g. Jellyfin only). -->

.github/workflows/publish-linux.yml

@@ -0,0 +1,39 @@
+name: Publish Linux (Manual)
+
+on: workflow_dispatch
+
+jobs:
+  publish:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+
+    steps:
+      - name: Checkout git repo
+        uses: actions/checkout@v1
+
+      - name: Install Node and NPM
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16
+          cache: npm
+
+      - name: Install dependencies
+        run: |
+          npm install --legacy-peer-deps
+
+      - name: Publish releases
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        uses: nick-invision/retry@v2.8.2
+        with:
+          timeout_minutes: 30
+          max_attempts: 3
+          retry_on: error
+          command: |
+            npm run postinstall
+            npm run build
+            npm exec electron-builder -- --publish always --linux
+          on_retry_command: npm cache clean --force

.github/workflows/publish-macos.yml

@@ -1,4 +1,4 @@
-name: Publish (Manual)
+name: Publish Windows and macOS (Manual)
 
 on: workflow_dispatch
 
@@ -35,5 +35,5 @@ jobs:
           command: |
             npm run postinstall
             npm run build
-            npm exec electron-builder -- --publish always --win --mac --linux
+            npm exec electron-builder -- --publish always --win --mac
           on_retry_command: npm cache clean --force

.github/workflows/publish-pr-comment.yml

@@ -0,0 +1,54 @@
+name: Comment on pull request
+on:
+  workflow_run:
+    workflows: ['Publish (PR)']
+    types: [completed]
+jobs:
+  pr_comment:
+    if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          # This snippet is public-domain, taken from
+          # https://github.com/oprypin/nightly.link/blob/master/.github/workflows/pr-comment.yml
+          script: |
+            async function upsertComment(owner, repo, issue_number, purpose, body) {
+              const {data: comments} = await github.rest.issues.listComments(
+                {owner, repo, issue_number});
+              const marker = `<!-- bot: ${purpose} -->`;
+              body = marker + "\n" + body;
+              const existing = comments.filter((c) => c.body.includes(marker));
+              if (existing.length > 0) {
+                const last = existing[existing.length - 1];
+                core.info(`Updating comment ${last.id}`);
+                await github.rest.issues.updateComment({
+                  owner, repo,
+                  body,
+                  comment_id: last.id,
+                });
+              } else {
+                core.info(`Creating a comment in issue / PR #${issue_number}`);
+                await github.rest.issues.createComment({issue_number, body, owner, repo});
+              }
+            }
+            const {owner, repo} = context.repo;
+            const run_id = ${{github.event.workflow_run.id}};
+            const pull_requests = ${{ toJSON(github.event.workflow_run.pull_requests) }};
+            if (!pull_requests.length) {
+              return core.error("This workflow doesn't match any pull requests!");
+            }
+            const artifacts = await github.paginate(
+              github.rest.actions.listWorkflowRunArtifacts, {owner, repo, run_id});
+            if (!artifacts.length) {
+              return core.error(`No artifacts found`);
+            }
+            let body = `Download the artifacts for this pull request:\n`;
+            for (const art of artifacts) {
+              body += `\n* [${art.name}.zip](https://nightly.link/${owner}/${repo}/actions/artifacts/${art.id}.zip)`;
+            }
+            core.info("Review thread message body:", body);
+            for (const pr of pull_requests) {
+              await upsertComment(owner, repo, pr.number,
+                "nightly-link", body);
+            }

.github/workflows/publish-pr.yml

@@ -0,0 +1,60 @@
+name: Publish (PR)
+
+on:
+  pull_request:
+    branches:
+      - development
+
+jobs:
+  publish:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [macos-latest]
+
+    steps:
+      - name: Checkout git repo
+        uses: actions/checkout@v3
+
+      - name: Install Node and NPM
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          cache: npm
+
+      - name: Install dependencies
+        run: |
+          npm install --legacy-peer-deps
+
+      - name: Build releases
+        uses: nick-invision/retry@v2.8.2
+        with:
+          timeout_minutes: 30
+          max_attempts: 3
+          retry_on: error
+          command: |
+            npm run postinstall
+            npm run build
+            npm run package:pr
+          on_retry_command: npm cache clean --force
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: windows-binaries
+          path: |
+            release/build/*.exe
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: linux-binaries
+          path: |
+            release/build/*.AppImage
+            release/build/*.deb
+            release/build/*.rpm
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: macos-binaries
+          path: |
+            release/build/*.dmg

README.md

@@ -25,29 +25,46 @@
     </a>
   </p>
 
-Repository for the rewrite of [Sonixd](https://github.com/jeffvli/sonixd).
+Rewrite of [Sonixd](https://github.com/jeffvli/sonixd).
+
+## Features
+
+- [x] MPV player backend
+- [x] Web player backend
+- [x] Modern UI
+- [x] Scrobble playback to your server
+- [x] Smart playlist editor (Navidrome)
+- [x] Synchronized and unsynchronized lyrics support
+- [ ] [Request a feature](https://github.com/jeffvli/feishin/issues) or [view taskboard](https://github.com/users/jeffvli/projects/5/views/1)
+
+## Screenshots
+
+<a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_full_screen_player.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_full_screen_player.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_artist_detail.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_artist_detail.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_detail.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_detail.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_smart_playlist.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_smart_playlist.png" width="49.5%"/></a>
 
 ## Getting Started
 
 Download the [latest desktop client](https://github.com/jeffvli/feishin/releases).
 
-### After installing the server and database
+If you're using an M1 macOS device, [check here](https://github.com/jeffvli/feishin/issues/104#issuecomment-1553914730) for instructions on how to remove the app from quarantine.
 
-You can access the desktop client via the [latest release](https://github.com/jeffvli/feishin/releases), or you can visit the web client at your server URL (e.g http://192.168.0.1:8643).
+### Configuration
+
+1. Upon startup you will be greeted with a prompt to select the path to your MPV binary. If you do not have MPV installed, you can download it [here](https://mpv.io/installation/) or install it using any package manager supported by your OS. After inputting the path, restart the app.
+
+2. After restarting the app, you will be prompted to select a server. Click the `Open menu` button and select `Manage servers`. Click the `Add server` button in the popup and fill out all applicable details. You will need to enter the full URL to your server, including the protocol and port if applicable (e.g. `https://navidrome.my-server.com` or `http://192.168.0.1:4533`).
+
+- **Navidrome** - For the best experience, select "Save password" when creating the server and configure the `SessionTimeout` setting in your Navidrome config to a larger value (e.g. 72h).
 
 ## FAQ
 
 ### What music servers does Feishin support?
 
-Feishin supports any music server that implements a [Navidrome](https://www.navidrome.org/) or [Jellyfin](https://jellyfin.org/) API.
+Feishin supports any music server that implements a [Navidrome](https://www.navidrome.org/) or [Jellyfin](https://jellyfin.org/) API. **Subsonic API is not currently supported**. This will likely be added in [later when the new Subsonic API is decided on](https://support.symfonium.app/t/subsonic-servers-participation/1233).
 
-- [Jellyfin](https://github.com/jellyfin/jellyfin)
 - [Navidrome](https://github.com/navidrome/navidrome)
-- ~~[Airsonic](https://github.com/airsonic/airsonic)~~
-- ~~[Airsonic-Advanced](https://github.com/airsonic-advanced/airsonic-advanced)~~
-- ~~[Gonic](https://github.com/sentriz/gonic)~~
-- ~~[Astiga](https://asti.ga/)~~
-- ~~[Supysonic](https://github.com/spl0k/supysonic)~~
+- [Jellyfin](https://github.com/jellyfin/jellyfin)
+- [Funkwhale](https://funkwhale.audio/) - TBD
+- Subsonic-compatible servers - TBD
 
 ## Development
 

package.json

@@ -2,7 +2,7 @@
   "name": "feishin",
   "productName": "Feishin",
   "description": "Feishin music server",
-  "version": "0.0.1-alpha3",
+  "version": "0.2.0",
   "scripts": {
     "build": "concurrently \"npm run build:main\" \"npm run build:renderer\"",
     "build:main": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.main.prod.ts",
@@ -11,6 +11,7 @@
     "lint": "cross-env NODE_ENV=development eslint . --ext .js,.jsx,.ts,.tsx",
     "lint:styles": "npx stylelint **/*.tsx",
     "package": "ts-node ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never",
+    "package:pr": "ts-node ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --win --mac --linux",
     "package:dev": "ts-node ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --dir",
     "postinstall": "ts-node .erb/scripts/check-native-dep.js && electron-builder install-app-deps && cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.renderer.dev.dll.ts",
     "start": "ts-node ./.erb/scripts/check-port-in-use.js && npm run start:renderer",
@@ -50,6 +51,7 @@
       "package.json"
     ],
     "afterSign": ".erb/scripts/notarize.js",
+    "electronVersion": "22.3.1",
     "mac": {
       "target": {
         "target": "default",
@@ -157,6 +159,7 @@
     ]
   },
   "devDependencies": {
+    "@electron/rebuild": "^3.2.10",
     "@pmmmwh/react-refresh-webpack-plugin": "0.5.5",
     "@stylelint/postcss-css-in-js": "^0.38.0",
     "@teamsupercell/typings-for-css-modules-loader": "^2.5.1",
@@ -169,7 +172,6 @@
     "@types/node": "^17.0.23",
     "@types/react": "^18.0.25",
     "@types/react-dom": "^18.0.8",
-    "@types/react-slider": "^1.3.1",
     "@types/react-test-renderer": "^17.0.1",
     "@types/react-virtualized-auto-sizer": "^1.0.1",
     "@types/react-window": "^1.8.5",
@@ -188,11 +190,10 @@
     "css-loader": "^6.7.1",
     "css-minimizer-webpack-plugin": "^3.4.1",
     "detect-port": "^1.3.0",
-    "electron": "^21.2.0",
-    "electron-builder": "^23.0.3",
+    "electron": "^22.3.1",
+    "electron-builder": "^24.0.0-alpha.13",
     "electron-devtools-installer": "^3.2.0",
     "electron-notarize": "^1.2.1",
-    "electron-rebuild": "^3.2.7",
     "electronmon": "^2.0.2",
     "eslint": "^8.30.0",
     "eslint-config-airbnb-base": "^15.0.0",
@@ -253,52 +254,54 @@
     "@ag-grid-community/react": "^28.2.1",
     "@ag-grid-community/styles": "^28.2.1",
     "@emotion/react": "^11.10.4",
-    "@mantine/core": "^5.9.5",
-    "@mantine/dates": "^5.9.5",
-    "@mantine/dropzone": "^5.9.5",
-    "@mantine/form": "^5.9.5",
-    "@mantine/hooks": "^5.9.5",
-    "@mantine/modals": "^5.9.5",
-    "@mantine/notifications": "^5.9.5",
-    "@mantine/spotlight": "^5.9.5",
-    "@tanstack/react-query": "^4.16.1",
-    "@tanstack/react-query-devtools": "^4.16.1",
+    "@mantine/core": "^6.0.13",
+    "@mantine/dates": "^6.0.13",
+    "@mantine/form": "^6.0.13",
+    "@mantine/hooks": "^6.0.13",
+    "@mantine/modals": "^6.0.13",
+    "@mantine/notifications": "^6.0.13",
+    "@mantine/utils": "^6.0.13",
+    "@tanstack/react-query": "^4.29.5",
+    "@tanstack/react-query-devtools": "^4.29.6",
+    "@ts-rest/core": "^3.23.0",
+    "axios": "^1.4.0",
+    "cmdk": "^0.2.0",
     "dayjs": "^1.11.6",
     "electron-debug": "^3.2.0",
     "electron-localshortcut": "^3.2.1",
     "electron-log": "^4.4.6",
     "electron-store": "^8.1.0",
     "electron-updater": "^4.6.5",
-    "fast-average-color": "^9.2.0",
+    "fast-average-color": "^9.3.0",
     "format-duration": "^2.0.0",
-    "framer-motion": "^8.1.3",
+    "framer-motion": "^9.1.7",
+    "fuse.js": "^6.6.2",
     "history": "^5.3.0",
     "i18next": "^21.6.16",
-    "immer": "^9.0.15",
-    "is-electron": "^2.2.1",
-    "ky": "^0.33.0",
+    "immer": "^9.0.21",
+    "is-electron": "^2.2.2",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "memoize-one": "^6.0.0",
     "nanoid": "^3.3.3",
     "net": "^1.0.2",
-    "node-mpv": "^2.0.0-beta.2",
+    "node-mpv": "github:jeffvli/Node-MPV",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-error-boundary": "^3.1.4",
     "react-i18next": "^11.16.7",
-    "react-icons": "^4.7.1",
+    "react-icons": "^4.8.0",
     "react-player": "^2.11.0",
     "react-router": "^6.5.0",
     "react-router-dom": "^6.5.0",
     "react-simple-img": "^3.0.0",
-    "react-slider": "^2.0.4",
-    "react-virtualized-auto-sizer": "^1.0.6",
-    "react-window": "^1.8.8",
-    "react-window-infinite-loader": "^1.0.8",
-    "styled-components": "^5.3.6",
-    "zod": "^3.19.1",
-    "zustand": "^4.1.4"
+    "react-virtualized-auto-sizer": "^1.0.17",
+    "react-window": "^1.8.9",
+    "react-window-infinite-loader": "^1.0.9",
+    "styled-components": "^5.3.11",
+    "swiper": "^9.3.1",
+    "zod": "^3.21.4",
+    "zustand": "^4.3.8"
   },
   "resolutions": {
     "styled-components": "^5"

release/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feishin",
-  "version": "0.0.1-alpha3",
+  "version": "0.2.0",
   "description": "",
   "main": "./dist/main/main.js",
   "author": {
@@ -12,6 +12,12 @@
     "link-modules": "node -r ts-node/register ../../.erb/scripts/link-modules.ts",
     "postinstall": "npm run electron-rebuild && npm run link-modules"
   },
-  "dependencies": {},
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12",
+    "mpris-service": "^2.1.2"
+  },
+  "devDependencies": {
+    "electron": "22.3.1"
+  },
   "license": "GPL-3.0"
 }

src/main/features/core/index.ts

@@ -1,2 +1,3 @@
+import './lyrics';
 import './player';
 import './settings';

src/main/features/core/lyrics/genius.ts

@@ -0,0 +1,209 @@
+import axios, { AxiosResponse } from 'axios';
+import { load } from 'cheerio';
+import {
+  LyricSource,
+  InternetProviderLyricResponse,
+  InternetProviderLyricSearchResponse,
+  LyricSearchQuery,
+} from '../../../../renderer/api/types';
+import { orderSearchResults } from './shared';
+
+const SEARCH_URL = 'https://genius.com/api/search/song';
+
+// Adapted from https://github.com/NyaomiDEV/Sunamu/blob/master/src/main/lyricproviders/genius.ts
+
+export interface GeniusResponse {
+  meta: Meta;
+  response: Response;
+}
+
+export interface Meta {
+  status: number;
+}
+
+export interface Response {
+  next_page: number;
+  sections: Section[];
+}
+
+export interface Section {
+  hits: Hit[];
+  type: string;
+}
+
+export interface Hit {
+  highlights: any[];
+  index: string;
+  result: Result;
+  type: string;
+}
+
+export interface Result {
+  _type: string;
+  annotation_count: number;
+  api_path: string;
+  artist_names: string;
+  featured_artists: any[];
+  full_title: string;
+  header_image_thumbnail_url: string;
+  header_image_url: string;
+  id: number;
+  instrumental: boolean;
+  language: string;
+  lyrics_owner_id: number;
+  lyrics_state: string;
+  lyrics_updated_at: number;
+  path: string;
+  primary_artist: PrimaryArtist;
+  pyongs_count: null;
+  relationships_index_url: string;
+  release_date_components: ReleaseDateComponents;
+  release_date_for_display: string;
+  release_date_with_abbreviated_month_for_display: string;
+  song_art_image_thumbnail_url: string;
+  song_art_image_url: string;
+  stats: Stats;
+  title: string;
+  title_with_featured: string;
+  updated_by_human_at: number;
+  url: string;
+}
+
+export interface PrimaryArtist {
+  _type: string;
+  api_path: string;
+  header_image_url: string;
+  id: number;
+  image_url: string;
+  index_character: string;
+  is_meme_verified: boolean;
+  is_verified: boolean;
+  name: string;
+  slug: string;
+  url: string;
+}
+
+export interface ReleaseDateComponents {
+  day: number;
+  month: number;
+  year: number;
+}
+
+export interface Stats {
+  hot: boolean;
+  unreviewed_annotations: number;
+}
+
+export async function getSearchResults(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricSearchResponse[] | null> {
+  let result: AxiosResponse<GeniusResponse>;
+
+  const searchQuery = [params.artist, params.name].join(' ');
+
+  if (!searchQuery) {
+    return null;
+  }
+
+  try {
+    result = await axios.get(SEARCH_URL, {
+      params: {
+        per_page: '5',
+        q: searchQuery,
+      },
+    });
+  } catch (e) {
+    console.error('Genius search request got an error!', e);
+    return null;
+  }
+
+  const rawSongsResult = result.data.response?.sections?.[0]?.hits?.map((hit) => hit.result);
+
+  if (!rawSongsResult) return null;
+
+  const songResults: InternetProviderLyricSearchResponse[] = rawSongsResult.map((song) => {
+    return {
+      artist: song.artist_names,
+      id: song.url,
+      name: song.full_title,
+      source: LyricSource.GENIUS,
+    };
+  });
+
+  return orderSearchResults({ params, results: songResults });
+}
+
+async function getSongId(
+  params: LyricSearchQuery,
+): Promise<Omit<InternetProviderLyricResponse, 'lyrics'> | null> {
+  let result: AxiosResponse<GeniusResponse>;
+  try {
+    result = await axios.get(SEARCH_URL, {
+      params: {
+        per_page: '1',
+        q: `${params.artist} ${params.name}`,
+      },
+    });
+  } catch (e) {
+    console.error('Genius search request got an error!', e);
+    return null;
+  }
+
+  const hit = result.data.response?.sections?.[0]?.hits?.[0]?.result;
+
+  if (!hit) {
+    return null;
+  }
+
+  return {
+    artist: hit.artist_names,
+    id: hit.url,
+    name: hit.full_title,
+    source: LyricSource.GENIUS,
+  };
+}
+
+export async function getLyricsBySongId(url: string): Promise<string | null> {
+  let result: AxiosResponse<string, any>;
+  try {
+    result = await axios.get<string>(url, { responseType: 'text' });
+  } catch (e) {
+    console.error('Genius lyrics request got an error!', e);
+    return null;
+  }
+
+  const $ = load(result.data.split('<br/>').join('\n'));
+  const lyricsDiv = $('div.lyrics');
+
+  if (lyricsDiv.length > 0) return lyricsDiv.text().trim();
+
+  const lyricSections = $('div[class^=Lyrics__Container]')
+    .map((_, e) => $(e).text())
+    .toArray()
+    .join('\n');
+  return lyricSections;
+}
+
+export async function query(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricResponse | null> {
+  const response = await getSongId(params);
+  if (!response) {
+    console.error('Could not find the song on Genius!');
+    return null;
+  }
+
+  const lyrics = await getLyricsBySongId(response.id);
+  if (!lyrics) {
+    console.error('Could not get lyrics on Genius!');
+    return null;
+  }
+
+  return {
+    artist: response.artist,
+    id: response.id,
+    lyrics,
+    name: response.name,
+    source: LyricSource.GENIUS,
+  };
+}

src/main/features/core/lyrics/index.ts

@@ -0,0 +1,149 @@
+import { ipcMain } from 'electron';
+import {
+  InternetProviderLyricResponse,
+  InternetProviderLyricSearchResponse,
+  LyricSearchQuery,
+  QueueSong,
+  LyricGetQuery,
+  LyricSource,
+} from '../../../../renderer/api/types';
+import { store } from '../settings/index';
+import {
+  query as queryGenius,
+  getSearchResults as searchGenius,
+  getLyricsBySongId as getGenius,
+} from './genius';
+import {
+  query as queryLrclib,
+  getSearchResults as searchLrcLib,
+  getLyricsBySongId as getLrcLib,
+} from './lrclib';
+import {
+  query as queryNetease,
+  getSearchResults as searchNetease,
+  getLyricsBySongId as getNetease,
+} from './netease';
+
+type SongFetcher = (params: LyricSearchQuery) => Promise<InternetProviderLyricResponse | null>;
+type SearchFetcher = (
+  params: LyricSearchQuery,
+) => Promise<InternetProviderLyricSearchResponse[] | null>;
+type GetFetcher = (id: string) => Promise<string | null>;
+
+type CachedLyrics = Record<LyricSource, InternetProviderLyricResponse>;
+
+const FETCHERS: Record<LyricSource, SongFetcher> = {
+  [LyricSource.GENIUS]: queryGenius,
+  [LyricSource.LRCLIB]: queryLrclib,
+  [LyricSource.NETEASE]: queryNetease,
+};
+
+const SEARCH_FETCHERS: Record<LyricSource, SearchFetcher> = {
+  [LyricSource.GENIUS]: searchGenius,
+  [LyricSource.LRCLIB]: searchLrcLib,
+  [LyricSource.NETEASE]: searchNetease,
+};
+
+const GET_FETCHERS: Record<LyricSource, GetFetcher> = {
+  [LyricSource.GENIUS]: getGenius,
+  [LyricSource.LRCLIB]: getLrcLib,
+  [LyricSource.NETEASE]: getNetease,
+};
+
+const MAX_CACHED_ITEMS = 10;
+
+const lyricCache = new Map<string, CachedLyrics>();
+
+const getRemoteLyrics = async (song: QueueSong) => {
+  const sources = store.get('lyrics', []) as LyricSource[];
+
+  const cached = lyricCache.get(song.id);
+
+  if (cached) {
+    for (const source of sources) {
+      const data = cached[source];
+      if (data) return data;
+    }
+  }
+
+  let lyricsFromSource = null;
+
+  for (const source of sources) {
+    const params = {
+      album: song.album || song.name,
+      artist: song.artistName,
+      duration: song.duration,
+      name: song.name,
+    };
+    const response = await FETCHERS[source](params);
+
+    if (response) {
+      const newResult = cached
+        ? {
+            ...cached,
+            [source]: response,
+          }
+        : ({ [source]: response } as CachedLyrics);
+
+      if (lyricCache.size === MAX_CACHED_ITEMS && cached === undefined) {
+        const toRemove = lyricCache.keys().next().value;
+        lyricCache.delete(toRemove);
+      }
+
+      lyricCache.set(song.id, newResult);
+
+      lyricsFromSource = response;
+      break;
+    }
+  }
+
+  return lyricsFromSource;
+};
+
+const searchRemoteLyrics = async (params: LyricSearchQuery) => {
+  const sources = store.get('lyrics', []) as LyricSource[];
+
+  const results: Record<LyricSource, InternetProviderLyricSearchResponse[]> = {
+    [LyricSource.GENIUS]: [],
+    [LyricSource.LRCLIB]: [],
+    [LyricSource.NETEASE]: [],
+  };
+
+  for (const source of sources) {
+    const response = await SEARCH_FETCHERS[source](params);
+
+    if (response) {
+      response.forEach((result) => {
+        results[source].push(result);
+      });
+    }
+  }
+
+  return results;
+};
+
+const getRemoteLyricsById = async (params: LyricGetQuery): Promise<string | null> => {
+  const { remoteSongId, remoteSource } = params;
+  const response = await GET_FETCHERS[remoteSource](remoteSongId);
+
+  if (!response) {
+    return null;
+  }
+
+  return response;
+};
+
+ipcMain.handle('lyric-by-song', async (_event, song: QueueSong) => {
+  const lyric = await getRemoteLyrics(song);
+  return lyric;
+});
+
+ipcMain.handle('lyric-search', async (_event, params: LyricSearchQuery) => {
+  const lyricResults = await searchRemoteLyrics(params);
+  return lyricResults;
+});
+
+ipcMain.handle('lyric-by-remote-id', async (_event, params: LyricGetQuery) => {
+  const lyricResults = await getRemoteLyricsById(params);
+  return lyricResults;
+});

src/main/features/core/lyrics/lrclib.ts

@@ -0,0 +1,119 @@
+// Credits to https://github.com/tranxuanthang/lrcget for API implementation
+import axios, { AxiosResponse } from 'axios';
+import {
+  InternetProviderLyricResponse,
+  InternetProviderLyricSearchResponse,
+  LyricSearchQuery,
+  LyricSource,
+} from '../../../../renderer/api/types';
+import { orderSearchResults } from './shared';
+
+const FETCH_URL = 'https://lrclib.net/api/get';
+const SEEARCH_URL = 'https://lrclib.net/api/search';
+
+const TIMEOUT_MS = 5000;
+
+export interface LrcLibSearchResponse {
+  albumName: string;
+  artistName: string;
+  id: number;
+  name: string;
+}
+
+export interface LrcLibTrackResponse {
+  albumName: string;
+  artistName: string;
+  duration: number;
+  id: number;
+  instrumental: boolean;
+  isrc: string;
+  lang: string;
+  name: string;
+  plainLyrics: string | null;
+  releaseDate: string;
+  spotifyId: string;
+  syncedLyrics: string | null;
+}
+
+export async function getSearchResults(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricSearchResponse[] | null> {
+  let result: AxiosResponse<LrcLibSearchResponse[]>;
+
+  if (!params.name) {
+    return null;
+  }
+
+  try {
+    result = await axios.get<LrcLibSearchResponse[]>(SEEARCH_URL, {
+      params: {
+        q: params.name,
+      },
+    });
+  } catch (e) {
+    console.error('LrcLib search request got an error!', e);
+    return null;
+  }
+
+  if (!result.data) return null;
+
+  const songResults: InternetProviderLyricSearchResponse[] = result.data.map((song) => {
+    return {
+      artist: song.artistName,
+      id: String(song.id),
+      name: song.name,
+      source: LyricSource.LRCLIB,
+    };
+  });
+
+  return orderSearchResults({ params, results: songResults });
+}
+
+export async function getLyricsBySongId(songId: string): Promise<string | null> {
+  let result: AxiosResponse<LrcLibTrackResponse, any>;
+
+  try {
+    result = await axios.get<LrcLibTrackResponse>(`${FETCH_URL}/${songId}`);
+  } catch (e) {
+    console.error('LrcLib lyrics request got an error!', e);
+    return null;
+  }
+
+  return result.data.syncedLyrics || result.data.plainLyrics || null;
+}
+
+export async function query(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricResponse | null> {
+  let result: AxiosResponse<LrcLibTrackResponse, any>;
+
+  try {
+    result = await axios.get<LrcLibTrackResponse>(FETCH_URL, {
+      params: {
+        album_name: params.album,
+        artist_name: params.artist,
+        duration: params.duration,
+        track_name: params.name,
+      },
+      timeout: TIMEOUT_MS,
+    });
+  } catch (e) {
+    console.error('LrcLib search request got an error!', e);
+    return null;
+  }
+
+  const lyrics = result.data.syncedLyrics || result.data.plainLyrics || null;
+
+  if (!lyrics) {
+    console.error(`Could not get lyrics on LrcLib!`);
+    return null;
+  }
+
+  return {
+    artist: result.data.artistName,
+    id: String(result.data.id),
+    lyrics,
+    name: result.data.name,
+    source: LyricSource.LRCLIB,
+  };
+}

src/main/features/core/lyrics/netease.ts

@@ -0,0 +1,167 @@
+import axios, { AxiosResponse } from 'axios';
+import { LyricSource } from '../../../../renderer/api/types';
+import { orderSearchResults } from './shared';
+import type {
+  InternetProviderLyricResponse,
+  InternetProviderLyricSearchResponse,
+  LyricSearchQuery,
+} from '/@/renderer/api/types';
+
+const SEARCH_URL = 'https://music.163.com/api/search/get';
+const LYRICS_URL = 'https://music.163.com/api/song/lyric';
+
+// Adapted from https://github.com/NyaomiDEV/Sunamu/blob/master/src/main/lyricproviders/netease.ts
+
+export interface NetEaseResponse {
+  code: number;
+  result: Result;
+}
+
+export interface Result {
+  hasMore: boolean;
+  songCount: number;
+  songs: Song[];
+}
+
+export interface Song {
+  album: Album;
+  alias: string[];
+  artists: Artist[];
+  copyrightId: number;
+  duration: number;
+  fee: number;
+  ftype: number;
+  id: number;
+  mark: number;
+  mvid: number;
+  name: string;
+  rUrl: null;
+  rtype: number;
+  status: number;
+  transNames?: string[];
+}
+
+export interface Album {
+  artist: Artist;
+  copyrightId: number;
+  id: number;
+  mark: number;
+  name: string;
+  picId: number;
+  publishTime: number;
+  size: number;
+  status: number;
+  transNames?: string[];
+}
+
+export interface Artist {
+  albumSize: number;
+  alias: any[];
+  fansGroup: null;
+  id: number;
+  img1v1: number;
+  img1v1Url: string;
+  name: string;
+  picId: number;
+  picUrl: null;
+  trans: null;
+}
+
+export async function getSearchResults(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricSearchResponse[] | null> {
+  let result: AxiosResponse<NetEaseResponse>;
+
+  const searchQuery = [params.artist, params.name].join(' ');
+
+  if (!searchQuery) {
+    return null;
+  }
+
+  try {
+    result = await axios.get(SEARCH_URL, {
+      params: {
+        limit: 5,
+        offset: 0,
+        s: searchQuery,
+        type: '1',
+      },
+    });
+  } catch (e) {
+    console.error('NetEase search request got an error!', e);
+    return null;
+  }
+
+  const rawSongsResult = result?.data.result?.songs;
+
+  if (!rawSongsResult) return null;
+
+  const songResults: InternetProviderLyricSearchResponse[] = rawSongsResult.map((song) => {
+    const artist = song.artists ? song.artists.map((artist) => artist.name).join(', ') : '';
+
+    return {
+      artist,
+      id: String(song.id),
+      name: song.name,
+      source: LyricSource.NETEASE,
+    };
+  });
+
+  return orderSearchResults({ params, results: songResults });
+}
+
+async function getMatchedLyrics(
+  params: LyricSearchQuery,
+): Promise<Omit<InternetProviderLyricResponse, 'lyrics'> | null> {
+  const results = await getSearchResults(params);
+
+  const firstMatch = results?.[0];
+
+  if (!firstMatch || (firstMatch?.score && firstMatch.score > 0.5)) {
+    return null;
+  }
+
+  return firstMatch;
+}
+
+export async function getLyricsBySongId(songId: string): Promise<string | null> {
+  let result: AxiosResponse<any, any>;
+  try {
+    result = await axios.get(LYRICS_URL, {
+      params: {
+        id: songId,
+        kv: '-1',
+        lv: '-1',
+      },
+    });
+  } catch (e) {
+    console.error('NetEase lyrics request got an error!', e);
+    return null;
+  }
+
+  return result.data.klyric?.lyric || result.data.lrc?.lyric;
+}
+
+export async function query(
+  params: LyricSearchQuery,
+): Promise<InternetProviderLyricResponse | null> {
+  const lyricsMatch = await getMatchedLyrics(params);
+  if (!lyricsMatch) {
+    console.error('Could not find the song on NetEase!');
+    return null;
+  }
+
+  const lyrics = await getLyricsBySongId(lyricsMatch.id);
+  if (!lyrics) {
+    console.error('Could not get lyrics on NetEase!');
+    return null;
+  }
+
+  return {
+    artist: lyricsMatch.artist,
+    id: lyricsMatch.id,
+    lyrics,
+    name: lyricsMatch.name,
+    source: LyricSource.NETEASE,
+  };
+}

src/main/features/core/lyrics/shared.ts

@@ -0,0 +1,34 @@
+import Fuse from 'fuse.js';
+import {
+  InternetProviderLyricSearchResponse,
+  LyricSearchQuery,
+} from '../../../../renderer/api/types';
+
+export const orderSearchResults = (args: {
+  params: LyricSearchQuery;
+  results: InternetProviderLyricSearchResponse[];
+}) => {
+  const { params, results } = args;
+
+  const options: Fuse.IFuseOptions<InternetProviderLyricSearchResponse> = {
+    fieldNormWeight: 1,
+    includeScore: true,
+    keys: [
+      { getFn: (song) => song.name, name: 'name', weight: 3 },
+      { getFn: (song) => song.artist, name: 'artist' },
+    ],
+    threshold: 1.0,
+  };
+
+  const fuse = new Fuse(results, options);
+
+  const searchResults = fuse.search<InternetProviderLyricSearchResponse>({
+    ...(params.artist && { artist: params.artist }),
+    ...(params.name && { name: params.name }),
+  });
+
+  return searchResults.map((result) => ({
+    ...result.item,
+    score: result.score,
+  }));
+};

src/main/features/core/player/index.ts

@@ -1,140 +1,179 @@
+import console from 'console';
 import { ipcMain } from 'electron';
-import uniq from 'lodash/uniq';
-import MpvAPI from 'node-mpv';
-import { store } from '../settings';
-import { getMainWindow } from '../../../main';
+import { getMainWindow, getMpvInstance } from '../../../main';
 import { PlayerData } from '/@/renderer/store';
 
 declare module 'node-mpv';
 
-const BINARY_PATH = store.get('mpv_path') as string | undefined;
-const MPV_PARAMETERS = store.get('mpv_parameters') as Array<string> | undefined;
-const DEFAULT_MPV_PARAMETERS = () => {
-  const parameters = [];
-  if (
-    !MPV_PARAMETERS?.includes('--gapless-audio=weak') ||
-    !MPV_PARAMETERS?.includes('--gapless-audio=no') ||
-    !MPV_PARAMETERS?.includes('--gapless-audio=yes') ||
-    !MPV_PARAMETERS?.includes('--gapless-audio')
-  ) {
-    parameters.push('--gapless-audio=yes');
-  }
+function wait(timeout: number) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve('resolved');
+    }, timeout);
+  });
+}
 
-  if (
-    !MPV_PARAMETERS?.includes('--prefetch-playlist=no') ||
-    !MPV_PARAMETERS?.includes('--prefetch-playlist=yes') ||
-    !MPV_PARAMETERS?.includes('--prefetch-playlist')
-  ) {
-    parameters.push('--prefetch-playlist=yes');
-  }
-
-  return parameters;
-};
-
-const mpv = new MpvAPI(
-  {
-    audio_only: true,
-    auto_restart: true,
-    binary: BINARY_PATH || '',
-    time_update: 1,
-  },
-  MPV_PARAMETERS
-    ? uniq([...DEFAULT_MPV_PARAMETERS(), ...MPV_PARAMETERS])
-    : DEFAULT_MPV_PARAMETERS(),
-);
-
-mpv.start().catch((error) => {
-  console.log('error starting mpv', error);
+ipcMain.handle('player-is-running', async () => {
+  return getMpvInstance()?.isRunning();
 });
 
-mpv.on('status', (status) => {
-  if (status.property === 'playlist-pos') {
-    if (status.value !== 0) {
-      getMainWindow()?.webContents.send('renderer-player-auto-next');
-    }
-  }
+ipcMain.handle('player-clean-up', async () => {
+  getMpvInstance()?.stop();
+  getMpvInstance()?.clearPlaylist();
 });
 
-// Automatically updates the play button when the player is playing
-mpv.on('resumed', () => {
-  getMainWindow()?.webContents.send('renderer-player-play');
-});
-
-// Automatically updates the play button when the player is stopped
-mpv.on('stopped', () => {
-  getMainWindow()?.webContents.send('renderer-player-stop');
-});
-
-// Automatically updates the play button when the player is paused
-mpv.on('paused', () => {
-  getMainWindow()?.webContents.send('renderer-player-pause');
-});
-
-mpv.on('quit', () => {
-  console.log('mpv quit');
-});
-
-// Event output every interval set by time_update, used to update the current time
-mpv.on('timeposition', (time: number) => {
-  getMainWindow()?.webContents.send('renderer-player-current-time', time);
+ipcMain.on('player-start', async () => {
+  await getMpvInstance()
+    ?.play()
+    .catch((err) => {
+      console.log('MPV failed to play', err);
+    });
 });
 
 // Starts the player
 ipcMain.on('player-play', async () => {
-  await mpv.play();
+  await getMpvInstance()
+    ?.play()
+    .catch((err) => {
+      console.log('MPV failed to play', err);
+    });
 });
 
 // Pauses the player
 ipcMain.on('player-pause', async () => {
-  await mpv.pause();
+  await getMpvInstance()
+    ?.pause()
+    .catch((err) => {
+      console.log('MPV failed to pause', err);
+    });
 });
 
 // Stops the player
 ipcMain.on('player-stop', async () => {
-  await mpv.stop();
+  await getMpvInstance()
+    ?.stop()
+    .catch((err) => {
+      console.log('MPV failed to stop', err);
+    });
 });
 
 // Goes to the next track in the playlist
 ipcMain.on('player-next', async () => {
-  await mpv.next();
+  await getMpvInstance()
+    ?.next()
+    .catch((err) => {
+      console.log('MPV failed to go to next', err);
+    });
 });
 
 // Goes to the previous track in the playlist
 ipcMain.on('player-previous', async () => {
-  await mpv.prev();
+  await getMpvInstance()
+    ?.prev()
+    .catch((err) => {
+      console.log('MPV failed to go to previous', err);
+    });
 });
 
 // Seeks forward or backward by the given amount of seconds
 ipcMain.on('player-seek', async (_event, time: number) => {
-  await mpv.seek(time);
+  await getMpvInstance()
+    ?.seek(time)
+    .catch((err) => {
+      console.log('MPV failed to seek', err);
+    });
 });
 
 // Seeks to the given time in seconds
 ipcMain.on('player-seek-to', async (_event, time: number) => {
-  await mpv.goToPosition(time);
+  await getMpvInstance()
+    ?.goToPosition(time)
+    .catch((err) => {
+      console.log(`MPV failed to seek to ${time}`, err);
+    });
 });
 
 // Sets the queue in position 0 and 1 to the given data. Used when manually starting a song or using the next/prev buttons
-ipcMain.on('player-set-queue', async (_event, data: PlayerData) => {
-  if (data.queue.current) {
-    await mpv.load(data.queue.current.streamUrl, 'replace');
+ipcMain.on('player-set-queue', async (_event, data: PlayerData, pause?: boolean) => {
+  if (!data.queue.current && !data.queue.next) {
+    await getMpvInstance()
+      ?.clearPlaylist()
+      .catch((err) => {
+        console.log('MPV failed to clear playlist', err);
+      });
+    await getMpvInstance()
+      ?.pause()
+      .catch((err) => {
+        console.log('MPV failed to pause', err);
+      });
+    return;
   }
 
-  if (data.queue.next) {
-    await mpv.load(data.queue.next.streamUrl, 'append');
+  let complete = false;
+  let tryAttempts = 0;
+
+  while (!complete) {
+    if (tryAttempts > 3) {
+      getMainWindow()?.webContents.send('renderer-player-error', 'Failed to load song');
+      complete = true;
+    } else {
+      try {
+        if (data.queue.current) {
+          await getMpvInstance()
+            ?.load(data.queue.current.streamUrl, 'replace')
+            .catch((err) => {
+              console.log('MPV failed to load song', err);
+            });
+        }
+
+        if (data.queue.next) {
+          await getMpvInstance()
+            ?.load(data.queue.next.streamUrl, 'append')
+            .catch((err) => {
+              console.log('MPV failed to load next song', err);
+            });
+        }
+
+        complete = true;
+      } catch (err) {
+        console.error(err);
+        tryAttempts += 1;
+        await wait(500);
+      }
+    }
+  }
+
+  if (pause) {
+    await getMpvInstance()?.pause();
   }
 });
 
 // Replaces the queue in position 1 to the given data
 ipcMain.on('player-set-queue-next', async (_event, data: PlayerData) => {
-  const size = await mpv.getPlaylistSize();
+  const size = await getMpvInstance()
+    ?.getPlaylistSize()
+    .catch((err) => {
+      console.log('MPV failed to get playlist size', err);
+    });
+
+  if (!size) {
+    return;
+  }
 
   if (size > 1) {
-    await mpv.playlistRemove(1);
+    await getMpvInstance()
+      ?.playlistRemove(1)
+      .catch((err) => {
+        console.log('MPV failed to remove song from playlist', err);
+      });
   }
 
   if (data.queue.next) {
-    await mpv.load(data.queue.next.streamUrl, 'append');
+    await getMpvInstance()
+      ?.load(data.queue.next.streamUrl, 'append')
+      .catch((err) => {
+        console.log('MPV failed to load next song', err);
+      });
   }
 });
 
@@ -143,23 +182,39 @@ ipcMain.on('player-auto-next', async (_event, data: PlayerData) => {
   // Always keep the current song as position 0 in the mpv queue
   // This allows us to easily set update the next song in the queue without
   // disturbing the currently playing song
-  await mpv.playlistRemove(0);
+  await getMpvInstance()
+    ?.playlistRemove(0)
+    .catch((err) => {
+      console.log('MPV failed to remove song from playlist', err);
+    });
 
   if (data.queue.next) {
-    await mpv.load(data.queue.next.streamUrl, 'append');
+    await getMpvInstance()
+      ?.load(data.queue.next.streamUrl, 'append')
+      .catch((err) => {
+        console.log('MPV failed to load next song', err);
+      });
   }
 });
 
 // Sets the volume to the given value (0-100)
 ipcMain.on('player-volume', async (_event, value: number) => {
-  await mpv.volume(value);
+  await getMpvInstance()
+    ?.volume(value)
+    .catch((err) => {
+      console.log('MPV failed to set volume', err);
+    });
 });
 
 // Toggles the mute status
 ipcMain.on('player-mute', async () => {
-  await mpv.mute();
+  await getMpvInstance()
+    ?.mute()
+    .catch((err) => {
+      console.log('MPV failed to toggle mute', err);
+    });
 });
 
-ipcMain.on('player-quit', async () => {
-  await mpv.quit();
+ipcMain.handle('player-get-time', async (): Promise<number | undefined> => {
+  return getMpvInstance()?.getTimePosition();
 });

src/main/features/core/settings/index.ts

@@ -1,4 +1,4 @@
-import { ipcMain } from 'electron';
+import { ipcMain, safeStorage } from 'electron';
 import Store from 'electron-store';
 
 export const store = new Store();
@@ -10,3 +10,41 @@ ipcMain.handle('settings-get', (_event, data: { property: string }) => {
 ipcMain.on('settings-set', (__event, data: { property: string; value: any }) => {
   store.set(`${data.property}`, data.value);
 });
+
+ipcMain.handle('password-get', (_event, server: string): string | null => {
+  if (safeStorage.isEncryptionAvailable()) {
+    const servers = store.get('server') as Record<string, string> | undefined;
+
+    if (!servers) {
+      return null;
+    }
+
+    const encrypted = servers[server];
+    if (!encrypted) return null;
+
+    const decrypted = safeStorage.decryptString(Buffer.from(encrypted, 'hex'));
+    return decrypted;
+  }
+
+  return null;
+});
+
+ipcMain.on('password-remove', (_event, server: string) => {
+  const passwords = store.get('server', {}) as Record<string, string>;
+  if (server in passwords) {
+    delete passwords[server];
+  }
+  store.set({ server: passwords });
+});
+
+ipcMain.handle('password-set', (_event, password: string, server: string) => {
+  if (safeStorage.isEncryptionAvailable()) {
+    const encrypted = safeStorage.encryptString(password);
+    const passwords = store.get('server', {}) as Record<string, string>;
+    passwords[server] = encrypted.toString('hex');
+    store.set({ server: passwords });
+
+    return true;
+  }
+  return false;
+});

src/main/features/linux/index.ts

@@ -0,0 +1 @@
+import './mpris';

src/main/features/linux/mpris.ts

@@ -0,0 +1,168 @@
+import { ipcMain } from 'electron';
+import Player from 'mpris-service';
+import { QueueSong, RelatedArtist } from '../../../renderer/api/types';
+import { getMainWindow } from '../../main';
+import { PlayerRepeat, PlayerShuffle, PlayerStatus } from '/@/renderer/types';
+
+const mprisPlayer = Player({
+  identity: 'Feishin',
+  maximumRate: 1.0,
+  minimumRate: 1.0,
+  name: 'Feishin',
+  rate: 1.0,
+  supportedInterfaces: ['player'],
+  supportedMimeTypes: ['audio/mpeg', 'application/ogg'],
+  supportedUriSchemes: ['file'],
+});
+
+mprisPlayer.on('quit', () => {
+  process.exit();
+});
+
+mprisPlayer.on('stop', () => {
+  getMainWindow()?.webContents.send('renderer-player-stop');
+  mprisPlayer.playbackStatus = 'Paused';
+});
+
+mprisPlayer.on('pause', () => {
+  getMainWindow()?.webContents.send('renderer-player-pause');
+  mprisPlayer.playbackStatus = 'Paused';
+});
+
+mprisPlayer.on('play', () => {
+  getMainWindow()?.webContents.send('renderer-player-play');
+  mprisPlayer.playbackStatus = 'Playing';
+});
+
+mprisPlayer.on('playpause', () => {
+  getMainWindow()?.webContents.send('renderer-player-play-pause');
+  if (mprisPlayer.playbackStatus !== 'Playing') {
+    mprisPlayer.playbackStatus = 'Playing';
+  } else {
+    mprisPlayer.playbackStatus = 'Paused';
+  }
+});
+
+mprisPlayer.on('next', () => {
+  getMainWindow()?.webContents.send('renderer-player-next');
+
+  if (mprisPlayer.playbackStatus !== 'Playing') {
+    mprisPlayer.playbackStatus = 'Playing';
+  }
+});
+
+mprisPlayer.on('previous', () => {
+  getMainWindow()?.webContents.send('renderer-player-previous');
+
+  if (mprisPlayer.playbackStatus !== 'Playing') {
+    mprisPlayer.playbackStatus = Player.PLAYBACK_STATUS_PLAYING;
+  }
+});
+
+mprisPlayer.on('volume', (event: any) => {
+  getMainWindow()?.webContents.send('mpris-request-volume', {
+    volume: event,
+  });
+});
+
+mprisPlayer.on('shuffle', (event: boolean) => {
+  getMainWindow()?.webContents.send('mpris-request-toggle-shuffle', { shuffle: event });
+  mprisPlayer.shuffle = event;
+});
+
+mprisPlayer.on('loopStatus', (event: string) => {
+  getMainWindow()?.webContents.send('mpris-request-toggle-repeat', { repeat: event });
+  mprisPlayer.loopStatus = event;
+});
+
+mprisPlayer.on('position', (event: any) => {
+  getMainWindow()?.webContents.send('mpris-request-position', {
+    position: event.position / 1e6,
+  });
+});
+
+mprisPlayer.on('seek', (event: number) => {
+  getMainWindow()?.webContents.send('mpris-request-seek', {
+    offset: event / 1e6,
+  });
+});
+
+ipcMain.on('mpris-update-position', (_event, arg) => {
+  mprisPlayer.getPosition = () => arg * 1e6;
+});
+
+ipcMain.on('mpris-update-seek', (_event, arg) => {
+  mprisPlayer.seeked(arg * 1e6);
+});
+
+ipcMain.on('mpris-update-volume', (_event, arg) => {
+  mprisPlayer.volume = Number(arg);
+});
+
+ipcMain.on('mpris-update-repeat', (_event, arg) => {
+  mprisPlayer.loopStatus = arg;
+});
+
+ipcMain.on('mpris-update-shuffle', (_event, arg) => {
+  mprisPlayer.shuffle = arg;
+});
+
+ipcMain.on(
+  'mpris-update-song',
+  (
+    _event,
+    args: {
+      currentTime: number;
+      repeat: PlayerRepeat;
+      shuffle: PlayerShuffle;
+      song: QueueSong;
+      status: PlayerStatus;
+    },
+  ) => {
+    const { song, status, repeat, shuffle } = args || {};
+
+    try {
+      mprisPlayer.playbackStatus = status;
+
+      if (repeat) {
+        mprisPlayer.loopStatus =
+          repeat === 'all' ? 'Playlist' : repeat === 'one' ? 'Track' : 'None';
+      }
+
+      if (shuffle) {
+        mprisPlayer.shuffle = shuffle !== 'none';
+      }
+
+      if (!song) return;
+
+      const upsizedImageUrl = song.imageUrl
+        ? song.imageUrl
+            ?.replace(/&size=\d+/, '&size=300')
+            .replace(/\?width=\d+/, '?width=300')
+            .replace(/&height=\d+/, '&height=300')
+        : null;
+
+      mprisPlayer.metadata = {
+        'mpris:artUrl': upsizedImageUrl,
+        'mpris:length': song.duration ? Math.round((song.duration || 0) * 1e6) : null,
+        'mpris:trackid': song?.id
+          ? mprisPlayer.objectPath(`track/${song.id?.replace('-', '')}`)
+          : '',
+        'xesam:album': song.album || null,
+        'xesam:albumArtist': song.albumArtists?.length ? song.albumArtists[0].name : null,
+        'xesam:artist':
+          song.artists?.length !== 0
+            ? song.artists?.map((artist: RelatedArtist) => artist.name)
+            : null,
+        'xesam:discNumber': song.discNumber ? song.discNumber : null,
+        'xesam:genre': song.genres?.length ? song.genres.map((genre: any) => genre.name) : null,
+        'xesam:title': song.name || null,
+        'xesam:trackNumber': song.trackNumber ? song.trackNumber : null,
+        'xesam:useCount':
+          song.playCount !== null && song.playCount !== undefined ? song.playCount : null,
+      };
+    } catch (err) {
+      console.log(err);
+    }
+  },
+);

src/main/main.ts

@@ -8,17 +8,33 @@
  * When running `npm run build` or `npm run build:main`, this file is compiled to
  * `./src/main.js` using webpack. This gives us some performance wins.
  */
-import path from 'path';
-import { app, BrowserWindow, shell, ipcMain, globalShortcut } from 'electron';
+import { access, constants, readFile, writeFile } from 'fs';
+import path, { join } from 'path';
+import { deflate, inflate } from 'zlib';
+import {
+  app,
+  BrowserWindow,
+  shell,
+  ipcMain,
+  globalShortcut,
+  Tray,
+  Menu,
+  nativeImage,
+  BrowserWindowConstructorOptions,
+} from 'electron';
 import electronLocalShortcut from 'electron-localshortcut';
 import log from 'electron-log';
 import { autoUpdater } from 'electron-updater';
+import uniq from 'lodash/uniq';
+import MpvAPI from 'node-mpv';
 import { disableMediaKeys, enableMediaKeys } from './features/core/player/media-keys';
 import { store } from './features/core/settings/index';
 import MenuBuilder from './menu';
-import { resolveHtmlPath } from './utils';
+import { hotkeyToElectronAccelerator, isLinux, isMacOS, isWindows, resolveHtmlPath } from './utils';
 import './features';
 
+declare module 'node-mpv';
+
 export default class AppUpdater {
   constructor() {
     log.transports.file.level = 'info';
@@ -27,7 +43,18 @@ export default class AppUpdater {
   }
 }
 
+process.on('uncaughtException', (error: any) => {
+  console.log('Error in main process', error);
+});
+
+if (store.get('ignore_ssl')) {
+  app.commandLine.appendSwitch('ignore-certificate-errors');
+}
+
 let mainWindow: BrowserWindow | null = null;
+let tray: Tray | null = null;
+let exitFromTray = false;
+let forceQuit = false;
 
 if (process.env.NODE_ENV === 'production') {
   const sourceMapSupport = require('source-map-support');
@@ -53,27 +80,140 @@ const installExtensions = async () => {
     .catch(console.log);
 };
 
+const singleInstance = app.requestSingleInstanceLock();
+
+if (!singleInstance) {
+  app.quit();
+}
+
+const RESOURCES_PATH = app.isPackaged
+  ? path.join(process.resourcesPath, 'assets')
+  : path.join(__dirname, '../../assets');
+
+const getAssetPath = (...paths: string[]): string => {
+  return path.join(RESOURCES_PATH, ...paths);
+};
+
+export const getMainWindow = () => {
+  return mainWindow;
+};
+
+const createWinThumbarButtons = () => {
+  if (isWindows()) {
+    getMainWindow()?.setThumbarButtons([
+      {
+        click: () => getMainWindow()?.webContents.send('renderer-player-previous'),
+        icon: nativeImage.createFromPath(getAssetPath('skip-previous.png')),
+        tooltip: 'Previous Track',
+      },
+      {
+        click: () => getMainWindow()?.webContents.send('renderer-player-play-pause'),
+        icon: nativeImage.createFromPath(getAssetPath('play-circle.png')),
+        tooltip: 'Play/Pause',
+      },
+      {
+        click: () => getMainWindow()?.webContents.send('renderer-player-next'),
+        icon: nativeImage.createFromPath(getAssetPath('skip-next.png')),
+        tooltip: 'Next Track',
+      },
+    ]);
+  }
+};
+
+const createTray = () => {
+  if (isMacOS()) {
+    return;
+  }
+
+  tray = isLinux() ? new Tray(getAssetPath('icon.png')) : new Tray(getAssetPath('icon.ico'));
+  const contextMenu = Menu.buildFromTemplate([
+    {
+      click: () => {
+        getMainWindow()?.webContents.send('renderer-player-play-pause');
+      },
+      label: 'Play/Pause',
+    },
+    {
+      click: () => {
+        getMainWindow()?.webContents.send('renderer-player-next');
+      },
+      label: 'Next Track',
+    },
+    {
+      click: () => {
+        getMainWindow()?.webContents.send('renderer-player-previous');
+      },
+      label: 'Previous Track',
+    },
+    {
+      click: () => {
+        getMainWindow()?.webContents.send('renderer-player-stop');
+      },
+      label: 'Stop',
+    },
+    {
+      type: 'separator',
+    },
+    {
+      click: () => {
+        mainWindow?.show();
+        createWinThumbarButtons();
+      },
+      label: 'Open main window',
+    },
+    {
+      click: () => {
+        exitFromTray = true;
+        app.quit();
+      },
+      label: 'Quit',
+    },
+  ]);
+
+  tray.on('double-click', () => {
+    mainWindow?.show();
+    createWinThumbarButtons();
+  });
+
+  tray.setToolTip('Feishin');
+  tray.setContextMenu(contextMenu);
+};
+
 const createWindow = async () => {
   if (isDevelopment) {
     await installExtensions();
   }
 
-  const RESOURCES_PATH = app.isPackaged
-    ? path.join(process.resourcesPath, 'assets')
-    : path.join(__dirname, '../../assets');
+  const nativeFrame = store.get('window_window_bar_style') === 'linux';
+  store.set('window_has_frame', nativeFrame);
 
-  const getAssetPath = (...paths: string[]): string => {
-    return path.join(RESOURCES_PATH, ...paths);
+  const nativeFrameConfig: Record<string, BrowserWindowConstructorOptions> = {
+    linux: {
+      autoHideMenuBar: true,
+      frame: true,
+    },
+    macOS: {
+      autoHideMenuBar: true,
+      frame: false,
+      titleBarStyle: 'hidden',
+      trafficLightPosition: { x: 10, y: 10 },
+    },
+    windows: {
+      autoHideMenuBar: true,
+      frame: true,
+    },
   };
 
   mainWindow = new BrowserWindow({
+    autoHideMenuBar: true,
     frame: false,
     height: 900,
     icon: getAssetPath('icon.png'),
-    minHeight: 600,
-    minWidth: 640,
+    minHeight: 640,
+    minWidth: 480,
     show: false,
     webPreferences: {
+      allowRunningInsecureContent: !!store.get('ignore_ssl'),
       backgroundThrottling: false,
       contextIsolation: true,
       devTools: true,
@@ -81,14 +221,22 @@ const createWindow = async () => {
       preload: app.isPackaged
         ? path.join(__dirname, 'preload.js')
         : path.join(__dirname, '../../.erb/dll/preload.js'),
+      webSecurity: !store.get('ignore_cors'),
     },
     width: 1440,
+    ...(nativeFrame && isLinux() && nativeFrameConfig.linux),
+    ...(nativeFrame && isMacOS() && nativeFrameConfig.macOS),
+    ...(nativeFrame && isWindows() && nativeFrameConfig.windows),
   });
 
   electronLocalShortcut.register(mainWindow, 'Ctrl+Shift+I', () => {
     mainWindow?.webContents.openDevTools();
   });
 
+  ipcMain.on('window-dev-tools', () => {
+    mainWindow?.webContents.openDevTools();
+  });
+
   ipcMain.on('window-maximize', () => {
     mainWindow?.maximize();
   });
@@ -106,8 +254,18 @@ const createWindow = async () => {
   });
 
   ipcMain.on('app-restart', () => {
-    app.relaunch();
-    app.exit(0);
+    // Fix for .AppImage
+    if (process.env.APPIMAGE) {
+      app.exit();
+      app.relaunch({
+        args: process.argv.slice(1).concat(['--appimage-extract-and-run']),
+        execPath: process.env.APPIMAGE,
+      });
+      app.exit(0);
+    } else {
+      app.relaunch();
+      app.exit(0);
+    }
   });
 
   ipcMain.on('global-media-keys-enable', () => {
@@ -118,9 +276,39 @@ const createWindow = async () => {
     disableMediaKeys();
   });
 
+  ipcMain.on('player-restore-queue', () => {
+    if (store.get('resume')) {
+      const queueLocation = join(app.getPath('userData'), 'queue');
+
+      access(queueLocation, constants.F_OK, (accessError) => {
+        if (accessError) {
+          console.error('unable to access saved queue: ', accessError);
+          return;
+        }
+
+        readFile(queueLocation, (readError, buffer) => {
+          if (readError) {
+            console.error('failed to read saved queue: ', readError);
+            return;
+          }
+
+          inflate(buffer, (decompressError, data) => {
+            if (decompressError) {
+              console.error('failed to decompress queue: ', decompressError);
+              return;
+            }
+
+            const queue = JSON.parse(data.toString());
+            getMainWindow()?.webContents.send('renderer-player-restore-queue', queue);
+          });
+        });
+      });
+    }
+  });
+
   const globalMediaKeysEnabled = store.get('global_media_hotkeys') as boolean;
 
-  if (globalMediaKeysEnabled) {
+  if (globalMediaKeysEnabled !== false) {
     enableMediaKeys(mainWindow);
   }
 
@@ -134,6 +322,7 @@ const createWindow = async () => {
       mainWindow.minimize();
     } else {
       mainWindow.show();
+      createWinThumbarButtons();
     }
   });
 
@@ -141,6 +330,72 @@ const createWindow = async () => {
     mainWindow = null;
   });
 
+  let saved = false;
+
+  mainWindow.on('close', (event) => {
+    if (!exitFromTray && store.get('window_exit_to_tray')) {
+      if (isMacOS() && !forceQuit) {
+        exitFromTray = true;
+      }
+      event.preventDefault();
+      mainWindow?.hide();
+    }
+
+    if (!saved && store.get('resume')) {
+      event.preventDefault();
+      saved = true;
+
+      getMainWindow()?.webContents.send('renderer-player-save-queue');
+
+      ipcMain.once('player-save-queue', async (_event, data: Record<string, any>) => {
+        const queueLocation = join(app.getPath('userData'), 'queue');
+        const serialized = JSON.stringify(data);
+
+        try {
+          await new Promise<void>((resolve, reject) => {
+            deflate(serialized, { level: 1 }, (error, deflated) => {
+              if (error) {
+                reject(error);
+              } else {
+                writeFile(queueLocation, deflated, (writeError) => {
+                  if (writeError) {
+                    reject(writeError);
+                  } else {
+                    resolve();
+                  }
+                });
+              }
+            });
+          });
+        } catch (error) {
+          console.error('error saving queue state: ', error);
+        } finally {
+          mainWindow?.close();
+          if (forceQuit) {
+            app.exit();
+          }
+        }
+      });
+    }
+  });
+
+  mainWindow.on('minimize', (event: any) => {
+    if (store.get('window_minimize_to_tray') === true) {
+      event.preventDefault();
+      mainWindow?.hide();
+    }
+  });
+
+  if (isWindows()) {
+    app.setAppUserModelId(process.execPath);
+  }
+
+  if (isMacOS()) {
+    app.on('before-quit', () => {
+      forceQuit = true;
+    });
+  }
+
   const menuBuilder = new MenuBuilder(mainWindow);
   menuBuilder.buildMenu();
 
@@ -150,30 +405,229 @@ const createWindow = async () => {
     return { action: 'deny' };
   });
 
-  // Remove this if your app does not use auto updates
-  // eslint-disable-next-line
-  new AppUpdater();
+  if (store.get('disable_auto_updates') !== true) {
+    // eslint-disable-next-line
+    new AppUpdater();
+  }
 };
 
-/**
- * Add event listeners...
- */
-
 app.commandLine.appendSwitch('disable-features', 'HardwareMediaKeyHandling,MediaSessionService');
 
-export const getMainWindow = () => {
-  return mainWindow;
+const MPV_BINARY_PATH = store.get('mpv_path') as string | undefined;
+
+const prefetchPlaylistParams = [
+  '--prefetch-playlist=no',
+  '--prefetch-playlist=yes',
+  '--prefetch-playlist',
+];
+
+const DEFAULT_MPV_PARAMETERS = (extraParameters?: string[]) => {
+  const parameters = ['--idle=yes'];
+
+  if (!extraParameters?.some((param) => prefetchPlaylistParams.includes(param))) {
+    parameters.push('--prefetch-playlist=yes');
+  }
+
+  return parameters;
 };
 
+let mpvInstance: MpvAPI | null = null;
+
+const createMpv = (data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
+  const { extraParameters, properties } = data;
+
+  const params = uniq([...DEFAULT_MPV_PARAMETERS(extraParameters), ...(extraParameters || [])]);
+  console.log('Setting mpv params: ', params);
+
+  const mpv = new MpvAPI(
+    {
+      audio_only: true,
+      auto_restart: false,
+      binary: MPV_BINARY_PATH || '',
+      time_update: 1,
+    },
+    params,
+  );
+
+  console.log('Setting MPV properties: ', properties);
+  mpv.setMultipleProperties(properties || {});
+
+  mpv.start().catch((error) => {
+    console.log('MPV failed to start', error);
+  });
+
+  mpv.on('status', (status, ...rest) => {
+    console.log('MPV Event: status', status.property, status.value, rest);
+    if (status.property === 'playlist-pos') {
+      if (status.value === -1) {
+        mpv?.stop();
+      }
+
+      if (status.value !== 0) {
+        getMainWindow()?.webContents.send('renderer-player-auto-next');
+      }
+    }
+  });
+
+  // Automatically updates the play button when the player is playing
+  mpv.on('resumed', () => {
+    console.log('MPV Event: resumed');
+    getMainWindow()?.webContents.send('renderer-player-play');
+  });
+
+  // Automatically updates the play button when the player is stopped
+  mpv.on('stopped', () => {
+    console.log('MPV Event: stopped');
+    getMainWindow()?.webContents.send('renderer-player-stop');
+  });
+
+  // Automatically updates the play button when the player is paused
+  mpv.on('paused', () => {
+    console.log('MPV Event: paused');
+    getMainWindow()?.webContents.send('renderer-player-pause');
+  });
+
+  // Event output every interval set by time_update, used to update the current time
+  mpv.on('timeposition', (time: number) => {
+    getMainWindow()?.webContents.send('renderer-player-current-time', time);
+  });
+
+  mpv.on('quit', () => {
+    console.log('MPV Event: quit');
+  });
+
+  return mpv;
+};
+
+export const getMpvInstance = () => {
+  return mpvInstance;
+};
+
+ipcMain.on('player-set-properties', async (_event, data: Record<string, any>) => {
+  if (data.length === 0) {
+    return;
+  }
+
+  if (data.length === 1) {
+    getMpvInstance()?.setProperty(Object.keys(data)[0], Object.values(data)[0]);
+  } else {
+    getMpvInstance()?.setMultipleProperties(data);
+  }
+});
+
+ipcMain.on(
+  'player-restart',
+  async (_event, data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
+    mpvInstance?.quit();
+    mpvInstance = createMpv(data);
+  },
+);
+
+ipcMain.on(
+  'player-initialize',
+  async (_event, data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
+    console.log('Initializing MPV with data: ', data);
+    mpvInstance = createMpv(data);
+  },
+);
+
+ipcMain.on('player-quit', async () => {
+  mpvInstance?.stop();
+  mpvInstance?.quit();
+  mpvInstance = null;
+});
+
+// Must duplicate with the one in renderer process settings.store.ts
+enum BindingActions {
+  GLOBAL_SEARCH = 'globalSearch',
+  LOCAL_SEARCH = 'localSearch',
+  MUTE = 'volumeMute',
+  NEXT = 'next',
+  PAUSE = 'pause',
+  PLAY = 'play',
+  PLAY_PAUSE = 'playPause',
+  PREVIOUS = 'previous',
+  SHUFFLE = 'toggleShuffle',
+  SKIP_BACKWARD = 'skipBackward',
+  SKIP_FORWARD = 'skipForward',
+  STOP = 'stop',
+  TOGGLE_FULLSCREEN_PLAYER = 'toggleFullscreenPlayer',
+  TOGGLE_QUEUE = 'toggleQueue',
+  TOGGLE_REPEAT = 'toggleRepeat',
+  VOLUME_DOWN = 'volumeDown',
+  VOLUME_UP = 'volumeUp',
+}
+
+const HOTKEY_ACTIONS: Record<BindingActions, () => void> = {
+  [BindingActions.MUTE]: () => getMainWindow()?.webContents.send('renderer-player-volume-mute'),
+  [BindingActions.NEXT]: () => getMainWindow()?.webContents.send('renderer-player-next'),
+  [BindingActions.PAUSE]: () => getMainWindow()?.webContents.send('renderer-player-pause'),
+  [BindingActions.PLAY]: () => getMainWindow()?.webContents.send('renderer-player-play'),
+  [BindingActions.PLAY_PAUSE]: () =>
+    getMainWindow()?.webContents.send('renderer-player-play-pause'),
+  [BindingActions.PREVIOUS]: () => getMainWindow()?.webContents.send('renderer-player-previous'),
+  [BindingActions.SHUFFLE]: () =>
+    getMainWindow()?.webContents.send('renderer-player-toggle-shuffle'),
+  [BindingActions.SKIP_BACKWARD]: () =>
+    getMainWindow()?.webContents.send('renderer-player-skip-backward'),
+  [BindingActions.SKIP_FORWARD]: () =>
+    getMainWindow()?.webContents.send('renderer-player-skip-forward'),
+  [BindingActions.STOP]: () => getMainWindow()?.webContents.send('renderer-player-stop'),
+  [BindingActions.TOGGLE_REPEAT]: () =>
+    getMainWindow()?.webContents.send('renderer-player-toggle-repeat'),
+  [BindingActions.VOLUME_UP]: () => getMainWindow()?.webContents.send('renderer-player-volume-up'),
+  [BindingActions.VOLUME_DOWN]: () =>
+    getMainWindow()?.webContents.send('renderer-player-volume-down'),
+  [BindingActions.GLOBAL_SEARCH]: () => {},
+  [BindingActions.LOCAL_SEARCH]: () => {},
+  [BindingActions.TOGGLE_QUEUE]: () => {},
+  [BindingActions.TOGGLE_FULLSCREEN_PLAYER]: () => {},
+};
+
+ipcMain.on(
+  'set-global-shortcuts',
+  (
+    _event,
+    data: Record<BindingActions, { allowGlobal: boolean; hotkey: string; isGlobal: boolean }>,
+  ) => {
+    // Since we're not tracking the previous shortcuts, we need to unregister all of them
+    globalShortcut.unregisterAll();
+
+    for (const shortcut of Object.keys(data)) {
+      const isGlobalHotkey = data[shortcut as BindingActions].isGlobal;
+      const isValidHotkey =
+        data[shortcut as BindingActions].hotkey && data[shortcut as BindingActions].hotkey !== '';
+
+      if (isGlobalHotkey && isValidHotkey) {
+        const accelerator = hotkeyToElectronAccelerator(data[shortcut as BindingActions].hotkey);
+
+        globalShortcut.register(accelerator, () => {
+          HOTKEY_ACTIONS[shortcut as BindingActions]();
+        });
+      }
+    }
+
+    const globalMediaKeysEnabled = store.get('global_media_hotkeys') as boolean;
+
+    if (globalMediaKeysEnabled) {
+      enableMediaKeys(mainWindow);
+    }
+  },
+);
+
 app.on('before-quit', () => {
-  mainWindow?.webContents.send('renderer-player-quit');
+  getMpvInstance()?.stop();
+  getMpvInstance()?.quit();
 });
 
 app.on('window-all-closed', () => {
+  globalShortcut.unregisterAll();
+  getMpvInstance()?.quit();
   // Respect the OSX convention of having the application in memory even
   // after all windows have been closed
-  globalShortcut.unregisterAll();
-  if (process.platform !== 'darwin') {
+  if (isMacOS()) {
+    mainWindow = null;
+  } else {
     app.quit();
   }
 });
@@ -182,6 +636,7 @@ app
   .whenReady()
   .then(() => {
     createWindow();
+    createTray();
     app.on('activate', () => {
       // On macOS it's common to re-create a window in the app when the
       // dock icon is clicked and there are no other windows open.

src/main/preload.ts

@@ -1,109 +1,19 @@
-import { contextBridge, ipcRenderer, IpcRendererEvent } from 'electron';
-import { PlayerData } from '../renderer/store';
+import { contextBridge } from 'electron';
 import { browser } from './preload/browser';
 import { ipc } from './preload/ipc';
 import { localSettings } from './preload/local-settings';
+import { lyrics } from './preload/lyrics';
+import { mpris } from './preload/mpris';
 import { mpvPlayer, mpvPlayerListener } from './preload/mpv-player';
+import { utils } from './preload/utils';
 
 contextBridge.exposeInMainWorld('electron', {
   browser,
   ipc,
-  ipcRenderer: {
-    APP_RESTART() {
-      ipcRenderer.send('app-restart');
-    },
-    PLAYER_AUTO_NEXT(data: PlayerData) {
-      ipcRenderer.send('player-auto-next', data);
-    },
-    PLAYER_CURRENT_TIME() {
-      ipcRenderer.send('player-current-time');
-    },
-    PLAYER_MEDIA_KEYS_DISABLE() {
-      ipcRenderer.send('global-media-keys-disable');
-    },
-    PLAYER_MEDIA_KEYS_ENABLE() {
-      ipcRenderer.send('global-media-keys-enable');
-    },
-    PLAYER_MUTE() {
-      ipcRenderer.send('player-mute');
-    },
-    PLAYER_NEXT() {
-      ipcRenderer.send('player-next');
-    },
-    PLAYER_PAUSE() {
-      ipcRenderer.send('player-pause');
-    },
-    PLAYER_PLAY() {
-      ipcRenderer.send('player-play');
-    },
-    PLAYER_PREVIOUS() {
-      ipcRenderer.send('player-previous');
-    },
-    PLAYER_SEEK(seconds: number) {
-      ipcRenderer.send('player-seek', seconds);
-    },
-    PLAYER_SEEK_TO(seconds: number) {
-      ipcRenderer.send('player-seek-to', seconds);
-    },
-    PLAYER_SET_QUEUE(data: PlayerData) {
-      ipcRenderer.send('player-set-queue', data);
-    },
-    PLAYER_SET_QUEUE_NEXT(data: PlayerData) {
-      ipcRenderer.send('player-set-queue-next', data);
-    },
-    PLAYER_STOP() {
-      ipcRenderer.send('player-stop');
-    },
-    PLAYER_VOLUME(value: number) {
-      ipcRenderer.send('player-volume', value);
-    },
-    RENDERER_PLAYER_AUTO_NEXT(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-auto-next', cb);
-    },
-    RENDERER_PLAYER_CURRENT_TIME(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-current-time', cb);
-    },
-    RENDERER_PLAYER_NEXT(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-next', cb);
-    },
-    RENDERER_PLAYER_PAUSE(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-pause', cb);
-    },
-    RENDERER_PLAYER_PLAY(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-play', cb);
-    },
-    RENDERER_PLAYER_PLAY_PAUSE(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-play-pause', cb);
-    },
-    RENDERER_PLAYER_PREVIOUS(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-previous', cb);
-    },
-    RENDERER_PLAYER_STOP(cb: (event: IpcRendererEvent, data: any) => void) {
-      ipcRenderer.on('renderer-player-stop', cb);
-    },
-    SETTINGS_GET(data: { property: string }) {
-      return ipcRenderer.invoke('settings-get', data);
-    },
-    SETTINGS_SET(data: { property: string; value: any }) {
-      ipcRenderer.send('settings-set', data);
-    },
-    removeAllListeners(value: string) {
-      ipcRenderer.removeAllListeners(value);
-    },
-    windowClose() {
-      ipcRenderer.send('window-close');
-    },
-    windowMaximize() {
-      ipcRenderer.send('window-maximize');
-    },
-    windowMinimize() {
-      ipcRenderer.send('window-minimize');
-    },
-    windowUnmaximize() {
-      ipcRenderer.send('window-unmaximize');
-    },
-  },
   localSettings,
+  lyrics,
+  mpris,
   mpvPlayer,
   mpvPlayerListener,
+  utils,
 });

src/main/preload/browser.ts

@@ -13,7 +13,12 @@ const unmaximize = () => {
   ipcRenderer.send('window-unmaximize');
 };
 
+const devtools = () => {
+  ipcRenderer.send('window-dev-tools');
+};
+
 export const browser = {
+  devtools,
   exit,
   maximize,
   minimize,

src/main/preload/ipc.ts

@@ -4,6 +4,11 @@ const removeAllListeners = (channel: string) => {
   ipcRenderer.removeAllListeners(channel);
 };
 
+const send = (channel: string, ...args: any[]) => {
+  ipcRenderer.send(channel, ...args);
+};
+
 export const ipc = {
   removeAllListeners,
+  send,
 };

src/main/preload/local-settings.ts

@@ -1,4 +1,4 @@
-import { ipcRenderer } from 'electron';
+import { ipcRenderer, webFrame } from 'electron';
 import Store from 'electron-store';
 
 const store = new Store();
@@ -23,10 +23,30 @@ const disableMediaKeys = () => {
   ipcRenderer.send('global-media-keys-disable');
 };
 
+const passwordGet = async (server: string): Promise<string | null> => {
+  return ipcRenderer.invoke('password-get', server);
+};
+
+const passwordRemove = (server: string) => {
+  ipcRenderer.send('password-remove', server);
+};
+
+const passwordSet = async (password: string, server: string): Promise<boolean> => {
+  return ipcRenderer.invoke('password-set', password, server);
+};
+
+const setZoomFactor = (zoomFactor: number) => {
+  webFrame.setZoomFactor(zoomFactor / 100);
+};
+
 export const localSettings = {
   disableMediaKeys,
   enableMediaKeys,
   get,
+  passwordGet,
+  passwordRemove,
+  passwordSet,
   restart,
   set,
+  setZoomFactor,
 };

src/main/preload/lyrics.ts

@@ -0,0 +1,23 @@
+import { ipcRenderer } from 'electron';
+import { LyricSearchQuery, QueueSong } from '/@/renderer/api/types';
+
+const getRemoteLyricsBySong = (song: QueueSong) => {
+  const result = ipcRenderer.invoke('lyric-by-song', song);
+  return result;
+};
+
+const searchRemoteLyrics = (params: LyricSearchQuery) => {
+  const result = ipcRenderer.invoke('lyric-search', params);
+  return result;
+};
+
+const getRemoteLyricsByRemoteId = (id: string) => {
+  const result = ipcRenderer.invoke('lyric-by-remote-id', id);
+  return result;
+};
+
+export const lyrics = {
+  getRemoteLyricsByRemoteId,
+  getRemoteLyricsBySong,
+  searchRemoteLyrics,
+};

src/main/preload/mpris.ts

@@ -0,0 +1,70 @@
+import { IpcRendererEvent, ipcRenderer } from 'electron';
+import { QueueSong } from '/@/renderer/api/types';
+
+const updateSong = (args: { currentTime: number; song: QueueSong }) => {
+  ipcRenderer.send('mpris-update-song', args);
+};
+
+const updatePosition = (timeSec: number) => {
+  ipcRenderer.send('mpris-update-position', timeSec);
+};
+
+const updateSeek = (timeSec: number) => {
+  ipcRenderer.send('mpris-update-seek', timeSec);
+};
+
+const updateVolume = (volume: number) => {
+  ipcRenderer.send('mpris-update-volume', volume);
+};
+
+const updateRepeat = (repeat: string) => {
+  ipcRenderer.send('mpris-update-repeat', repeat);
+};
+
+const updateShuffle = (shuffle: boolean) => {
+  ipcRenderer.send('mpris-update-shuffle', shuffle);
+};
+
+const toggleRepeat = () => {
+  ipcRenderer.send('mpris-toggle-repeat');
+};
+
+const toggleShuffle = () => {
+  ipcRenderer.send('mpris-toggle-shuffle');
+};
+
+const requestPosition = (cb: (event: IpcRendererEvent, data: { position: number }) => void) => {
+  ipcRenderer.on('mpris-request-position', cb);
+};
+
+const requestSeek = (cb: (event: IpcRendererEvent, data: { offset: number }) => void) => {
+  ipcRenderer.on('mpris-request-seek', cb);
+};
+
+const requestVolume = (cb: (event: IpcRendererEvent, data: { volume: number }) => void) => {
+  ipcRenderer.on('mpris-request-volume', cb);
+};
+
+const requestToggleRepeat = (cb: (event: IpcRendererEvent) => void) => {
+  ipcRenderer.on('mpris-request-toggle-repeat', cb);
+};
+
+const requestToggleShuffle = (cb: (event: IpcRendererEvent) => void) => {
+  ipcRenderer.on('mpris-request-toggle-shuffle', cb);
+};
+
+export const mpris = {
+  requestPosition,
+  requestSeek,
+  requestToggleRepeat,
+  requestToggleShuffle,
+  requestVolume,
+  toggleRepeat,
+  toggleShuffle,
+  updatePosition,
+  updateRepeat,
+  updateSeek,
+  updateShuffle,
+  updateSong,
+  updateVolume,
+};

src/main/preload/mpv-player.ts

@@ -1,6 +1,27 @@
 import { ipcRenderer, IpcRendererEvent } from 'electron';
 import { PlayerData } from '/@/renderer/store';
 
+const initialize = (data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
+  ipcRenderer.send('player-initialize', data);
+};
+
+const restart = (data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
+  ipcRenderer.send('player-restart', data);
+};
+
+const isRunning = () => {
+  return ipcRenderer.invoke('player-is-running');
+};
+
+const cleanup = () => {
+  return ipcRenderer.invoke('player-clean-up');
+};
+
+const setProperties = (data: Record<string, any>) => {
+  console.log('Setting property :>>', data);
+  ipcRenderer.send('player-set-properties', data);
+};
+
 const autoNext = (data: PlayerData) => {
   ipcRenderer.send('player-auto-next', data);
 };
@@ -8,36 +29,55 @@ const autoNext = (data: PlayerData) => {
 const currentTime = () => {
   ipcRenderer.send('player-current-time');
 };
+
 const mute = () => {
   ipcRenderer.send('player-mute');
 };
+
 const next = () => {
   ipcRenderer.send('player-next');
 };
+
 const pause = () => {
   ipcRenderer.send('player-pause');
 };
+
 const play = () => {
   ipcRenderer.send('player-play');
 };
+
 const previous = () => {
   ipcRenderer.send('player-previous');
 };
+
+const restoreQueue = () => {
+  ipcRenderer.send('player-restore-queue');
+};
+
+const saveQueue = (data: Record<string, any>) => {
+  ipcRenderer.send('player-save-queue', data);
+};
+
 const seek = (seconds: number) => {
   ipcRenderer.send('player-seek', seconds);
 };
+
 const seekTo = (seconds: number) => {
   ipcRenderer.send('player-seek-to', seconds);
 };
-const setQueue = (data: PlayerData) => {
-  ipcRenderer.send('player-set-queue', data);
+
+const setQueue = (data: PlayerData, pause?: boolean) => {
+  ipcRenderer.send('player-set-queue', data, pause);
 };
+
 const setQueueNext = (data: PlayerData) => {
   ipcRenderer.send('player-set-queue-next', data);
 };
+
 const stop = () => {
   ipcRenderer.send('player-stop');
 };
+
 const volume = (value: number) => {
   ipcRenderer.send('player-volume', value);
 };
@@ -46,6 +86,10 @@ const quit = () => {
   ipcRenderer.send('player-quit');
 };
 
+const getCurrentTime = async () => {
+  return ipcRenderer.invoke('player-get-time');
+};
+
 const rendererAutoNext = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
   ipcRenderer.on('renderer-player-auto-next', cb);
 };
@@ -78,21 +122,69 @@ const rendererStop = (cb: (event: IpcRendererEvent, data: PlayerData) => void) =
   ipcRenderer.on('renderer-player-stop', cb);
 };
 
+const rendererSkipForward = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-skip-forward', cb);
+};
+
+const rendererSkipBackward = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-skip-backward', cb);
+};
+
+const rendererVolumeUp = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-volume-up', cb);
+};
+
+const rendererVolumeDown = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-volume-down', cb);
+};
+
+const rendererVolumeMute = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-volume-mute', cb);
+};
+
+const rendererToggleRepeat = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-toggle-repeat', cb);
+};
+
+const rendererToggleShuffle = (cb: (event: IpcRendererEvent, data: PlayerData) => void) => {
+  ipcRenderer.on('renderer-player-toggle-shuffle', cb);
+};
+
 const rendererQuit = (cb: (event: IpcRendererEvent) => void) => {
   ipcRenderer.on('renderer-player-quit', cb);
 };
 
+const rendererSaveQueue = (cb: (event: IpcRendererEvent) => void) => {
+  ipcRenderer.on('renderer-player-save-queue', cb);
+};
+
+const rendererRestoreQueue = (cb: (event: IpcRendererEvent) => void) => {
+  ipcRenderer.on('renderer-player-restore-queue', cb);
+};
+
+const rendererError = (cb: (event: IpcRendererEvent, data: string) => void) => {
+  ipcRenderer.on('renderer-player-error', cb);
+};
+
 export const mpvPlayer = {
   autoNext,
+  cleanup,
   currentTime,
+  getCurrentTime,
+  initialize,
+  isRunning,
   mute,
   next,
   pause,
   play,
   previous,
   quit,
+  restart,
+  restoreQueue,
+  saveQueue,
   seek,
   seekTo,
+  setProperties,
   setQueue,
   setQueueNext,
   stop,
@@ -102,11 +194,21 @@ export const mpvPlayer = {
 export const mpvPlayerListener = {
   rendererAutoNext,
   rendererCurrentTime,
+  rendererError,
   rendererNext,
   rendererPause,
   rendererPlay,
   rendererPlayPause,
   rendererPrevious,
   rendererQuit,
+  rendererRestoreQueue,
+  rendererSaveQueue,
+  rendererSkipBackward,
+  rendererSkipForward,
   rendererStop,
+  rendererToggleRepeat,
+  rendererToggleShuffle,
+  rendererVolumeDown,
+  rendererVolumeMute,
+  rendererVolumeUp,
 };

src/main/preload/utils.ts

@@ -0,0 +1,7 @@
+import { isMacOS, isWindows, isLinux } from '../utils';
+
+export const utils = {
+  isLinux,
+  isMacOS,
+  isWindows,
+};

src/main/utils.ts

@@ -29,3 +29,24 @@ export const isWindows = () => {
 export const isLinux = () => {
   return process.platform === 'linux';
 };
+
+export const hotkeyToElectronAccelerator = (hotkey: string) => {
+  let accelerator = hotkey;
+
+  const replacements = {
+    mod: 'CmdOrCtrl',
+    numpad: 'num',
+    numpadadd: 'numadd',
+    numpaddecimal: 'numdec',
+    numpaddivide: 'numdiv',
+    numpadenter: 'numenter',
+    numpadmultiply: 'nummult',
+    numpadsubtract: 'numsub',
+  };
+
+  Object.keys(replacements).forEach((key) => {
+    accelerator = accelerator.replace(key, replacements[key as keyof typeof replacements]);
+  });
+
+  return accelerator;
+};

src/renderer/api/controller.ts

@@ -1,69 +1,98 @@
 import { useAuthStore } from '/@/renderer/store';
-import { navidromeApi } from '/@/renderer/api/navidrome.api';
-import { toast } from '/@/renderer/components/toast';
+import { toast } from '/@/renderer/components/toast/index';
 import type {
   AlbumDetailArgs,
-  RawAlbumDetailResponse,
-  RawAlbumListResponse,
   AlbumListArgs,
   SongListArgs,
-  RawSongListResponse,
   SongDetailArgs,
-  RawSongDetailResponse,
   AlbumArtistDetailArgs,
-  RawAlbumArtistDetailResponse,
   AlbumArtistListArgs,
-  RawAlbumArtistListResponse,
-  RatingArgs,
-  RawRatingResponse,
-  FavoriteArgs,
-  RawFavoriteResponse,
+  SetRatingArgs,
   GenreListArgs,
-  RawGenreListResponse,
   CreatePlaylistArgs,
-  RawCreatePlaylistResponse,
   DeletePlaylistArgs,
-  RawDeletePlaylistResponse,
   PlaylistDetailArgs,
-  RawPlaylistDetailResponse,
   PlaylistListArgs,
-  RawPlaylistListResponse,
   MusicFolderListArgs,
-  RawMusicFolderListResponse,
   PlaylistSongListArgs,
   ArtistListArgs,
-  RawArtistListResponse,
   UpdatePlaylistArgs,
-  RawUpdatePlaylistResponse,
+  UserListArgs,
+  FavoriteArgs,
+  TopSongListArgs,
+  AddToPlaylistArgs,
+  AddToPlaylistResponse,
+  RemoveFromPlaylistArgs,
+  RemoveFromPlaylistResponse,
+  ScrobbleArgs,
+  ScrobbleResponse,
+  AlbumArtistDetailResponse,
+  FavoriteResponse,
+  CreatePlaylistResponse,
+  AlbumArtistListResponse,
+  AlbumDetailResponse,
+  AlbumListResponse,
+  ArtistListResponse,
+  GenreListResponse,
+  MusicFolderListResponse,
+  PlaylistDetailResponse,
+  PlaylistListResponse,
+  RatingResponse,
+  SongDetailResponse,
+  SongListResponse,
+  TopSongListResponse,
+  UpdatePlaylistResponse,
+  UserListResponse,
+  AuthenticationResponse,
+  SearchArgs,
+  SearchResponse,
+  LyricsArgs,
+  LyricsResponse,
 } from '/@/renderer/api/types';
-import { subsonicApi } from '/@/renderer/api/subsonic.api';
-import { jellyfinApi } from '/@/renderer/api/jellyfin.api';
+import { ServerType } from '/@/renderer/types';
+import { DeletePlaylistResponse, RandomSongListArgs } from './types';
+import { ndController } from '/@/renderer/api/navidrome/navidrome-controller';
+import { ssController } from '/@/renderer/api/subsonic/subsonic-controller';
+import { jfController } from '/@/renderer/api/jellyfin/jellyfin-controller';
 
 export type ControllerEndpoint = Partial<{
+  addToPlaylist: (args: AddToPlaylistArgs) => Promise<AddToPlaylistResponse>;
+  authenticate: (
+    url: string,
+    body: { password: string; username: string },
+  ) => Promise<AuthenticationResponse>;
   clearPlaylist: () => void;
-  createFavorite: (args: FavoriteArgs) => Promise<RawFavoriteResponse>;
-  createPlaylist: (args: CreatePlaylistArgs) => Promise<RawCreatePlaylistResponse>;
-  deleteFavorite: (args: FavoriteArgs) => Promise<RawFavoriteResponse>;
-  deletePlaylist: (args: DeletePlaylistArgs) => Promise<RawDeletePlaylistResponse>;
-  getAlbumArtistDetail: (args: AlbumArtistDetailArgs) => Promise<RawAlbumArtistDetailResponse>;
-  getAlbumArtistList: (args: AlbumArtistListArgs) => Promise<RawAlbumArtistListResponse>;
-  getAlbumDetail: (args: AlbumDetailArgs) => Promise<RawAlbumDetailResponse>;
-  getAlbumList: (args: AlbumListArgs) => Promise<RawAlbumListResponse>;
+  createFavorite: (args: FavoriteArgs) => Promise<FavoriteResponse>;
+  createPlaylist: (args: CreatePlaylistArgs) => Promise<CreatePlaylistResponse>;
+  deleteFavorite: (args: FavoriteArgs) => Promise<FavoriteResponse>;
+  deletePlaylist: (args: DeletePlaylistArgs) => Promise<DeletePlaylistResponse>;
+  getAlbumArtistDetail: (args: AlbumArtistDetailArgs) => Promise<AlbumArtistDetailResponse>;
+  getAlbumArtistList: (args: AlbumArtistListArgs) => Promise<AlbumArtistListResponse>;
+  getAlbumDetail: (args: AlbumDetailArgs) => Promise<AlbumDetailResponse>;
+  getAlbumList: (args: AlbumListArgs) => Promise<AlbumListResponse>;
   getArtistDetail: () => void;
-  getArtistList: (args: ArtistListArgs) => Promise<RawArtistListResponse>;
+  getArtistInfo: (args: any) => void;
+  getArtistList: (args: ArtistListArgs) => Promise<ArtistListResponse>;
   getFavoritesList: () => void;
   getFolderItemList: () => void;
   getFolderList: () => void;
   getFolderSongs: () => void;
-  getGenreList: (args: GenreListArgs) => Promise<RawGenreListResponse>;
-  getMusicFolderList: (args: MusicFolderListArgs) => Promise<RawMusicFolderListResponse>;
-  getPlaylistDetail: (args: PlaylistDetailArgs) => Promise<RawPlaylistDetailResponse>;
-  getPlaylistList: (args: PlaylistListArgs) => Promise<RawPlaylistListResponse>;
-  getPlaylistSongList: (args: PlaylistSongListArgs) => Promise<RawSongListResponse>;
-  getSongDetail: (args: SongDetailArgs) => Promise<RawSongDetailResponse>;
-  getSongList: (args: SongListArgs) => Promise<RawSongListResponse>;
-  updatePlaylist: (args: UpdatePlaylistArgs) => Promise<RawUpdatePlaylistResponse>;
-  updateRating: (args: RatingArgs) => Promise<RawRatingResponse>;
+  getGenreList: (args: GenreListArgs) => Promise<GenreListResponse>;
+  getLyrics: (args: LyricsArgs) => Promise<LyricsResponse>;
+  getMusicFolderList: (args: MusicFolderListArgs) => Promise<MusicFolderListResponse>;
+  getPlaylistDetail: (args: PlaylistDetailArgs) => Promise<PlaylistDetailResponse>;
+  getPlaylistList: (args: PlaylistListArgs) => Promise<PlaylistListResponse>;
+  getPlaylistSongList: (args: PlaylistSongListArgs) => Promise<SongListResponse>;
+  getRandomSongList: (args: RandomSongListArgs) => Promise<SongListResponse>;
+  getSongDetail: (args: SongDetailArgs) => Promise<SongDetailResponse>;
+  getSongList: (args: SongListArgs) => Promise<SongListResponse>;
+  getTopSongs: (args: TopSongListArgs) => Promise<TopSongListResponse>;
+  getUserList: (args: UserListArgs) => Promise<UserListResponse>;
+  removeFromPlaylist: (args: RemoveFromPlaylistArgs) => Promise<RemoveFromPlaylistResponse>;
+  scrobble: (args: ScrobbleArgs) => Promise<ScrobbleResponse>;
+  search: (args: SearchArgs) => Promise<SearchResponse>;
+  setRating: (args: SetRatingArgs) => Promise<RatingResponse>;
+  updatePlaylist: (args: UpdatePlaylistArgs) => Promise<UpdatePlaylistResponse>;
 }>;
 
 type ApiController = {
@@ -74,171 +103,389 @@ type ApiController = {
 
 const endpoints: ApiController = {
   jellyfin: {
+    addToPlaylist: jfController.addToPlaylist,
+    authenticate: jfController.authenticate,
     clearPlaylist: undefined,
-    createFavorite: jellyfinApi.createFavorite,
-    createPlaylist: jellyfinApi.createPlaylist,
-    deleteFavorite: jellyfinApi.deleteFavorite,
-    deletePlaylist: jellyfinApi.deletePlaylist,
-    getAlbumArtistDetail: jellyfinApi.getAlbumArtistDetail,
-    getAlbumArtistList: jellyfinApi.getAlbumArtistList,
-    getAlbumDetail: jellyfinApi.getAlbumDetail,
-    getAlbumList: jellyfinApi.getAlbumList,
-    getArtistDetail: undefined,
-    getArtistList: jellyfinApi.getArtistList,
-    getFavoritesList: undefined,
-    getFolderItemList: undefined,
-    getFolderList: undefined,
-    getFolderSongs: undefined,
-    getGenreList: jellyfinApi.getGenreList,
-    getMusicFolderList: jellyfinApi.getMusicFolderList,
-    getPlaylistDetail: jellyfinApi.getPlaylistDetail,
-    getPlaylistList: jellyfinApi.getPlaylistList,
-    getPlaylistSongList: jellyfinApi.getPlaylistSongList,
-    getSongDetail: undefined,
-    getSongList: jellyfinApi.getSongList,
-    updatePlaylist: jellyfinApi.updatePlaylist,
-    updateRating: undefined,
-  },
-  navidrome: {
-    clearPlaylist: undefined,
-    createFavorite: subsonicApi.createFavorite,
-    createPlaylist: navidromeApi.createPlaylist,
-    deleteFavorite: subsonicApi.deleteFavorite,
-    deletePlaylist: navidromeApi.deletePlaylist,
-    getAlbumArtistDetail: navidromeApi.getAlbumArtistDetail,
-    getAlbumArtistList: navidromeApi.getAlbumArtistList,
-    getAlbumDetail: navidromeApi.getAlbumDetail,
-    getAlbumList: navidromeApi.getAlbumList,
+    createFavorite: jfController.createFavorite,
+    createPlaylist: jfController.createPlaylist,
+    deleteFavorite: jfController.deleteFavorite,
+    deletePlaylist: jfController.deletePlaylist,
+    getAlbumArtistDetail: jfController.getAlbumArtistDetail,
+    getAlbumArtistList: jfController.getAlbumArtistList,
+    getAlbumDetail: jfController.getAlbumDetail,
+    getAlbumList: jfController.getAlbumList,
     getArtistDetail: undefined,
+    getArtistInfo: undefined,
     getArtistList: undefined,
     getFavoritesList: undefined,
     getFolderItemList: undefined,
     getFolderList: undefined,
     getFolderSongs: undefined,
-    getGenreList: navidromeApi.getGenreList,
-    getMusicFolderList: subsonicApi.getMusicFolderList,
-    getPlaylistDetail: navidromeApi.getPlaylistDetail,
-    getPlaylistList: navidromeApi.getPlaylistList,
-    getPlaylistSongList: navidromeApi.getPlaylistSongList,
-    getSongDetail: navidromeApi.getSongDetail,
-    getSongList: navidromeApi.getSongList,
-    updatePlaylist: navidromeApi.updatePlaylist,
-    updateRating: subsonicApi.updateRating,
+    getGenreList: jfController.getGenreList,
+    getLyrics: jfController.getLyrics,
+    getMusicFolderList: jfController.getMusicFolderList,
+    getPlaylistDetail: jfController.getPlaylistDetail,
+    getPlaylistList: jfController.getPlaylistList,
+    getPlaylistSongList: jfController.getPlaylistSongList,
+    getRandomSongList: jfController.getRandomSongList,
+    getSongDetail: undefined,
+    getSongList: jfController.getSongList,
+    getTopSongs: jfController.getTopSongList,
+    getUserList: undefined,
+    removeFromPlaylist: jfController.removeFromPlaylist,
+    scrobble: jfController.scrobble,
+    search: jfController.search,
+    setRating: undefined,
+    updatePlaylist: jfController.updatePlaylist,
+  },
+  navidrome: {
+    addToPlaylist: ndController.addToPlaylist,
+    authenticate: ndController.authenticate,
+    clearPlaylist: undefined,
+    createFavorite: ssController.createFavorite,
+    createPlaylist: ndController.createPlaylist,
+    deleteFavorite: ssController.removeFavorite,
+    deletePlaylist: ndController.deletePlaylist,
+    getAlbumArtistDetail: ndController.getAlbumArtistDetail,
+    getAlbumArtistList: ndController.getAlbumArtistList,
+    getAlbumDetail: ndController.getAlbumDetail,
+    getAlbumList: ndController.getAlbumList,
+    getArtistDetail: undefined,
+    getArtistInfo: undefined,
+    getArtistList: undefined,
+    getFavoritesList: undefined,
+    getFolderItemList: undefined,
+    getFolderList: undefined,
+    getFolderSongs: undefined,
+    getGenreList: ndController.getGenreList,
+    getLyrics: undefined,
+    getMusicFolderList: ssController.getMusicFolderList,
+    getPlaylistDetail: ndController.getPlaylistDetail,
+    getPlaylistList: ndController.getPlaylistList,
+    getPlaylistSongList: ndController.getPlaylistSongList,
+    getRandomSongList: ssController.getRandomSongList,
+    getSongDetail: ndController.getSongDetail,
+    getSongList: ndController.getSongList,
+    getTopSongs: ssController.getTopSongList,
+    getUserList: ndController.getUserList,
+    removeFromPlaylist: ndController.removeFromPlaylist,
+    scrobble: ssController.scrobble,
+    search: ssController.search3,
+    setRating: ssController.setRating,
+    updatePlaylist: ndController.updatePlaylist,
   },
   subsonic: {
+    authenticate: ssController.authenticate,
     clearPlaylist: undefined,
-    createFavorite: subsonicApi.createFavorite,
+    createFavorite: ssController.createFavorite,
     createPlaylist: undefined,
-    deleteFavorite: subsonicApi.deleteFavorite,
+    deleteFavorite: ssController.removeFavorite,
     deletePlaylist: undefined,
-    getAlbumArtistDetail: subsonicApi.getAlbumArtistDetail,
-    getAlbumArtistList: subsonicApi.getAlbumArtistList,
-    getAlbumDetail: subsonicApi.getAlbumDetail,
-    getAlbumList: subsonicApi.getAlbumList,
+    getAlbumArtistDetail: undefined,
+    getAlbumArtistList: undefined,
+    getAlbumDetail: undefined,
+    getAlbumList: undefined,
     getArtistDetail: undefined,
+    getArtistInfo: undefined,
     getArtistList: undefined,
     getFavoritesList: undefined,
     getFolderItemList: undefined,
     getFolderList: undefined,
     getFolderSongs: undefined,
     getGenreList: undefined,
-    getMusicFolderList: subsonicApi.getMusicFolderList,
+    getLyrics: undefined,
+    getMusicFolderList: ssController.getMusicFolderList,
     getPlaylistDetail: undefined,
     getPlaylistList: undefined,
     getSongDetail: undefined,
     getSongList: undefined,
+    getTopSongs: ssController.getTopSongList,
+    getUserList: undefined,
+    scrobble: ssController.scrobble,
+    search: ssController.search3,
+    setRating: undefined,
     updatePlaylist: undefined,
-    updateRating: undefined,
   },
 };
 
-const apiController = (endpoint: keyof ControllerEndpoint) => {
-  const serverType = useAuthStore.getState().currentServer?.type;
+const apiController = (endpoint: keyof ControllerEndpoint, type?: ServerType) => {
+  const serverType = type || useAuthStore.getState().currentServer?.type;
 
   if (!serverType) {
     toast.error({ message: 'No server selected', title: 'Unable to route request' });
-    return () => undefined;
+    throw new Error(`No server selected`);
   }
 
-  const controllerFn = endpoints[serverType][endpoint];
+  const controllerFn = endpoints?.[serverType]?.[endpoint];
 
   if (typeof controllerFn !== 'function') {
     toast.error({
       message: `Endpoint ${endpoint} is not implemented for ${serverType}`,
       title: 'Unable to route request',
     });
-    return () => undefined;
+
+    throw new Error(`Endpoint ${endpoint} is not implemented for ${serverType}`);
   }
 
   return endpoints[serverType][endpoint];
 };
 
+const authenticate = async (
+  url: string,
+  body: { legacy?: boolean; password: string; username: string },
+  type: ServerType,
+) => {
+  return (apiController('authenticate', type) as ControllerEndpoint['authenticate'])?.(url, body);
+};
+
 const getAlbumList = async (args: AlbumListArgs) => {
-  return (apiController('getAlbumList') as ControllerEndpoint['getAlbumList'])?.(args);
+  return (
+    apiController(
+      'getAlbumList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getAlbumList']
+  )?.(args);
 };
 
 const getAlbumDetail = async (args: AlbumDetailArgs) => {
-  return (apiController('getAlbumDetail') as ControllerEndpoint['getAlbumDetail'])?.(args);
+  return (
+    apiController(
+      'getAlbumDetail',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getAlbumDetail']
+  )?.(args);
 };
 
 const getSongList = async (args: SongListArgs) => {
-  return (apiController('getSongList') as ControllerEndpoint['getSongList'])?.(args);
+  return (
+    apiController(
+      'getSongList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getSongList']
+  )?.(args);
+};
+
+const getSongDetail = async (args: SongDetailArgs) => {
+  return (
+    apiController(
+      'getSongDetail',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getSongDetail']
+  )?.(args);
 };
 
 const getMusicFolderList = async (args: MusicFolderListArgs) => {
-  return (apiController('getMusicFolderList') as ControllerEndpoint['getMusicFolderList'])?.(args);
+  return (
+    apiController(
+      'getMusicFolderList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getMusicFolderList']
+  )?.(args);
 };
 
 const getGenreList = async (args: GenreListArgs) => {
-  return (apiController('getGenreList') as ControllerEndpoint['getGenreList'])?.(args);
+  return (
+    apiController(
+      'getGenreList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getGenreList']
+  )?.(args);
+};
+
+const getAlbumArtistDetail = async (args: AlbumArtistDetailArgs) => {
+  return (
+    apiController(
+      'getAlbumArtistDetail',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getAlbumArtistDetail']
+  )?.(args);
 };
 
 const getAlbumArtistList = async (args: AlbumArtistListArgs) => {
-  return (apiController('getAlbumArtistList') as ControllerEndpoint['getAlbumArtistList'])?.(args);
+  return (
+    apiController(
+      'getAlbumArtistList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getAlbumArtistList']
+  )?.(args);
 };
 
 const getArtistList = async (args: ArtistListArgs) => {
-  return (apiController('getArtistList') as ControllerEndpoint['getArtistList'])?.(args);
+  return (
+    apiController(
+      'getArtistList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getArtistList']
+  )?.(args);
 };
 
 const getPlaylistList = async (args: PlaylistListArgs) => {
-  return (apiController('getPlaylistList') as ControllerEndpoint['getPlaylistList'])?.(args);
+  return (
+    apiController(
+      'getPlaylistList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getPlaylistList']
+  )?.(args);
 };
 
 const createPlaylist = async (args: CreatePlaylistArgs) => {
-  return (apiController('createPlaylist') as ControllerEndpoint['createPlaylist'])?.(args);
+  return (
+    apiController(
+      'createPlaylist',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['createPlaylist']
+  )?.(args);
 };
 
 const updatePlaylist = async (args: UpdatePlaylistArgs) => {
-  return (apiController('updatePlaylist') as ControllerEndpoint['updatePlaylist'])?.(args);
+  return (
+    apiController(
+      'updatePlaylist',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['updatePlaylist']
+  )?.(args);
 };
 
 const deletePlaylist = async (args: DeletePlaylistArgs) => {
-  return (apiController('deletePlaylist') as ControllerEndpoint['deletePlaylist'])?.(args);
+  return (
+    apiController(
+      'deletePlaylist',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['deletePlaylist']
+  )?.(args);
+};
+
+const addToPlaylist = async (args: AddToPlaylistArgs) => {
+  return (
+    apiController(
+      'addToPlaylist',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['addToPlaylist']
+  )?.(args);
+};
+
+const removeFromPlaylist = async (args: RemoveFromPlaylistArgs) => {
+  return (
+    apiController(
+      'removeFromPlaylist',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['removeFromPlaylist']
+  )?.(args);
 };
 
 const getPlaylistDetail = async (args: PlaylistDetailArgs) => {
-  return (apiController('getPlaylistDetail') as ControllerEndpoint['getPlaylistDetail'])?.(args);
+  return (
+    apiController(
+      'getPlaylistDetail',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getPlaylistDetail']
+  )?.(args);
 };
 
 const getPlaylistSongList = async (args: PlaylistSongListArgs) => {
-  return (apiController('getPlaylistSongList') as ControllerEndpoint['getPlaylistSongList'])?.(
-    args,
-  );
+  return (
+    apiController(
+      'getPlaylistSongList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getPlaylistSongList']
+  )?.(args);
+};
+
+const getUserList = async (args: UserListArgs) => {
+  return (
+    apiController(
+      'getUserList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getUserList']
+  )?.(args);
+};
+
+const createFavorite = async (args: FavoriteArgs) => {
+  return (
+    apiController(
+      'createFavorite',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['createFavorite']
+  )?.(args);
+};
+
+const deleteFavorite = async (args: FavoriteArgs) => {
+  return (
+    apiController(
+      'deleteFavorite',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['deleteFavorite']
+  )?.(args);
+};
+
+const updateRating = async (args: SetRatingArgs) => {
+  return (
+    apiController('setRating', args.apiClientProps.server?.type) as ControllerEndpoint['setRating']
+  )?.(args);
+};
+
+const getTopSongList = async (args: TopSongListArgs) => {
+  return (
+    apiController(
+      'getTopSongs',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getTopSongs']
+  )?.(args);
+};
+
+const scrobble = async (args: ScrobbleArgs) => {
+  return (
+    apiController('scrobble', args.apiClientProps.server?.type) as ControllerEndpoint['scrobble']
+  )?.(args);
+};
+
+const search = async (args: SearchArgs) => {
+  return (
+    apiController('search', args.apiClientProps.server?.type) as ControllerEndpoint['search']
+  )?.(args);
+};
+
+const getRandomSongList = async (args: RandomSongListArgs) => {
+  return (
+    apiController(
+      'getRandomSongList',
+      args.apiClientProps.server?.type,
+    ) as ControllerEndpoint['getRandomSongList']
+  )?.(args);
+};
+
+const getLyrics = async (args: LyricsArgs) => {
+  return (
+    apiController('getLyrics', args.apiClientProps.server?.type) as ControllerEndpoint['getLyrics']
+  )?.(args);
 };
 
 export const controller = {
+  addToPlaylist,
+  authenticate,
+  createFavorite,
   createPlaylist,
+  deleteFavorite,
   deletePlaylist,
+  getAlbumArtistDetail,
   getAlbumArtistList,
   getAlbumDetail,
   getAlbumList,
   getArtistList,
   getGenreList,
+  getLyrics,
   getMusicFolderList,
   getPlaylistDetail,
   getPlaylistList,
   getPlaylistSongList,
+  getRandomSongList,
+  getSongDetail,
   getSongList,
+  getTopSongList,
+  getUserList,
+  removeFromPlaylist,
+  scrobble,
+  search,
   updatePlaylist,
+  updateRating,
 };

src/renderer/api/index.ts

@@ -1,7 +1,5 @@
 import { controller } from '/@/renderer/api/controller';
-import { normalize } from '/@/renderer/api/normalize';
 
 export const api = {
   controller,
-  normalize,
 };

src/renderer/api/jellyfin.api.ts

@@ -1,847 +0,0 @@
-import ky from 'ky';
-import { nanoid } from 'nanoid/non-secure';
-import type {
-  JFAlbum,
-  JFAlbumArtist,
-  JFAlbumArtistDetail,
-  JFAlbumArtistDetailResponse,
-  JFAlbumArtistList,
-  JFAlbumArtistListParams,
-  JFAlbumArtistListResponse,
-  JFAlbumDetail,
-  JFAlbumDetailResponse,
-  JFAlbumList,
-  JFAlbumListParams,
-  JFAlbumListResponse,
-  JFArtistList,
-  JFArtistListParams,
-  JFArtistListResponse,
-  JFAuthenticate,
-  JFCreatePlaylistResponse,
-  JFGenreList,
-  JFGenreListResponse,
-  JFMusicFolderList,
-  JFMusicFolderListResponse,
-  JFPlaylist,
-  JFPlaylistDetail,
-  JFPlaylistDetailResponse,
-  JFPlaylistList,
-  JFPlaylistListResponse,
-  JFSong,
-  JFSongList,
-  JFSongListParams,
-  JFSongListResponse,
-} from '/@/renderer/api/jellyfin.types';
-import { JFCollectionType } from '/@/renderer/api/jellyfin.types';
-import {
-  Album,
-  AlbumArtist,
-  AlbumArtistDetailArgs,
-  AlbumArtistListArgs,
-  AlbumDetailArgs,
-  AlbumListArgs,
-  ArtistListArgs,
-  AuthenticationResponse,
-  CreatePlaylistArgs,
-  CreatePlaylistResponse,
-  DeletePlaylistArgs,
-  FavoriteArgs,
-  FavoriteResponse,
-  GenreListArgs,
-  MusicFolderListArgs,
-  Playlist,
-  PlaylistDetailArgs,
-  PlaylistListArgs,
-  playlistListSortMap,
-  PlaylistSongListArgs,
-  Song,
-  SongListArgs,
-  songListSortMap,
-  albumListSortMap,
-  artistListSortMap,
-  sortOrderMap,
-  albumArtistListSortMap,
-  UpdatePlaylistArgs,
-  UpdatePlaylistResponse,
-} from '/@/renderer/api/types';
-import { useAuthStore } from '/@/renderer/store';
-import { ServerListItem, ServerType } from '/@/renderer/types';
-import { parseSearchParams } from '/@/renderer/utils';
-
-const getCommaDelimitedString = (value: string[]) => {
-  return value.join(',');
-};
-
-const api = ky.create({});
-
-const authenticate = async (
-  url: string,
-  body: {
-    password: string;
-    username: string;
-  },
-): Promise<AuthenticationResponse> => {
-  const cleanServerUrl = url.replace(/\/$/, '');
-
-  const data = await ky
-    .post(`${cleanServerUrl}/users/authenticatebyname`, {
-      headers: {
-        'X-Emby-Authorization':
-          'MediaBrowser Client="Feishin", Device="PC", DeviceId="Feishin", Version="0.0.1"',
-      },
-      json: {
-        pw: body.password,
-        username: body.username,
-      },
-    })
-    .json<JFAuthenticate>();
-
-  return {
-    credential: data.AccessToken,
-    userId: data.User.Id,
-    username: data.User.Name,
-  };
-};
-
-const getMusicFolderList = async (args: MusicFolderListArgs): Promise<JFMusicFolderList> => {
-  const { server, signal } = args;
-  const userId = useAuthStore.getState().currentServer?.userId;
-
-  const data = await api
-    .get(`users/${userId}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<JFMusicFolderListResponse>();
-
-  const musicFolders = data.Items.filter(
-    (folder) => folder.CollectionType === JFCollectionType.MUSIC,
-  );
-
-  return musicFolders;
-};
-
-const getGenreList = async (args: GenreListArgs): Promise<JFGenreList> => {
-  const { signal, server } = args;
-
-  const data = await api
-    .get('genres', {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<JFGenreListResponse>();
-  return data;
-};
-
-const getAlbumArtistDetail = async (args: AlbumArtistDetailArgs): Promise<JFAlbumArtistDetail> => {
-  const { query, server, signal } = args;
-
-  const searchParams = {
-    fields: 'Genres',
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items/${query.id}`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFAlbumArtistDetailResponse>();
-
-  return data;
-};
-
-// const getAlbumArtistAlbums = () => {
-//   const { data: albumData } = await api.get(`/users/${auth.username}/items`, {
-//     params: {
-//       artistIds: options.id,
-//       fields: 'AudioInfo, ParentId, Genres, DateCreated, ChildCount, ParentId',
-//       includeItemTypes: 'MusicAlbum',
-//       parentId: options.musicFolderId,
-//       recursive: true,
-//       sortBy: 'SortName',
-//     },
-//   });
-
-//   const { data: similarData } = await api.get(`/artists/${options.id}/similar`, {
-//     params: { limit: 15, parentId: options.musicFolderId, userId: auth.username },
-//   });
-// };
-
-const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<JFAlbumArtistList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: JFAlbumArtistListParams = {
-    fields: 'Genres, DateCreated, ExternalUrls, Overview',
-    imageTypeLimit: 1,
-    limit: query.limit,
-    parentId: query.musicFolderId,
-    recursive: true,
-    searchTerm: query.searchTerm,
-    sortBy: albumArtistListSortMap.jellyfin[query.sortBy],
-    sortOrder: sortOrderMap.jellyfin[query.sortOrder],
-    startIndex: query.startIndex,
-    userId: server?.userId || undefined,
-  };
-
-  const data = await api
-    .get('artists/albumArtists', {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFAlbumArtistListResponse>();
-
-  return {
-    items: data.Items,
-    startIndex: query.startIndex,
-    totalRecordCount: data.TotalRecordCount,
-  };
-};
-
-const getArtistList = async (args: ArtistListArgs): Promise<JFArtistList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: JFArtistListParams = {
-    limit: query.limit,
-    parentId: query.musicFolderId,
-    recursive: true,
-    sortBy: artistListSortMap.jellyfin[query.sortBy],
-    sortOrder: sortOrderMap.jellyfin[query.sortOrder],
-    startIndex: query.startIndex,
-  };
-
-  const data = await api
-    .get('artists', {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFArtistListResponse>();
-
-  return data;
-};
-
-const getAlbumDetail = async (args: AlbumDetailArgs): Promise<JFAlbumDetail> => {
-  const { query, server, signal } = args;
-
-  const searchParams = {
-    fields: 'Genres, DateCreated, ChildCount',
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items/${query.id}`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<JFAlbumDetailResponse>();
-
-  const songsSearchParams = {
-    fields: 'Genres, DateCreated, MediaSources, ParentId',
-    parentId: query.id,
-    sortBy: 'SortName',
-  };
-
-  const songsData = await api
-    .get(`users/${server?.userId}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: songsSearchParams,
-      signal,
-    })
-    .json<JFSongListResponse>();
-
-  return { ...data, songs: songsData.Items };
-};
-
-const getAlbumList = async (args: AlbumListArgs): Promise<JFAlbumList> => {
-  const { query, server, signal } = args;
-
-  const yearsGroup = [];
-  if (query.jfParams?.minYear && query.jfParams?.maxYear) {
-    for (let i = Number(query.jfParams.minYear); i <= Number(query.jfParams.maxYear); i += 1) {
-      yearsGroup.push(String(i));
-    }
-  }
-
-  const yearsFilter = yearsGroup.length ? yearsGroup.join(',') : undefined;
-
-  const searchParams: JFAlbumListParams & { maxYear?: number; minYear?: number } = {
-    includeItemTypes: 'MusicAlbum',
-    limit: query.limit,
-    parentId: query.musicFolderId,
-    recursive: true,
-    searchTerm: query.searchTerm,
-    sortBy: albumListSortMap.jellyfin[query.sortBy],
-    sortOrder: sortOrderMap.jellyfin[query.sortOrder],
-    startIndex: query.startIndex,
-    ...query.jfParams,
-    maxYear: undefined,
-    minYear: undefined,
-    years: yearsFilter,
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFAlbumListResponse>();
-
-  return {
-    items: data.Items,
-    startIndex: query.startIndex,
-    totalRecordCount: data.TotalRecordCount,
-  };
-};
-
-const getSongList = async (args: SongListArgs): Promise<JFSongList> => {
-  const { query, server, signal } = args;
-
-  const yearsGroup = [];
-  if (query.jfParams?.minYear && query.jfParams?.maxYear) {
-    for (let i = Number(query.jfParams.minYear); i <= Number(query.jfParams.maxYear); i += 1) {
-      yearsGroup.push(String(i));
-    }
-  }
-
-  const yearsFilter = yearsGroup.length ? getCommaDelimitedString(yearsGroup) : undefined;
-  const albumIdsFilter = query.albumIds ? getCommaDelimitedString(query.albumIds) : undefined;
-  const artistIdsFilter = query.artistIds ? getCommaDelimitedString(query.artistIds) : undefined;
-
-  const searchParams: JFSongListParams & { maxYear?: number; minYear?: number } = {
-    albumIds: albumIdsFilter,
-    artistIds: artistIdsFilter,
-    fields: 'Genres, DateCreated, MediaSources, ParentId',
-    includeItemTypes: 'Audio',
-    limit: query.limit,
-    parentId: query.musicFolderId,
-    recursive: true,
-    searchTerm: query.searchTerm,
-    sortBy: songListSortMap.jellyfin[query.sortBy],
-    sortOrder: sortOrderMap.jellyfin[query.sortOrder],
-    startIndex: query.startIndex,
-    ...query.jfParams,
-    maxYear: undefined,
-    minYear: undefined,
-    years: yearsFilter,
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFSongListResponse>();
-
-  return {
-    items: data.Items,
-    startIndex: query.startIndex,
-    totalRecordCount: data.TotalRecordCount,
-  };
-};
-
-const getPlaylistDetail = async (args: PlaylistDetailArgs): Promise<JFPlaylistDetail> => {
-  const { query, server, signal } = args;
-
-  const searchParams = {
-    fields: 'Genres, DateCreated, MediaSources, ChildCount, ParentId',
-    ids: query.id,
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items/${query.id}`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<JFPlaylistDetailResponse>();
-
-  return data;
-};
-
-const getPlaylistSongList = async (args: PlaylistSongListArgs): Promise<JFSongList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: JFSongListParams = {
-    fields: 'Genres, DateCreated, MediaSources, UserData, ParentId',
-    includeItemTypes: 'Audio',
-    limit: query.limit,
-    sortBy: query.sortBy ? songListSortMap.jellyfin[query.sortBy] : undefined,
-    sortOrder: query.sortOrder ? sortOrderMap.jellyfin[query.sortOrder] : undefined,
-    startIndex: 0,
-    userId: server?.userId || '',
-  };
-
-  const data = await api
-    .get(`playlists/${query.id}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFSongListResponse>();
-
-  return {
-    items: data.Items,
-    startIndex: query.startIndex,
-    totalRecordCount: data.TotalRecordCount,
-  };
-};
-
-const getPlaylistList = async (args: PlaylistListArgs): Promise<JFPlaylistList> => {
-  const { query, server, signal } = args;
-
-  const searchParams = {
-    fields: 'ChildCount, Genres, DateCreated, ParentId, Overview',
-    includeItemTypes: 'Playlist',
-    limit: query.limit,
-    recursive: true,
-    sortBy: playlistListSortMap.jellyfin[query.sortBy],
-    sortOrder: sortOrderMap.jellyfin[query.sortOrder],
-    startIndex: query.startIndex,
-  };
-
-  const data = await api
-    .get(`users/${server?.userId}/items`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      prefixUrl: server?.url,
-      searchParams: parseSearchParams(searchParams),
-      signal,
-    })
-    .json<JFPlaylistListResponse>();
-
-  const playlistItems = data.Items.filter((item) => item.MediaType === 'Audio');
-
-  return {
-    items: playlistItems,
-    startIndex: 0,
-    totalRecordCount: playlistItems.length,
-  };
-};
-
-const createPlaylist = async (args: CreatePlaylistArgs): Promise<CreatePlaylistResponse> => {
-  const { query, server } = args;
-
-  const body = {
-    MediaType: 'Audio',
-    Name: query.name,
-    Overview: query.comment || '',
-    UserId: server?.userId,
-  };
-
-  const data = await api
-    .post('playlists', {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      json: body,
-      prefixUrl: server?.url,
-    })
-    .json<JFCreatePlaylistResponse>();
-
-  return {
-    id: data.Id,
-    name: query.name,
-  };
-};
-
-const updatePlaylist = async (args: UpdatePlaylistArgs): Promise<UpdatePlaylistResponse> => {
-  const { query, body, server } = args;
-
-  const json = {
-    Genres: body.genres?.map((item) => ({ Id: item.id, Name: item.name })) || [],
-    MediaType: 'Audio',
-    Name: body.name,
-    Overview: body.comment || '',
-    PremiereDate: null,
-    ProviderIds: {},
-    Tags: [],
-    UserId: server?.userId, // Required
-  };
-
-  await api
-    .post(`items/${query.id}`, {
-      headers: { 'X-MediaBrowser-Token': server?.credential },
-      json,
-      prefixUrl: server?.url,
-    })
-    .json<null>();
-
-  return {
-    id: query.id,
-  };
-};
-
-const deletePlaylist = async (args: DeletePlaylistArgs): Promise<null> => {
-  const { query, server } = args;
-
-  await api.delete(`items/${query.id}`, {
-    headers: { 'X-MediaBrowser-Token': server?.credential },
-    prefixUrl: server?.url,
-  });
-
-  return null;
-};
-
-const createFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
-  const { query, server } = args;
-
-  await api.post(`users/${server?.userId}/favoriteitems/${query.id}`, {
-    headers: { 'X-MediaBrowser-Token': server?.credential },
-    prefixUrl: server?.url,
-  });
-
-  return {
-    id: query.id,
-  };
-};
-
-const deleteFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
-  const { query, server } = args;
-
-  await api.delete(`users/${server?.userId}/favoriteitems/${query.id}`, {
-    headers: { 'X-MediaBrowser-Token': server?.credential },
-    prefixUrl: server?.url,
-  });
-
-  return {
-    id: query.id,
-  };
-};
-
-const getStreamUrl = (args: {
-  container?: string;
-  deviceId: string;
-  eTag?: string;
-  id: string;
-  mediaSourceId?: string;
-  server: ServerListItem;
-}) => {
-  const { id, server, deviceId } = args;
-
-  return (
-    `${server?.url}/audio` +
-    `/${id}/universal` +
-    `?userId=${server.userId}` +
-    `&deviceId=${deviceId}` +
-    '&audioCodec=aac' +
-    `&api_key=${server.credential}` +
-    `&playSessionId=${deviceId}` +
-    '&container=opus,mp3,aac,m4a,m4b,flac,wav,ogg' +
-    '&transcodingContainer=ts' +
-    '&transcodingProtocol=hls'
-  );
-};
-
-const getAlbumArtistCoverArtUrl = (args: {
-  baseUrl: string;
-  item: JFAlbumArtist;
-  size: number;
-}) => {
-  const size = args.size ? args.size : 300;
-
-  if (!args.item.ImageTags?.Primary) {
-    return null;
-  }
-
-  return (
-    `${args.baseUrl}/Items` +
-    `/${args.item.Id}` +
-    '/Images/Primary' +
-    `?width=${size}&height=${size}` +
-    '&quality=96'
-  );
-};
-
-const getAlbumCoverArtUrl = (args: { baseUrl: string; item: JFAlbum; size: number }) => {
-  const size = args.size ? args.size : 300;
-
-  if (!args.item.ImageTags?.Primary && !args.item?.AlbumPrimaryImageTag) {
-    return null;
-  }
-
-  return (
-    `${args.baseUrl}/Items` +
-    `/${args.item.Id}` +
-    '/Images/Primary' +
-    `?width=${size}&height=${size}` +
-    '&quality=96'
-  );
-};
-
-const getSongCoverArtUrl = (args: { baseUrl: string; item: JFSong; size: number }) => {
-  const size = args.size ? args.size : 300;
-
-  if (!args.item.ImageTags?.Primary) {
-    return null;
-  }
-
-  if (args.item.ImageTags.Primary) {
-    return (
-      `${args.baseUrl}/Items` +
-      `/${args.item.Id}` +
-      '/Images/Primary' +
-      `?width=${size}&height=${size}` +
-      '&quality=96'
-    );
-  }
-
-  if (!args.item?.AlbumPrimaryImageTag) {
-    return null;
-  }
-
-  // Fall back to album art if no image embedded
-  return (
-    `${args.baseUrl}/Items` +
-    `/${args.item?.AlbumId}` +
-    '/Images/Primary' +
-    `?width=${size}&height=${size}` +
-    '&quality=96'
-  );
-};
-
-const getPlaylistCoverArtUrl = (args: { baseUrl: string; item: JFPlaylist; size: number }) => {
-  const size = args.size ? args.size : 300;
-
-  if (!args.item.ImageTags?.Primary) {
-    return null;
-  }
-
-  return (
-    `${args.baseUrl}/Items` +
-    `/${args.item.Id}` +
-    '/Images/Primary' +
-    `?width=${size}&height=${size}` +
-    '&quality=96'
-  );
-};
-
-const normalizeSong = (
-  item: JFSong,
-  server: ServerListItem,
-  deviceId: string,
-  imageSize?: number,
-): Song => {
-  return {
-    album: item.Album,
-    albumArtists: item.AlbumArtists?.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    albumId: item.AlbumId,
-    artistName: item.ArtistItems[0]?.Name,
-    artists: item.ArtistItems.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    bitRate: item.MediaSources && Number(Math.trunc(item.MediaSources[0]?.Bitrate / 1000)),
-    bpm: null,
-    channels: null,
-    compilation: null,
-    container: (item.MediaSources && item.MediaSources[0]?.Container) || null,
-    createdAt: item.DateCreated,
-    discNumber: (item.ParentIndexNumber && item.ParentIndexNumber) || 1,
-    duration: item.RunTimeTicks / 10000000,
-    genres: item.GenreItems.map((entry: any) => ({ id: entry.Id, name: entry.Name })),
-    id: item.Id,
-    imagePlaceholderUrl: null,
-    imageUrl: getSongCoverArtUrl({ baseUrl: server.url, item, size: imageSize || 300 }),
-    isFavorite: (item.UserData && item.UserData.IsFavorite) || false,
-    lastPlayedAt: null,
-    name: item.Name,
-    note: null,
-    path: (item.MediaSources && item.MediaSources[0]?.Path) || null,
-    playCount: (item.UserData && item.UserData.PlayCount) || 0,
-    // releaseDate: (item.ProductionYear && new Date(item.ProductionYear, 0, 1).toISOString()) || null,
-    releaseDate: null,
-    releaseYear: (item.ProductionYear && String(item.ProductionYear)) || null,
-    serverId: server.id,
-    size: item.MediaSources && item.MediaSources[0]?.Size,
-    streamUrl: getStreamUrl({
-      container: item.MediaSources[0]?.Container,
-      deviceId,
-      eTag: item.MediaSources[0]?.ETag,
-      id: item.Id,
-      mediaSourceId: item.MediaSources[0]?.Id,
-      server,
-    }),
-    trackNumber: item.IndexNumber,
-    type: ServerType.JELLYFIN,
-    uniqueId: nanoid(),
-    updatedAt: item.DateCreated,
-  };
-};
-
-const normalizeAlbum = (item: JFAlbum, server: ServerListItem, imageSize?: number): Album => {
-  return {
-    albumArtists:
-      item.AlbumArtists.map((entry) => ({
-        id: entry.Id,
-        name: entry.Name,
-      })) || [],
-    artists: item.ArtistItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    backdropImageUrl: null,
-    createdAt: item.DateCreated,
-    duration: item.RunTimeTicks / 10000,
-    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    id: item.Id,
-    imagePlaceholderUrl: null,
-    imageUrl: getAlbumCoverArtUrl({
-      baseUrl: server.url,
-      item,
-      size: imageSize || 300,
-    }),
-    isCompilation: null,
-    isFavorite: item.UserData?.IsFavorite || false,
-    lastPlayedAt: null,
-    name: item.Name,
-    playCount: item.UserData?.PlayCount || 0,
-    rating: null,
-    releaseDate: item.PremiereDate?.split('T')[0] || null,
-    releaseYear: item.ProductionYear,
-    serverType: ServerType.JELLYFIN,
-    size: null,
-    songCount: item?.ChildCount || null,
-    songs: item.songs?.map((song) => normalizeSong(song, server, '', imageSize)),
-    uniqueId: nanoid(),
-    updatedAt: item?.DateLastMediaAdded || item.DateCreated,
-  };
-};
-
-const normalizeAlbumArtist = (
-  item: JFAlbumArtist,
-  server: ServerListItem,
-  imageSize?: number,
-): AlbumArtist => {
-  return {
-    albumCount: null,
-    backgroundImageUrl: null,
-    biography: item.Overview || null,
-    duration: item.RunTimeTicks / 10000,
-    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    id: item.Id,
-    imageUrl: getAlbumArtistCoverArtUrl({
-      baseUrl: server.url,
-      item,
-      size: imageSize || 300,
-    }),
-    isFavorite: item.UserData.IsFavorite || false,
-    lastPlayedAt: null,
-    name: item.Name,
-    playCount: item.UserData.PlayCount,
-    rating: null,
-    songCount: null,
-  };
-};
-
-const normalizePlaylist = (
-  item: JFPlaylist,
-  server: ServerListItem,
-  imageSize?: number,
-): Playlist => {
-  const imageUrl = getPlaylistCoverArtUrl({
-    baseUrl: server.url,
-    item,
-    size: imageSize || 300,
-  });
-
-  const imagePlaceholderUrl = null;
-
-  return {
-    description: item.Overview || null,
-    duration: item.RunTimeTicks / 10000,
-    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
-    id: item.Id,
-    imagePlaceholderUrl,
-    imageUrl: imageUrl || null,
-    name: item.Name,
-    public: null,
-    rules: null,
-    size: null,
-    songCount: item?.ChildCount || null,
-    userId: null,
-    username: null,
-  };
-};
-
-// const normalizeArtist = (item: any) => {
-//   return {
-//     album: (item.album || []).map((entry: any) => normalizeAlbum(entry)),
-//     albumCount: item.AlbumCount,
-//     duration: item.RunTimeTicks / 10000000,
-//     genre: item.GenreItems && item.GenreItems.map((entry: any) => normalizeItem(entry)),
-//     id: item.Id,
-//     image: getCoverArtUrl(item),
-//     info: {
-//       biography: item.Overview,
-//       externalUrl: (item.ExternalUrls || []).map((entry: any) => normalizeItem(entry)),
-//       imageUrl: undefined,
-//       similarArtist: (item.similarArtist || []).map((entry: any) => normalizeArtist(entry)),
-//     },
-//     starred: item.UserData && item.UserData?.IsFavorite ? 'true' : undefined,
-//     title: item.Name,
-//     uniqueId: nanoid(),
-//   };
-// };
-
-// const normalizeGenre = (item: any) => {
-//   return {
-//     albumCount: undefined,
-//     id: item.Id,
-//     songCount: undefined,
-//     title: item.Name,
-//     type: Item.Genre,
-//     uniqueId: nanoid(),
-//   };
-// };
-
-// const normalizeFolder = (item: any) => {
-//   return {
-//     created: item.DateCreated,
-//     id: item.Id,
-//     image: getCoverArtUrl(item, 150),
-//     isDir: true,
-//     title: item.Name,
-//     type: Item.Folder,
-//     uniqueId: nanoid(),
-//   };
-// };
-
-// const normalizeScanStatus = () => {
-//   return {
-//     count: 'N/a',
-//     scanning: false,
-//   };
-// };
-
-export const jellyfinApi = {
-  authenticate,
-  createFavorite,
-  createPlaylist,
-  deleteFavorite,
-  deletePlaylist,
-  getAlbumArtistDetail,
-  getAlbumArtistList,
-  getAlbumDetail,
-  getAlbumList,
-  getArtistList,
-  getGenreList,
-  getMusicFolderList,
-  getPlaylistDetail,
-  getPlaylistList,
-  getPlaylistSongList,
-  getSongList,
-  updatePlaylist,
-};
-
-export const jfNormalize = {
-  album: normalizeAlbum,
-  albumArtist: normalizeAlbumArtist,
-  playlist: normalizePlaylist,
-  song: normalizeSong,
-};

src/renderer/api/jellyfin.types.ts

@@ -59,6 +59,25 @@ export type JFSongList = {
   totalRecordCount: number;
 };
 
+export type JFAddToPlaylistResponse = {
+  added: number;
+};
+
+export type JFAddToPlaylistParams = {
+  ids: string[];
+  userId: string;
+};
+
+export type JFAddToPlaylist = null;
+
+export type JFRemoveFromPlaylistResponse = null;
+
+export type JFRemoveFromPlaylistParams = {
+  entryIds: string[];
+};
+
+export type JFRemoveFromPlaylist = null;
+
 export interface JFPlaylistListResponse extends JFBasePaginatedResponse {
   Items: JFPlaylist[];
 }
@@ -173,6 +192,10 @@ export type JFAlbumArtist = {
     PlaybackPositionTicks: number;
     Played: boolean;
   };
+} & {
+  similarArtists: {
+    items: JFAlbumArtist[];
+  };
 };
 
 export type JFArtist = {
@@ -248,6 +271,7 @@ export type JFSong = {
   MediaType: string;
   Name: string;
   ParentIndexNumber: number;
+  PlaylistItemId?: string;
   PremiereDate?: string;
   ProductionYear: number;
   RunTimeTicks: number;
@@ -543,6 +567,7 @@ export enum JFSongListSort {
   ALBUM = 'Album,SortName',
   ALBUM_ARTIST = 'AlbumArtist,Album,SortName',
   ARTIST = 'Artist,Album,SortName',
+  COMMUNITY_RATING = 'CommunityRating,SortName',
   DURATION = 'Runtime,AlbumArtist,Album,SortName',
   NAME = 'Name,SortName',
   PLAY_COUNT = 'PlayCount,SortName',

src/renderer/api/jellyfin/jellyfin-api.ts

@@ -0,0 +1,350 @@
+import { useAuthStore } from '/@/renderer/store';
+import { jfType } from '/@/renderer/api/jellyfin/jellyfin-types';
+import { initClient, initContract } from '@ts-rest/core';
+import axios, { AxiosError, AxiosResponse, isAxiosError, Method } from 'axios';
+import qs from 'qs';
+import { ServerListItem } from '/@/renderer/types';
+import omitBy from 'lodash/omitBy';
+import { z } from 'zod';
+import { authenticationFailure } from '/@/renderer/api/utils';
+
+const c = initContract();
+
+export const contract = c.router({
+  addToPlaylist: {
+    body: z.null(),
+    method: 'POST',
+    path: 'playlists/:id/items',
+    query: jfType._parameters.addToPlaylist,
+    responses: {
+      204: jfType._response.addToPlaylist,
+      400: jfType._response.error,
+    },
+  },
+  authenticate: {
+    body: jfType._parameters.authenticate,
+    headers: z.object({
+      'X-Emby-Authorization': z.string(),
+    }),
+    method: 'POST',
+    path: 'users/authenticatebyname',
+    responses: {
+      200: jfType._response.authenticate,
+      400: jfType._response.error,
+    },
+  },
+  createFavorite: {
+    body: jfType._parameters.favorite,
+    method: 'POST',
+    path: 'users/:userId/favoriteitems/:id',
+    responses: {
+      200: jfType._response.favorite,
+      400: jfType._response.error,
+    },
+  },
+  createPlaylist: {
+    body: jfType._parameters.createPlaylist,
+    method: 'POST',
+    path: 'playlists',
+    responses: {
+      200: jfType._response.createPlaylist,
+      400: jfType._response.error,
+    },
+  },
+  deletePlaylist: {
+    body: null,
+    method: 'DELETE',
+    path: 'items/:id',
+    responses: {
+      204: jfType._response.deletePlaylist,
+      400: jfType._response.error,
+    },
+  },
+  getAlbumArtistDetail: {
+    method: 'GET',
+    path: 'users/:userId/items/:id',
+    query: jfType._parameters.albumArtistDetail,
+    responses: {
+      200: jfType._response.albumArtist,
+      400: jfType._response.error,
+    },
+  },
+  getAlbumArtistList: {
+    method: 'GET',
+    path: 'artists/albumArtists',
+    query: jfType._parameters.albumArtistList,
+    responses: {
+      200: jfType._response.albumArtistList,
+      400: jfType._response.error,
+    },
+  },
+  getAlbumDetail: {
+    method: 'GET',
+    path: 'users/:userId/items/:id',
+    query: jfType._parameters.albumDetail,
+    responses: {
+      200: jfType._response.album,
+      400: jfType._response.error,
+    },
+  },
+  getAlbumList: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    query: jfType._parameters.albumList,
+    responses: {
+      200: jfType._response.albumList,
+      400: jfType._response.error,
+    },
+  },
+  getArtistList: {
+    method: 'GET',
+    path: 'artists',
+    query: jfType._parameters.albumArtistList,
+    responses: {
+      200: jfType._response.albumArtistList,
+      400: jfType._response.error,
+    },
+  },
+  getGenreList: {
+    method: 'GET',
+    path: 'genres',
+    responses: {
+      200: jfType._response.genreList,
+      400: jfType._response.error,
+    },
+  },
+  getMusicFolderList: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    responses: {
+      200: jfType._response.musicFolderList,
+      400: jfType._response.error,
+    },
+  },
+  getPlaylistDetail: {
+    method: 'GET',
+    path: 'users/:userId/items/:id',
+    query: jfType._parameters.playlistDetail,
+    responses: {
+      200: jfType._response.playlist,
+      400: jfType._response.error,
+    },
+  },
+  getPlaylistList: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    query: jfType._parameters.playlistList,
+    responses: {
+      200: jfType._response.playlistList,
+      400: jfType._response.error,
+    },
+  },
+  getPlaylistSongList: {
+    method: 'GET',
+    path: 'playlists/:id/items',
+    query: jfType._parameters.songList,
+    responses: {
+      200: jfType._response.playlistSongList,
+      400: jfType._response.error,
+    },
+  },
+  getSimilarArtistList: {
+    method: 'GET',
+    path: 'artists/:id/similar',
+    query: jfType._parameters.similarArtistList,
+    responses: {
+      200: jfType._response.albumArtistList,
+      400: jfType._response.error,
+    },
+  },
+  getSongDetail: {
+    method: 'GET',
+    path: 'song/:id',
+    responses: {
+      200: jfType._response.song,
+      400: jfType._response.error,
+    },
+  },
+  getSongList: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    query: jfType._parameters.songList,
+    responses: {
+      200: jfType._response.songList,
+      400: jfType._response.error,
+    },
+  },
+  getSongLyrics: {
+    method: 'GET',
+    path: 'users/:userId/Items/:id/Lyrics',
+    responses: {
+      200: jfType._response.lyrics,
+      404: jfType._response.error,
+    },
+  },
+  getTopSongsList: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    query: jfType._parameters.songList,
+    responses: {
+      200: jfType._response.topSongsList,
+      400: jfType._response.error,
+    },
+  },
+  removeFavorite: {
+    body: jfType._parameters.favorite,
+    method: 'DELETE',
+    path: 'users/:userId/favoriteitems/:id',
+    responses: {
+      200: jfType._response.favorite,
+      400: jfType._response.error,
+    },
+  },
+  removeFromPlaylist: {
+    body: null,
+    method: 'DELETE',
+    path: 'playlists/:id/items',
+    query: jfType._parameters.removeFromPlaylist,
+    responses: {
+      200: jfType._response.removeFromPlaylist,
+      400: jfType._response.error,
+    },
+  },
+  scrobblePlaying: {
+    body: jfType._parameters.scrobble,
+    method: 'POST',
+    path: 'sessions/playing',
+    responses: {
+      200: jfType._response.scrobble,
+      400: jfType._response.error,
+    },
+  },
+  scrobbleProgress: {
+    body: jfType._parameters.scrobble,
+    method: 'POST',
+    path: 'sessions/playing/progress',
+    responses: {
+      200: jfType._response.scrobble,
+      400: jfType._response.error,
+    },
+  },
+  scrobbleStopped: {
+    body: jfType._parameters.scrobble,
+    method: 'POST',
+    path: 'sessions/playing/stopped',
+    responses: {
+      200: jfType._response.scrobble,
+      400: jfType._response.error,
+    },
+  },
+  search: {
+    method: 'GET',
+    path: 'users/:userId/items',
+    query: jfType._parameters.search,
+    responses: {
+      200: jfType._response.search,
+      400: jfType._response.error,
+    },
+  },
+  updatePlaylist: {
+    body: jfType._parameters.updatePlaylist,
+    method: 'PUT',
+    path: 'items/:id',
+    responses: {
+      200: jfType._response.updatePlaylist,
+      400: jfType._response.error,
+    },
+  },
+});
+
+const axiosClient = axios.create({});
+
+axiosClient.defaults.paramsSerializer = (params) => {
+  return qs.stringify(params, { arrayFormat: 'repeat' });
+};
+
+axiosClient.interceptors.response.use(
+  (response) => {
+    return response;
+  },
+  (error) => {
+    if (error.response && error.response.status === 401) {
+      const currentServer = useAuthStore.getState().currentServer;
+
+      authenticationFailure(currentServer);
+    }
+
+    return Promise.reject(error);
+  },
+);
+
+const parsePath = (fullPath: string) => {
+  const [path, params] = fullPath.split('?');
+
+  const parsedParams = qs.parse(params);
+  const notNilParams = omitBy(parsedParams, (value) => value === 'undefined' || value === 'null');
+
+  return {
+    params: notNilParams,
+    path,
+  };
+};
+
+export const jfApiClient = (args: {
+  server: ServerListItem | null;
+  signal?: AbortSignal;
+  url?: string;
+}) => {
+  const { server, url, signal } = args;
+
+  return initClient(contract, {
+    api: async ({ path, method, headers, body }) => {
+      let baseUrl: string | undefined;
+      let token: string | undefined;
+
+      const { params, path: api } = parsePath(path);
+
+      if (server) {
+        baseUrl = `${server?.url}`;
+        token = server?.credential;
+      } else {
+        baseUrl = url;
+      }
+
+      try {
+        const result = await axiosClient.request({
+          data: body,
+          headers: {
+            ...headers,
+            ...(token && { 'X-MediaBrowser-Token': token }),
+          },
+          method: method as Method,
+          params,
+          signal,
+          url: `${baseUrl}/${api}`,
+        });
+        return {
+          body: result.data,
+          headers: result.headers as any,
+          status: result.status,
+        };
+      } catch (e: Error | AxiosError | any) {
+        if (isAxiosError(e)) {
+          const error = e as AxiosError;
+          const response = error.response as AxiosResponse;
+          return {
+            body: response?.data,
+            headers: response?.headers as any,
+            status: response.status,
+          };
+        }
+        throw e;
+      }
+    },
+    baseHeaders: {
+      'Content-Type': 'application/json',
+    },
+    baseUrl: '',
+    jsonQuery: false,
+  });
+};

src/renderer/api/jellyfin/jellyfin-controller.ts

@@ -0,0 +1,902 @@
+import {
+  AuthenticationResponse,
+  MusicFolderListArgs,
+  MusicFolderListResponse,
+  GenreListArgs,
+  AlbumArtistDetailArgs,
+  AlbumArtistListArgs,
+  albumArtistListSortMap,
+  sortOrderMap,
+  ArtistListArgs,
+  artistListSortMap,
+  AlbumDetailArgs,
+  AlbumListArgs,
+  albumListSortMap,
+  TopSongListArgs,
+  SongListArgs,
+  songListSortMap,
+  AddToPlaylistArgs,
+  RemoveFromPlaylistArgs,
+  PlaylistDetailArgs,
+  PlaylistSongListArgs,
+  PlaylistListArgs,
+  playlistListSortMap,
+  CreatePlaylistArgs,
+  CreatePlaylistResponse,
+  UpdatePlaylistArgs,
+  UpdatePlaylistResponse,
+  DeletePlaylistArgs,
+  FavoriteArgs,
+  FavoriteResponse,
+  ScrobbleArgs,
+  ScrobbleResponse,
+  GenreListResponse,
+  AlbumArtistDetailResponse,
+  AlbumArtistListResponse,
+  AlbumDetailResponse,
+  AlbumListResponse,
+  SongListResponse,
+  AddToPlaylistResponse,
+  RemoveFromPlaylistResponse,
+  PlaylistDetailResponse,
+  PlaylistListResponse,
+  SearchArgs,
+  SearchResponse,
+  RandomSongListResponse,
+  RandomSongListArgs,
+  LyricsArgs,
+  LyricsResponse,
+} from '/@/renderer/api/types';
+import { jfApiClient } from '/@/renderer/api/jellyfin/jellyfin-api';
+import { jfNormalize } from './jellyfin-normalize';
+import { jfType } from '/@/renderer/api/jellyfin/jellyfin-types';
+import packageJson from '../../../../package.json';
+import { z } from 'zod';
+import { JFSongListSort, JFSortOrder } from '/@/renderer/api/jellyfin.types';
+
+const formatCommaDelimitedString = (value: string[]) => {
+  return value.join(',');
+};
+
+const authenticate = async (
+  url: string,
+  body: {
+    password: string;
+    username: string;
+  },
+): Promise<AuthenticationResponse> => {
+  const cleanServerUrl = url.replace(/\/$/, '');
+
+  const res = await jfApiClient({ server: null, url: cleanServerUrl }).authenticate({
+    body: {
+      Pw: body.password,
+      Username: body.username,
+    },
+    headers: {
+      'x-emby-authorization': `MediaBrowser Client="Feishin", Device="PC", DeviceId="Feishin", Version="${packageJson.version}"`,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to authenticate');
+  }
+
+  return {
+    credential: res.body.AccessToken,
+    userId: res.body.User.Id,
+    username: res.body.User.Name,
+  };
+};
+
+const getMusicFolderList = async (args: MusicFolderListArgs): Promise<MusicFolderListResponse> => {
+  const { apiClientProps } = args;
+  const userId = apiClientProps.server?.userId;
+
+  if (!userId) throw new Error('No userId found');
+
+  const res = await jfApiClient(apiClientProps).getMusicFolderList({
+    params: {
+      userId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get genre list');
+  }
+
+  const musicFolders = res.body.Items.filter(
+    (folder) => folder.CollectionType === jfType._enum.collection.MUSIC,
+  );
+
+  return {
+    items: musicFolders.map(jfNormalize.musicFolder),
+    startIndex: 0,
+    totalRecordCount: musicFolders?.length || 0,
+  };
+};
+
+const getGenreList = async (args: GenreListArgs): Promise<GenreListResponse> => {
+  const { apiClientProps } = args;
+
+  const res = await jfApiClient(apiClientProps).getGenreList();
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get genre list');
+  }
+
+  return {
+    items: res.body.Items.map(jfNormalize.genre),
+    startIndex: 0,
+    totalRecordCount: res.body?.Items?.length || 0,
+  };
+};
+
+const getAlbumArtistDetail = async (
+  args: AlbumArtistDetailArgs,
+): Promise<AlbumArtistDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getAlbumArtistDetail({
+    params: {
+      id: query.id,
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      Fields: 'Genres, Overview',
+    },
+  });
+
+  const similarArtistsRes = await jfApiClient(apiClientProps).getSimilarArtistList({
+    params: {
+      id: query.id,
+    },
+    query: {
+      Limit: 10,
+    },
+  });
+
+  if (res.status !== 200 || similarArtistsRes.status !== 200) {
+    throw new Error('Failed to get album artist detail');
+  }
+
+  return jfNormalize.albumArtist(
+    { ...res.body, similarArtists: similarArtistsRes.body },
+    apiClientProps.server,
+  );
+};
+
+const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<AlbumArtistListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await jfApiClient(apiClientProps).getAlbumArtistList({
+    query: {
+      Fields: 'Genres, DateCreated, ExternalUrls, Overview',
+      ImageTypeLimit: 1,
+      Limit: query.limit,
+      ParentId: query.musicFolderId,
+      Recursive: true,
+      SearchTerm: query.searchTerm,
+      SortBy: albumArtistListSortMap.jellyfin[query.sortBy] || 'Name,SortName',
+      SortOrder: sortOrderMap.jellyfin[query.sortOrder],
+      StartIndex: query.startIndex,
+      UserId: apiClientProps.server?.userId || undefined,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get album artist list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.albumArtist(item, apiClientProps.server)),
+    startIndex: query.startIndex,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const getArtistList = async (args: ArtistListArgs): Promise<AlbumArtistListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await jfApiClient(apiClientProps).getAlbumArtistList({
+    query: {
+      Limit: query.limit,
+      ParentId: query.musicFolderId,
+      Recursive: true,
+      SortBy: artistListSortMap.jellyfin[query.sortBy] || 'Name,SortName',
+      SortOrder: sortOrderMap.jellyfin[query.sortOrder],
+      StartIndex: query.startIndex,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get artist list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.albumArtist(item, apiClientProps.server)),
+    startIndex: query.startIndex,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const getAlbumDetail = async (args: AlbumDetailArgs): Promise<AlbumDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getAlbumDetail({
+    params: {
+      id: query.id,
+      userId: apiClientProps.server.userId,
+    },
+    query: {
+      Fields: 'Genres, DateCreated, ChildCount',
+    },
+  });
+
+  const songsRes = await jfApiClient(apiClientProps).getSongList({
+    params: {
+      userId: apiClientProps.server.userId,
+    },
+    query: {
+      Fields: 'Genres, DateCreated, MediaSources, ParentId',
+      IncludeItemTypes: 'Audio',
+      ParentId: query.id,
+      SortBy: 'Album,SortName',
+    },
+  });
+
+  if (res.status !== 200 || songsRes.status !== 200) {
+    throw new Error('Failed to get album detail');
+  }
+
+  return jfNormalize.album({ ...res.body, Songs: songsRes.body.Items }, apiClientProps.server);
+};
+
+const getAlbumList = async (args: AlbumListArgs): Promise<AlbumListResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const yearsGroup = [];
+  if (query._custom?.jellyfin?.minYear && query._custom?.jellyfin?.maxYear) {
+    for (
+      let i = Number(query._custom?.jellyfin?.minYear);
+      i <= Number(query._custom?.jellyfin?.maxYear);
+      i += 1
+    ) {
+      yearsGroup.push(String(i));
+    }
+  }
+
+  const yearsFilter = yearsGroup.length ? yearsGroup.join(',') : undefined;
+
+  const res = await jfApiClient(apiClientProps).getAlbumList({
+    params: {
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      AlbumArtistIds: query.artistIds ? formatCommaDelimitedString(query.artistIds) : undefined,
+      IncludeItemTypes: 'MusicAlbum',
+      Limit: query.limit,
+      ParentId: query.musicFolderId,
+      Recursive: true,
+      SearchTerm: query.searchTerm,
+      SortBy: albumListSortMap.jellyfin[query.sortBy] || 'SortName',
+      SortOrder: sortOrderMap.jellyfin[query.sortOrder],
+      StartIndex: query.startIndex,
+      ...query._custom?.jellyfin,
+      Years: yearsFilter,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get album list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.album(item, apiClientProps.server)),
+    startIndex: query.startIndex,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const getTopSongList = async (args: TopSongListArgs): Promise<SongListResponse> => {
+  const { apiClientProps, query } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getTopSongsList({
+    params: {
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      ArtistIds: query.artistId,
+      Fields: 'Genres, DateCreated, MediaSources, ParentId',
+      IncludeItemTypes: 'Audio',
+      Limit: query.limit,
+      Recursive: true,
+      SortBy: 'CommunityRating,SortName',
+      SortOrder: 'Descending',
+      UserId: apiClientProps.server?.userId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get top song list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
+    startIndex: 0,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const getSongList = async (args: SongListArgs): Promise<SongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const yearsGroup = [];
+  if (query._custom?.jellyfin?.minYear && query._custom?.jellyfin?.maxYear) {
+    for (
+      let i = Number(query._custom?.jellyfin?.minYear);
+      i <= Number(query._custom?.jellyfin?.maxYear);
+      i += 1
+    ) {
+      yearsGroup.push(String(i));
+    }
+  }
+
+  const yearsFilter = yearsGroup.length ? formatCommaDelimitedString(yearsGroup) : undefined;
+  const albumIdsFilter = query.albumIds ? formatCommaDelimitedString(query.albumIds) : undefined;
+  const artistIdsFilter = query.artistIds ? formatCommaDelimitedString(query.artistIds) : undefined;
+
+  const res = await jfApiClient(apiClientProps).getSongList({
+    params: {
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      AlbumIds: albumIdsFilter,
+      ArtistIds: artistIdsFilter,
+      Fields: 'Genres, DateCreated, MediaSources, ParentId',
+      IncludeItemTypes: 'Audio',
+      Limit: query.limit,
+      ParentId: query.musicFolderId,
+      Recursive: true,
+      SearchTerm: query.searchTerm,
+      SortBy: songListSortMap.jellyfin[query.sortBy] || 'Album,SortName',
+      SortOrder: sortOrderMap.jellyfin[query.sortOrder],
+      StartIndex: query.startIndex,
+      ...query._custom?.jellyfin,
+      Years: yearsFilter,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get song list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
+    startIndex: query.startIndex,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const addToPlaylist = async (args: AddToPlaylistArgs): Promise<AddToPlaylistResponse> => {
+  const { query, body, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).addToPlaylist({
+    body: null,
+    params: {
+      id: query.id,
+    },
+    query: {
+      Ids: body.songId,
+      UserId: apiClientProps.server?.userId,
+    },
+  });
+
+  if (res.status !== 204) {
+    throw new Error('Failed to add to playlist');
+  }
+
+  return null;
+};
+
+const removeFromPlaylist = async (
+  args: RemoveFromPlaylistArgs,
+): Promise<RemoveFromPlaylistResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await jfApiClient(apiClientProps).removeFromPlaylist({
+    body: null,
+    params: {
+      id: query.id,
+    },
+    query: {
+      EntryIds: query.songId,
+    },
+  });
+
+  if (res.status !== 204) {
+    throw new Error('Failed to remove from playlist');
+  }
+
+  return null;
+};
+
+const getPlaylistDetail = async (args: PlaylistDetailArgs): Promise<PlaylistDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getPlaylistDetail({
+    params: {
+      id: query.id,
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      Fields: 'Genres, DateCreated, MediaSources, ChildCount, ParentId',
+      Ids: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist detail');
+  }
+
+  return jfNormalize.playlist(res.body, apiClientProps.server);
+};
+
+const getPlaylistSongList = async (args: PlaylistSongListArgs): Promise<SongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getPlaylistSongList({
+    params: {
+      id: query.id,
+    },
+    query: {
+      Fields: 'Genres, DateCreated, MediaSources, UserData, ParentId',
+      IncludeItemTypes: 'Audio',
+      Limit: query.limit,
+      SortBy: query.sortBy ? songListSortMap.jellyfin[query.sortBy] : undefined,
+      SortOrder: query.sortOrder ? sortOrderMap.jellyfin[query.sortOrder] : undefined,
+      StartIndex: 0,
+      UserId: apiClientProps.server?.userId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist song list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
+    startIndex: query.startIndex,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const getPlaylistList = async (args: PlaylistListArgs): Promise<PlaylistListResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getPlaylistList({
+    params: {
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      Fields: 'ChildCount, Genres, DateCreated, ParentId, Overview',
+      IncludeItemTypes: 'Playlist',
+      Limit: query.limit,
+      MediaTypes: 'Audio',
+      Recursive: true,
+      SortBy: playlistListSortMap.jellyfin[query.sortBy],
+      SortOrder: sortOrderMap.jellyfin[query.sortOrder],
+      StartIndex: query.startIndex,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist list');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.playlist(item, apiClientProps.server)),
+    startIndex: 0,
+    totalRecordCount: res.body.TotalRecordCount,
+  };
+};
+
+const createPlaylist = async (args: CreatePlaylistArgs): Promise<CreatePlaylistResponse> => {
+  const { body, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).createPlaylist({
+    body: {
+      MediaType: 'Audio',
+      Name: body.name,
+      Overview: body.comment || '',
+      UserId: apiClientProps.server.userId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to create playlist');
+  }
+
+  return {
+    id: res.body.Id,
+  };
+};
+
+const updatePlaylist = async (args: UpdatePlaylistArgs): Promise<UpdatePlaylistResponse> => {
+  const { query, body, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).updatePlaylist({
+    body: {
+      Genres: body.genres?.map((item) => ({ Id: item.id, Name: item.name })) || [],
+      MediaType: 'Audio',
+      Name: body.name,
+      Overview: body.comment || '',
+      PremiereDate: null,
+      ProviderIds: {},
+      Tags: [],
+      UserId: apiClientProps.server?.userId, // Required
+    },
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to update playlist');
+  }
+
+  return null;
+};
+
+const deletePlaylist = async (args: DeletePlaylistArgs): Promise<null> => {
+  const { query, apiClientProps } = args;
+
+  const res = await jfApiClient(apiClientProps).deletePlaylist({
+    body: null,
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 204) {
+    throw new Error('Failed to delete playlist');
+  }
+
+  return null;
+};
+
+const createFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  for (const id of query.id) {
+    await jfApiClient(apiClientProps).createFavorite({
+      body: {},
+      params: {
+        id,
+        userId: apiClientProps.server?.userId,
+      },
+    });
+  }
+
+  return null;
+};
+
+const deleteFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  for (const id of query.id) {
+    await jfApiClient(apiClientProps).removeFavorite({
+      body: {},
+      params: {
+        id,
+        userId: apiClientProps.server?.userId,
+      },
+    });
+  }
+
+  return null;
+};
+
+const scrobble = async (args: ScrobbleArgs): Promise<ScrobbleResponse> => {
+  const { query, apiClientProps } = args;
+
+  const position = query.position && Math.round(query.position);
+
+  if (query.submission) {
+    // Checked by jellyfin-plugin-lastfm for whether or not to send the "finished" scrobble (uses PositionTicks)
+    jfApiClient(apiClientProps).scrobbleStopped({
+      body: {
+        IsPaused: true,
+        ItemId: query.id,
+        PositionTicks: position,
+      },
+    });
+
+    return null;
+  }
+
+  if (query.event === 'start') {
+    jfApiClient(apiClientProps).scrobblePlaying({
+      body: {
+        ItemId: query.id,
+        PositionTicks: position,
+      },
+    });
+
+    return null;
+  }
+
+  if (query.event === 'pause') {
+    jfApiClient(apiClientProps).scrobbleProgress({
+      body: {
+        EventName: query.event,
+        IsPaused: true,
+        ItemId: query.id,
+        PositionTicks: position,
+      },
+    });
+
+    return null;
+  }
+
+  if (query.event === 'unpause') {
+    jfApiClient(apiClientProps).scrobbleProgress({
+      body: {
+        EventName: query.event,
+        IsPaused: false,
+        ItemId: query.id,
+        PositionTicks: position,
+      },
+    });
+
+    return null;
+  }
+
+  jfApiClient(apiClientProps).scrobbleProgress({
+    body: {
+      ItemId: query.id,
+      PositionTicks: position,
+    },
+  });
+
+  return null;
+};
+
+const search = async (args: SearchArgs): Promise<SearchResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  let albums: z.infer<typeof jfType._response.albumList>['Items'] = [];
+  let albumArtists: z.infer<typeof jfType._response.albumArtistList>['Items'] = [];
+  let songs: z.infer<typeof jfType._response.songList>['Items'] = [];
+
+  if (query.albumLimit) {
+    const res = await jfApiClient(apiClientProps).getAlbumList({
+      params: {
+        userId: apiClientProps.server?.userId,
+      },
+      query: {
+        EnableTotalRecordCount: true,
+        ImageTypeLimit: 1,
+        IncludeItemTypes: 'MusicAlbum',
+        Limit: query.albumLimit,
+        Recursive: true,
+        SearchTerm: query.query,
+        SortBy: 'SortName',
+        SortOrder: 'Ascending',
+        StartIndex: query.albumStartIndex || 0,
+      },
+    });
+
+    if (res.status !== 200) {
+      throw new Error('Failed to get album list');
+    }
+
+    albums = res.body.Items;
+  }
+
+  if (query.albumArtistLimit) {
+    const res = await jfApiClient(apiClientProps).getAlbumArtistList({
+      query: {
+        EnableTotalRecordCount: true,
+        Fields: 'Genres, DateCreated, ExternalUrls, Overview',
+        ImageTypeLimit: 1,
+        IncludeArtists: true,
+        Limit: query.albumArtistLimit,
+        Recursive: true,
+        SearchTerm: query.query,
+        StartIndex: query.albumArtistStartIndex || 0,
+        UserId: apiClientProps.server?.userId,
+      },
+    });
+
+    if (res.status !== 200) {
+      throw new Error('Failed to get album artist list');
+    }
+
+    albumArtists = res.body.Items;
+  }
+
+  if (query.songLimit) {
+    const res = await jfApiClient(apiClientProps).getSongList({
+      params: {
+        userId: apiClientProps.server?.userId,
+      },
+      query: {
+        EnableTotalRecordCount: true,
+        Fields: 'Genres, DateCreated, MediaSources, ParentId',
+        IncludeItemTypes: 'Audio',
+        Limit: query.songLimit,
+        Recursive: true,
+        SearchTerm: query.query,
+        SortBy: 'Album,SortName',
+        SortOrder: 'Ascending',
+        StartIndex: query.songStartIndex || 0,
+        UserId: apiClientProps.server?.userId,
+      },
+    });
+
+    if (res.status !== 200) {
+      throw new Error('Failed to get song list');
+    }
+
+    songs = res.body.Items;
+  }
+
+  return {
+    albumArtists: albumArtists.map((item) => jfNormalize.albumArtist(item, apiClientProps.server)),
+    albums: albums.map((item) => jfNormalize.album(item, apiClientProps.server)),
+    songs: songs.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
+  };
+};
+
+const getRandomSongList = async (args: RandomSongListArgs): Promise<RandomSongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const yearsGroup = [];
+  if (query.minYear && query.maxYear) {
+    for (let i = Number(query.minYear); i <= Number(query.maxYear); i += 1) {
+      yearsGroup.push(String(i));
+    }
+  }
+
+  const yearsFilter = yearsGroup.length ? formatCommaDelimitedString(yearsGroup) : undefined;
+
+  const res = await jfApiClient(apiClientProps).getSongList({
+    params: {
+      userId: apiClientProps.server?.userId,
+    },
+    query: {
+      Fields: 'Genres, DateCreated, MediaSources, ParentId',
+      GenreIds: query.genre ? query.genre : undefined,
+      IncludeItemTypes: 'Audio',
+      Limit: query.limit,
+      ParentId: query.musicFolderId,
+      Recursive: true,
+      SortBy: JFSongListSort.RANDOM,
+      SortOrder: JFSortOrder.ASC,
+      StartIndex: 0,
+      Years: yearsFilter,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get random songs');
+  }
+
+  return {
+    items: res.body.Items.map((item) => jfNormalize.song(item, apiClientProps.server, '')),
+    startIndex: 0,
+    totalRecordCount: res.body.Items.length || 0,
+  };
+};
+
+const getLyrics = async (args: LyricsArgs): Promise<LyricsResponse> => {
+  const { query, apiClientProps } = args;
+
+  if (!apiClientProps.server?.userId) {
+    throw new Error('No userId found');
+  }
+
+  const res = await jfApiClient(apiClientProps).getSongLyrics({
+    params: {
+      id: query.songId,
+      userId: apiClientProps.server?.userId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get lyrics');
+  }
+
+  if (res.body.Lyrics.length > 0 && res.body.Lyrics[0].Start === undefined) {
+    return res.body.Lyrics[0].Text;
+  }
+
+  return res.body.Lyrics.map((lyric) => [lyric.Start! / 1e4, lyric.Text]);
+};
+
+export const jfController = {
+  addToPlaylist,
+  authenticate,
+  createFavorite,
+  createPlaylist,
+  deleteFavorite,
+  deletePlaylist,
+  getAlbumArtistDetail,
+  getAlbumArtistList,
+  getAlbumDetail,
+  getAlbumList,
+  getArtistList,
+  getGenreList,
+  getLyrics,
+  getMusicFolderList,
+  getPlaylistDetail,
+  getPlaylistList,
+  getPlaylistSongList,
+  getRandomSongList,
+  getSongList,
+  getTopSongList,
+  removeFromPlaylist,
+  scrobble,
+  search,
+  updatePlaylist,
+};

src/renderer/api/jellyfin/jellyfin-normalize.ts

@@ -0,0 +1,369 @@
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+import { JFAlbum, JFPlaylist, JFMusicFolder, JFGenre } from '/@/renderer/api/jellyfin.types';
+import { jfType } from '/@/renderer/api/jellyfin/jellyfin-types';
+import {
+  Song,
+  LibraryItem,
+  Album,
+  AlbumArtist,
+  Playlist,
+  MusicFolder,
+  Genre,
+} from '/@/renderer/api/types';
+import { ServerListItem, ServerType } from '/@/renderer/types';
+
+const getStreamUrl = (args: {
+  container?: string;
+  deviceId: string;
+  eTag?: string;
+  id: string;
+  mediaSourceId?: string;
+  server: ServerListItem | null;
+}) => {
+  const { id, server, deviceId } = args;
+
+  return (
+    `${server?.url}/audio` +
+    `/${id}/universal` +
+    `?userId=${server?.userId}` +
+    `&deviceId=${deviceId}` +
+    '&audioCodec=aac' +
+    `&api_key=${server?.credential}` +
+    `&playSessionId=${deviceId}` +
+    '&container=opus,mp3,aac,m4a,m4b,flac,wav,ogg' +
+    '&transcodingContainer=ts' +
+    '&transcodingProtocol=hls'
+  );
+};
+
+const getAlbumArtistCoverArtUrl = (args: {
+  baseUrl: string;
+  item: z.infer<typeof jfType._response.albumArtist>;
+  size: number;
+}) => {
+  const size = args.size ? args.size : 300;
+
+  if (!args.item.ImageTags?.Primary) {
+    return null;
+  }
+
+  return (
+    `${args.baseUrl}/Items` +
+    `/${args.item.Id}` +
+    '/Images/Primary' +
+    `?width=${size}&height=${size}` +
+    '&quality=96'
+  );
+};
+
+const getAlbumCoverArtUrl = (args: { baseUrl: string; item: JFAlbum; size: number }) => {
+  const size = args.size ? args.size : 300;
+
+  if (!args.item.ImageTags?.Primary && !args.item?.AlbumPrimaryImageTag) {
+    return null;
+  }
+
+  return (
+    `${args.baseUrl}/Items` +
+    `/${args.item.Id}` +
+    '/Images/Primary' +
+    `?width=${size}&height=${size}` +
+    '&quality=96'
+  );
+};
+
+const getSongCoverArtUrl = (args: {
+  baseUrl: string;
+  item: z.infer<typeof jfType._response.song>;
+  size: number;
+}) => {
+  const size = args.size ? args.size : 100;
+
+  if (args.item.ImageTags.Primary) {
+    return (
+      `${args.baseUrl}/Items` +
+      `/${args.item.Id}` +
+      '/Images/Primary' +
+      `?width=${size}&height=${size}` +
+      '&quality=96'
+    );
+  }
+
+  if (args.item?.AlbumPrimaryImageTag) {
+    // Fall back to album art if no image embedded
+    return (
+      `${args.baseUrl}/Items` +
+      `/${args.item?.AlbumId}` +
+      '/Images/Primary' +
+      `?width=${size}&height=${size}` +
+      '&quality=96'
+    );
+  }
+
+  return null;
+};
+
+const getPlaylistCoverArtUrl = (args: { baseUrl: string; item: JFPlaylist; size: number }) => {
+  const size = args.size ? args.size : 300;
+
+  if (!args.item.ImageTags?.Primary) {
+    return null;
+  }
+
+  return (
+    `${args.baseUrl}/Items` +
+    `/${args.item.Id}` +
+    '/Images/Primary' +
+    `?width=${size}&height=${size}` +
+    '&quality=96'
+  );
+};
+
+const normalizeSong = (
+  item: z.infer<typeof jfType._response.song>,
+  server: ServerListItem | null,
+  deviceId: string,
+  imageSize?: number,
+): Song => {
+  return {
+    album: item.Album,
+    albumArtists: item.AlbumArtists?.map((entry) => ({
+      id: entry.Id,
+      imageUrl: null,
+      name: entry.Name,
+    })),
+    albumId: item.AlbumId,
+    artistName: item?.ArtistItems?.[0]?.Name,
+    artists: item?.ArtistItems?.map((entry) => ({
+      id: entry.Id,
+      imageUrl: null,
+      name: entry.Name,
+    })),
+    bitRate: item.MediaSources && Number(Math.trunc(item.MediaSources[0]?.Bitrate / 1000)),
+    bpm: null,
+    channels: null,
+    comment: null,
+    compilation: null,
+    container: (item.MediaSources && item.MediaSources[0]?.Container) || null,
+    createdAt: item.DateCreated,
+    discNumber: (item.ParentIndexNumber && item.ParentIndexNumber) || 1,
+    duration: item.RunTimeTicks / 10000000,
+    genres: item.GenreItems.map((entry: any) => ({ id: entry.Id, name: entry.Name })),
+    id: item.Id,
+    imagePlaceholderUrl: null,
+    imageUrl: getSongCoverArtUrl({ baseUrl: server?.url || '', item, size: imageSize || 100 }),
+    itemType: LibraryItem.SONG,
+    lastPlayedAt: null,
+    lyrics: null,
+    name: item.Name,
+    path: (item.MediaSources && item.MediaSources[0]?.Path) || null,
+    playCount: (item.UserData && item.UserData.PlayCount) || 0,
+    playlistItemId: item.PlaylistItemId,
+    // releaseDate: (item.ProductionYear && new Date(item.ProductionYear, 0, 1).toISOString()) || null,
+    releaseDate: null,
+    releaseYear: item.ProductionYear ? String(item.ProductionYear) : null,
+    serverId: server?.id || '',
+    serverType: ServerType.JELLYFIN,
+    size: item.MediaSources && item.MediaSources[0]?.Size,
+    streamUrl: getStreamUrl({
+      container: item.MediaSources?.[0]?.Container,
+      deviceId,
+      eTag: item.MediaSources?.[0]?.ETag,
+      id: item.Id,
+      mediaSourceId: item.MediaSources?.[0]?.Id,
+      server,
+    }),
+    trackNumber: item.IndexNumber,
+    uniqueId: nanoid(),
+    updatedAt: item.DateCreated,
+    userFavorite: (item.UserData && item.UserData.IsFavorite) || false,
+    userRating: null,
+  };
+};
+
+const normalizeAlbum = (
+  item: z.infer<typeof jfType._response.album>,
+  server: ServerListItem | null,
+  imageSize?: number,
+): Album => {
+  return {
+    albumArtists:
+      item.AlbumArtists.map((entry) => ({
+        id: entry.Id,
+        imageUrl: null,
+        name: entry.Name,
+      })) || [],
+    artists: item.ArtistItems?.map((entry) => ({ id: entry.Id, imageUrl: null, name: entry.Name })),
+    backdropImageUrl: null,
+    createdAt: item.DateCreated,
+    duration: item.RunTimeTicks / 10000,
+    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
+    id: item.Id,
+    imagePlaceholderUrl: null,
+    imageUrl: getAlbumCoverArtUrl({
+      baseUrl: server?.url || '',
+      item,
+      size: imageSize || 300,
+    }),
+    isCompilation: null,
+    itemType: LibraryItem.ALBUM,
+    lastPlayedAt: null,
+    name: item.Name,
+    playCount: item.UserData?.PlayCount || 0,
+    releaseDate: item.PremiereDate?.split('T')[0] || null,
+    releaseYear: item.ProductionYear || null,
+    serverId: server?.id || '',
+    serverType: ServerType.JELLYFIN,
+    size: null,
+    songCount: item?.ChildCount || null,
+    songs: item.Songs?.map((song) => normalizeSong(song, server, '', imageSize)),
+    uniqueId: nanoid(),
+    updatedAt: item?.DateLastMediaAdded || item.DateCreated,
+    userFavorite: item.UserData?.IsFavorite || false,
+    userRating: null,
+  };
+};
+
+const normalizeAlbumArtist = (
+  item: z.infer<typeof jfType._response.albumArtist> & {
+    similarArtists?: z.infer<typeof jfType._response.albumArtistList>;
+  },
+  server: ServerListItem | null,
+  imageSize?: number,
+): AlbumArtist => {
+  const similarArtists =
+    item.similarArtists?.Items?.filter((entry) => entry.Name !== 'Various Artists').map(
+      (entry) => ({
+        id: entry.Id,
+        imageUrl: getAlbumArtistCoverArtUrl({
+          baseUrl: server?.url || '',
+          item: entry,
+          size: imageSize || 300,
+        }),
+        name: entry.Name,
+      }),
+    ) || [];
+
+  return {
+    albumCount: null,
+    backgroundImageUrl: null,
+    biography: item.Overview || null,
+    duration: item.RunTimeTicks / 10000,
+    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
+    id: item.Id,
+    imageUrl: getAlbumArtistCoverArtUrl({
+      baseUrl: server?.url || '',
+      item,
+      size: imageSize || 300,
+    }),
+    itemType: LibraryItem.ALBUM_ARTIST,
+    lastPlayedAt: null,
+    name: item.Name,
+    playCount: item.UserData?.PlayCount || 0,
+    serverId: server?.id || '',
+    serverType: ServerType.JELLYFIN,
+    similarArtists,
+    songCount: null,
+    userFavorite: item.UserData?.IsFavorite || false,
+    userRating: null,
+  };
+};
+
+const normalizePlaylist = (
+  item: z.infer<typeof jfType._response.playlist>,
+  server: ServerListItem | null,
+  imageSize?: number,
+): Playlist => {
+  const imageUrl = getPlaylistCoverArtUrl({
+    baseUrl: server?.url || '',
+    item,
+    size: imageSize || 300,
+  });
+
+  const imagePlaceholderUrl = null;
+
+  return {
+    description: item.Overview || null,
+    duration: item.RunTimeTicks / 10000,
+    genres: item.GenreItems?.map((entry) => ({ id: entry.Id, name: entry.Name })),
+    id: item.Id,
+    imagePlaceholderUrl,
+    imageUrl: imageUrl || null,
+    itemType: LibraryItem.PLAYLIST,
+    name: item.Name,
+    owner: null,
+    ownerId: null,
+    public: null,
+    rules: null,
+    serverId: server?.id || '',
+    serverType: ServerType.JELLYFIN,
+    size: null,
+    songCount: item?.ChildCount || null,
+    sync: null,
+  };
+};
+
+const normalizeMusicFolder = (item: JFMusicFolder): MusicFolder => {
+  return {
+    id: item.Id,
+    name: item.Name,
+  };
+};
+
+// const normalizeArtist = (item: any) => {
+//   return {
+//     album: (item.album || []).map((entry: any) => normalizeAlbum(entry)),
+//     albumCount: item.AlbumCount,
+//     duration: item.RunTimeTicks / 10000000,
+//     genre: item.GenreItems && item.GenreItems.map((entry: any) => normalizeItem(entry)),
+//     id: item.Id,
+//     image: getCoverArtUrl(item),
+//     info: {
+//       biography: item.Overview,
+//       externalUrl: (item.ExternalUrls || []).map((entry: any) => normalizeItem(entry)),
+//       imageUrl: undefined,
+//       similarArtist: (item.similarArtist || []).map((entry: any) => normalizeArtist(entry)),
+//     },
+//     starred: item.UserData && item.UserData?.IsFavorite ? 'true' : undefined,
+//     title: item.Name,
+//     uniqueId: nanoid(),
+//   };
+// };
+
+const normalizeGenre = (item: JFGenre): Genre => {
+  return {
+    albumCount: undefined,
+    id: item.Id,
+    name: item.Name,
+    songCount: undefined,
+  };
+};
+
+// const normalizeFolder = (item: any) => {
+//   return {
+//     created: item.DateCreated,
+//     id: item.Id,
+//     image: getCoverArtUrl(item, 150),
+//     isDir: true,
+//     title: item.Name,
+//     type: Item.Folder,
+//     uniqueId: nanoid(),
+//   };
+// };
+
+// const normalizeScanStatus = () => {
+//   return {
+//     count: 'N/a',
+//     scanning: false,
+//   };
+// };
+
+export const jfNormalize = {
+  album: normalizeAlbum,
+  albumArtist: normalizeAlbumArtist,
+  genre: normalizeGenre,
+  musicFolder: normalizeMusicFolder,
+  playlist: normalizePlaylist,
+  song: normalizeSong,
+};

src/renderer/api/jellyfin/jellyfin-types.ts

@@ -0,0 +1,696 @@
+import { z } from 'zod';
+
+const sortOrderValues = ['Ascending', 'Descending'] as const;
+
+const jfExternal = {
+  IMDB: 'Imdb',
+  MUSIC_BRAINZ: 'MusicBrainz',
+  THE_AUDIO_DB: 'TheAudioDb',
+  THE_MOVIE_DB: 'TheMovieDb',
+  TVDB: 'Tvdb',
+};
+
+const jfImage = {
+  BACKDROP: 'Backdrop',
+  BANNER: 'Banner',
+  BOX: 'Box',
+  CHAPTER: 'Chapter',
+  DISC: 'Disc',
+  LOGO: 'Logo',
+  PRIMARY: 'Primary',
+  THUMB: 'Thumb',
+} as const;
+
+const jfCollection = {
+  MUSIC: 'music',
+  PLAYLISTS: 'playlists',
+} as const;
+
+const error = z.object({
+  errors: z.object({
+    recursive: z.array(z.string()),
+  }),
+  status: z.number(),
+  title: z.string(),
+  traceId: z.string(),
+  type: z.string(),
+});
+
+const baseParameters = z.object({
+  AlbumArtistIds: z.string().optional(),
+  ArtistIds: z.string().optional(),
+  ContributingArtistIds: z.string().optional(),
+  EnableImageTypes: z.string().optional(),
+  EnableTotalRecordCount: z.boolean().optional(),
+  EnableUserData: z.boolean().optional(),
+  EnableUserDataTypes: z.boolean().optional(),
+  ExcludeArtistIds: z.string().optional(),
+  ExcludeItemIds: z.string().optional(),
+  ExcludeItemTypes: z.string().optional(),
+  Fields: z.string().optional(),
+  ImageTypeLimit: z.number().optional(),
+  IncludeArtists: z.boolean().optional(),
+  IncludeGenres: z.boolean().optional(),
+  IncludeItemTypes: z.string().optional(),
+  IncludeMedia: z.boolean().optional(),
+  IncludePeople: z.boolean().optional(),
+  IncludeStudios: z.boolean().optional(),
+  IsFavorite: z.boolean().optional(),
+  Limit: z.number().optional(),
+  MediaTypes: z.string().optional(),
+  NameStartsWith: z.string().optional(),
+  ParentId: z.string().optional(),
+  Recursive: z.boolean().optional(),
+  SearchTerm: z.string().optional(),
+  SortBy: z.string().optional(),
+  SortOrder: z.enum(sortOrderValues).optional(),
+  StartIndex: z.number().optional(),
+  Tags: z.string().optional(),
+  UserId: z.string().optional(),
+  Years: z.string().optional(),
+});
+
+const paginationParameters = z.object({
+  Limit: z.number().optional(),
+  SortOrder: z.enum(sortOrderValues).optional(),
+  StartIndex: z.number().optional(),
+});
+
+const pagination = z.object({
+  StartIndex: z.number(),
+  TotalRecordCount: z.number(),
+});
+
+const imageTags = z.object({
+  Logo: z.string().optional(),
+  Primary: z.string().optional(),
+});
+
+const imageBlurHashes = z.object({
+  Backdrop: z.record(z.string(), z.string()).optional(),
+  Logo: z.record(z.string(), z.string()).optional(),
+  Primary: z.record(z.string(), z.string()).optional(),
+});
+
+const userData = z.object({
+  IsFavorite: z.boolean(),
+  Key: z.string(),
+  PlayCount: z.number(),
+  PlaybackPositionTicks: z.number(),
+  Played: z.boolean(),
+});
+
+const externalUrl = z.object({
+  Name: z.string(),
+  Url: z.string(),
+});
+
+const mediaStream = z.object({
+  AspectRatio: z.string().optional(),
+  BitDepth: z.number().optional(),
+  BitRate: z.number().optional(),
+  ChannelLayout: z.string().optional(),
+  Channels: z.number().optional(),
+  Codec: z.string(),
+  CodecTimeBase: z.string(),
+  ColorSpace: z.string().optional(),
+  Comment: z.string().optional(),
+  DisplayTitle: z.string().optional(),
+  Height: z.number().optional(),
+  Index: z.number(),
+  IsDefault: z.boolean(),
+  IsExternal: z.boolean(),
+  IsForced: z.boolean(),
+  IsInterlaced: z.boolean(),
+  IsTextSubtitleStream: z.boolean(),
+  Level: z.number(),
+  PixelFormat: z.string().optional(),
+  Profile: z.string().optional(),
+  RealFrameRate: z.number().optional(),
+  RefFrames: z.number().optional(),
+  SampleRate: z.number().optional(),
+  SupportsExternalStream: z.boolean(),
+  TimeBase: z.string(),
+  Type: z.string(),
+  Width: z.number().optional(),
+});
+
+const mediaSources = z.object({
+  Bitrate: z.number(),
+  Container: z.string(),
+  DefaultAudioStreamIndex: z.number(),
+  ETag: z.string(),
+  Formats: z.array(z.any()),
+  GenPtsInput: z.boolean(),
+  Id: z.string(),
+  IgnoreDts: z.boolean(),
+  IgnoreIndex: z.boolean(),
+  IsInfiniteStream: z.boolean(),
+  IsRemote: z.boolean(),
+  MediaAttachments: z.array(z.any()),
+  MediaStreams: z.array(mediaStream),
+  Name: z.string(),
+  Path: z.string(),
+  Protocol: z.string(),
+  ReadAtNativeFramerate: z.boolean(),
+  RequiredHttpHeaders: z.any(),
+  RequiresClosing: z.boolean(),
+  RequiresLooping: z.boolean(),
+  RequiresOpening: z.boolean(),
+  RunTimeTicks: z.number(),
+  Size: z.number(),
+  SupportsDirectPlay: z.boolean(),
+  SupportsDirectStream: z.boolean(),
+  SupportsProbing: z.boolean(),
+  SupportsTranscoding: z.boolean(),
+  Type: z.string(),
+});
+
+const sessionInfo = z.object({
+  AdditionalUsers: z.array(z.any()),
+  ApplicationVersion: z.string(),
+  Capabilities: z.object({
+    PlayableMediaTypes: z.array(z.any()),
+    SupportedCommands: z.array(z.any()),
+    SupportsContentUploading: z.boolean(),
+    SupportsMediaControl: z.boolean(),
+    SupportsPersistentIdentifier: z.boolean(),
+    SupportsSync: z.boolean(),
+  }),
+  Client: z.string(),
+  DeviceId: z.string(),
+  DeviceName: z.string(),
+  HasCustomDeviceName: z.boolean(),
+  Id: z.string(),
+  IsActive: z.boolean(),
+  LastActivityDate: z.string(),
+  LastPlaybackCheckIn: z.string(),
+  NowPlayingQueue: z.array(z.any()),
+  NowPlayingQueueFullItems: z.array(z.any()),
+  PlayState: z.object({
+    CanSeek: z.boolean(),
+    IsMuted: z.boolean(),
+    IsPaused: z.boolean(),
+    RepeatMode: z.string(),
+  }),
+  PlayableMediaTypes: z.array(z.any()),
+  RemoteEndPoint: z.string(),
+  ServerId: z.string(),
+  SupportedCommands: z.array(z.any()),
+  SupportsMediaControl: z.boolean(),
+  SupportsRemoteControl: z.boolean(),
+  UserId: z.string(),
+  UserName: z.string(),
+});
+
+const configuration = z.object({
+  DisplayCollectionsView: z.boolean(),
+  DisplayMissingEpisodes: z.boolean(),
+  EnableLocalPassword: z.boolean(),
+  EnableNextEpisodeAutoPlay: z.boolean(),
+  GroupedFolders: z.array(z.any()),
+  HidePlayedInLatest: z.boolean(),
+  LatestItemsExcludes: z.array(z.any()),
+  MyMediaExcludes: z.array(z.any()),
+  OrderedViews: z.array(z.any()),
+  PlayDefaultAudioTrack: z.boolean(),
+  RememberAudioSelections: z.boolean(),
+  RememberSubtitleSelections: z.boolean(),
+  SubtitleLanguagePreference: z.string(),
+  SubtitleMode: z.string(),
+});
+
+const policy = z.object({
+  AccessSchedules: z.array(z.any()),
+  AuthenticationProviderId: z.string(),
+  BlockUnratedItems: z.array(z.any()),
+  BlockedChannels: z.array(z.any()),
+  BlockedMediaFolders: z.array(z.any()),
+  BlockedTags: z.array(z.any()),
+  EnableAllChannels: z.boolean(),
+  EnableAllDevices: z.boolean(),
+  EnableAllFolders: z.boolean(),
+  EnableAudioPlaybackTranscoding: z.boolean(),
+  EnableContentDeletion: z.boolean(),
+  EnableContentDeletionFromFolders: z.array(z.any()),
+  EnableContentDownloading: z.boolean(),
+  EnableLiveTvAccess: z.boolean(),
+  EnableLiveTvManagement: z.boolean(),
+  EnableMediaConversion: z.boolean(),
+  EnableMediaPlayback: z.boolean(),
+  EnablePlaybackRemuxing: z.boolean(),
+  EnablePublicSharing: z.boolean(),
+  EnableRemoteAccess: z.boolean(),
+  EnableRemoteControlOfOtherUsers: z.boolean(),
+  EnableSharedDeviceControl: z.boolean(),
+  EnableSyncTranscoding: z.boolean(),
+  EnableUserPreferenceAccess: z.boolean(),
+  EnableVideoPlaybackTranscoding: z.boolean(),
+  EnabledChannels: z.array(z.any()),
+  EnabledDevices: z.array(z.any()),
+  EnabledFolders: z.array(z.any()),
+  ForceRemoteSourceTranscoding: z.boolean(),
+  InvalidLoginAttemptCount: z.number(),
+  IsAdministrator: z.boolean(),
+  IsDisabled: z.boolean(),
+  IsHidden: z.boolean(),
+  LoginAttemptsBeforeLockout: z.number(),
+  MaxActiveSessions: z.number(),
+  PasswordResetProviderId: z.string(),
+  RemoteClientBitrateLimit: z.number(),
+  SyncPlayAccess: z.string(),
+});
+
+const user = z.object({
+  Configuration: configuration,
+  EnableAutoLogin: z.boolean(),
+  HasConfiguredEasyPassword: z.boolean(),
+  HasConfiguredPassword: z.boolean(),
+  HasPassword: z.boolean(),
+  Id: z.string(),
+  LastActivityDate: z.string(),
+  LastLoginDate: z.string(),
+  Name: z.string(),
+  Policy: policy,
+  ServerId: z.string(),
+});
+
+const authenticateParameters = z.object({
+  Pw: z.string(),
+  Username: z.string(),
+});
+
+const authenticate = z.object({
+  AccessToken: z.string(),
+  ServerId: z.string(),
+  SessionInfo: sessionInfo,
+  User: user,
+});
+
+const genreItem = z.object({
+  Id: z.string(),
+  Name: z.string(),
+});
+
+const genre = z.object({
+  BackdropImageTags: z.array(z.any()),
+  ChannelId: z.null(),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  LocationType: z.string(),
+  Name: z.string(),
+  ServerId: z.string(),
+  Type: z.string(),
+});
+
+const genreList = z.object({
+  Items: z.array(genre),
+});
+
+const musicFolder = z.object({
+  BackdropImageTags: z.array(z.string()),
+  ChannelId: z.null(),
+  CollectionType: z.string(),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  IsFolder: z.boolean(),
+  LocationType: z.string(),
+  Name: z.string(),
+  ServerId: z.string(),
+  Type: z.string(),
+  UserData: userData,
+});
+
+const musicFolderListParameters = z.object({
+  UserId: z.string(),
+});
+
+const musicFolderList = z.object({
+  Items: z.array(musicFolder),
+});
+
+const playlist = z.object({
+  BackdropImageTags: z.array(z.string()),
+  ChannelId: z.null(),
+  ChildCount: z.number().optional(),
+  DateCreated: z.string(),
+  GenreItems: z.array(genreItem),
+  Genres: z.array(z.string()),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  IsFolder: z.boolean(),
+  LocationType: z.string(),
+  MediaType: z.string(),
+  Name: z.string(),
+  Overview: z.string().optional(),
+  RunTimeTicks: z.number(),
+  ServerId: z.string(),
+  Type: z.string(),
+  UserData: userData,
+});
+
+const jfPlaylistListSort = {
+  ALBUM_ARTIST: 'AlbumArtist,SortName',
+  DURATION: 'Runtime',
+  NAME: 'SortName',
+  RECENTLY_ADDED: 'DateCreated,SortName',
+  SONG_COUNT: 'ChildCount',
+} as const;
+
+const playlistListParameters = paginationParameters.merge(
+  baseParameters.extend({
+    IncludeItemTypes: z.literal('Playlist'),
+    SortBy: z.nativeEnum(jfPlaylistListSort).optional(),
+  }),
+);
+
+const playlistList = pagination.extend({
+  Items: z.array(playlist),
+});
+
+const genericItem = z.object({
+  Id: z.string(),
+  Name: z.string(),
+});
+
+const song = z.object({
+  Album: z.string(),
+  AlbumArtist: z.string(),
+  AlbumArtists: z.array(genericItem),
+  AlbumId: z.string(),
+  AlbumPrimaryImageTag: z.string(),
+  ArtistItems: z.array(genericItem),
+  Artists: z.array(z.string()),
+  BackdropImageTags: z.array(z.string()),
+  ChannelId: z.null(),
+  DateCreated: z.string(),
+  ExternalUrls: z.array(externalUrl),
+  GenreItems: z.array(genericItem),
+  Genres: z.array(z.string()),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  IndexNumber: z.number(),
+  IsFolder: z.boolean(),
+  LocationType: z.string(),
+  MediaSources: z.array(mediaSources),
+  MediaType: z.string(),
+  Name: z.string(),
+  ParentIndexNumber: z.number(),
+  PlaylistItemId: z.string().optional(),
+  PremiereDate: z.string().optional(),
+  ProductionYear: z.number(),
+  RunTimeTicks: z.number(),
+  ServerId: z.string(),
+  SortName: z.string(),
+  Type: z.string(),
+  UserData: userData.optional(),
+});
+
+const albumArtist = z.object({
+  BackdropImageTags: z.array(z.string()),
+  ChannelId: z.null(),
+  DateCreated: z.string(),
+  ExternalUrls: z.array(externalUrl),
+  GenreItems: z.array(genreItem),
+  Genres: z.array(z.string()),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  LocationType: z.string(),
+  Name: z.string(),
+  Overview: z.string(),
+  RunTimeTicks: z.number(),
+  ServerId: z.string(),
+  Type: z.string(),
+  UserData: userData.optional(),
+});
+
+const albumDetailParameters = baseParameters;
+
+const album = z.object({
+  AlbumArtist: z.string(),
+  AlbumArtists: z.array(genericItem),
+  AlbumPrimaryImageTag: z.string(),
+  ArtistItems: z.array(genericItem),
+  Artists: z.array(z.string()),
+  ChannelId: z.null(),
+  ChildCount: z.number().optional(),
+  DateCreated: z.string(),
+  DateLastMediaAdded: z.string().optional(),
+  ExternalUrls: z.array(externalUrl),
+  GenreItems: z.array(genericItem),
+  Genres: z.array(z.string()),
+  Id: z.string(),
+  ImageBlurHashes: imageBlurHashes,
+  ImageTags: imageTags,
+  IsFolder: z.boolean(),
+  LocationType: z.string(),
+  Name: z.string(),
+  ParentLogoImageTag: z.string(),
+  ParentLogoItemId: z.string(),
+  PremiereDate: z.string().optional(),
+  ProductionYear: z.number(),
+  RunTimeTicks: z.number(),
+  ServerId: z.string(),
+  Songs: z.array(song).optional(), // This is not a native Jellyfin property -- this is used for combined album detail
+  Type: z.string(),
+  UserData: userData.optional(),
+});
+
+const jfAlbumListSort = {
+  ALBUM_ARTIST: 'AlbumArtist,SortName',
+  COMMUNITY_RATING: 'CommunityRating,SortName',
+  CRITIC_RATING: 'CriticRating,SortName',
+  NAME: 'SortName',
+  RANDOM: 'Random,SortName',
+  RECENTLY_ADDED: 'DateCreated,SortName',
+  RELEASE_DATE: 'ProductionYear,PremiereDate,SortName',
+} as const;
+
+const albumListParameters = paginationParameters.merge(
+  baseParameters.extend({
+    Filters: z.string().optional(),
+    GenreIds: z.string().optional(),
+    Genres: z.string().optional(),
+    IncludeItemTypes: z.literal('MusicAlbum'),
+    IsFavorite: z.boolean().optional(),
+    SearchTerm: z.string().optional(),
+    SortBy: z.nativeEnum(jfAlbumListSort).optional(),
+    Tags: z.string().optional(),
+    Years: z.string().optional(),
+  }),
+);
+
+const albumList = pagination.extend({
+  Items: z.array(album),
+});
+
+const jfAlbumArtistListSort = {
+  ALBUM: 'Album,SortName',
+  DURATION: 'Runtime,AlbumArtist,Album,SortName',
+  NAME: 'Name,SortName',
+  RANDOM: 'Random,SortName',
+  RECENTLY_ADDED: 'DateCreated,SortName',
+  RELEASE_DATE: 'PremiereDate,AlbumArtist,Album,SortName',
+} as const;
+
+const albumArtistListParameters = paginationParameters.merge(
+  baseParameters.extend({
+    Filters: z.string().optional(),
+    Genres: z.string().optional(),
+    SortBy: z.nativeEnum(jfAlbumArtistListSort).optional(),
+    Years: z.string().optional(),
+  }),
+);
+
+const albumArtistList = pagination.extend({
+  Items: z.array(albumArtist),
+});
+
+const similarArtistListParameters = baseParameters.extend({
+  Limit: z.number().optional(),
+});
+
+const jfSongListSort = {
+  ALBUM: 'Album,SortName',
+  ALBUM_ARTIST: 'AlbumArtist,Album,SortName',
+  ARTIST: 'Artist,Album,SortName',
+  COMMUNITY_RATING: 'CommunityRating,SortName',
+  DURATION: 'Runtime,AlbumArtist,Album,SortName',
+  NAME: 'Name,SortName',
+  PLAY_COUNT: 'PlayCount,SortName',
+  RANDOM: 'Random,SortName',
+  RECENTLY_ADDED: 'DateCreated,SortName',
+  RECENTLY_PLAYED: 'DatePlayed,SortName',
+  RELEASE_DATE: 'PremiereDate,AlbumArtist,Album,SortName',
+} as const;
+
+const songListParameters = paginationParameters.merge(
+  baseParameters.extend({
+    AlbumArtistIds: z.string().optional(),
+    AlbumIds: z.string().optional(),
+    ArtistIds: z.string().optional(),
+    Filters: z.string().optional(),
+    GenreIds: z.string().optional(),
+    Genres: z.string().optional(),
+    IsFavorite: z.boolean().optional(),
+    SearchTerm: z.string().optional(),
+    SortBy: z.nativeEnum(jfSongListSort).optional(),
+    Tags: z.string().optional(),
+    Years: z.string().optional(),
+  }),
+);
+
+const songList = pagination.extend({
+  Items: z.array(song),
+});
+
+const playlistSongList = songList;
+
+const topSongsList = songList;
+
+const playlistDetailParameters = baseParameters.extend({
+  Ids: z.string(),
+});
+
+const createPlaylistParameters = z.object({
+  MediaType: z.literal('Audio'),
+  Name: z.string(),
+  Overview: z.string(),
+  UserId: z.string(),
+});
+
+const createPlaylist = z.object({
+  Id: z.string(),
+});
+
+const updatePlaylist = z.null();
+
+const updatePlaylistParameters = z.object({
+  Genres: z.array(genreItem),
+  MediaType: z.literal('Audio'),
+  Name: z.string(),
+  Overview: z.string(),
+  PremiereDate: z.null(),
+  ProviderIds: z.object({}),
+  Tags: z.array(genericItem),
+  UserId: z.string(),
+});
+
+const addToPlaylist = z.object({
+  Added: z.number(),
+});
+
+const addToPlaylistParameters = z.object({
+  Ids: z.array(z.string()),
+  UserId: z.string(),
+});
+
+const removeFromPlaylist = z.null();
+
+const removeFromPlaylistParameters = z.object({
+  EntryIds: z.array(z.string()),
+});
+
+const deletePlaylist = z.null();
+
+const deletePlaylistParameters = z.object({
+  Id: z.string(),
+});
+
+const scrobbleParameters = z.object({
+  EventName: z.string().optional(),
+  IsPaused: z.boolean().optional(),
+  ItemId: z.string(),
+  PositionTicks: z.number().optional(),
+});
+
+const scrobble = z.any();
+
+const favorite = z.object({
+  IsFavorite: z.boolean(),
+  ItemId: z.string(),
+  Key: z.string(),
+  LastPlayedDate: z.string(),
+  Likes: z.boolean(),
+  PlayCount: z.number(),
+  PlaybackPositionTicks: z.number(),
+  Played: z.boolean(),
+  PlayedPercentage: z.number(),
+  Rating: z.number(),
+  UnplayedItemCount: z.number(),
+});
+
+const favoriteParameters = z.object({});
+
+const searchParameters = paginationParameters.merge(baseParameters);
+
+const search = z.any();
+
+const lyricText = z.object({
+  Start: z.number().optional(),
+  Text: z.string(),
+});
+
+const lyrics = z.object({
+  Lyrics: z.array(lyricText),
+});
+
+export const jfType = {
+  _enum: {
+    collection: jfCollection,
+    external: jfExternal,
+    image: jfImage,
+  },
+  _parameters: {
+    addToPlaylist: addToPlaylistParameters,
+    albumArtistDetail: baseParameters,
+    albumArtistList: albumArtistListParameters,
+    albumDetail: albumDetailParameters,
+    albumList: albumListParameters,
+    authenticate: authenticateParameters,
+    createPlaylist: createPlaylistParameters,
+    deletePlaylist: deletePlaylistParameters,
+    favorite: favoriteParameters,
+    musicFolderList: musicFolderListParameters,
+    playlistDetail: playlistDetailParameters,
+    playlistList: playlistListParameters,
+    removeFromPlaylist: removeFromPlaylistParameters,
+    scrobble: scrobbleParameters,
+    search: searchParameters,
+    similarArtistList: similarArtistListParameters,
+    songList: songListParameters,
+    updatePlaylist: updatePlaylistParameters,
+  },
+  _response: {
+    addToPlaylist,
+    album,
+    albumArtist,
+    albumArtistList,
+    albumList,
+    authenticate,
+    createPlaylist,
+    deletePlaylist,
+    error,
+    favorite,
+    genre,
+    genreList,
+    lyrics,
+    musicFolderList,
+    playlist,
+    playlistList,
+    playlistSongList,
+    removeFromPlaylist,
+    scrobble,
+    search,
+    song,
+    songList,
+    topSongsList,
+    updatePlaylist,
+    user,
+  },
+};

src/renderer/api/navidrome.api.ts

@@ -1,617 +0,0 @@
-import { nanoid } from 'nanoid/non-secure';
-import ky from 'ky';
-import type {
-  NDGenreListResponse,
-  NDArtistListResponse,
-  NDAlbumDetail,
-  NDAlbumListParams,
-  NDAlbumList,
-  NDSongDetailResponse,
-  NDAlbum,
-  NDSong,
-  NDAuthenticationResponse,
-  NDAlbumDetailResponse,
-  NDSongDetail,
-  NDGenreList,
-  NDAlbumArtistListParams,
-  NDAlbumArtistDetail,
-  NDAlbumListResponse,
-  NDAlbumArtistDetailResponse,
-  NDAlbumArtistList,
-  NDSongListParams,
-  NDCreatePlaylistParams,
-  NDCreatePlaylistResponse,
-  NDDeletePlaylist,
-  NDDeletePlaylistResponse,
-  NDPlaylistListParams,
-  NDPlaylistDetail,
-  NDPlaylistList,
-  NDPlaylistListResponse,
-  NDPlaylistDetailResponse,
-  NDSongList,
-  NDSongListResponse,
-  NDAlbumArtist,
-  NDPlaylist,
-  NDUpdatePlaylistParams,
-  NDUpdatePlaylistResponse,
-  NDPlaylistSongListResponse,
-  NDPlaylistSongList,
-  NDPlaylistSong,
-} from '/@/renderer/api/navidrome.types';
-import { NDPlaylistListSort, NDSongListSort, NDSortOrder } from '/@/renderer/api/navidrome.types';
-import type {
-  Album,
-  Song,
-  AuthenticationResponse,
-  AlbumDetailArgs,
-  GenreListArgs,
-  AlbumListArgs,
-  AlbumArtistListArgs,
-  AlbumArtistDetailArgs,
-  SongListArgs,
-  SongDetailArgs,
-  CreatePlaylistArgs,
-  DeletePlaylistArgs,
-  PlaylistListArgs,
-  PlaylistDetailArgs,
-  CreatePlaylistResponse,
-  PlaylistSongListArgs,
-  AlbumArtist,
-  Playlist,
-  UpdatePlaylistResponse,
-  UpdatePlaylistArgs,
-} from '/@/renderer/api/types';
-import {
-  playlistListSortMap,
-  albumArtistListSortMap,
-  songListSortMap,
-  albumListSortMap,
-  sortOrderMap,
-} from '/@/renderer/api/types';
-import { toast } from '/@/renderer/components/toast';
-import { useAuthStore } from '/@/renderer/store';
-import { ServerListItem, ServerType } from '/@/renderer/types';
-import { parseSearchParams } from '/@/renderer/utils';
-
-const api = ky.create({
-  hooks: {
-    afterResponse: [
-      async (_request, _options, response) => {
-        const serverId = useAuthStore.getState().currentServer?.id;
-
-        if (serverId) {
-          useAuthStore.getState().actions.updateServer(serverId, {
-            ndCredential: response.headers.get('x-nd-authorization') as string,
-          });
-        }
-
-        return response;
-      },
-    ],
-    beforeError: [
-      (error) => {
-        if (error.response && error.response.status === 401) {
-          toast.error({
-            message: 'Your session has expired.',
-          });
-
-          const serverId = useAuthStore.getState().currentServer?.id;
-
-          if (serverId) {
-            useAuthStore.getState().actions.setCurrentServer(null);
-            useAuthStore.getState().actions.updateServer(serverId, { ndCredential: undefined });
-          }
-        }
-
-        return error;
-      },
-    ],
-  },
-});
-
-const authenticate = async (
-  url: string,
-  body: { password: string; username: string },
-): Promise<AuthenticationResponse> => {
-  const cleanServerUrl = url.replace(/\/$/, '');
-
-  const data = await ky
-    .post(`${cleanServerUrl}/auth/login`, {
-      json: {
-        password: body.password,
-        username: body.username,
-      },
-    })
-    .json<NDAuthenticationResponse>();
-
-  return {
-    credential: `u=${body.username}&s=${data.subsonicSalt}&t=${data.subsonicToken}`,
-    ndCredential: data.token,
-    userId: data.id,
-    username: data.username,
-  };
-};
-
-const getGenreList = async (args: GenreListArgs): Promise<NDGenreList> => {
-  const { server, signal } = args;
-
-  const data = await api
-    .get('api/genre', {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDGenreListResponse>();
-
-  return data;
-};
-
-const getAlbumArtistDetail = async (args: AlbumArtistDetailArgs): Promise<NDAlbumArtistDetail> => {
-  const { query, server, signal } = args;
-
-  const data = await api
-    .get(`api/artist/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDAlbumArtistDetailResponse>();
-
-  return { ...data };
-};
-
-const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<NDAlbumArtistList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: NDAlbumArtistListParams = {
-    _end: query.startIndex + (query.limit || 0),
-    _order: sortOrderMap.navidrome[query.sortOrder],
-    _sort: albumArtistListSortMap.navidrome[query.sortBy],
-    _start: query.startIndex,
-    name: query.searchTerm,
-    ...query.ndParams,
-  };
-
-  const res = await api.get('api/artist', {
-    headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-    prefixUrl: server?.url,
-    searchParams: parseSearchParams(searchParams),
-    signal,
-  });
-
-  const data = await res.json<NDArtistListResponse>();
-  const itemCount = res.headers.get('x-total-count');
-
-  return {
-    items: data,
-    startIndex: query.startIndex,
-    totalRecordCount: Number(itemCount),
-  };
-};
-
-const getAlbumDetail = async (args: AlbumDetailArgs): Promise<NDAlbumDetail> => {
-  const { query, server, signal } = args;
-
-  const data = await api
-    .get(`api/album/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDAlbumDetailResponse>();
-
-  const songsData = await api
-    .get('api/song', {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      searchParams: {
-        _end: 0,
-        _order: NDSortOrder.ASC,
-        _sort: 'album',
-        _start: 0,
-        album_id: query.id,
-      },
-      signal,
-    })
-    .json<NDSongListResponse>();
-
-  return { ...data, songs: songsData };
-};
-
-const getAlbumList = async (args: AlbumListArgs): Promise<NDAlbumList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: NDAlbumListParams = {
-    _end: query.startIndex + (query.limit || 0),
-    _order: sortOrderMap.navidrome[query.sortOrder],
-    _sort: albumListSortMap.navidrome[query.sortBy],
-    _start: query.startIndex,
-    name: query.searchTerm,
-    ...query.ndParams,
-  };
-
-  const res = await api.get('api/album', {
-    headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-    prefixUrl: server?.url,
-    searchParams: parseSearchParams(searchParams),
-    signal,
-  });
-
-  const data = await res.json<NDAlbumListResponse>();
-  const itemCount = res.headers.get('x-total-count');
-
-  return {
-    items: data,
-    startIndex: query?.startIndex || 0,
-    totalRecordCount: Number(itemCount),
-  };
-};
-
-const getSongList = async (args: SongListArgs): Promise<NDSongList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: NDSongListParams = {
-    _end: query.startIndex + (query.limit || -1),
-    _order: sortOrderMap.navidrome[query.sortOrder],
-    _sort: songListSortMap.navidrome[query.sortBy],
-    _start: query.startIndex,
-    album_id: query.albumIds,
-    artist_id: query.artistIds,
-    title: query.searchTerm,
-    ...query.ndParams,
-  };
-
-  const res = await api.get('api/song', {
-    headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-    prefixUrl: server?.url,
-    searchParams: parseSearchParams(searchParams),
-    signal,
-  });
-
-  const data = await res.json<NDSongListResponse>();
-  const itemCount = res.headers.get('x-total-count');
-
-  return {
-    items: data,
-    startIndex: query?.startIndex || 0,
-    totalRecordCount: Number(itemCount),
-  };
-};
-
-const getSongDetail = async (args: SongDetailArgs): Promise<NDSongDetail> => {
-  const { query, server, signal } = args;
-
-  const data = await api
-    .get(`api/song/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDSongDetailResponse>();
-
-  return data;
-};
-
-const createPlaylist = async (args: CreatePlaylistArgs): Promise<CreatePlaylistResponse> => {
-  const { query, server } = args;
-
-  const json: NDCreatePlaylistParams = {
-    comment: query.comment,
-    name: query.name,
-    public: query.public || false,
-  };
-
-  const data = await api
-    .post('api/playlist', {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      json,
-      prefixUrl: server?.url,
-    })
-    .json<NDCreatePlaylistResponse>();
-
-  return {
-    id: data.id,
-    name: query.name,
-  };
-};
-
-const updatePlaylist = async (args: UpdatePlaylistArgs): Promise<UpdatePlaylistResponse> => {
-  const { query, body, server, signal } = args;
-
-  const json: NDUpdatePlaylistParams = {
-    comment: body.comment || '',
-    name: body.name,
-    public: body.public || false,
-  };
-
-  const data = await api
-    .put(`api/playlist/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      json,
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDUpdatePlaylistResponse>();
-
-  return {
-    id: data.id,
-  };
-};
-
-const deletePlaylist = async (args: DeletePlaylistArgs): Promise<NDDeletePlaylist> => {
-  const { query, server, signal } = args;
-
-  const data = await api
-    .delete(`api/playlist/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDDeletePlaylistResponse>();
-
-  return data;
-};
-
-const getPlaylistList = async (args: PlaylistListArgs): Promise<NDPlaylistList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: NDPlaylistListParams = {
-    _end: query.startIndex + (query.limit || 0),
-    _order: query.sortOrder ? sortOrderMap.navidrome[query.sortOrder] : NDSortOrder.ASC,
-    _sort: query.sortBy ? playlistListSortMap.navidrome[query.sortBy] : NDPlaylistListSort.NAME,
-    _start: query.startIndex,
-    ...query.ndParams,
-  };
-
-  const res = await api.get('api/playlist', {
-    headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-    prefixUrl: server?.url,
-    searchParams: parseSearchParams(searchParams),
-    signal,
-  });
-
-  const data = await res.json<NDPlaylistListResponse>();
-  const itemCount = res.headers.get('x-total-count');
-
-  return {
-    items: data,
-    startIndex: query?.startIndex || 0,
-    totalRecordCount: Number(itemCount),
-  };
-};
-
-const getPlaylistDetail = async (args: PlaylistDetailArgs): Promise<NDPlaylistDetail> => {
-  const { query, server, signal } = args;
-
-  const data = await api
-    .get(`api/playlist/${query.id}`, {
-      headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<NDPlaylistDetailResponse>();
-
-  return data;
-};
-
-const getPlaylistSongList = async (args: PlaylistSongListArgs): Promise<NDPlaylistSongList> => {
-  const { query, server, signal } = args;
-
-  const searchParams: NDSongListParams & { playlist_id: string } = {
-    _end: query.startIndex + (query.limit || 0),
-    _order: query.sortOrder ? sortOrderMap.navidrome[query.sortOrder] : NDSortOrder.ASC,
-    _sort: query.sortBy ? songListSortMap.navidrome[query.sortBy] : NDSongListSort.ID,
-    _start: query.startIndex,
-    playlist_id: query.id,
-  };
-
-  const res = await api.get(`api/playlist/${query.id}/tracks`, {
-    headers: { 'x-nd-authorization': `Bearer ${server?.ndCredential}` },
-    prefixUrl: server?.url,
-    searchParams: parseSearchParams(searchParams),
-    signal,
-  });
-
-  const data = await res.json<NDPlaylistSongListResponse>();
-  const itemCount = res.headers.get('x-total-count');
-
-  return {
-    items: data,
-    startIndex: query?.startIndex || 0,
-    totalRecordCount: Number(itemCount),
-  };
-};
-
-const getCoverArtUrl = (args: {
-  baseUrl: string;
-  coverArtId: string;
-  credential: string;
-  size: number;
-}) => {
-  const size = args.size ? args.size : 250;
-
-  if (!args.coverArtId || args.coverArtId.match('2a96cbd8b46e442fc41c2b86b821562f')) {
-    return null;
-  }
-
-  return (
-    `${args.baseUrl}/rest/getCoverArt.view` +
-    `?id=${args.coverArtId}` +
-    `&${args.credential}` +
-    '&v=1.13.0' +
-    '&c=feishin' +
-    `&size=${size}`
-  );
-};
-
-const normalizeSong = (
-  item: NDSong | NDPlaylistSong,
-  server: ServerListItem,
-  deviceId: string,
-  imageSize?: number,
-): Song => {
-  let id;
-
-  // Dynamically determine the id field based on whether or not the item is a playlist song
-  if ('mediaFileId' in item) {
-    id = item.mediaFileId;
-  } else {
-    id = item.id;
-  }
-
-  const imageUrl = getCoverArtUrl({
-    baseUrl: server.url,
-    coverArtId: id,
-    credential: server.credential,
-    size: imageSize || 300,
-  });
-
-  const imagePlaceholderUrl = null;
-
-  return {
-    album: item.album,
-    albumArtists: [{ id: item.artistId, name: item.artist }],
-    albumId: item.albumId,
-    artistName: item.artist,
-    artists: [{ id: item.artistId, name: item.artist }],
-    bitRate: item.bitRate,
-    bpm: item.bpm ? item.bpm : null,
-    channels: item.channels ? item.channels : null,
-    compilation: item.compilation,
-    container: item.suffix,
-    createdAt: item.createdAt.split('T')[0],
-    discNumber: item.discNumber,
-    duration: item.duration,
-    genres: item.genres,
-    id,
-    imagePlaceholderUrl,
-    imageUrl,
-    isFavorite: item.starred,
-    lastPlayedAt: item.playDate ? item.playDate : null,
-    name: item.title,
-    note: item.comment ? item.comment : null,
-    path: item.path,
-    playCount: item.playCount,
-    releaseDate: new Date(item.year, 0, 1).toISOString(),
-    releaseYear: String(item.year),
-    serverId: server.id,
-    size: item.size,
-    streamUrl: `${server.url}/rest/stream.view?id=${id}&v=1.13.0&c=feishin_${deviceId}&${server.credential}`,
-    trackNumber: item.trackNumber,
-    type: ServerType.NAVIDROME,
-    uniqueId: nanoid(),
-    updatedAt: item.updatedAt,
-  };
-};
-
-const normalizeAlbum = (item: NDAlbum, server: ServerListItem, imageSize?: number): Album => {
-  const imageUrl = getCoverArtUrl({
-    baseUrl: server.url,
-    coverArtId: item.coverArtId || item.id,
-    credential: server.credential,
-    size: imageSize || 300,
-  });
-
-  const imagePlaceholderUrl = null;
-
-  const imageBackdropUrl = imageUrl?.replace(/size=\d+/, 'size=1000') || null;
-
-  return {
-    albumArtists: [{ id: item.albumArtistId, name: item.albumArtist }],
-    artists: [{ id: item.artistId, name: item.artist }],
-    backdropImageUrl: imageBackdropUrl,
-    createdAt: item.createdAt.split('T')[0],
-    duration: item.duration * 1000 || null,
-    genres: item.genres,
-    id: item.id,
-    imagePlaceholderUrl,
-    imageUrl,
-    isCompilation: item.compilation,
-    isFavorite: item.starred,
-    lastPlayedAt: item.playDate ? item.playDate.split('T')[0] : null,
-    name: item.name,
-    playCount: item.playCount,
-    rating: item.rating,
-    releaseDate: new Date(item.minYear, 0, 1).toISOString(),
-    releaseYear: item.minYear,
-    serverType: ServerType.NAVIDROME,
-    size: item.size,
-    songCount: item.songCount,
-    songs: item.songs ? item.songs.map((song) => normalizeSong(song, server, '')) : undefined,
-    uniqueId: nanoid(),
-    updatedAt: item.updatedAt,
-  };
-};
-
-const normalizeAlbumArtist = (item: NDAlbumArtist): AlbumArtist => {
-  return {
-    albumCount: item.albumCount,
-    backgroundImageUrl: null,
-    biography: item.biography,
-    duration: null,
-    genres: item.genres,
-    id: item.id,
-    imageUrl: item.largeImageUrl,
-    isFavorite: item.starred,
-    lastPlayedAt: item.playDate ? item.playDate.split('T')[0] : null,
-    name: item.name,
-    playCount: item.playCount,
-    rating: item.rating,
-    songCount: item.songCount,
-  };
-};
-
-const normalizePlaylist = (
-  item: NDPlaylist,
-  server: ServerListItem,
-  imageSize?: number,
-): Playlist => {
-  const imageUrl = getCoverArtUrl({
-    baseUrl: server.url,
-    coverArtId: item.id,
-    credential: server.credential,
-    size: imageSize || 300,
-  });
-
-  const imagePlaceholderUrl = null;
-
-  return {
-    description: item.comment,
-    duration: item.duration * 1000,
-    genres: [],
-    id: item.id,
-    imagePlaceholderUrl,
-    imageUrl,
-    name: item.name,
-    public: item.public,
-    rules: item?.rules || null,
-    size: item.size,
-    songCount: item.songCount,
-    userId: item.ownerId,
-    username: item.ownerName,
-  };
-};
-
-export const navidromeApi = {
-  authenticate,
-  createPlaylist,
-  deletePlaylist,
-  getAlbumArtistDetail,
-  getAlbumArtistList,
-  getAlbumDetail,
-  getAlbumList,
-  getGenreList,
-  getPlaylistDetail,
-  getPlaylistList,
-  getPlaylistSongList,
-  getSongDetail,
-  getSongList,
-  updatePlaylist,
-};
-
-export const ndNormalize = {
-  album: normalizeAlbum,
-  albumArtist: normalizeAlbumArtist,
-  playlist: normalizePlaylist,
-  song: normalizeSong,
-};

src/renderer/api/navidrome.types.ts

@@ -1,3 +1,5 @@
+import { SSArtistInfo } from '/@/renderer/api/subsonic.types';
+
 export type NDAuthenticate = {
   id: string;
   isAdmin: boolean;
@@ -8,6 +10,18 @@ export type NDAuthenticate = {
   username: string;
 };
 
+export type NDUser = {
+  createdAt: string;
+  email: string;
+  id: string;
+  isAdmin: boolean;
+  lastAccessAt: string;
+  lastLoginAt: string;
+  name: string;
+  updatedAt: string;
+  userName: string;
+};
+
 export type NDGenre = {
   id: string;
   name: string;
@@ -101,19 +115,21 @@ export type NDAlbumArtist = {
   fullText: string;
   genres: NDGenre[];
   id: string;
-  largeImageUrl: string;
+  largeImageUrl?: string;
   mbzArtistId: string;
-  mediumImageUrl: string;
+  mediumImageUrl?: string;
   name: string;
   orderArtistName: string;
   playCount: number;
   playDate: string;
   rating: number;
   size: number;
-  smallImageUrl: string;
+  smallImageUrl?: string;
   songCount: number;
   starred: boolean;
   starredAt: string;
+} & {
+  similarArtists?: SSArtistInfo['similarArtist'];
 };
 
 export type NDAuthenticationResponse = NDAuthenticate;
@@ -214,8 +230,8 @@ export type NDAlbumListParams = {
 
 export enum NDSongListSort {
   ALBUM = 'album, order_album_artist_name, disc_number, track_number, title',
-  ALBUM_ARTIST = 'albumArtist',
-  ALBUM_SONGS = 'discNumber, trackNumber',
+  ALBUM_ARTIST = 'order_album_artist_name, album, disc_number, track_number, title',
+  ALBUM_SONGS = 'album, discNumber, trackNumber',
   ARTIST = 'artist',
   BPM = 'bpm',
   CHANNELS = 'channels',
@@ -227,9 +243,10 @@ export enum NDSongListSort {
   PLAY_COUNT = 'playCount',
   PLAY_DATE = 'playDate',
   RATING = 'rating',
+  RECENTLY_ADDED = 'createdAt',
   TITLE = 'title',
   TRACK = 'track',
-  YEAR = 'year',
+  YEAR = 'year, album, discNumber, trackNumber',
 }
 
 export type NDSongListParams = {
@@ -257,6 +274,26 @@ export type NDAlbumArtistListParams = {
 } & NDPagination &
   NDOrder;
 
+export type NDAddToPlaylistResponse = {
+  added: number;
+};
+
+export type NDAddToPlaylistBody = {
+  ids: string[];
+};
+
+export type NDAddToPlaylist = null;
+
+export type NDRemoveFromPlaylistResponse = {
+  ids: string[];
+};
+
+export type NDRemoveFromPlaylistParams = {
+  id: string[];
+};
+
+export type NDRemoveFromPlaylist = null;
+
 export type NDCreatePlaylistParams = {
   comment?: string;
   name: string;
@@ -339,3 +376,91 @@ export type NDPlaylistSongList = {
   startIndex: number;
   totalRecordCount: number;
 };
+
+export const NDSongQueryFields = [
+  { label: 'Album', type: 'string', value: 'album' },
+  { label: 'Album Artist', type: 'string', value: 'albumartist' },
+  { label: 'Album Comment', type: 'string', value: 'albumcomment' },
+  { label: 'Album Type', type: 'string', value: 'albumtype' },
+  { label: 'Artist', type: 'string', value: 'artist' },
+  { label: 'Bitrate', type: 'number', value: 'bitrate' },
+  { label: 'BPM', type: 'number', value: 'bpm' },
+  { label: 'Catalog Number', type: 'string', value: 'catalognumber' },
+  { label: 'Channels', type: 'number', value: 'channels' },
+  { label: 'Comment', type: 'string', value: 'comment' },
+  { label: 'Date Added', type: 'date', value: 'dateadded' },
+  { label: 'Date Favorited', type: 'date', value: 'dateloved' },
+  { label: 'Date Last Played', type: 'date', value: 'lastplayed' },
+  { label: 'Date Modified', type: 'date', value: 'datemodified' },
+  { label: 'Disc Subtitle', type: 'string', value: 'discsubtitle' },
+  { label: 'Disc Number', type: 'number', value: 'discnumber' },
+  { label: 'Duration', type: 'number', value: 'duration' },
+  { label: 'File Path', type: 'string', value: 'filepath' },
+  { label: 'File Type', type: 'string', value: 'filetype' },
+  { label: 'Genre', type: 'string', value: 'genre' },
+  { label: 'Has CoverArt', type: 'boolean', value: 'hascoverart' },
+  { label: 'Is Compilation', type: 'boolean', value: 'compilation' },
+  { label: 'Is Favorite', type: 'boolean', value: 'loved' },
+  { label: 'Lyrics', type: 'string', value: 'lyrics' },
+  { label: 'Name', type: 'string', value: 'title' },
+  { label: 'Play Count', type: 'number', value: 'playcount' },
+  { label: 'Rating', type: 'number', value: 'rating' },
+  { label: 'Size', type: 'number', value: 'size' },
+  { label: 'Sort Album', type: 'string', value: 'sortalbum' },
+  { label: 'Sort Album Artist', type: 'string', value: 'sortalbumartist' },
+  { label: 'Sort Artist', type: 'string', value: 'sortartist' },
+  { label: 'Sort Name', type: 'string', value: 'sorttitle' },
+  { label: 'Track Number', type: 'number', value: 'tracknumber' },
+  { label: 'Year', type: 'number', value: 'year' },
+];
+
+export const NDSongQueryDateOperators = [
+  { label: 'is', value: 'is' },
+  { label: 'is not', value: 'isNot' },
+  { label: 'is before', value: 'before' },
+  { label: 'is after', value: 'after' },
+  { label: 'is in the last', value: 'inTheLast' },
+  { label: 'is not in the last', value: 'notInTheLast' },
+  { label: 'is in the range', value: 'inTheRange' },
+];
+
+export const NDSongQueryStringOperators = [
+  { label: 'is', value: 'is' },
+  { label: 'is not', value: 'isNot' },
+  { label: 'contains', value: 'contains' },
+  { label: 'does not contain', value: 'notContains' },
+  { label: 'starts with', value: 'startsWith' },
+  { label: 'ends with', value: 'endsWith' },
+];
+
+export const NDSongQueryBooleanOperators = [
+  { label: 'is', value: 'is' },
+  { label: 'is not', value: 'isNot' },
+];
+
+export const NDSongQueryNumberOperators = [
+  { label: 'is', value: 'is' },
+  { label: 'is not', value: 'isNot' },
+  { label: 'contains', value: 'contains' },
+  { label: 'does not contain', value: 'notContains' },
+  { label: 'is greater than', value: 'gt' },
+  { label: 'is less than', value: 'lt' },
+  { label: 'is in the range', value: 'inTheRange' },
+];
+
+export type NDUserListParams = {
+  _sort?: NDUserListSort;
+} & NDPagination &
+  NDOrder;
+
+export type NDUserListResponse = NDUser[];
+
+export type NDUserList = {
+  items: NDUser[];
+  startIndex: number;
+  totalRecordCount: number;
+};
+
+export enum NDUserListSort {
+  NAME = 'name',
+}

src/renderer/api/navidrome/navidrome-api.ts

@@ -0,0 +1,388 @@
+import { initClient, initContract } from '@ts-rest/core';
+import axios, { Method, AxiosError, AxiosResponse, isAxiosError } from 'axios';
+import isElectron from 'is-electron';
+import { debounce } from 'lodash';
+import omitBy from 'lodash/omitBy';
+import qs from 'qs';
+import { ndType } from './navidrome-types';
+import { authenticationFailure, resultWithHeaders } from '/@/renderer/api/utils';
+import { useAuthStore } from '/@/renderer/store';
+import { ServerListItem } from '/@/renderer/types';
+import { toast } from '/@/renderer/components';
+
+const localSettings = isElectron() ? window.electron.localSettings : null;
+
+const c = initContract();
+
+export const contract = c.router({
+  addToPlaylist: {
+    body: ndType._parameters.addToPlaylist,
+    method: 'POST',
+    path: 'playlist/:id/tracks',
+    responses: {
+      200: resultWithHeaders(ndType._response.addToPlaylist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  authenticate: {
+    body: ndType._parameters.authenticate,
+    method: 'POST',
+    path: 'auth/login',
+    responses: {
+      200: resultWithHeaders(ndType._response.authenticate),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  createPlaylist: {
+    body: ndType._parameters.createPlaylist,
+    method: 'POST',
+    path: 'playlist',
+    responses: {
+      200: resultWithHeaders(ndType._response.createPlaylist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  deletePlaylist: {
+    body: null,
+    method: 'DELETE',
+    path: 'playlist/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.deletePlaylist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getAlbumArtistDetail: {
+    method: 'GET',
+    path: 'artist/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.albumArtist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getAlbumArtistList: {
+    method: 'GET',
+    path: 'artist',
+    query: ndType._parameters.albumArtistList,
+    responses: {
+      200: resultWithHeaders(ndType._response.albumArtistList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getAlbumDetail: {
+    method: 'GET',
+    path: 'album/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.album),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getAlbumList: {
+    method: 'GET',
+    path: 'album',
+    query: ndType._parameters.albumList,
+    responses: {
+      200: resultWithHeaders(ndType._response.albumList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getGenreList: {
+    method: 'GET',
+    path: 'genre',
+    responses: {
+      200: resultWithHeaders(ndType._response.genreList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getPlaylistDetail: {
+    method: 'GET',
+    path: 'playlist/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.playlist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getPlaylistList: {
+    method: 'GET',
+    path: 'playlist',
+    query: ndType._parameters.playlistList,
+    responses: {
+      200: resultWithHeaders(ndType._response.playlistList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getPlaylistSongList: {
+    method: 'GET',
+    path: 'playlist/:id/tracks',
+    query: ndType._parameters.songList,
+    responses: {
+      200: resultWithHeaders(ndType._response.playlistSongList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getSongDetail: {
+    method: 'GET',
+    path: 'song/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.song),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getSongList: {
+    method: 'GET',
+    path: 'song',
+    query: ndType._parameters.songList,
+    responses: {
+      200: resultWithHeaders(ndType._response.songList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  getUserList: {
+    method: 'GET',
+    path: 'user',
+    query: ndType._parameters.userList,
+    responses: {
+      200: resultWithHeaders(ndType._response.userList),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  removeFromPlaylist: {
+    body: null,
+    method: 'DELETE',
+    path: 'playlist/:id/tracks',
+    query: ndType._parameters.removeFromPlaylist,
+    responses: {
+      200: resultWithHeaders(ndType._response.removeFromPlaylist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+  updatePlaylist: {
+    body: ndType._parameters.updatePlaylist,
+    method: 'PUT',
+    path: 'playlist/:id',
+    responses: {
+      200: resultWithHeaders(ndType._response.updatePlaylist),
+      500: resultWithHeaders(ndType._response.error),
+    },
+  },
+});
+
+const axiosClient = axios.create({});
+
+axiosClient.defaults.paramsSerializer = (params) => {
+  return qs.stringify(params, { arrayFormat: 'repeat' });
+};
+
+const parsePath = (fullPath: string) => {
+  const [path, params] = fullPath.split('?');
+
+  const parsedParams = qs.parse(params);
+
+  // Convert indexed object to array
+  const newParams: Record<string, any> = {};
+  Object.keys(parsedParams).forEach((key) => {
+    const isIndexedArrayObject =
+      typeof parsedParams[key] === 'object' && Object.keys(parsedParams[key] || {}).includes('0');
+
+    if (!isIndexedArrayObject) {
+      newParams[key] = parsedParams[key];
+    } else {
+      newParams[key] = Object.values(parsedParams[key] || {});
+    }
+  });
+
+  const notNilParams = omitBy(newParams, (value) => value === 'undefined' || value === 'null');
+
+  return {
+    params: notNilParams,
+    path,
+  };
+};
+
+let authSuccess = true;
+let shouldDelay = false;
+
+const RETRY_DELAY_MS = 1000;
+const MAX_RETRIES = 5;
+
+const waitForResult = async (count = 0): Promise<void> => {
+  return new Promise((resolve) => {
+    if (count === MAX_RETRIES || !shouldDelay) resolve();
+
+    setTimeout(() => {
+      waitForResult(count + 1)
+        .then(resolve)
+        .catch(resolve);
+    }, RETRY_DELAY_MS);
+  });
+};
+
+const limitedFail = debounce(authenticationFailure, RETRY_DELAY_MS);
+const TIMEOUT_ERROR = Error();
+
+axiosClient.interceptors.response.use(
+  (response) => {
+    const serverId = useAuthStore.getState().currentServer?.id;
+
+    if (serverId) {
+      const headerCredential = response.headers['x-nd-authorization'] as string | undefined;
+
+      if (headerCredential) {
+        useAuthStore.getState().actions.updateServer(serverId, {
+          ndCredential: headerCredential,
+        });
+      }
+    }
+
+    authSuccess = true;
+
+    return response;
+  },
+  (error) => {
+    if (error.response && error.response.status === 401) {
+      const currentServer = useAuthStore.getState().currentServer;
+
+      if (localSettings && currentServer?.savePassword) {
+        // eslint-disable-next-line promise/no-promise-in-callback
+        return localSettings
+          .passwordGet(currentServer.id)
+          .then(async (password: string | null) => {
+            authSuccess = false;
+
+            if (password === null) {
+              throw error;
+            }
+
+            if (shouldDelay) {
+              await waitForResult();
+
+              // Hopefully the delay was sufficient for authentication.
+              // Otherwise, it will require manual intervention
+              if (authSuccess) {
+                return axiosClient.request(error.config);
+              }
+
+              throw error;
+            }
+
+            shouldDelay = true;
+
+            // Do not use axiosClient. Instead, manually make a post
+            const res = await axios.post(`${currentServer.url}/auth/login`, {
+              password,
+              username: currentServer.username,
+            });
+
+            if (res.status === 429) {
+              toast.error({
+                message:
+                  'you have exceeded the number of allowed login requests. Please wait before logging, or consider tweaking AuthRequestLimit',
+                title: 'Your session has expired.',
+              });
+
+              const serverId = currentServer.id;
+              useAuthStore.getState().actions.updateServer(serverId, { ndCredential: undefined });
+              useAuthStore.getState().actions.setCurrentServer(null);
+
+              // special error to prevent sending a second message, and stop other messages that could be enqueued
+              limitedFail.cancel();
+              throw TIMEOUT_ERROR;
+            }
+            if (res.status !== 200) {
+              throw new Error('Failed to authenticate');
+            }
+
+            const newCredential = res.data.token;
+            const subsonicCredential = `u=${currentServer.username}&s=${res.data.subsonicSalt}&t=${res.data.subsonicToken}`;
+
+            useAuthStore.getState().actions.updateServer(currentServer.id, {
+              credential: subsonicCredential,
+              ndCredential: newCredential,
+            });
+
+            error.config.headers['x-nd-authorization'] = `Bearer ${newCredential}`;
+
+            authSuccess = true;
+
+            return axiosClient.request(error.config);
+          })
+          .catch((newError: any) => {
+            if (newError !== TIMEOUT_ERROR) {
+              console.error('Error when trying to reauthenticate: ', newError);
+              limitedFail(currentServer);
+            }
+
+            // make sure to pass the error so axios will error later on
+            throw newError;
+          })
+          .finally(() => {
+            shouldDelay = false;
+          });
+      }
+
+      limitedFail(currentServer);
+    }
+
+    return Promise.reject(error);
+  },
+);
+
+export const ndApiClient = (args: {
+  server: ServerListItem | null;
+  signal?: AbortSignal;
+  url?: string;
+}) => {
+  const { server, url, signal } = args;
+
+  return initClient(contract, {
+    api: async ({ path, method, headers, body }) => {
+      let baseUrl: string | undefined;
+      let token: string | undefined;
+
+      const { params, path: api } = parsePath(path);
+
+      if (server) {
+        baseUrl = `${server?.url}/api`;
+        token = server?.ndCredential;
+      } else {
+        baseUrl = url;
+      }
+
+      try {
+        if (shouldDelay) await waitForResult();
+
+        const result = await axiosClient.request({
+          data: body,
+          headers: {
+            ...headers,
+            ...(token && { 'x-nd-authorization': `Bearer ${token}` }),
+          },
+          method: method as Method,
+          params,
+          signal,
+          url: `${baseUrl}/${api}`,
+        });
+        return {
+          body: { data: result.data, headers: result.headers },
+          headers: result.headers as any,
+          status: result.status,
+        };
+      } catch (e: Error | AxiosError | any) {
+        if (isAxiosError(e)) {
+          const error = e as AxiosError;
+          const response = error.response as AxiosResponse;
+          return {
+            body: { data: response.data, headers: response.headers },
+            headers: response.headers as any,
+            status: response.status,
+          };
+        }
+        throw e;
+      }
+    },
+    baseHeaders: {
+      'Content-Type': 'application/json',
+    },
+    baseUrl: '',
+    jsonQuery: false,
+  });
+};

src/renderer/api/navidrome/navidrome-controller.ts

@@ -0,0 +1,472 @@
+import {
+  AlbumArtistDetailArgs,
+  AlbumArtistDetailResponse,
+  AddToPlaylistArgs,
+  AddToPlaylistResponse,
+  CreatePlaylistResponse,
+  CreatePlaylistArgs,
+  DeletePlaylistArgs,
+  DeletePlaylistResponse,
+  AlbumArtistListResponse,
+  AlbumArtistListArgs,
+  albumArtistListSortMap,
+  sortOrderMap,
+  AuthenticationResponse,
+  UserListResponse,
+  UserListArgs,
+  userListSortMap,
+  GenreListArgs,
+  GenreListResponse,
+  AlbumDetailResponse,
+  AlbumDetailArgs,
+  AlbumListArgs,
+  albumListSortMap,
+  AlbumListResponse,
+  SongListResponse,
+  SongListArgs,
+  songListSortMap,
+  SongDetailResponse,
+  SongDetailArgs,
+  UpdatePlaylistArgs,
+  UpdatePlaylistResponse,
+  PlaylistListResponse,
+  PlaylistDetailArgs,
+  PlaylistListArgs,
+  playlistListSortMap,
+  PlaylistDetailResponse,
+  PlaylistSongListArgs,
+  PlaylistSongListResponse,
+  RemoveFromPlaylistResponse,
+  RemoveFromPlaylistArgs,
+} from '../types';
+import { ndApiClient } from '/@/renderer/api/navidrome/navidrome-api';
+import { ndNormalize } from '/@/renderer/api/navidrome/navidrome-normalize';
+import { ndType } from '/@/renderer/api/navidrome/navidrome-types';
+import { ssApiClient } from '/@/renderer/api/subsonic/subsonic-api';
+
+const authenticate = async (
+  url: string,
+  body: { password: string; username: string },
+): Promise<AuthenticationResponse> => {
+  const cleanServerUrl = url.replace(/\/$/, '');
+
+  const res = await ndApiClient({ server: null, url: cleanServerUrl }).authenticate({
+    body: {
+      password: body.password,
+      username: body.username,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to authenticate');
+  }
+
+  return {
+    credential: `u=${body.username}&s=${res.body.data.subsonicSalt}&t=${res.body.data.subsonicToken}`,
+    ndCredential: res.body.data.token,
+    userId: res.body.data.id,
+    username: res.body.data.username,
+  };
+};
+
+const getUserList = async (args: UserListArgs): Promise<UserListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getUserList({
+    query: {
+      _end: query.startIndex + (query.limit || 0),
+      _order: sortOrderMap.navidrome[query.sortOrder],
+      _sort: userListSortMap.navidrome[query.sortBy],
+      _start: query.startIndex,
+      ...query._custom?.navidrome,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get user list');
+  }
+
+  return {
+    items: res.body.data.map((user) => ndNormalize.user(user)),
+    startIndex: query?.startIndex || 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getGenreList = async (args: GenreListArgs): Promise<GenreListResponse> => {
+  const { apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getGenreList({});
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get genre list');
+  }
+
+  return {
+    items: res.body.data,
+    startIndex: 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getAlbumArtistDetail = async (
+  args: AlbumArtistDetailArgs,
+): Promise<AlbumArtistDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getAlbumArtistDetail({
+    params: {
+      id: query.id,
+    },
+  });
+
+  const artistInfoRes = await ssApiClient(apiClientProps).getArtistInfo({
+    query: {
+      count: 10,
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get album artist detail');
+  }
+
+  if (!apiClientProps.server) {
+    throw new Error('Server is required');
+  }
+
+  return ndNormalize.albumArtist(
+    {
+      ...res.body.data,
+      ...(artistInfoRes.status === 200 && {
+        similarArtists: artistInfoRes.body.artistInfo.similarArtist,
+        ...(!res.body.data.largeImageUrl && {
+          largeImageUrl: artistInfoRes.body.artistInfo.largeImageUrl,
+        }),
+        ...(!res.body.data.mediumImageUrl && {
+          largeImageUrl: artistInfoRes.body.artistInfo.mediumImageUrl,
+        }),
+        ...(!res.body.data.smallImageUrl && {
+          largeImageUrl: artistInfoRes.body.artistInfo.smallImageUrl,
+        }),
+      }),
+    },
+    apiClientProps.server,
+  );
+};
+
+const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<AlbumArtistListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getAlbumArtistList({
+    query: {
+      _end: query.startIndex + (query.limit || 0),
+      _order: sortOrderMap.navidrome[query.sortOrder],
+      _sort: albumArtistListSortMap.navidrome[query.sortBy],
+      _start: query.startIndex,
+      name: query.searchTerm,
+      ...query._custom?.navidrome,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get album artist list');
+  }
+
+  return {
+    items: res.body.data.map((albumArtist) =>
+      ndNormalize.albumArtist(albumArtist, apiClientProps.server),
+    ),
+    startIndex: query.startIndex,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getAlbumDetail = async (args: AlbumDetailArgs): Promise<AlbumDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  const albumRes = await ndApiClient(apiClientProps).getAlbumDetail({
+    params: {
+      id: query.id,
+    },
+  });
+
+  const songsData = await ndApiClient(apiClientProps).getSongList({
+    query: {
+      _end: 0,
+      _order: 'ASC',
+      _sort: 'album',
+      _start: 0,
+      album_id: [query.id],
+    },
+  });
+
+  if (albumRes.status !== 200 || songsData.status !== 200) {
+    throw new Error('Failed to get album detail');
+  }
+
+  return ndNormalize.album(
+    { ...albumRes.body.data, songs: songsData.body.data },
+    apiClientProps.server,
+  );
+};
+
+const getAlbumList = async (args: AlbumListArgs): Promise<AlbumListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getAlbumList({
+    query: {
+      _end: query.startIndex + (query.limit || 0),
+      _order: sortOrderMap.navidrome[query.sortOrder],
+      _sort: albumListSortMap.navidrome[query.sortBy],
+      _start: query.startIndex,
+      artist_id: query.artistIds?.[0],
+      name: query.searchTerm,
+      ...query._custom?.navidrome,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get album list');
+  }
+
+  return {
+    items: res.body.data.map((album) => ndNormalize.album(album, apiClientProps.server)),
+    startIndex: query?.startIndex || 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getSongList = async (args: SongListArgs): Promise<SongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getSongList({
+    query: {
+      _end: query.startIndex + (query.limit || -1),
+      _order: sortOrderMap.navidrome[query.sortOrder],
+      _sort: songListSortMap.navidrome[query.sortBy],
+      _start: query.startIndex,
+      album_artist_id: query.artistIds,
+      album_id: query.albumIds,
+      title: query.searchTerm,
+      ...query._custom?.navidrome,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get song list');
+  }
+
+  return {
+    items: res.body.data.map((song) => ndNormalize.song(song, apiClientProps.server, '')),
+    startIndex: query?.startIndex || 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getSongDetail = async (args: SongDetailArgs): Promise<SongDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getSongDetail({
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get song detail');
+  }
+
+  return ndNormalize.song(res.body.data, apiClientProps.server, '');
+};
+
+const createPlaylist = async (args: CreatePlaylistArgs): Promise<CreatePlaylistResponse> => {
+  const { body, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).createPlaylist({
+    body: {
+      comment: body.comment,
+      name: body.name,
+      public: body._custom?.navidrome?.public,
+      rules: body._custom?.navidrome?.rules,
+      sync: body._custom?.navidrome?.sync,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to create playlist');
+  }
+
+  return {
+    id: res.body.data.id,
+  };
+};
+
+const updatePlaylist = async (args: UpdatePlaylistArgs): Promise<UpdatePlaylistResponse> => {
+  const { query, body, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).updatePlaylist({
+    body: {
+      comment: body.comment || '',
+      name: body.name,
+      public: body._custom?.navidrome?.public || false,
+      rules: body._custom?.navidrome?.rules ? body._custom.navidrome.rules : undefined,
+      sync: body._custom?.navidrome?.sync || undefined,
+    },
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to update playlist');
+  }
+
+  return null;
+};
+
+const deletePlaylist = async (args: DeletePlaylistArgs): Promise<DeletePlaylistResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).deletePlaylist({
+    body: null,
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to delete playlist');
+  }
+
+  return null;
+};
+
+const getPlaylistList = async (args: PlaylistListArgs): Promise<PlaylistListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getPlaylistList({
+    query: {
+      _end: query.startIndex + (query.limit || 0),
+      _order: sortOrderMap.navidrome[query.sortOrder],
+      _sort: query.sortBy ? playlistListSortMap.navidrome[query.sortBy] : undefined,
+      _start: query.startIndex,
+      ...query._custom?.navidrome,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist list');
+  }
+
+  return {
+    items: res.body.data.map((item) => ndNormalize.playlist(item, apiClientProps.server)),
+    startIndex: query?.startIndex || 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const getPlaylistDetail = async (args: PlaylistDetailArgs): Promise<PlaylistDetailResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getPlaylistDetail({
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist detail');
+  }
+
+  return ndNormalize.playlist(res.body.data, apiClientProps.server);
+};
+
+const getPlaylistSongList = async (
+  args: PlaylistSongListArgs,
+): Promise<PlaylistSongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).getPlaylistSongList({
+    params: {
+      id: query.id,
+    },
+    query: {
+      _end: query.startIndex + (query.limit || 0),
+      _order: query.sortOrder ? sortOrderMap.navidrome[query.sortOrder] : 'ASC',
+      _sort: query.sortBy ? songListSortMap.navidrome[query.sortBy] : ndType._enum.songList.ID,
+      _start: query.startIndex,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get playlist song list');
+  }
+
+  return {
+    items: res.body.data.map((item) => ndNormalize.song(item, apiClientProps.server, '')),
+    startIndex: query?.startIndex || 0,
+    totalRecordCount: Number(res.body.headers.get('x-total-count') || 0),
+  };
+};
+
+const addToPlaylist = async (args: AddToPlaylistArgs): Promise<AddToPlaylistResponse> => {
+  const { body, query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).addToPlaylist({
+    body: {
+      ids: body.songId,
+    },
+    params: {
+      id: query.id,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to add to playlist');
+  }
+
+  return null;
+};
+
+const removeFromPlaylist = async (
+  args: RemoveFromPlaylistArgs,
+): Promise<RemoveFromPlaylistResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ndApiClient(apiClientProps).removeFromPlaylist({
+    body: null,
+    params: {
+      id: query.id,
+    },
+    query: {
+      id: query.songId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to remove from playlist');
+  }
+
+  return null;
+};
+
+export const ndController = {
+  addToPlaylist,
+  authenticate,
+  createPlaylist,
+  deletePlaylist,
+  getAlbumArtistDetail,
+  getAlbumArtistList,
+  getAlbumDetail,
+  getAlbumList,
+  getGenreList,
+  getPlaylistDetail,
+  getPlaylistList,
+  getPlaylistSongList,
+  getSongDetail,
+  getSongList,
+  getUserList,
+  removeFromPlaylist,
+  updatePlaylist,
+};

src/renderer/api/navidrome/navidrome-normalize.ts

@@ -0,0 +1,231 @@
+import { nanoid } from 'nanoid';
+import { Song, LibraryItem, Album, Playlist, User, AlbumArtist } from '/@/renderer/api/types';
+import { ServerListItem, ServerType } from '/@/renderer/types';
+import z from 'zod';
+import { ndType } from './navidrome-types';
+import { ssType } from '/@/renderer/api/subsonic/subsonic-types';
+
+const getCoverArtUrl = (args: {
+  baseUrl: string | undefined;
+  coverArtId: string;
+  credential: string | undefined;
+  size: number;
+}) => {
+  const size = args.size ? args.size : 250;
+
+  if (!args.coverArtId || args.coverArtId.match('2a96cbd8b46e442fc41c2b86b821562f')) {
+    return null;
+  }
+
+  return (
+    `${args.baseUrl}/rest/getCoverArt.view` +
+    `?id=${args.coverArtId}` +
+    `&${args.credential}` +
+    '&v=1.13.0' +
+    '&c=feishin' +
+    `&size=${size}`
+  );
+};
+
+const normalizeSong = (
+  item: z.infer<typeof ndType._response.song> | z.infer<typeof ndType._response.playlistSong>,
+  server: ServerListItem | null,
+  deviceId: string,
+  imageSize?: number,
+): Song => {
+  let id;
+  let playlistItemId;
+
+  // Dynamically determine the id field based on whether or not the item is a playlist song
+  if ('mediaFileId' in item) {
+    id = item.mediaFileId;
+    playlistItemId = item.id;
+  } else {
+    id = item.id;
+  }
+
+  const imageUrl = getCoverArtUrl({
+    baseUrl: server?.url,
+    coverArtId: id,
+    credential: server?.credential,
+    size: imageSize || 100,
+  });
+
+  const imagePlaceholderUrl = null;
+
+  return {
+    album: item.album,
+    albumArtists: [{ id: item.artistId, imageUrl: null, name: item.artist }],
+    albumId: item.albumId,
+    artistName: item.artist,
+    artists: [{ id: item.artistId, imageUrl: null, name: item.artist }],
+    bitRate: item.bitRate,
+    bpm: item.bpm ? item.bpm : null,
+    channels: item.channels ? item.channels : null,
+    comment: item.comment ? item.comment : null,
+    compilation: item.compilation,
+    container: item.suffix,
+    createdAt: item.createdAt.split('T')[0],
+    discNumber: item.discNumber,
+    duration: item.duration,
+    genres: item.genres,
+    id,
+    imagePlaceholderUrl,
+    imageUrl,
+    itemType: LibraryItem.SONG,
+    lastPlayedAt: item.playDate.includes('0001-') ? null : item.playDate,
+    lyrics: item.lyrics ? item.lyrics : null,
+    name: item.title,
+    path: item.path,
+    playCount: item.playCount,
+    playlistItemId,
+    releaseDate: new Date(item.year, 0, 1).toISOString(),
+    releaseYear: String(item.year),
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.NAVIDROME,
+    size: item.size,
+    streamUrl: `${server?.url}/rest/stream.view?id=${id}&v=1.13.0&c=feishin_${deviceId}&${server?.credential}`,
+    trackNumber: item.trackNumber,
+    uniqueId: nanoid(),
+    updatedAt: item.updatedAt,
+    userFavorite: item.starred || false,
+    userRating: item.rating || null,
+  };
+};
+
+const normalizeAlbum = (
+  item: z.infer<typeof ndType._response.album> & {
+    songs?: z.infer<typeof ndType._response.songList>;
+  },
+  server: ServerListItem | null,
+  imageSize?: number,
+): Album => {
+  const imageUrl = getCoverArtUrl({
+    baseUrl: server?.url,
+    coverArtId: item.coverArtId || item.id,
+    credential: server?.credential,
+    size: imageSize || 300,
+  });
+
+  const imagePlaceholderUrl = null;
+
+  const imageBackdropUrl = imageUrl?.replace(/size=\d+/, 'size=1000') || null;
+
+  return {
+    albumArtists: [{ id: item.albumArtistId, imageUrl: null, name: item.albumArtist }],
+    artists: [{ id: item.artistId, imageUrl: null, name: item.artist }],
+    backdropImageUrl: imageBackdropUrl,
+    createdAt: item.createdAt.split('T')[0],
+    duration: item.duration * 1000 || null,
+    genres: item.genres,
+    id: item.id,
+    imagePlaceholderUrl,
+    imageUrl,
+    isCompilation: item.compilation,
+    itemType: LibraryItem.ALBUM,
+    lastPlayedAt: item.playDate.includes('0001-') ? null : item.playDate,
+    name: item.name,
+    playCount: item.playCount,
+    releaseDate: new Date(item.minYear, 0, 1).toISOString(),
+    releaseYear: item.minYear,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.NAVIDROME,
+    size: item.size,
+    songCount: item.songCount,
+    songs: item.songs ? item.songs.map((song) => normalizeSong(song, server, '')) : undefined,
+    uniqueId: nanoid(),
+    updatedAt: item.updatedAt,
+    userFavorite: item.starred,
+    userRating: item.rating || null,
+  };
+};
+
+const normalizeAlbumArtist = (
+  item: z.infer<typeof ndType._response.albumArtist> & {
+    similarArtists?: z.infer<typeof ssType._response.artistInfo>['artistInfo']['similarArtist'];
+  },
+  server: ServerListItem | null,
+): AlbumArtist => {
+  const imageUrl =
+    item.largeImageUrl === '/app/artist-placeholder.webp' ? null : item.largeImageUrl;
+
+  return {
+    albumCount: item.albumCount,
+    backgroundImageUrl: null,
+    biography: item.biography || null,
+    duration: null,
+    genres: item.genres,
+    id: item.id,
+    imageUrl: imageUrl || null,
+    itemType: LibraryItem.ALBUM_ARTIST,
+    lastPlayedAt: item.playDate.includes('0001-') ? null : item.playDate,
+    name: item.name,
+    playCount: item.playCount,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.NAVIDROME,
+    similarArtists:
+      item.similarArtists?.map((artist) => ({
+        id: artist.id,
+        imageUrl: artist?.artistImageUrl || null,
+        name: artist.name,
+      })) || null,
+    songCount: item.songCount,
+    userFavorite: item.starred,
+    userRating: item.rating,
+  };
+};
+
+const normalizePlaylist = (
+  item: z.infer<typeof ndType._response.playlist>,
+  server: ServerListItem | null,
+  imageSize?: number,
+): Playlist => {
+  const imageUrl = getCoverArtUrl({
+    baseUrl: server?.url,
+    coverArtId: item.id,
+    credential: server?.credential,
+    size: imageSize || 300,
+  });
+
+  const imagePlaceholderUrl = null;
+
+  return {
+    description: item.comment,
+    duration: item.duration * 1000,
+    genres: [],
+    id: item.id,
+    imagePlaceholderUrl,
+    imageUrl,
+    itemType: LibraryItem.PLAYLIST,
+    name: item.name,
+    owner: item.ownerName,
+    ownerId: item.ownerId,
+    public: item.public,
+    rules: item?.rules || null,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.NAVIDROME,
+    size: item.size,
+    songCount: item.songCount,
+    sync: item.sync,
+  };
+};
+
+const normalizeUser = (item: z.infer<typeof ndType._response.user>): User => {
+  return {
+    createdAt: item.createdAt,
+    email: item.email || null,
+    id: item.id,
+    isAdmin: item.isAdmin,
+    lastLoginAt: item.lastLoginAt,
+    name: item.userName,
+    updatedAt: item.updatedAt,
+  };
+};
+
+export const ndNormalize = {
+  album: normalizeAlbum,
+  albumArtist: normalizeAlbumArtist,
+  playlist: normalizePlaylist,
+  song: normalizeSong,
+  user: normalizeUser,
+};

src/renderer/api/navidrome/navidrome-types.ts

@@ -0,0 +1,363 @@
+import { z } from 'zod';
+
+const sortOrderValues = ['ASC', 'DESC'] as const;
+
+const error = z.string();
+
+const paginationParameters = z.object({
+  _end: z.number().optional(),
+  _order: z.enum(sortOrderValues),
+  _start: z.number().optional(),
+});
+
+const authenticate = z.object({
+  id: z.string(),
+  isAdmin: z.boolean(),
+  name: z.string(),
+  subsonicSalt: z.string(),
+  subsonicToken: z.string(),
+  token: z.string(),
+  username: z.string(),
+});
+
+const authenticateParameters = z.object({
+  password: z.string(),
+  username: z.string(),
+});
+
+const user = z.object({
+  createdAt: z.string(),
+  email: z.string().optional(),
+  id: z.string(),
+  isAdmin: z.boolean(),
+  lastAccessAt: z.string(),
+  lastLoginAt: z.string(),
+  name: z.string(),
+  updatedAt: z.string(),
+  userName: z.string(),
+});
+
+const userList = z.array(user);
+
+const ndUserListSort = {
+  NAME: 'name',
+} as const;
+
+const userListParameters = paginationParameters.extend({
+  _sort: z.nativeEnum(ndUserListSort).optional(),
+});
+
+const genre = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+const genreList = z.array(genre);
+
+const albumArtist = z.object({
+  albumCount: z.number(),
+  biography: z.string(),
+  externalInfoUpdatedAt: z.string(),
+  externalUrl: z.string(),
+  fullText: z.string(),
+  genres: z.array(genre),
+  id: z.string(),
+  largeImageUrl: z.string().optional(),
+  mbzArtistId: z.string().optional(),
+  mediumImageUrl: z.string().optional(),
+  name: z.string(),
+  orderArtistName: z.string(),
+  playCount: z.number(),
+  playDate: z.string(),
+  rating: z.number(),
+  size: z.number(),
+  smallImageUrl: z.string().optional(),
+  songCount: z.number(),
+  starred: z.boolean(),
+  starredAt: z.string(),
+});
+
+const albumArtistList = z.array(albumArtist);
+
+const ndAlbumArtistListSort = {
+  ALBUM_COUNT: 'albumCount',
+  FAVORITED: 'starred ASC, starredAt ASC',
+  NAME: 'name',
+  PLAY_COUNT: 'playCount',
+  RATING: 'rating',
+  SONG_COUNT: 'songCount',
+} as const;
+
+const albumArtistListParameters = paginationParameters.extend({
+  _sort: z.nativeEnum(ndAlbumArtistListSort).optional(),
+  genre_id: z.string().optional(),
+  name: z.string().optional(),
+  starred: z.boolean().optional(),
+});
+
+const album = z.object({
+  albumArtist: z.string(),
+  albumArtistId: z.string(),
+  allArtistIds: z.string(),
+  artist: z.string(),
+  artistId: z.string(),
+  compilation: z.boolean(),
+  coverArtId: z.string().optional(), // Removed after v0.48.0
+  coverArtPath: z.string().optional(), // Removed after v0.48.0
+  createdAt: z.string(),
+  duration: z.number(),
+  fullText: z.string(),
+  genre: z.string(),
+  genres: z.array(genre),
+  id: z.string(),
+  maxYear: z.number(),
+  mbzAlbumArtistId: z.string().optional(),
+  mbzAlbumId: z.string().optional(),
+  minYear: z.number(),
+  name: z.string(),
+  orderAlbumArtistName: z.string(),
+  orderAlbumName: z.string(),
+  playCount: z.number(),
+  playDate: z.string(),
+  rating: z.number().optional(),
+  size: z.number(),
+  songCount: z.number(),
+  sortAlbumArtistName: z.string(),
+  sortArtistName: z.string(),
+  starred: z.boolean(),
+  starredAt: z.string().optional(),
+  updatedAt: z.string(),
+});
+
+const albumList = z.array(album);
+
+const ndAlbumListSort = {
+  ALBUM_ARTIST: 'albumArtist',
+  ARTIST: 'artist',
+  DURATION: 'duration',
+  NAME: 'name',
+  PLAY_COUNT: 'playCount',
+  PLAY_DATE: 'play_date',
+  RANDOM: 'random',
+  RATING: 'rating',
+  RECENTLY_ADDED: 'recently_added',
+  SONG_COUNT: 'songCount',
+  STARRED: 'starred',
+  YEAR: 'max_year',
+} as const;
+
+const albumListParameters = paginationParameters.extend({
+  _sort: z.nativeEnum(ndAlbumListSort).optional(),
+  album_id: z.string().optional(),
+  artist_id: z.string().optional(),
+  compilation: z.boolean().optional(),
+  genre_id: z.string().optional(),
+  has_rating: z.boolean().optional(),
+  id: z.string().optional(),
+  name: z.string().optional(),
+  recently_added: z.boolean().optional(),
+  recently_played: z.boolean().optional(),
+  starred: z.boolean().optional(),
+  year: z.number().optional(),
+});
+
+const song = z.object({
+  album: z.string(),
+  albumArtist: z.string(),
+  albumArtistId: z.string(),
+  albumId: z.string(),
+  artist: z.string(),
+  artistId: z.string(),
+  bitRate: z.number(),
+  bookmarkPosition: z.number(),
+  bpm: z.number().optional(),
+  channels: z.number().optional(),
+  comment: z.string().optional(),
+  compilation: z.boolean(),
+  createdAt: z.string(),
+  discNumber: z.number(),
+  duration: z.number(),
+  fullText: z.string(),
+  genre: z.string(),
+  genres: z.array(genre),
+  hasCoverArt: z.boolean(),
+  id: z.string(),
+  lyrics: z.string().optional(),
+  mbzAlbumArtistId: z.string().optional(),
+  mbzAlbumId: z.string().optional(),
+  mbzArtistId: z.string().optional(),
+  mbzTrackId: z.string().optional(),
+  orderAlbumArtistName: z.string(),
+  orderAlbumName: z.string(),
+  orderArtistName: z.string(),
+  orderTitle: z.string(),
+  path: z.string(),
+  playCount: z.number(),
+  playDate: z.string(),
+  rating: z.number().optional(),
+  size: z.number(),
+  sortAlbumArtistName: z.string(),
+  sortArtistName: z.string(),
+  starred: z.boolean(),
+  starredAt: z.string().optional(),
+  suffix: z.string(),
+  title: z.string(),
+  trackNumber: z.number(),
+  updatedAt: z.string(),
+  year: z.number(),
+});
+
+const songList = z.array(song);
+
+const ndSongListSort = {
+  ALBUM: 'album, order_album_artist_name, disc_number, track_number, title',
+  ALBUM_ARTIST: 'order_album_artist_name, album, disc_number, track_number, title',
+  ALBUM_SONGS: 'album, discNumber, trackNumber',
+  ARTIST: 'artist',
+  BPM: 'bpm',
+  CHANNELS: 'channels',
+  COMMENT: 'comment',
+  DURATION: 'duration',
+  FAVORITED: 'starred ASC, starredAt ASC',
+  GENRE: 'genre',
+  ID: 'id',
+  PLAY_COUNT: 'playCount',
+  PLAY_DATE: 'playDate',
+  RATING: 'rating',
+  RECENTLY_ADDED: 'createdAt',
+  TITLE: 'title',
+  TRACK: 'track',
+  YEAR: 'year, album, discNumber, trackNumber',
+};
+
+const songListParameters = paginationParameters.extend({
+  _sort: z.nativeEnum(ndSongListSort).optional(),
+  album_artist_id: z.array(z.string()).optional(),
+  album_id: z.array(z.string()).optional(),
+  artist_id: z.array(z.string()).optional(),
+  genre_id: z.string().optional(),
+  starred: z.boolean().optional(),
+  title: z.string().optional(),
+  year: z.number().optional(),
+});
+
+const playlist = z.object({
+  comment: z.string(),
+  createdAt: z.string(),
+  duration: z.number(),
+  evaluatedAt: z.string(),
+  id: z.string(),
+  name: z.string(),
+  ownerId: z.string(),
+  ownerName: z.string(),
+  path: z.string(),
+  public: z.boolean(),
+  rules: z.record(z.string(), z.any()),
+  size: z.number(),
+  songCount: z.number(),
+  sync: z.boolean(),
+  updatedAt: z.string(),
+});
+
+const playlistList = z.array(playlist);
+
+const ndPlaylistListSort = {
+  DURATION: 'duration',
+  NAME: 'name',
+  OWNER: 'ownerName',
+  PUBLIC: 'public',
+  SONG_COUNT: 'songCount',
+  UPDATED_AT: 'updatedAt',
+} as const;
+
+const playlistListParameters = paginationParameters.extend({
+  _sort: z.nativeEnum(ndPlaylistListSort).optional(),
+  owner_id: z.string().optional(),
+  smart: z.boolean().optional(),
+});
+
+const playlistSong = song.extend({
+  mediaFileId: z.string(),
+  playlistId: z.string(),
+});
+
+const playlistSongList = z.array(playlistSong);
+
+const createPlaylist = playlist.pick({
+  id: true,
+});
+
+const createPlaylistParameters = z.object({
+  comment: z.string().optional(),
+  name: z.string(),
+  public: z.boolean().optional(),
+  rules: z.record(z.any()).optional(),
+  sync: z.boolean().optional(),
+});
+
+const updatePlaylist = playlist;
+
+const updatePlaylistParameters = createPlaylistParameters.partial();
+
+const deletePlaylist = z.null();
+
+const addToPlaylist = z.object({
+  added: z.number(),
+});
+
+const addToPlaylistParameters = z.object({
+  ids: z.array(z.string()),
+});
+
+const removeFromPlaylist = z.object({
+  ids: z.array(z.string()),
+});
+
+const removeFromPlaylistParameters = z.object({
+  id: z.array(z.string()),
+});
+
+export const ndType = {
+  _enum: {
+    albumArtistList: ndAlbumArtistListSort,
+    albumList: ndAlbumListSort,
+    playlistList: ndPlaylistListSort,
+    songList: ndSongListSort,
+    userList: ndUserListSort,
+  },
+  _parameters: {
+    addToPlaylist: addToPlaylistParameters,
+    albumArtistList: albumArtistListParameters,
+    albumList: albumListParameters,
+    authenticate: authenticateParameters,
+    createPlaylist: createPlaylistParameters,
+    playlistList: playlistListParameters,
+    removeFromPlaylist: removeFromPlaylistParameters,
+    songList: songListParameters,
+    updatePlaylist: updatePlaylistParameters,
+    userList: userListParameters,
+  },
+  _response: {
+    addToPlaylist,
+    album,
+    albumArtist,
+    albumArtistList,
+    albumList,
+    authenticate,
+    createPlaylist,
+    deletePlaylist,
+    error,
+    genre,
+    genreList,
+    playlist,
+    playlistList,
+    playlistSong,
+    playlistSongList,
+    removeFromPlaylist,
+    song,
+    songList,
+    updatePlaylist,
+    user,
+    userList,
+  },
+};

src/renderer/api/normalize.ts

@@ -1,223 +0,0 @@
-import { jfNormalize } from '/@/renderer/api/jellyfin.api';
-import type {
-  JFAlbum,
-  JFAlbumArtist,
-  JFGenreList,
-  JFMusicFolderList,
-  JFPlaylist,
-  JFSong,
-} from '/@/renderer/api/jellyfin.types';
-import { ndNormalize } from '/@/renderer/api/navidrome.api';
-import type {
-  NDAlbum,
-  NDAlbumArtist,
-  NDGenreList,
-  NDPlaylist,
-  NDSong,
-} from '/@/renderer/api/navidrome.types';
-import { SSGenreList, SSMusicFolderList } from '/@/renderer/api/subsonic.types';
-import type {
-  Album,
-  RawAlbumArtistListResponse,
-  RawAlbumDetailResponse,
-  RawAlbumListResponse,
-  RawGenreListResponse,
-  RawMusicFolderListResponse,
-  RawPlaylistDetailResponse,
-  RawPlaylistListResponse,
-  RawSongListResponse,
-} from '/@/renderer/api/types';
-import { ServerListItem } from '/@/renderer/types';
-
-const albumList = (data: RawAlbumListResponse | undefined, server: ServerListItem | null) => {
-  let albums;
-  switch (server?.type) {
-    case 'jellyfin':
-      albums = data?.items.map((item) => jfNormalize.album(item as JFAlbum, server));
-      break;
-    case 'navidrome':
-      albums = data?.items.map((item) => ndNormalize.album(item as NDAlbum, server));
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return {
-    items: albums,
-    startIndex: data?.startIndex,
-    totalRecordCount: data?.totalRecordCount,
-  };
-};
-
-const albumDetail = (
-  data: RawAlbumDetailResponse | undefined,
-  server: ServerListItem | null,
-): Album | undefined => {
-  let album: Album | undefined;
-  switch (server?.type) {
-    case 'jellyfin':
-      album = jfNormalize.album(data as JFAlbum, server);
-      break;
-    case 'navidrome':
-      album = ndNormalize.album(data as NDAlbum, server);
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return album;
-};
-
-const songList = (data: RawSongListResponse | undefined, server: ServerListItem | null) => {
-  let songs;
-  switch (server?.type) {
-    case 'jellyfin':
-      songs = data?.items.map((item) => jfNormalize.song(item as JFSong, server, ''));
-      break;
-    case 'navidrome':
-      songs = data?.items.map((item) => ndNormalize.song(item as NDSong, server, ''));
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return {
-    items: songs,
-    startIndex: data?.startIndex,
-    totalRecordCount: data?.totalRecordCount,
-  };
-};
-
-const musicFolderList = (
-  data: RawMusicFolderListResponse | undefined,
-  server: ServerListItem | null,
-) => {
-  let musicFolders;
-  switch (server?.type) {
-    case 'jellyfin':
-      musicFolders = (data as JFMusicFolderList)?.map((item) => ({
-        id: String(item.Id),
-        name: item.Name,
-      }));
-      break;
-    case 'navidrome':
-      musicFolders = (data as SSMusicFolderList)?.map((item) => ({
-        id: String(item.id),
-        name: item.name,
-      }));
-      break;
-    case 'subsonic':
-      musicFolders = (data as SSMusicFolderList)?.map((item) => ({
-        id: String(item.id),
-        name: item.name,
-      }));
-      break;
-  }
-
-  return musicFolders;
-};
-
-const genreList = (data: RawGenreListResponse | undefined, server: ServerListItem | null) => {
-  let genres;
-  switch (server?.type) {
-    case 'jellyfin':
-      genres = (data as JFGenreList)?.Items.map((item) => ({
-        id: String(item.Id),
-        name: item.Name,
-      })).sort((a, b) => a.name.localeCompare(b.name));
-      break;
-    case 'navidrome':
-      genres = (data as NDGenreList)
-        ?.map((item) => ({
-          id: String(item.id),
-          name: item.name,
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      break;
-    case 'subsonic':
-      genres = (data as SSGenreList)
-        ?.map((item) => ({
-          id: item.value,
-          name: item.value,
-        }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      break;
-  }
-
-  return genres;
-};
-
-const albumArtistList = (
-  data: RawAlbumArtistListResponse | undefined,
-  server: ServerListItem | null,
-) => {
-  let albumArtists;
-  switch (server?.type) {
-    case 'jellyfin':
-      albumArtists = data?.items.map((item) =>
-        jfNormalize.albumArtist(item as JFAlbumArtist, server),
-      );
-      break;
-    case 'navidrome':
-      albumArtists = data?.items.map((item) => ndNormalize.albumArtist(item as NDAlbumArtist));
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return {
-    items: albumArtists,
-    startIndex: data?.startIndex,
-    totalRecordCount: data?.totalRecordCount,
-  };
-};
-
-const playlistList = (data: RawPlaylistListResponse | undefined, server: ServerListItem | null) => {
-  let playlists;
-  switch (server?.type) {
-    case 'jellyfin':
-      playlists = data?.items.map((item) => jfNormalize.playlist(item as JFPlaylist, server));
-      break;
-    case 'navidrome':
-      playlists = data?.items.map((item) => ndNormalize.playlist(item as NDPlaylist, server));
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return {
-    items: playlists,
-    startIndex: data?.startIndex,
-    totalRecordCount: data?.totalRecordCount,
-  };
-};
-
-const playlistDetail = (
-  data: RawPlaylistDetailResponse | undefined,
-  server: ServerListItem | null,
-) => {
-  let playlist;
-  switch (server?.type) {
-    case 'jellyfin':
-      playlist = jfNormalize.playlist(data as JFPlaylist, server);
-      break;
-    case 'navidrome':
-      playlist = ndNormalize.playlist(data as NDPlaylist, server);
-      break;
-    case 'subsonic':
-      break;
-  }
-
-  return playlist;
-};
-
-export const normalize = {
-  albumArtistList,
-  albumDetail,
-  albumList,
-  genreList,
-  musicFolderList,
-  playlistDetail,
-  playlistList,
-  songList,
-};

src/renderer/api/query-keys.ts

@@ -1,3 +1,5 @@
+import { QueryFunctionContext } from '@tanstack/react-query';
+import { LyricSource } from './types';
 import type {
   AlbumListQuery,
   SongListQuery,
@@ -7,11 +9,22 @@ import type {
   PlaylistListQuery,
   PlaylistDetailQuery,
   PlaylistSongListQuery,
+  UserListQuery,
+  AlbumArtistDetailQuery,
+  TopSongListQuery,
+  SearchQuery,
+  SongDetailQuery,
+  RandomSongListQuery,
+  LyricsQuery,
+  LyricSearchQuery,
 } from './types';
 
-export const queryKeys = {
+export const queryKeys: Record<
+  string,
+  Record<string, (...props: any) => QueryFunctionContext['queryKey']>
+> = {
   albumArtists: {
-    detail: (serverId: string, query?: AlbumArtistListQuery) => {
+    detail: (serverId: string, query?: AlbumArtistDetailQuery) => {
       if (query) return [serverId, 'albumArtists', 'detail', query] as const;
       return [serverId, 'albumArtists', 'detail'] as const;
     },
@@ -20,6 +33,10 @@ export const queryKeys = {
       return [serverId, 'albumArtists', 'list'] as const;
     },
     root: (serverId: string) => [serverId, 'albumArtists'] as const,
+    topSongs: (serverId: string, query?: TopSongListQuery) => {
+      if (query) return [serverId, 'albumArtists', 'topSongs', query] as const;
+      return [serverId, 'albumArtists', 'topSongs'] as const;
+    },
   },
   albums: {
     detail: (serverId: string, query?: AlbumDetailQuery) =>
@@ -63,20 +80,53 @@ export const queryKeys = {
       return [serverId, 'playlists', 'list'] as const;
     },
     root: (serverId: string) => [serverId, 'playlists'] as const,
-    songList: (serverId: string, id: string, query?: PlaylistSongListQuery) => {
-      if (query) return [serverId, 'playlists', id, 'songList', query] as const;
+    songList: (serverId: string, id?: string, query?: PlaylistSongListQuery) => {
+      if (query && id) return [serverId, 'playlists', id, 'songList', query] as const;
       if (id) return [serverId, 'playlists', id, 'songList'] as const;
       return [serverId, 'playlists', 'songList'] as const;
     },
   },
+  search: {
+    list: (serverId: string, query?: SearchQuery) => {
+      if (query) return [serverId, 'search', 'list', query] as const;
+      return [serverId, 'search', 'list'] as const;
+    },
+    root: (serverId: string) => [serverId, 'search'] as const,
+  },
   server: {
     root: (serverId: string) => [serverId] as const,
   },
   songs: {
+    detail: (serverId: string, query?: SongDetailQuery) => {
+      if (query) return [serverId, 'songs', 'detail', query] as const;
+      return [serverId, 'songs', 'detail'] as const;
+    },
     list: (serverId: string, query?: SongListQuery) => {
       if (query) return [serverId, 'songs', 'list', query] as const;
       return [serverId, 'songs', 'list'] as const;
     },
+    lyrics: (serverId: string, query?: LyricsQuery) => {
+      if (query) return [serverId, 'song', 'lyrics', query] as const;
+      return [serverId, 'song', 'lyrics'] as const;
+    },
+    lyricsByRemoteId: (searchQuery: { remoteSongId: string; remoteSource: LyricSource }) => {
+      return ['song', 'lyrics', 'remote', searchQuery] as const;
+    },
+    lyricsSearch: (query?: LyricSearchQuery) => {
+      if (query) return ['lyrics', 'search', query] as const;
+      return ['lyrics', 'search'] as const;
+    },
+    randomSongList: (serverId: string, query?: RandomSongListQuery) => {
+      if (query) return [serverId, 'songs', 'randomSongList', query] as const;
+      return [serverId, 'songs', 'randomSongList'] as const;
+    },
     root: (serverId: string) => [serverId, 'songs'] as const,
   },
+  users: {
+    list: (serverId: string, query?: UserListQuery) => {
+      if (query) return [serverId, 'users', 'list', query] as const;
+      return [serverId, 'users', 'list'] as const;
+    },
+    root: (serverId: string) => [serverId, 'users'] as const,
+  },
 };

src/renderer/api/subsonic.api.ts

@@ -1,309 +0,0 @@
-import ky from 'ky';
-import md5 from 'md5';
-import { randomString } from '/@/renderer/utils';
-import type {
-  SSAlbumListResponse,
-  SSAlbumDetailResponse,
-  SSArtistIndex,
-  SSAlbumArtistList,
-  SSAlbumArtistListResponse,
-  SSGenreListResponse,
-  SSMusicFolderList,
-  SSMusicFolderListResponse,
-  SSGenreList,
-  SSAlbumDetail,
-  SSAlbumList,
-  SSAlbumArtistDetail,
-  SSAlbumArtistDetailResponse,
-  SSFavoriteParams,
-  SSFavoriteResponse,
-  SSRatingParams,
-  SSRatingResponse,
-  SSAlbumArtistDetailParams,
-  SSAlbumArtistListParams,
-} from '/@/renderer/api/subsonic.types';
-import type {
-  AlbumArtistDetailArgs,
-  AlbumArtistListArgs,
-  AlbumDetailArgs,
-  AlbumListArgs,
-  AuthenticationResponse,
-  FavoriteArgs,
-  FavoriteResponse,
-  GenreListArgs,
-  MusicFolderListArgs,
-  RatingArgs,
-} from '/@/renderer/api/types';
-import { useAuthStore } from '/@/renderer/store';
-import { toast } from '/@/renderer/components/toast';
-
-const getCoverArtUrl = (args: {
-  baseUrl: string;
-  coverArtId: string;
-  credential: string;
-  size: number;
-}) => {
-  const size = args.size ? args.size : 150;
-
-  if (!args.coverArtId || args.coverArtId.match('2a96cbd8b46e442fc41c2b86b821562f')) {
-    return null;
-  }
-
-  return (
-    `${args.baseUrl}/getCoverArt.view` +
-    `?id=${args.coverArtId}` +
-    `&${args.credential}` +
-    '&v=1.13.0' +
-    '&c=feishin' +
-    `&size=${size}`
-  );
-};
-
-const api = ky.create({
-  hooks: {
-    afterResponse: [
-      async (_request, _options, response) => {
-        const data = await response.json();
-        if (data['subsonic-response'].status !== 'ok') {
-          toast.warn({ message: 'Issue from Subsonic API' });
-        }
-
-        return new Response(JSON.stringify(data['subsonic-response']), { status: 200 });
-      },
-    ],
-    beforeRequest: [
-      (request) => {
-        const server = useAuthStore.getState().currentServer;
-
-        const searchParams = new URLSearchParams();
-
-        if (server) {
-          const authParams = server.credential.split(/&?\w=/gm);
-
-          searchParams.set('u', server.username);
-          searchParams.set('v', '1.13.0');
-          searchParams.set('c', 'Feishin');
-          searchParams.set('f', 'json');
-
-          if (authParams?.length === 4) {
-            searchParams.set('s', authParams[2]);
-            searchParams.set('t', authParams[3]);
-          } else if (authParams?.length === 3) {
-            searchParams.set('p', authParams[2]);
-          }
-        }
-
-        return ky(request, { searchParams });
-      },
-    ],
-  },
-});
-
-const authenticate = async (
-  url: string,
-  body: {
-    legacy?: boolean;
-    password: string;
-    username: string;
-  },
-): Promise<AuthenticationResponse> => {
-  let credential;
-  const cleanServerUrl = url.replace(/\/$/, '');
-
-  if (body.legacy) {
-    credential = `u=${body.username}&p=${body.password}`;
-  } else {
-    const salt = randomString(12);
-    const hash = md5(body.password + salt);
-    credential = `u=${body.username}&s=${salt}&t=${hash}`;
-  }
-
-  await ky.get(`${cleanServerUrl}/rest/ping.view?v=1.13.0&c=Feishin&f=json&${credential}`);
-
-  return {
-    credential,
-    userId: null,
-    username: body.username,
-  };
-};
-
-const getMusicFolderList = async (args: MusicFolderListArgs): Promise<SSMusicFolderList> => {
-  const { signal, server } = args;
-
-  const data = await api
-    .get('rest/getMusicFolders.view', {
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<SSMusicFolderListResponse>();
-
-  return data.musicFolders.musicFolder;
-};
-
-export const getAlbumArtistDetail = async (
-  args: AlbumArtistDetailArgs,
-): Promise<SSAlbumArtistDetail> => {
-  const { server, signal, query } = args;
-
-  const searchParams: SSAlbumArtistDetailParams = {
-    id: query.id,
-  };
-
-  const data = await api
-    .get('/getArtist.view', {
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<SSAlbumArtistDetailResponse>();
-
-  return data.artist;
-};
-
-const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<SSAlbumArtistList> => {
-  const { signal, server, query } = args;
-
-  const searchParams: SSAlbumArtistListParams = {
-    musicFolderId: query.musicFolderId,
-  };
-
-  const data = await api
-    .get('rest/getArtists.view', {
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<SSAlbumArtistListResponse>();
-
-  const artists = (data.artists?.index || []).flatMap((index: SSArtistIndex) => index.artist);
-
-  return {
-    items: artists,
-    startIndex: query.startIndex,
-    totalRecordCount: null,
-  };
-};
-
-const getGenreList = async (args: GenreListArgs): Promise<SSGenreList> => {
-  const { server, signal } = args;
-
-  const data = await api
-    .get('rest/getGenres.view', {
-      prefixUrl: server?.url,
-      signal,
-    })
-    .json<SSGenreListResponse>();
-
-  return data.genres.genre;
-};
-
-const getAlbumDetail = async (args: AlbumDetailArgs): Promise<SSAlbumDetail> => {
-  const { server, query, signal } = args;
-
-  const data = await api
-    .get('rest/getAlbum.view', {
-      prefixUrl: server?.url,
-      searchParams: { id: query.id },
-      signal,
-    })
-    .json<SSAlbumDetailResponse>();
-
-  const { song: songs, ...dataWithoutSong } = data.album;
-  return { ...dataWithoutSong, songs };
-};
-
-const getAlbumList = async (args: AlbumListArgs): Promise<SSAlbumList> => {
-  const { server, query, signal } = args;
-
-  const normalizedParams = {};
-  const data = await api
-    .get('rest/getAlbumList2.view', {
-      prefixUrl: server?.url,
-      searchParams: normalizedParams,
-      signal,
-    })
-    .json<SSAlbumListResponse>();
-
-  return {
-    items: data.albumList2.album,
-    startIndex: query.startIndex,
-    totalRecordCount: null,
-  };
-};
-
-const createFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
-  const { server, query, signal } = args;
-
-  const searchParams: SSFavoriteParams = {
-    albumId: query.type === 'album' ? query.id : undefined,
-    artistId: query.type === 'albumArtist' ? query.id : undefined,
-    id: query.type === 'song' ? query.id : undefined,
-  };
-
-  await api
-    .get('rest/star.view', {
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<SSFavoriteResponse>();
-
-  return {
-    id: query.id,
-  };
-};
-
-const deleteFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
-  const { server, query, signal } = args;
-
-  const searchParams: SSFavoriteParams = {
-    albumId: query.type === 'album' ? query.id : undefined,
-    artistId: query.type === 'albumArtist' ? query.id : undefined,
-    id: query.type === 'song' ? query.id : undefined,
-  };
-
-  await api
-    .get('rest/unstar.view', {
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<SSFavoriteResponse>();
-
-  return {
-    id: query.id,
-  };
-};
-
-const updateRating = async (args: RatingArgs) => {
-  const { server, query, signal } = args;
-
-  const searchParams: SSRatingParams = {
-    id: query.id,
-    rating: query.rating,
-  };
-
-  const data = await api
-    .get('rest/setRating.view', {
-      prefixUrl: server?.url,
-      searchParams,
-      signal,
-    })
-    .json<SSRatingResponse>();
-
-  return data;
-};
-
-export const subsonicApi = {
-  authenticate,
-  createFavorite,
-  deleteFavorite,
-  getAlbumArtistDetail,
-  getAlbumArtistList,
-  getAlbumDetail,
-  getAlbumList,
-  getCoverArtUrl,
-  getGenreList,
-  getMusicFolderList,
-  updateRating,
-};

src/renderer/api/subsonic.types.ts

@@ -65,6 +65,12 @@ export type SSAlbumDetailResponse = {
   album: SSAlbum;
 };
 
+export type SSArtistInfoParams = {
+  count?: number;
+  id: string;
+  includeNotPresent?: boolean;
+};
+
 export type SSArtistInfoResponse = {
   artistInfo2: SSArtistInfo;
 };
@@ -75,6 +81,13 @@ export type SSArtistInfo = {
   lastFmUrl?: string;
   mediumImageUrl?: string;
   musicBrainzId?: string;
+  similarArtist?: {
+    albumCount: string;
+    artistImageUrl?: string;
+    coverArt?: string;
+    id: string;
+    name: string;
+  }[];
   smallImageUrl?: string;
 };
 
@@ -186,3 +199,26 @@ export type SSRatingParams = {
 export type SSRating = null;
 
 export type SSRatingResponse = null;
+
+export type SSTopSongListParams = {
+  artist: string;
+  count?: number;
+};
+
+export type SSTopSongListResponse = {
+  topSongs: {
+    song: SSSong[];
+  };
+};
+
+export type SSTopSongList = {
+  items: SSSong[];
+  startIndex: number;
+  totalRecordCount: number | null;
+};
+
+export type SSScrobbleParams = {
+  id: string;
+  submission?: boolean;
+  time?: number;
+};

src/renderer/api/subsonic/subsonic-api.ts

@@ -0,0 +1,205 @@
+import { initClient, initContract } from '@ts-rest/core';
+import axios, { Method, AxiosError, isAxiosError, AxiosResponse } from 'axios';
+import omitBy from 'lodash/omitBy';
+import qs from 'qs';
+import { z } from 'zod';
+import { ssType } from '/@/renderer/api/subsonic/subsonic-types';
+import { ServerListItem } from '/@/renderer/api/types';
+import { toast } from '/@/renderer/components/toast/index';
+
+const c = initContract();
+
+export const contract = c.router({
+  authenticate: {
+    method: 'GET',
+    path: 'ping.view',
+    query: ssType._parameters.authenticate,
+    responses: {
+      200: ssType._response.authenticate,
+    },
+  },
+  createFavorite: {
+    method: 'GET',
+    path: 'star.view',
+    query: ssType._parameters.createFavorite,
+    responses: {
+      200: ssType._response.createFavorite,
+    },
+  },
+  getArtistInfo: {
+    method: 'GET',
+    path: 'getArtistInfo.view',
+    query: ssType._parameters.artistInfo,
+    responses: {
+      200: ssType._response.artistInfo,
+    },
+  },
+  getMusicFolderList: {
+    method: 'GET',
+    path: 'getMusicFolders.view',
+    responses: {
+      200: ssType._response.musicFolderList,
+    },
+  },
+  getRandomSongList: {
+    method: 'GET',
+    path: 'getRandomSongs.view',
+    query: ssType._parameters.randomSongList,
+    responses: {
+      200: ssType._response.randomSongList,
+    },
+  },
+  getTopSongsList: {
+    method: 'GET',
+    path: 'getTopSongs.view',
+    query: ssType._parameters.topSongsList,
+    responses: {
+      200: ssType._response.topSongsList,
+    },
+  },
+  removeFavorite: {
+    method: 'GET',
+    path: 'unstar.view',
+    query: ssType._parameters.removeFavorite,
+    responses: {
+      200: ssType._response.removeFavorite,
+    },
+  },
+  scrobble: {
+    method: 'GET',
+    path: 'scrobble.view',
+    query: ssType._parameters.scrobble,
+    responses: {
+      200: ssType._response.scrobble,
+    },
+  },
+  search3: {
+    method: 'GET',
+    path: 'search3.view',
+    query: ssType._parameters.search3,
+    responses: {
+      200: ssType._response.search3,
+    },
+  },
+  setRating: {
+    method: 'GET',
+    path: 'setRating.view',
+    query: ssType._parameters.setRating,
+    responses: {
+      200: ssType._response.setRating,
+    },
+  },
+});
+
+const axiosClient = axios.create({});
+
+axiosClient.defaults.paramsSerializer = (params) => {
+  return qs.stringify(params, { arrayFormat: 'repeat' });
+};
+
+axiosClient.interceptors.response.use(
+  (response) => {
+    const data = response.data;
+
+    if (data['subsonic-response'].status !== 'ok') {
+      // Suppress code related to non-linked lastfm or spotify from Navidrome
+      if (data['subsonic-response'].error.code !== 0) {
+        toast.error({
+          message: data['subsonic-response'].error.message,
+          title: 'Issue from Subsonic API',
+        });
+      }
+    }
+
+    return response;
+  },
+  (error) => {
+    return Promise.reject(error);
+  },
+);
+
+const parsePath = (fullPath: string) => {
+  const [path, params] = fullPath.split('?');
+
+  const parsedParams = qs.parse(params);
+  const notNilParams = omitBy(parsedParams, (value) => value === 'undefined' || value === 'null');
+
+  return {
+    params: notNilParams,
+    path,
+  };
+};
+
+export const ssApiClient = (args: {
+  server: ServerListItem | null;
+  signal?: AbortSignal;
+  url?: string;
+}) => {
+  const { server, url, signal } = args;
+
+  return initClient(contract, {
+    api: async ({ path, method, headers, body }) => {
+      let baseUrl: string | undefined;
+      const authParams: Record<string, any> = {};
+
+      const { params, path: api } = parsePath(path);
+
+      if (server) {
+        baseUrl = `${server.url}/rest`;
+        const token = server.credential;
+        const params = token.split(/&?\w=/gm);
+
+        authParams.u = server.username;
+        if (params?.length === 4) {
+          authParams.s = params[2];
+          authParams.t = params[3];
+        } else if (params?.length === 3) {
+          authParams.p = params[2];
+        }
+      } else {
+        baseUrl = url;
+      }
+
+      try {
+        const result = await axiosClient.request<z.infer<typeof ssType._response.baseResponse>>({
+          data: body,
+          headers,
+          method: method as Method,
+          params: {
+            c: 'Feishin',
+            f: 'json',
+            v: '1.13.0',
+            ...authParams,
+            ...params,
+          },
+          signal,
+          url: `${baseUrl}/${api}`,
+        });
+
+        return {
+          body: result.data['subsonic-response'],
+          headers: result.headers as any,
+          status: result.status,
+        };
+      } catch (e: Error | AxiosError | any) {
+        console.log('CATCH ERR');
+
+        if (isAxiosError(e)) {
+          const error = e as AxiosError;
+          const response = error.response as AxiosResponse;
+
+          return {
+            body: response?.data,
+            headers: response.headers as any,
+            status: response?.status,
+          };
+        }
+        throw e;
+      }
+    },
+    baseHeaders: {
+      'Content-Type': 'application/json',
+    },
+    baseUrl: '',
+  });
+};

src/renderer/api/subsonic/subsonic-controller.ts

@@ -0,0 +1,381 @@
+import md5 from 'md5';
+import { z } from 'zod';
+import { ssApiClient } from '/@/renderer/api/subsonic/subsonic-api';
+import { ssNormalize } from '/@/renderer/api/subsonic/subsonic-normalize';
+import { ssType } from '/@/renderer/api/subsonic/subsonic-types';
+import {
+  ArtistInfoArgs,
+  AuthenticationResponse,
+  FavoriteArgs,
+  FavoriteResponse,
+  LibraryItem,
+  MusicFolderListArgs,
+  MusicFolderListResponse,
+  SetRatingArgs,
+  RatingResponse,
+  ScrobbleArgs,
+  ScrobbleResponse,
+  SongListResponse,
+  TopSongListArgs,
+  SearchArgs,
+  SearchResponse,
+  RandomSongListResponse,
+  RandomSongListArgs,
+} from '/@/renderer/api/types';
+import { randomString } from '/@/renderer/utils';
+
+const authenticate = async (
+  url: string,
+  body: {
+    legacy?: boolean;
+    password: string;
+    username: string;
+  },
+): Promise<AuthenticationResponse> => {
+  let credential: string;
+  let credentialParams: {
+    p?: string;
+    s?: string;
+    t?: string;
+    u: string;
+  };
+
+  const cleanServerUrl = url.replace(/\/$/, '');
+
+  if (body.legacy) {
+    credential = `u=${body.username}&p=${body.password}`;
+    credentialParams = {
+      p: body.password,
+      u: body.username,
+    };
+  } else {
+    const salt = randomString(12);
+    const hash = md5(body.password + salt);
+    credential = `u=${body.username}&s=${salt}&t=${hash}`;
+    credentialParams = {
+      s: salt,
+      t: hash,
+      u: body.username,
+    };
+  }
+
+  await ssApiClient({ server: null, url: cleanServerUrl }).authenticate({
+    query: {
+      c: 'Feishin',
+      f: 'json',
+      v: '1.13.0',
+      ...credentialParams,
+    },
+  });
+
+  return {
+    credential,
+    userId: null,
+    username: body.username,
+  };
+};
+
+const getMusicFolderList = async (args: MusicFolderListArgs): Promise<MusicFolderListResponse> => {
+  const { apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).getMusicFolderList({});
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get music folder list');
+  }
+
+  return {
+    items: res.body.musicFolders.musicFolder,
+    startIndex: 0,
+    totalRecordCount: res.body.musicFolders.musicFolder.length,
+  };
+};
+
+// export const getAlbumArtistDetail = async (
+//   args: AlbumArtistDetailArgs,
+// ): Promise<SSAlbumArtistDetail> => {
+//   const { server, signal, query } = args;
+//   const defaultParams = getDefaultParams(server);
+
+//   const searchParams: SSAlbumArtistDetailParams = {
+//     id: query.id,
+//     ...defaultParams,
+//   };
+
+//   const data = await api
+//     .get('/getArtist.view', {
+//       prefixUrl: server?.url,
+//       searchParams,
+//       signal,
+//     })
+//     .json<SSAlbumArtistDetailResponse>();
+
+//   return data.artist;
+// };
+
+// const getAlbumArtistList = async (args: AlbumArtistListArgs): Promise<SSAlbumArtistList> => {
+//   const { signal, server, query } = args;
+//   const defaultParams = getDefaultParams(server);
+
+//   const searchParams: SSAlbumArtistListParams = {
+//     musicFolderId: query.musicFolderId,
+//     ...defaultParams,
+//   };
+
+//   const data = await api
+//     .get('rest/getArtists.view', {
+//       prefixUrl: server?.url,
+//       searchParams,
+//       signal,
+//     })
+//     .json<SSAlbumArtistListResponse>();
+
+//   const artists = (data.artists?.index || []).flatMap((index: SSArtistIndex) => index.artist);
+
+//   return {
+//     items: artists,
+//     startIndex: query.startIndex,
+//     totalRecordCount: null,
+//   };
+// };
+
+// const getGenreList = async (args: GenreListArgs): Promise<SSGenreList> => {
+//   const { server, signal } = args;
+//   const defaultParams = getDefaultParams(server);
+
+//   const data = await api
+//     .get('rest/getGenres.view', {
+//       prefixUrl: server?.url,
+//       searchParams: defaultParams,
+//       signal,
+//     })
+//     .json<SSGenreListResponse>();
+
+//   return data.genres.genre;
+// };
+
+// const getAlbumDetail = async (args: AlbumDetailArgs): Promise<SSAlbumDetail> => {
+//   const { server, query, signal } = args;
+//   const defaultParams = getDefaultParams(server);
+
+//   const searchParams = {
+//     id: query.id,
+//     ...defaultParams,
+//   };
+
+//   const data = await api
+//     .get('rest/getAlbum.view', {
+//       prefixUrl: server?.url,
+//       searchParams: parseSearchParams(searchParams),
+//       signal,
+//     })
+//     .json<SSAlbumDetailResponse>();
+
+//   const { song: songs, ...dataWithoutSong } = data.album;
+//   return { ...dataWithoutSong, songs };
+// };
+
+// const getAlbumList = async (args: AlbumListArgs): Promise<SSAlbumList> => {
+//   const { server, query, signal } = args;
+//   const defaultParams = getDefaultParams(server);
+
+//   const searchParams = {
+//     ...defaultParams,
+//   };
+//   const data = await api
+//     .get('rest/getAlbumList2.view', {
+//       prefixUrl: server?.url,
+//       searchParams: parseSearchParams(searchParams),
+//       signal,
+//     })
+//     .json<SSAlbumListResponse>();
+
+//   return {
+//     items: data.albumList2.album,
+//     startIndex: query.startIndex,
+//     totalRecordCount: null,
+//   };
+// };
+
+const createFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).createFavorite({
+    query: {
+      albumId: query.type === LibraryItem.ALBUM ? query.id : undefined,
+      artistId: query.type === LibraryItem.ALBUM_ARTIST ? query.id : undefined,
+      id: query.type === LibraryItem.SONG ? query.id : undefined,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to create favorite');
+  }
+
+  return null;
+};
+
+const removeFavorite = async (args: FavoriteArgs): Promise<FavoriteResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).removeFavorite({
+    query: {
+      albumId: query.type === LibraryItem.ALBUM ? query.id : undefined,
+      artistId: query.type === LibraryItem.ALBUM_ARTIST ? query.id : undefined,
+      id: query.type === LibraryItem.SONG ? query.id : undefined,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to delete favorite');
+  }
+
+  return null;
+};
+
+const setRating = async (args: SetRatingArgs): Promise<RatingResponse> => {
+  const { query, apiClientProps } = args;
+
+  const itemIds = query.item.map((item) => item.id);
+
+  for (const id of itemIds) {
+    await ssApiClient(apiClientProps).setRating({
+      query: {
+        id,
+        rating: query.rating,
+      },
+    });
+  }
+
+  return null;
+};
+
+const getTopSongList = async (args: TopSongListArgs): Promise<SongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).getTopSongsList({
+    query: {
+      artist: query.artist,
+      count: query.limit,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get top songs');
+  }
+
+  return {
+    items:
+      res.body.topSongs?.song?.map((song) => ssNormalize.song(song, apiClientProps.server, '')) ||
+      [],
+    startIndex: 0,
+    totalRecordCount: res.body.topSongs?.song?.length || 0,
+  };
+};
+
+const getArtistInfo = async (
+  args: ArtistInfoArgs,
+): Promise<z.infer<typeof ssType._response.artistInfo>> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).getArtistInfo({
+    query: {
+      count: query.limit,
+      id: query.artistId,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get artist info');
+  }
+
+  return res.body;
+};
+
+const scrobble = async (args: ScrobbleArgs): Promise<ScrobbleResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).scrobble({
+    query: {
+      id: query.id,
+      submission: query.submission,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to scrobble');
+  }
+
+  return null;
+};
+
+const search3 = async (args: SearchArgs): Promise<SearchResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).search3({
+    query: {
+      albumCount: query.albumLimit,
+      albumOffset: query.albumStartIndex,
+      artistCount: query.albumArtistLimit,
+      artistOffset: query.albumArtistStartIndex,
+      query: query.query,
+      songCount: query.songLimit,
+      songOffset: query.songStartIndex,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to search');
+  }
+
+  return {
+    albumArtists: res.body.searchResult3?.artist?.map((artist) =>
+      ssNormalize.albumArtist(artist, apiClientProps.server),
+    ),
+    albums: res.body.searchResult3?.album?.map((album) =>
+      ssNormalize.album(album, apiClientProps.server),
+    ),
+    songs: res.body.searchResult3?.song?.map((song) =>
+      ssNormalize.song(song, apiClientProps.server, ''),
+    ),
+  };
+};
+
+const getRandomSongList = async (args: RandomSongListArgs): Promise<RandomSongListResponse> => {
+  const { query, apiClientProps } = args;
+
+  const res = await ssApiClient(apiClientProps).getRandomSongList({
+    query: {
+      fromYear: query.minYear,
+      genre: query.genre,
+      musicFolderId: query.musicFolderId,
+      size: query.limit,
+      toYear: query.maxYear,
+    },
+  });
+
+  if (res.status !== 200) {
+    throw new Error('Failed to get random songs');
+  }
+
+  return {
+    items: res.body.randomSongs?.song?.map((song) =>
+      ssNormalize.song(song, apiClientProps.server, ''),
+    ),
+    startIndex: 0,
+    totalRecordCount: res.body.randomSongs?.song?.length || 0,
+  };
+};
+
+export const ssController = {
+  authenticate,
+  createFavorite,
+  getArtistInfo,
+  getMusicFolderList,
+  getRandomSongList,
+  getTopSongList,
+  removeFavorite,
+  scrobble,
+  search3,
+  setRating,
+};

src/renderer/api/subsonic/subsonic-normalize.ts

@@ -0,0 +1,180 @@
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+import { ssType } from '/@/renderer/api/subsonic/subsonic-types';
+import { QueueSong, LibraryItem, AlbumArtist, Album } from '/@/renderer/api/types';
+import { ServerListItem, ServerType } from '/@/renderer/types';
+
+const getCoverArtUrl = (args: {
+  baseUrl: string | undefined;
+  coverArtId?: string;
+  credential: string | undefined;
+  size: number;
+}) => {
+  const size = args.size ? args.size : 250;
+
+  if (!args.coverArtId || args.coverArtId.match('2a96cbd8b46e442fc41c2b86b821562f')) {
+    return null;
+  }
+
+  return (
+    `${args.baseUrl}/rest/getCoverArt.view` +
+    `?id=${args.coverArtId}` +
+    `&${args.credential}` +
+    '&v=1.13.0' +
+    '&c=feishin' +
+    `&size=${size}`
+  );
+};
+
+const normalizeSong = (
+  item: z.infer<typeof ssType._response.song>,
+  server: ServerListItem | null,
+  deviceId: string,
+): QueueSong => {
+  const imageUrl =
+    getCoverArtUrl({
+      baseUrl: server?.url,
+      coverArtId: item.coverArt,
+      credential: server?.credential,
+      size: 100,
+    }) || null;
+
+  const streamUrl = `${server?.url}/rest/stream.view?id=${item.id}&v=1.13.0&c=feishin_${deviceId}&${server?.credential}`;
+
+  return {
+    album: item.album || '',
+    albumArtists: [
+      {
+        id: item.artistId || '',
+        imageUrl: null,
+        name: item.artist || '',
+      },
+    ],
+    albumId: item.albumId || '',
+    artistName: item.artist || '',
+    artists: [
+      {
+        id: item.artistId || '',
+        imageUrl: null,
+        name: item.artist || '',
+      },
+    ],
+    bitRate: item.bitRate || 0,
+    bpm: null,
+    channels: null,
+    comment: null,
+    compilation: null,
+    container: item.contentType,
+    createdAt: item.created,
+    discNumber: item.discNumber || 1,
+    duration: item.duration || 0,
+    genres: item.genre
+      ? [
+          {
+            id: item.genre,
+            name: item.genre,
+          },
+        ]
+      : [],
+    id: item.id,
+    imagePlaceholderUrl: null,
+    imageUrl,
+    itemType: LibraryItem.SONG,
+    lastPlayedAt: null,
+    lyrics: null,
+    name: item.title,
+    path: item.path,
+    playCount: item?.playCount || 0,
+    releaseDate: null,
+    releaseYear: item.year ? String(item.year) : null,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.SUBSONIC,
+    size: item.size,
+    streamUrl,
+    trackNumber: item.track || 1,
+    uniqueId: nanoid(),
+    updatedAt: '',
+    userFavorite: item.starred || false,
+    userRating: item.userRating || null,
+  };
+};
+
+const normalizeAlbumArtist = (
+  item: z.infer<typeof ssType._response.albumArtist>,
+  server: ServerListItem | null,
+): AlbumArtist => {
+  const imageUrl =
+    getCoverArtUrl({
+      baseUrl: server?.url,
+      coverArtId: item.coverArt,
+      credential: server?.credential,
+      size: 100,
+    }) || null;
+
+  return {
+    albumCount: item.albumCount ? Number(item.albumCount) : 0,
+    backgroundImageUrl: null,
+    biography: null,
+    duration: null,
+    genres: [],
+    id: item.id,
+    imageUrl,
+    itemType: LibraryItem.ALBUM_ARTIST,
+    lastPlayedAt: null,
+    name: item.name,
+    playCount: null,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.SUBSONIC,
+    similarArtists: [],
+    songCount: null,
+    userFavorite: false,
+    userRating: null,
+  };
+};
+
+const normalizeAlbum = (
+  item: z.infer<typeof ssType._response.album>,
+  server: ServerListItem | null,
+): Album => {
+  const imageUrl =
+    getCoverArtUrl({
+      baseUrl: server?.url,
+      coverArtId: item.coverArt,
+      credential: server?.credential,
+      size: 300,
+    }) || null;
+
+  return {
+    albumArtists: item.artistId ? [{ id: item.artistId, imageUrl: null, name: item.artist }] : [],
+    artists: item.artistId ? [{ id: item.artistId, imageUrl: null, name: item.artist }] : [],
+    backdropImageUrl: null,
+    createdAt: item.created,
+    duration: item.duration,
+    genres: item.genre ? [{ id: item.genre, name: item.genre }] : [],
+    id: item.id,
+    imagePlaceholderUrl: null,
+    imageUrl,
+    isCompilation: null,
+    itemType: LibraryItem.ALBUM,
+    lastPlayedAt: null,
+    name: item.name,
+    playCount: null,
+    releaseDate: item.year ? new Date(item.year, 0, 1).toISOString() : null,
+    releaseYear: item.year ? Number(item.year) : null,
+    serverId: server?.id || 'unknown',
+    serverType: ServerType.SUBSONIC,
+    size: null,
+    songCount: item.songCount,
+    songs: [],
+    uniqueId: nanoid(),
+    updatedAt: item.created,
+    userFavorite: item.starred || false,
+    userRating: item.userRating || null,
+  };
+};
+
+export const ssNormalize = {
+  album: normalizeAlbum,
+  albumArtist: normalizeAlbumArtist,
+  song: normalizeSong,
+};

src/renderer/api/subsonic/subsonic-types.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+
+const baseResponse = z.object({
+  'subsonic-response': z.object({
+    status: z.string(),
+    version: z.string(),
+  }),
+});
+
+const authenticate = z.null();
+
+const authenticateParameters = z.object({
+  c: z.string(),
+  f: z.string(),
+  p: z.string().optional(),
+  s: z.string().optional(),
+  t: z.string().optional(),
+  u: z.string(),
+  v: z.string(),
+});
+
+const createFavoriteParameters = z.object({
+  albumId: z.array(z.string()).optional(),
+  artistId: z.array(z.string()).optional(),
+  id: z.array(z.string()).optional(),
+});
+
+const createFavorite = z.null();
+
+const removeFavoriteParameters = z.object({
+  albumId: z.array(z.string()).optional(),
+  artistId: z.array(z.string()).optional(),
+  id: z.array(z.string()).optional(),
+});
+
+const removeFavorite = z.null();
+
+const setRatingParameters = z.object({
+  id: z.string(),
+  rating: z.number(),
+});
+
+const setRating = z.null();
+
+const musicFolder = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+const musicFolderList = z.object({
+  musicFolders: z.object({
+    musicFolder: z.array(musicFolder),
+  }),
+});
+
+const song = z.object({
+  album: z.string().optional(),
+  albumId: z.string().optional(),
+  artist: z.string().optional(),
+  artistId: z.string().optional(),
+  averageRating: z.number().optional(),
+  bitRate: z.number().optional(),
+  contentType: z.string(),
+  coverArt: z.string().optional(),
+  created: z.string(),
+  discNumber: z.number(),
+  duration: z.number().optional(),
+  genre: z.string().optional(),
+  id: z.string(),
+  isDir: z.boolean(),
+  isVideo: z.boolean(),
+  parent: z.string(),
+  path: z.string(),
+  playCount: z.number().optional(),
+  size: z.number(),
+  starred: z.boolean().optional(),
+  suffix: z.string(),
+  title: z.string(),
+  track: z.number().optional(),
+  type: z.string(),
+  userRating: z.number().optional(),
+  year: z.number().optional(),
+});
+
+const album = z.object({
+  album: z.string(),
+  artist: z.string(),
+  artistId: z.string(),
+  coverArt: z.string(),
+  created: z.string(),
+  duration: z.number(),
+  genre: z.string().optional(),
+  id: z.string(),
+  isDir: z.boolean(),
+  isVideo: z.boolean(),
+  name: z.string(),
+  parent: z.string(),
+  song: z.array(song),
+  songCount: z.number(),
+  starred: z.boolean().optional(),
+  title: z.string(),
+  userRating: z.number().optional(),
+  year: z.number().optional(),
+});
+
+const albumListParameters = z.object({
+  fromYear: z.number().optional(),
+  genre: z.string().optional(),
+  musicFolderId: z.string().optional(),
+  offset: z.number().optional(),
+  size: z.number().optional(),
+  toYear: z.number().optional(),
+  type: z.string().optional(),
+});
+
+const albumList = z.array(album.omit({ song: true }));
+
+const albumArtist = z.object({
+  albumCount: z.string(),
+  artistImageUrl: z.string().optional(),
+  coverArt: z.string().optional(),
+  id: z.string(),
+  name: z.string(),
+});
+
+const albumArtistList = z.object({
+  artist: z.array(albumArtist),
+  name: z.string(),
+});
+
+const artistInfoParameters = z.object({
+  count: z.number().optional(),
+  id: z.string(),
+  includeNotPresent: z.boolean().optional(),
+});
+
+const artistInfo = z.object({
+  artistInfo: z.object({
+    biography: z.string().optional(),
+    largeImageUrl: z.string().optional(),
+    lastFmUrl: z.string().optional(),
+    mediumImageUrl: z.string().optional(),
+    musicBrainzId: z.string().optional(),
+    similarArtist: z.array(
+      z.object({
+        albumCount: z.string(),
+        artistImageUrl: z.string().optional(),
+        coverArt: z.string().optional(),
+        id: z.string(),
+        name: z.string(),
+      }),
+    ),
+    smallImageUrl: z.string().optional(),
+  }),
+});
+
+const topSongsListParameters = z.object({
+  artist: z.string(), // The name of the artist, not the artist ID
+  count: z.number().optional(),
+});
+
+const topSongsList = z.object({
+  topSongs: z.object({
+    song: z.array(song),
+  }),
+});
+
+const scrobbleParameters = z.object({
+  id: z.string(),
+  submission: z.boolean().optional(),
+  time: z.number().optional(), // The time (in milliseconds since 1 Jan 1970) at which the song was listened to.
+});
+
+const scrobble = z.null();
+
+const search3 = z.object({
+  searchResult3: z.object({
+    album: z.array(album),
+    artist: z.array(albumArtist),
+    song: z.array(song),
+  }),
+});
+
+const search3Parameters = z.object({
+  albumCount: z.number().optional(),
+  albumOffset: z.number().optional(),
+  artistCount: z.number().optional(),
+  artistOffset: z.number().optional(),
+  musicFolderId: z.string().optional(),
+  query: z.string().optional(),
+  songCount: z.number().optional(),
+  songOffset: z.number().optional(),
+});
+
+const randomSongListParameters = z.object({
+  fromYear: z.number().optional(),
+  genre: z.string().optional(),
+  musicFolderId: z.string().optional(),
+  size: z.number().optional(),
+  toYear: z.number().optional(),
+});
+
+const randomSongList = z.object({
+  randomSongs: z.object({
+    song: z.array(song),
+  }),
+});
+
+export const ssType = {
+  _parameters: {
+    albumList: albumListParameters,
+    artistInfo: artistInfoParameters,
+    authenticate: authenticateParameters,
+    createFavorite: createFavoriteParameters,
+    randomSongList: randomSongListParameters,
+    removeFavorite: removeFavoriteParameters,
+    scrobble: scrobbleParameters,
+    search3: search3Parameters,
+    setRating: setRatingParameters,
+    topSongsList: topSongsListParameters,
+  },
+  _response: {
+    album,
+    albumArtist,
+    albumArtistList,
+    albumList,
+    artistInfo,
+    authenticate,
+    baseResponse,
+    createFavorite,
+    musicFolderList,
+    randomSongList,
+    removeFavorite,
+    scrobble,
+    search3,
+    setRating,
+    song,
+    topSongsList,
+  },
+};

src/renderer/api/types.ts

@@ -1,53 +1,57 @@
+import { z } from 'zod';
 import {
   JFSortOrder,
-  JFGenreList,
-  JFAlbumList,
   JFAlbumListSort,
-  JFAlbumDetail,
-  JFSongList,
   JFSongListSort,
-  JFAlbumArtistList,
   JFAlbumArtistListSort,
-  JFAlbumArtistDetail,
-  JFArtistList,
   JFArtistListSort,
-  JFPlaylistList,
-  JFPlaylistDetail,
-  JFMusicFolderList,
   JFPlaylistListSort,
-} from '/@/renderer/api/jellyfin.types';
+} from './jellyfin.types';
+import { jfType } from './jellyfin/jellyfin-types';
 import {
   NDSortOrder,
   NDOrder,
-  NDGenreList,
-  NDAlbumList,
   NDAlbumListSort,
-  NDAlbumDetail,
-  NDSongList,
-  NDSongDetail,
-  NDAlbumArtistList,
   NDAlbumArtistListSort,
-  NDAlbumArtistDetail,
-  NDDeletePlaylist,
-  NDPlaylistList,
   NDPlaylistListSort,
-  NDPlaylistDetail,
   NDSongListSort,
-} from '/@/renderer/api/navidrome.types';
-import {
-  SSAlbumList,
-  SSAlbumDetail,
-  SSAlbumArtistList,
-  SSAlbumArtistDetail,
-  SSMusicFolderList,
-  SSGenreList,
-} from '/@/renderer/api/subsonic.types';
+  NDUserListSort,
+} from './navidrome.types';
+import { ndType } from './navidrome/navidrome-types';
+
+export enum LibraryItem {
+  ALBUM = 'album',
+  ALBUM_ARTIST = 'albumArtist',
+  ARTIST = 'artist',
+  PLAYLIST = 'playlist',
+  SONG = 'song',
+}
+
+export type AnyLibraryItem = Album | AlbumArtist | Artist | Playlist | Song | QueueSong;
+
+export type AnyLibraryItems =
+  | Album[]
+  | AlbumArtist[]
+  | Artist[]
+  | Playlist[]
+  | Song[]
+  | QueueSong[];
 
 export enum SortOrder {
   ASC = 'ASC',
   DESC = 'DESC',
 }
 
+export type User = {
+  createdAt: string | null;
+  email: string | null;
+  id: string;
+  isAdmin: boolean | null;
+  lastLoginAt: string | null;
+  name: string;
+  updatedAt: string | null;
+};
+
 export type ServerListItem = {
   credential: string;
   id: string;
@@ -128,8 +132,10 @@ export type AuthenticationResponse = {
 };
 
 export type Genre = {
+  albumCount?: number;
   id: string;
   name: string;
+  songCount?: number;
 };
 
 export type Album = {
@@ -143,23 +149,25 @@ export type Album = {
   imagePlaceholderUrl: string | null;
   imageUrl: string | null;
   isCompilation: boolean | null;
-  isFavorite: boolean;
+  itemType: LibraryItem.ALBUM;
   lastPlayedAt: string | null;
   name: string;
   playCount: number | null;
-  rating: number | null;
   releaseDate: string | null;
   releaseYear: number | null;
+  serverId: string;
   serverType: ServerType;
   size: number | null;
   songCount: number | null;
   songs?: Song[];
   uniqueId: string;
   updatedAt: string;
+  userFavorite: boolean;
+  userRating: number | null;
 } & { songs?: Song[] };
 
 export type Song = {
-  album: string;
+  album: string | null;
   albumArtists: RelatedArtist[];
   albumId: string;
   artistName: string;
@@ -167,6 +175,7 @@ export type Song = {
   bitRate: number;
   bpm: number | null;
   channels: number | null;
+  comment: string | null;
   compilation: boolean | null;
   container: string | null;
   createdAt: string;
@@ -176,21 +185,24 @@ export type Song = {
   id: string;
   imagePlaceholderUrl: string | null;
   imageUrl: string | null;
-  isFavorite: boolean;
+  itemType: LibraryItem.SONG;
   lastPlayedAt: string | null;
+  lyrics: string | null;
   name: string;
-  note: string | null;
   path: string | null;
   playCount: number;
+  playlistItemId?: string;
   releaseDate: string | null;
   releaseYear: string | null;
   serverId: string;
+  serverType: ServerType;
   size: number;
   streamUrl: string;
   trackNumber: number;
-  type: ServerType;
   uniqueId: string;
   updatedAt: string;
+  userFavorite: boolean;
+  userRating: number | null;
 };
 
 export type AlbumArtist = {
@@ -201,12 +213,16 @@ export type AlbumArtist = {
   genres: Genre[];
   id: string;
   imageUrl: string | null;
-  isFavorite: boolean;
+  itemType: LibraryItem.ALBUM_ARTIST;
   lastPlayedAt: string | null;
   name: string;
   playCount: number | null;
-  rating: number | null;
+  serverId: string;
+  serverType: ServerType;
+  similarArtists: RelatedArtist[] | null;
   songCount: number | null;
+  userFavorite: boolean;
+  userRating: number | null;
 };
 
 export type RelatedAlbumArtist = {
@@ -218,14 +234,18 @@ export type Artist = {
   biography: string | null;
   createdAt: string;
   id: string;
+  itemType: LibraryItem.ARTIST;
   name: string;
   remoteCreatedAt: string | null;
   serverFolderId: string;
+  serverId: string;
+  serverType: ServerType;
   updatedAt: string;
 };
 
 export type RelatedArtist = {
   id: string;
+  imageUrl: string | null;
   name: string;
 };
 
@@ -241,13 +261,17 @@ export type Playlist = {
   id: string;
   imagePlaceholderUrl: string | null;
   imageUrl: string | null;
+  itemType: LibraryItem.PLAYLIST;
   name: string;
+  owner: string | null;
+  ownerId: string | null;
   public: boolean | null;
   rules?: Record<string, any> | null;
+  serverId: string;
+  serverType: ServerType;
   size: number | null;
   songCount: number | null;
-  userId: string | null;
-  username: string | null;
+  sync?: boolean | null;
 };
 
 export type GenresResponse = Genre[];
@@ -257,13 +281,13 @@ export type MusicFoldersResponse = MusicFolder[];
 export type ListSortOrder = NDOrder | JFSortOrder;
 
 type BaseEndpointArgs = {
-  server: ServerListItem | null;
-  signal?: AbortSignal;
+  apiClientProps: {
+    server: ServerListItem | null;
+    signal?: AbortSignal;
+  };
 };
 
 // Genre List
-export type RawGenreListResponse = NDGenreList | JFGenreList | SSGenreList | undefined;
-
 export type GenreListResponse = BasePaginatedResponse<Genre[]> | null | undefined;
 
 export type GenreListArgs = { query: GenreListQuery } & BaseEndpointArgs;
@@ -271,8 +295,6 @@ export type GenreListArgs = { query: GenreListQuery } & BaseEndpointArgs;
 export type GenreListQuery = null;
 
 // Album List
-export type RawAlbumListResponse = NDAlbumList | SSAlbumList | JFAlbumList | undefined;
-
 export type AlbumListResponse = BasePaginatedResponse<Album[]> | null | undefined;
 
 export enum AlbumListSort {
@@ -294,29 +316,16 @@ export enum AlbumListSort {
 }
 
 export type AlbumListQuery = {
-  jfParams?: {
-    albumArtistIds?: string;
-    artistIds?: string;
-    filters?: string;
-    genreIds?: string;
-    genres?: string;
-    isFavorite?: boolean;
-    maxYear?: number; // Parses to years
-    minYear?: number; // Parses to years
-    tags?: string;
+  _custom?: {
+    jellyfin?: Partial<z.infer<typeof jfType._parameters.albumList>> & {
+      maxYear?: number;
+      minYear?: number;
+    };
+    navidrome?: Partial<z.infer<typeof ndType._parameters.albumList>>;
   };
+  artistIds?: string[];
   limit?: number;
   musicFolderId?: string;
-  ndParams?: {
-    artist_id?: string;
-    compilation?: boolean;
-    genre_id?: string;
-    has_rating?: boolean;
-    name?: string;
-    recently_played?: boolean;
-    starred?: boolean;
-    year?: number;
-  };
   searchTerm?: string;
   sortBy: AlbumListSort;
   sortOrder: SortOrder;
@@ -386,8 +395,6 @@ export const albumListSortMap: AlbumListSortMap = {
 };
 
 // Album Detail
-export type RawAlbumDetailResponse = NDAlbumDetail | SSAlbumDetail | JFAlbumDetail | undefined;
-
 export type AlbumDetailResponse = Album | null | undefined;
 
 export type AlbumDetailQuery = { id: string };
@@ -395,8 +402,6 @@ export type AlbumDetailQuery = { id: string };
 export type AlbumDetailArgs = { query: AlbumDetailQuery } & BaseEndpointArgs;
 
 // Song List
-export type RawSongListResponse = NDSongList | JFSongList | undefined;
-
 export type SongListResponse = BasePaginatedResponse<Song[]>;
 
 export enum SongListSort {
@@ -421,31 +426,17 @@ export enum SongListSort {
 }
 
 export type SongListQuery = {
+  _custom?: {
+    jellyfin?: Partial<z.infer<typeof jfType._parameters.songList>> & {
+      maxYear?: number;
+      minYear?: number;
+    };
+    navidrome?: Partial<z.infer<typeof ndType._parameters.songList>>;
+  };
   albumIds?: string[];
   artistIds?: string[];
-  jfParams?: {
-    filters?: string;
-    genreIds?: string;
-    genres?: string;
-    includeItemTypes: 'Audio';
-    isFavorite?: boolean;
-    maxYear?: number; // Parses to years
-    minYear?: number; // Parses to years
-    sortBy?: JFSongListSort;
-    years?: string;
-  };
   limit?: number;
   musicFolderId?: string;
-  ndParams?: {
-    album_id?: string[];
-    artist_id?: string[];
-    compilation?: boolean;
-    genre_id?: string;
-    has_rating?: boolean;
-    starred?: boolean;
-    title?: string;
-    year?: number;
-  };
   searchTerm?: string;
   sortBy: SongListSort;
   sortOrder: SortOrder;
@@ -496,7 +487,7 @@ export const songListSortMap: SongListSortMap = {
     playCount: NDSongListSort.PLAY_COUNT,
     random: undefined,
     rating: NDSongListSort.RATING,
-    recentlyAdded: NDSongListSort.PLAY_DATE,
+    recentlyAdded: NDSongListSort.RECENTLY_ADDED,
     recentlyPlayed: NDSongListSort.PLAY_DATE,
     releaseDate: undefined,
     year: NDSongListSort.YEAR,
@@ -524,8 +515,6 @@ export const songListSortMap: SongListSortMap = {
 };
 
 // Song Detail
-export type RawSongDetailResponse = NDSongDetail | undefined;
-
 export type SongDetailResponse = Song | null | undefined;
 
 export type SongDetailQuery = { id: string };
@@ -533,13 +522,7 @@ export type SongDetailQuery = { id: string };
 export type SongDetailArgs = { query: SongDetailQuery } & BaseEndpointArgs;
 
 // Album Artist List
-export type RawAlbumArtistListResponse =
-  | NDAlbumArtistList
-  | SSAlbumArtistList
-  | JFAlbumArtistList
-  | undefined;
-
-export type AlbumArtistListResponse = BasePaginatedResponse<AlbumArtist[]>;
+export type AlbumArtistListResponse = BasePaginatedResponse<AlbumArtist[]> | null;
 
 export enum AlbumArtistListSort {
   ALBUM = 'album',
@@ -556,13 +539,12 @@ export enum AlbumArtistListSort {
 }
 
 export type AlbumArtistListQuery = {
+  _custom?: {
+    jellyfin?: Partial<z.infer<typeof jfType._parameters.albumArtistList>>;
+    navidrome?: Partial<z.infer<typeof ndType._parameters.albumArtistList>>;
+  };
   limit?: number;
   musicFolderId?: string;
-  ndParams?: {
-    genre_id?: string;
-    name?: string;
-    starred?: boolean;
-  };
   searchTerm?: string;
   sortBy: AlbumArtistListSort;
   sortOrder: SortOrder;
@@ -620,21 +602,14 @@ export const albumArtistListSortMap: AlbumArtistListSortMap = {
 };
 
 // Album Artist Detail
-export type RawAlbumArtistDetailResponse =
-  | NDAlbumArtistDetail
-  | SSAlbumArtistDetail
-  | JFAlbumArtistDetail
-  | undefined;
 
-export type AlbumArtistDetailResponse = BasePaginatedResponse<AlbumArtist[]>;
+export type AlbumArtistDetailResponse = AlbumArtist | null;
 
 export type AlbumArtistDetailQuery = { id: string };
 
 export type AlbumArtistDetailArgs = { query: AlbumArtistDetailQuery } & BaseEndpointArgs;
 
 // Artist List
-export type RawArtistListResponse = JFArtistList | undefined;
-
 export type ArtistListResponse = BasePaginatedResponse<Artist[]>;
 
 export enum ArtistListSort {
@@ -652,13 +627,12 @@ export enum ArtistListSort {
 }
 
 export type ArtistListQuery = {
+  _custom?: {
+    jellyfin?: Partial<z.infer<typeof jfType._parameters.albumArtistList>>;
+    navidrome?: Partial<z.infer<typeof ndType._parameters.albumArtistList>>;
+  };
   limit?: number;
   musicFolderId?: string;
-  ndParams?: {
-    genre_id?: string;
-    name?: string;
-    starred?: boolean;
-  };
   sortBy: ArtistListSort;
   sortOrder: SortOrder;
   startIndex: number;
@@ -717,71 +691,113 @@ export const artistListSortMap: ArtistListSortMap = {
 // Artist Detail
 
 // Favorite
-export type RawFavoriteResponse = FavoriteResponse | undefined;
+export type FavoriteResponse = null | undefined;
 
-export type FavoriteResponse = { id: string };
-
-export type FavoriteQuery = { id: string; type?: 'song' | 'album' | 'albumArtist' };
-
-export type FavoriteArgs = { query: FavoriteQuery } & BaseEndpointArgs;
-
-// Rating
-export type RawRatingResponse = null | undefined;
-
-export type RatingResponse = null;
-
-export type RatingQuery = { id: string; rating: number };
-
-export type RatingArgs = { query: RatingQuery } & BaseEndpointArgs;
-
-// Create Playlist
-export type RawCreatePlaylistResponse = CreatePlaylistResponse | undefined;
-
-export type CreatePlaylistResponse = { id: string; name: string };
-
-export type CreatePlaylistQuery = {
-  comment?: string;
-  name: string;
-  public?: boolean;
-  rules?: Record<string, any>;
+export type FavoriteQuery = {
+  id: string[];
+  type: LibraryItem;
 };
 
-export type CreatePlaylistArgs = { query: CreatePlaylistQuery } & BaseEndpointArgs;
+export type FavoriteArgs = { query: FavoriteQuery; serverId?: string } & BaseEndpointArgs;
+
+// Rating
+export type RatingResponse = null | undefined;
+
+export type RatingQuery = {
+  item: AnyLibraryItems;
+  rating: number;
+};
+
+export type SetRatingArgs = { query: RatingQuery; serverId?: string } & BaseEndpointArgs;
+
+// Add to playlist
+export type AddToPlaylistResponse = null | undefined;
+
+export type AddToPlaylistQuery = {
+  id: string;
+};
+
+export type AddToPlaylistBody = {
+  songId: string[];
+};
+
+export type AddToPlaylistArgs = {
+  body: AddToPlaylistBody;
+  query: AddToPlaylistQuery;
+  serverId?: string;
+} & BaseEndpointArgs;
+
+// Remove from playlist
+export type RemoveFromPlaylistResponse = null | undefined;
+
+export type RemoveFromPlaylistQuery = {
+  id: string;
+  songId: string[];
+};
+
+export type RemoveFromPlaylistArgs = {
+  query: RemoveFromPlaylistQuery;
+  serverId?: string;
+} & BaseEndpointArgs;
+
+// Create Playlist
+export type CreatePlaylistResponse = { id: string } | undefined;
+
+export type CreatePlaylistBody = {
+  _custom?: {
+    navidrome?: {
+      owner?: string;
+      ownerId?: string;
+      public?: boolean;
+      rules?: Record<string, any>;
+      sync?: boolean;
+    };
+  };
+  comment?: string;
+  name: string;
+};
+
+export type CreatePlaylistArgs = { body: CreatePlaylistBody; serverId?: string } & BaseEndpointArgs;
 
 // Update Playlist
-export type RawUpdatePlaylistResponse = UpdatePlaylistResponse | undefined;
-
-export type UpdatePlaylistResponse = { id: string };
+export type UpdatePlaylistResponse = null | undefined;
 
 export type UpdatePlaylistQuery = {
   id: string;
 };
 
 export type UpdatePlaylistBody = {
+  _custom?: {
+    navidrome?: {
+      owner?: string;
+      ownerId?: string;
+      public?: boolean;
+      rules?: Record<string, any>;
+      sync?: boolean;
+    };
+  };
   comment?: string;
   genres?: Genre[];
   name: string;
-  public?: boolean;
-  rules?: Record<string, any>;
 };
 
 export type UpdatePlaylistArgs = {
   body: UpdatePlaylistBody;
   query: UpdatePlaylistQuery;
+  serverId?: string;
 } & BaseEndpointArgs;
 
 // Delete Playlist
-export type RawDeletePlaylistResponse = NDDeletePlaylist | undefined;
-
-export type DeletePlaylistResponse = null;
+export type DeletePlaylistResponse = null | undefined;
 
 export type DeletePlaylistQuery = { id: string };
 
-export type DeletePlaylistArgs = { query: DeletePlaylistQuery } & BaseEndpointArgs;
+export type DeletePlaylistArgs = {
+  query: DeletePlaylistQuery;
+  serverId?: string;
+} & BaseEndpointArgs;
 
 // Playlist List
-export type RawPlaylistListResponse = NDPlaylistList | JFPlaylistList | undefined;
-
 export type PlaylistListResponse = BasePaginatedResponse<Playlist[]>;
 
 export enum PlaylistListSort {
@@ -794,10 +810,11 @@ export enum PlaylistListSort {
 }
 
 export type PlaylistListQuery = {
-  limit?: number;
-  ndParams?: {
-    owner_id?: string;
+  _custom?: {
+    jellyfin?: Partial<z.infer<typeof jfType._parameters.playlistList>>;
+    navidrome?: Partial<z.infer<typeof ndType._parameters.playlistList>>;
   };
+  limit?: number;
   searchTerm?: string;
   sortBy: PlaylistListSort;
   sortOrder: SortOrder;
@@ -840,9 +857,7 @@ export const playlistListSortMap: PlaylistListSortMap = {
 };
 
 // Playlist Detail
-export type RawPlaylistDetailResponse = NDPlaylistDetail | JFPlaylistDetail | undefined;
-
-export type PlaylistDetailResponse = BasePaginatedResponse<Playlist[]>;
+export type PlaylistDetailResponse = Playlist;
 
 export type PlaylistDetailQuery = {
   id: string;
@@ -851,8 +866,6 @@ export type PlaylistDetailQuery = {
 export type PlaylistDetailArgs = { query: PlaylistDetailQuery } & BaseEndpointArgs;
 
 // Playlist Songs
-export type RawPlaylistSongListResponse = JFSongList | undefined;
-
 export type PlaylistSongListResponse = BasePaginatedResponse<Song[]>;
 
 export type PlaylistSongListQuery = {
@@ -866,17 +879,206 @@ export type PlaylistSongListQuery = {
 export type PlaylistSongListArgs = { query: PlaylistSongListQuery } & BaseEndpointArgs;
 
 // Music Folder List
-export type RawMusicFolderListResponse = SSMusicFolderList | JFMusicFolderList | undefined;
+export type MusicFolderListResponse = BasePaginatedResponse<MusicFolder[]>;
 
-export type MusicFolderListResponse = BasePaginatedResponse<Playlist[]>;
+export type MusicFolderListQuery = null;
 
 export type MusicFolderListArgs = BaseEndpointArgs;
 
-// Create Favorite
-export type RawCreateFavoriteResponse = CreateFavoriteResponse | undefined;
+// User list
+// Playlist List
+export type UserListResponse = BasePaginatedResponse<User[]>;
 
-export type CreateFavoriteResponse = { id: string };
+export enum UserListSort {
+  NAME = 'name',
+}
 
-export type CreateFavoriteQuery = { comment?: string; name: string; public?: boolean };
+export type UserListQuery = {
+  _custom?: {
+    navidrome?: {
+      owner_id?: string;
+    };
+  };
+  limit?: number;
+  searchTerm?: string;
+  sortBy: UserListSort;
+  sortOrder: SortOrder;
+  startIndex: number;
+};
 
-export type CreateFavoriteArgs = { query: CreateFavoriteQuery } & BaseEndpointArgs;
+export type UserListArgs = { query: UserListQuery } & BaseEndpointArgs;
+
+type UserListSortMap = {
+  jellyfin: Record<UserListSort, undefined>;
+  navidrome: Record<UserListSort, NDUserListSort | undefined>;
+  subsonic: Record<UserListSort, undefined>;
+};
+
+export const userListSortMap: UserListSortMap = {
+  jellyfin: {
+    name: undefined,
+  },
+  navidrome: {
+    name: NDUserListSort.NAME,
+  },
+  subsonic: {
+    name: undefined,
+  },
+};
+
+// Top Songs List
+export type TopSongListResponse = BasePaginatedResponse<Song[]>;
+
+export type TopSongListQuery = {
+  artist: string;
+  artistId: string;
+  limit?: number;
+};
+
+export type TopSongListArgs = { query: TopSongListQuery } & BaseEndpointArgs;
+
+// Artist Info
+export type ArtistInfoQuery = {
+  artistId: string;
+  limit: number;
+  musicFolderId?: string;
+};
+
+export type ArtistInfoArgs = { query: ArtistInfoQuery } & BaseEndpointArgs;
+
+// Scrobble
+export type ScrobbleResponse = null | undefined;
+
+export type ScrobbleArgs = {
+  query: ScrobbleQuery;
+  serverId?: string;
+} & BaseEndpointArgs;
+
+export type ScrobbleQuery = {
+  event?: 'pause' | 'unpause' | 'timeupdate' | 'start';
+  id: string;
+  position?: number;
+  submission: boolean;
+};
+
+export type SearchQuery = {
+  albumArtistLimit?: number;
+  albumArtistStartIndex?: number;
+  albumLimit?: number;
+  albumStartIndex?: number;
+  musicFolderId?: string;
+  query?: string;
+  songLimit?: number;
+  songStartIndex?: number;
+};
+
+export type SearchSongsQuery = {
+  musicFolderId?: string;
+  query?: string;
+  songLimit?: number;
+  songStartIndex?: number;
+};
+
+export type SearchAlbumsQuery = {
+  albumLimit?: number;
+  albumStartIndex?: number;
+  musicFolderId?: string;
+  query?: string;
+};
+
+export type SearchAlbumArtistsQuery = {
+  albumArtistLimit?: number;
+  albumArtistStartIndex?: number;
+  musicFolderId?: string;
+  query?: string;
+};
+
+export type SearchArgs = {
+  query: SearchQuery;
+} & BaseEndpointArgs;
+
+export type SearchResponse = {
+  albumArtists: AlbumArtist[];
+  albums: Album[];
+  songs: Song[];
+};
+
+export type RandomSongListQuery = {
+  genre?: string;
+  limit?: number;
+  maxYear?: number;
+  minYear?: number;
+  musicFolderId?: string;
+};
+
+export type RandomSongListArgs = {
+  query: RandomSongListQuery;
+} & BaseEndpointArgs;
+
+export type RandomSongListResponse = SongListResponse;
+
+export type LyricsQuery = {
+  songId: string;
+};
+
+export type LyricsArgs = {
+  query: LyricsQuery;
+} & BaseEndpointArgs;
+
+export type SynchronizedLyricsArray = Array<[number, string]>;
+
+export type LyricsResponse = SynchronizedLyricsArray | string;
+
+export type InternetProviderLyricResponse = {
+  artist: string;
+  id: string;
+  lyrics: string;
+  name: string;
+  source: LyricSource;
+};
+
+export type InternetProviderLyricSearchResponse = {
+  artist: string;
+  id: string;
+  name: string;
+  score?: number;
+  source: LyricSource;
+};
+
+export type SynchronizedLyricMetadata = {
+  lyrics: SynchronizedLyricsArray;
+  remote: boolean;
+} & Omit<InternetProviderLyricResponse, 'lyrics'>;
+
+export type UnsynchronizedLyricMetadata = {
+  lyrics: string;
+  remote: boolean;
+} & Omit<InternetProviderLyricResponse, 'lyrics'>;
+
+export type FullLyricsMetadata = SynchronizedLyricMetadata | UnsynchronizedLyricMetadata;
+
+export type LyricOverride = Omit<InternetProviderLyricResponse, 'lyrics'>;
+
+export const instanceOfCancellationError = (error: any) => {
+  return 'revert' in error;
+};
+
+export type LyricSearchQuery = {
+  album?: string;
+  artist?: string;
+  duration?: number;
+  name?: string;
+};
+
+export type LyricGetQuery = {
+  remoteSongId: string;
+  remoteSource: LyricSource;
+};
+
+export enum LyricSource {
+  GENIUS = 'Genius',
+  LRCLIB = 'lrclib.net',
+  NETEASE = 'NetEase',
+}
+
+export type LyricsOverride = Omit<FullLyricsMetadata, 'lyrics'> & { id: string };

src/renderer/api/utils.ts

@@ -0,0 +1,40 @@
+import { AxiosHeaders } from 'axios';
+import { z } from 'zod';
+import { toast } from '/@/renderer/components';
+import { useAuthStore } from '/@/renderer/store';
+import { ServerListItem } from '/@/renderer/types';
+
+// Since ts-rest client returns a strict response type, we need to add the headers to the body object
+export const resultWithHeaders = <ItemType extends z.ZodTypeAny>(itemSchema: ItemType) => {
+  return z.object({
+    data: itemSchema,
+    headers: z.instanceof(AxiosHeaders),
+  });
+};
+
+export const resultSubsonicBaseResponse = <ItemType extends z.ZodRawShape>(
+  itemSchema: ItemType,
+) => {
+  return z.object({
+    'subsonic-response': z
+      .object({
+        status: z.string(),
+        version: z.string(),
+      })
+      .extend(itemSchema),
+  });
+};
+
+export const authenticationFailure = (currentServer: ServerListItem | null) => {
+  toast.error({
+    message: 'Your session has expired.',
+  });
+
+  if (currentServer) {
+    const serverId = currentServer.id;
+    const token = currentServer.ndCredential;
+    console.log(`token is expired: ${token}`);
+    useAuthStore.getState().actions.updateServer(serverId, { ndCredential: undefined });
+    useAuthStore.getState().actions.setCurrentServer(null);
+  }
+};

src/renderer/app.tsx

@@ -4,47 +4,130 @@ import { ModuleRegistry } from '@ag-grid-community/core';
 import { InfiniteRowModelModule } from '@ag-grid-community/infinite-row-model';
 import { MantineProvider } from '@mantine/core';
 import { ModalsProvider } from '@mantine/modals';
-import { NotificationsProvider } from '@mantine/notifications';
 import { initSimpleImg } from 'react-simple-img';
 import { BaseContextModal } from './components';
 import { useTheme } from './hooks';
 import { AppRouter } from './router/app-router';
-import { useSettingsStore } from './store/settings.store';
+import { useHotkeySettings, usePlaybackSettings, useSettingsStore } from './store/settings.store';
 import './styles/global.scss';
 import '@ag-grid-community/styles/ag-grid.css';
 import { ContextMenuProvider } from '/@/renderer/features/context-menu';
 import { useHandlePlayQueueAdd } from '/@/renderer/features/player/hooks/use-handle-playqueue-add';
 import { PlayQueueHandlerContext } from '/@/renderer/features/player';
+import { AddToPlaylistContextModal } from '/@/renderer/features/playlists';
+import isElectron from 'is-electron';
+import { getMpvProperties } from '/@/renderer/features/settings/components/playback/mpv-settings';
+import { PlayerState, usePlayerStore, useQueueControls } from '/@/renderer/store';
+import { PlaybackType, PlayerStatus } from '/@/renderer/types';
 
 ModuleRegistry.registerModules([ClientSideRowModelModule, InfiniteRowModelModule]);
 
 initSimpleImg({ threshold: 0.05 }, true);
 
+const mpvPlayer = isElectron() ? window.electron.mpvPlayer : null;
+const mpvPlayerListener = isElectron() ? window.electron.mpvPlayerListener : null;
+const ipc = isElectron() ? window.electron.ipc : null;
+
 export const App = () => {
   const theme = useTheme();
   const contentFont = useSettingsStore((state) => state.general.fontContent);
-
+  const { type: playbackType } = usePlaybackSettings();
+  const { bindings } = useHotkeySettings();
   const handlePlayQueueAdd = useHandlePlayQueueAdd();
+  const { clearQueue, restoreQueue } = useQueueControls();
 
   useEffect(() => {
     const root = document.documentElement;
     root.style.setProperty('--content-font-family', contentFont);
   }, [contentFont]);
 
+  // Start the mpv instance on startup
+  useEffect(() => {
+    const initializeMpv = async () => {
+      const isRunning: boolean | undefined = await mpvPlayer?.isRunning();
+
+      if (!isRunning) {
+        const extraParameters = useSettingsStore.getState().playback.mpvExtraParameters;
+        const properties = {
+          ...getMpvProperties(useSettingsStore.getState().playback.mpvProperties),
+        };
+
+        mpvPlayer?.initialize({
+          extraParameters,
+          properties,
+        });
+
+        mpvPlayer?.volume(properties.volume);
+      }
+    };
+
+    if (isElectron() && playbackType === PlaybackType.LOCAL) {
+      initializeMpv();
+    }
+
+    return () => {
+      clearQueue();
+      mpvPlayer?.stop();
+      mpvPlayer?.cleanup();
+    };
+  }, [clearQueue, playbackType]);
+
+  useEffect(() => {
+    if (isElectron()) {
+      ipc?.send('set-global-shortcuts', bindings);
+    }
+  }, [bindings]);
+
+  useEffect(() => {
+    if (isElectron()) {
+      mpvPlayer.restoreQueue();
+
+      mpvPlayerListener.rendererSaveQueue(() => {
+        const { current, queue } = usePlayerStore.getState();
+        const stateToSave: Partial<Pick<PlayerState, 'current' | 'queue'>> = {
+          current: {
+            ...current,
+            status: PlayerStatus.PAUSED,
+          },
+          queue,
+        };
+        mpvPlayer.saveQueue(stateToSave);
+      });
+
+      mpvPlayerListener.rendererRestoreQueue((_event: any, data: Partial<PlayerState>) => {
+        const playerData = restoreQueue(data);
+        if (playbackType === PlaybackType.LOCAL) {
+          mpvPlayer.setQueue(playerData, true);
+        }
+      });
+    }
+
+    return () => {
+      ipc?.removeAllListeners('renderer-player-restore-queue');
+      ipc?.removeAllListeners('renderer-player-save-queue');
+    };
+  }, [playbackType, restoreQueue]);
+
   return (
     <MantineProvider
       withGlobalStyles
       withNormalizeCSS
       theme={{
-        breakpoints: {
-          lg: 1200,
-          md: 1000,
-          sm: 800,
-          xl: 1400,
-          xs: 500,
-        },
         colorScheme: theme as 'light' | 'dark',
-        components: { Modal: { styles: { body: { padding: '.5rem' } } } },
+        components: {
+          Modal: {
+            styles: {
+              body: { background: 'var(--modal-bg)', padding: '1rem !important' },
+              close: { marginRight: '0.5rem' },
+              content: { borderRadius: '5px' },
+              header: {
+                background: 'var(--modal-header-bg)',
+                paddingBottom: '1rem',
+              },
+              title: { fontSize: 'medium', fontWeight: 500 },
+            },
+          },
+        },
         defaultRadius: 'xs',
         dir: 'ltr',
         focusRing: 'auto',
@@ -60,53 +143,47 @@ export const App = () => {
         },
         fontFamily: 'var(--content-font-family)',
         fontSizes: {
-          lg: 16,
-          md: 14,
-          sm: 12,
-          xl: 18,
-          xs: 10,
+          lg: '1.1rem',
+          md: '1rem',
+          sm: '0.9rem',
+          xl: '1.5rem',
+          xs: '0.8rem',
+        },
+        headings: {
+          fontFamily: 'var(--content-font-family)',
+          fontWeight: 700,
         },
-        headings: { fontFamily: 'var(--content-font-family)' },
         other: {},
         spacing: {
-          lg: 12,
-          md: 8,
-          sm: 4,
-          xl: 16,
-          xs: 2,
+          lg: '2rem',
+          md: '1rem',
+          sm: '0.5rem',
+          xl: '4rem',
+          xs: '0rem',
         },
       }}
     >
-      <NotificationsProvider
-        autoClose={1500}
-        position="bottom-center"
-        style={{
-          marginBottom: '85px',
-          opacity: '.8',
-          userSelect: 'none',
-          width: '300px',
+      <ModalsProvider
+        modalProps={{
+          centered: true,
+          styles: {
+            body: { position: 'relative' },
+            content: { overflow: 'auto' },
+          },
+          transitionProps: {
+            duration: 300,
+            exitDuration: 300,
+            transition: 'fade',
+          },
         }}
-        transitionDuration={200}
+        modals={{ addToPlaylist: AddToPlaylistContextModal, base: BaseContextModal }}
       >
-        <ModalsProvider
-          modalProps={{
-            centered: true,
-            exitTransitionDuration: 300,
-            overflow: 'inside',
-            overlayBlur: 0,
-            overlayOpacity: 0.8,
-            transition: 'slide-down',
-            transitionDuration: 300,
-          }}
-          modals={{ base: BaseContextModal }}
-        >
-          <PlayQueueHandlerContext.Provider value={{ handlePlayQueueAdd }}>
-            <ContextMenuProvider>
-              <AppRouter />
-            </ContextMenuProvider>
-          </PlayQueueHandlerContext.Provider>
-        </ModalsProvider>
-      </NotificationsProvider>
+        <PlayQueueHandlerContext.Provider value={{ handlePlayQueueAdd }}>
+          <ContextMenuProvider>
+            <AppRouter />
+          </ContextMenuProvider>
+        </PlayQueueHandlerContext.Provider>
+      </ModalsProvider>
     </MantineProvider>
   );
 };

src/renderer/components/audio-player/index.tsx

@@ -52,7 +52,7 @@ export const AudioPlayer = forwardRef(
     const player1Ref = useRef<any>(null);
     const player2Ref = useRef<any>(null);
     const [isTransitioning, setIsTransitioning] = useState(false);
-    const audioDeviceId = useSettingsStore((state) => state.player.audioDeviceId);
+    const audioDeviceId = useSettingsStore((state) => state.playback.audioDeviceId);
 
     useImperativeHandle(ref, () => ({
       get player1() {

src/renderer/components/badge/index.tsx

@@ -5,12 +5,13 @@ import styled from 'styled-components';
 export type BadgeProps = MantineBadgeProps;
 
 const StyledBadge = styled(MantineBadge)<BadgeProps>`
+  border-radius: var(--badge-radius);
+
   .mantine-Badge-root {
     color: var(--badge-fg);
   }
 
   .mantine-Badge-inner {
-    padding: 0 0.5rem;
     color: var(--badge-fg);
   }
 `;

src/renderer/components/button/index.tsx

@@ -20,145 +20,37 @@ interface StyledButtonProps extends ButtonProps {
 }
 
 const StyledButton = styled(MantineButton)<StyledButtonProps>`
-  color: ${(props) => {
-    switch (props.variant) {
-      case 'default':
-        return 'var(--btn-default-fg)';
-      case 'filled':
-        return 'var(--btn-primary-fg)';
-      case 'subtle':
-        return 'var(--btn-subtle-fg)';
-      default:
-        return '';
-    }
-  }};
-  background: ${(props) => {
-    switch (props.variant) {
-      case 'default':
-        return 'var(--btn-default-bg)';
-      case 'filled':
-        return 'var(--btn-primary-bg)';
-      case 'subtle':
-        return 'var(--btn-subtle-bg)';
-      default:
-        return '';
-    }
-  }};
-  border: none;
-  transition: background 0.2s ease-in-out, color 0.2s ease-in-out;
+  color: ${(props) => `var(--btn-${props.variant}-fg)`};
+  background: ${(props) => `var(--btn-${props.variant}-bg)`};
+  border: ${(props) => `var(--btn-${props.variant}-border)`};
+  border-radius: ${(props) => `var(--btn-${props.variant}-radius)`};
+  transition: background 0.2s ease-in-out, color 0.2s ease-in-out, border 0.2s ease-in-out;
 
   svg {
     transition: fill 0.2s ease-in-out;
-    fill: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-fg)';
-        case 'filled':
-          return 'var(--btn-primary-fg)';
-        case 'subtle':
-          return 'var(--btn-subtle-fg)';
-        default:
-          return '';
-      }
-    }};
+    fill: ${(props) => `var(--btn-${props.variant}-fg)`};
   }
 
   &:disabled {
-    color: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-fg)';
-        case 'filled':
-          return 'var(--btn-primary-fg)';
-        case 'subtle':
-          return 'var(--btn-subtle-fg)';
-        default:
-          return '';
-      }
-    }};
-    background: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-bg)';
-        case 'filled':
-          return 'var(--btn-primary-bg)';
-        case 'subtle':
-          return 'var(--btn-subtle-bg)';
-        default:
-          return '';
-      }
-    }};
+    color: ${(props) => `var(--btn-${props.variant}-fg)`};
+    background: ${(props) => `var(--btn-${props.variant}-bg)`};
 
     opacity: 0.6;
   }
 
-  &:hover {
-    color: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-fg-hover)';
-        case 'filled':
-          return 'var(--btn-primary-fg-hover)';
-        case 'subtle':
-          return 'var(--btn-subtle-fg-hover)';
-        default:
-          return '';
-      }
-    }};
-    background: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-bg-hover)';
-        case 'filled':
-          return 'var(--btn-primary-bg-hover)';
-        case 'subtle':
-          return 'var(--btn-subtle-bg-hover)';
-        default:
-          return '';
-      }
-    }};
+  &:not([data-disabled])&:hover {
+    color: ${(props) => `var(--btn-${props.variant}-fg-hover) !important`};
+    background: ${(props) => `var(--btn-${props.variant}-bg-hover)`};
+    border: ${(props) => `var(--btn-${props.variant}-border-hover)`};
 
     svg {
-      fill: ${(props) => {
-        switch (props.variant) {
-          case 'default':
-            return 'var(--btn-default-fg-hover)';
-          case 'filled':
-            return 'var(--btn-primary-fg-hover)';
-          case 'subtle':
-            return 'var(--btn-subtle-fg-hover)';
-          default:
-            return '';
-        }
-      }};
+      fill: ${(props) => `var(--btn-${props.variant}-fg-hover)`};
     }
   }
 
-  &:focus-visible {
-    color: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-fg-hover)';
-        case 'filled':
-          return 'var(--btn-primary-fg-hover)';
-        case 'subtle':
-          return 'var(--btn-subtle-fg-hover)';
-        default:
-          return '';
-      }
-    }};
-    background: ${(props) => {
-      switch (props.variant) {
-        case 'default':
-          return 'var(--btn-default-bg-hover)';
-        case 'filled':
-          return 'var(--btn-primary-bg-hover)';
-        case 'subtle':
-          return 'var(--btn-subtle-bg-hover)';
-        default:
-          return '';
-      }
-    }};
+  &:not([data-disabled])&:focus-visible {
+    color: ${(props) => `var(--btn-${props.variant}-fg-hover)`};
+    background: ${(props) => `var(--btn-${props.variant}-bg-hover)`};
   }
 
   &:active {
@@ -171,7 +63,9 @@ const StyledButton = styled(MantineButton)<StyledButtonProps>`
 
   & .mantine-Button-leftIcon {
     display: flex;
+    height: 100%;
     margin-right: 0.5rem;
+    transform: translateY(-0.1rem);
   }
 
   .mantine-Button-rightIcon {

src/renderer/components/card/album-card.tsx

@@ -1,15 +1,14 @@
-import React, { useCallback } from 'react';
+import { useCallback } from 'react';
 import { Center } from '@mantine/core';
 import { RiAlbumFill } from 'react-icons/ri';
 import { generatePath, useNavigate } from 'react-router';
-import { Link } from 'react-router-dom';
 import { SimpleImg } from 'react-simple-img';
 import styled from 'styled-components';
-import { Text } from '/@/renderer/components/text';
-import type { LibraryItem, CardRow, CardRoute, Play, PlayQueueAddOptions } from '/@/renderer/types';
+import type { CardRow, CardRoute, Play, PlayQueueAddOptions } from '/@/renderer/types';
 import { Skeleton } from '/@/renderer/components/skeleton';
 import { CardControls } from '/@/renderer/components/card/card-controls';
-import { Album } from '/@/renderer/api/types';
+import { Album, AlbumArtist, Artist, LibraryItem } from '/@/renderer/api/types';
+import { CardRows } from '/@/renderer/components/card/card-rows';
 
 const CardWrapper = styled.div<{
   link?: boolean;
@@ -103,7 +102,7 @@ const Row = styled.div<{ $secondary?: boolean }>`
 
 interface BaseGridCardProps {
   controls: {
-    cardRows: CardRow<Album>[];
+    cardRows: CardRow<Album | Artist | AlbumArtist>[];
     itemType: LibraryItem;
     playButtonBehavior: Play;
     route: CardRoute;
@@ -179,104 +178,10 @@ export const AlbumCard = ({
             </ControlsContainer>
           </ImageSection>
           <DetailSection>
-            {cardRows.map((row: CardRow<Album>, index: number) => {
-              if (row.arrayProperty && row.route) {
-                return (
-                  <Row
-                    key={`row-${row.property}-${index}`}
-                    $secondary={index > 0}
-                  >
-                    {data[row.property].map((item: any, itemIndex: number) => (
-                      <React.Fragment key={`${data.id}-${item.id}`}>
-                        {itemIndex > 0 && (
-                          <Text
-                            $noSelect
-                            sx={{
-                              display: 'inline-block',
-                              padding: '0 2px 0 1px',
-                            }}
-                          >
-                            ,
-                          </Text>
-                        )}{' '}
-                        <Text
-                          $link
-                          $noSelect
-                          $secondary={index > 0}
-                          component={Link}
-                          overflow="hidden"
-                          size={index > 0 ? 'xs' : 'md'}
-                          to={generatePath(
-                            row.route!.route,
-                            row.route!.slugs?.reduce((acc, slug) => {
-                              return {
-                                ...acc,
-                                [slug.slugProperty]: data[slug.idProperty],
-                              };
-                            }, {}),
-                          )}
-                          onClick={(e) => e.stopPropagation()}
-                        >
-                          {row.arrayProperty && item[row.arrayProperty]}
-                        </Text>
-                      </React.Fragment>
-                    ))}
-                  </Row>
-                );
-              }
-
-              if (row.arrayProperty) {
-                return (
-                  <Row key={`row-${row.property}`}>
-                    {data[row.property].map((item: any) => (
-                      <Text
-                        key={`${data.id}-${item.id}`}
-                        $noSelect
-                        $secondary={index > 0}
-                        overflow="hidden"
-                        size={index > 0 ? 'xs' : 'md'}
-                      >
-                        {row.arrayProperty && item[row.arrayProperty]}
-                      </Text>
-                    ))}
-                  </Row>
-                );
-              }
-
-              return (
-                <Row key={`row-${row.property}`}>
-                  {row.route ? (
-                    <Text
-                      $link
-                      $noSelect
-                      component={Link}
-                      overflow="hidden"
-                      to={generatePath(
-                        row.route.route,
-                        row.route.slugs?.reduce((acc, slug) => {
-                          return {
-                            ...acc,
-                            [slug.slugProperty]: data[slug.idProperty],
-                          };
-                        }, {}),
-                      )}
-                      onClick={(e) => e.stopPropagation()}
-                    >
-                      {data && data[row.property]}
-                    </Text>
-                  ) : (
-                    <Text
-                      $noSelect
-                      $secondary={index > 0}
-                      overflow="hidden"
-                      size={index > 0 ? 'xs' : 'md'}
-                    >
-                      {data && data[row.property]}
-                    </Text>
-                  )}
-                </Row>
-              );
-            })}
+            <CardRows
+              data={data}
+              rows={cardRows}
+            />
           </DetailSection>
         </StyledCard>
       </CardWrapper>

src/renderer/components/card/card-controls.tsx

@@ -5,10 +5,15 @@ import { Group } from '@mantine/core';
 import { RiPlayFill, RiMore2Fill, RiHeartFill, RiHeartLine } from 'react-icons/ri';
 import styled from 'styled-components';
 import { _Button } from '/@/renderer/components/button';
-import { DropdownMenu } from '/@/renderer/components/dropdown-menu';
-import type { LibraryItem, PlayQueueAddOptions } from '/@/renderer/types';
+import type { PlayQueueAddOptions } from '/@/renderer/types';
 import { Play } from '/@/renderer/types';
-import { useSettingsStore } from '/@/renderer/store/settings.store';
+import { usePlayButtonBehavior } from '/@/renderer/store/settings.store';
+import { LibraryItem } from '/@/renderer/api/types';
+import { useHandleGeneralContextMenu } from '/@/renderer/features/context-menu/hooks/use-handle-context-menu';
+import {
+  ALBUM_CONTEXT_MENU_ITEMS,
+  ARTIST_CONTEXT_MENU_ITEMS,
+} from '/@/renderer/features/context-menu/context-menu-items';
 
 type PlayButtonType = UnstyledButtonProps & React.ComponentPropsWithoutRef<'button'>;
 
@@ -98,21 +103,6 @@ const FavoriteWrapper = styled.span<{ isFavorite: boolean }>`
   }
 `;
 
-const PLAY_TYPES = [
-  {
-    label: 'Play',
-    play: Play.NOW,
-  },
-  {
-    label: 'Add to queue (last)',
-    play: Play.LAST,
-  },
-  {
-    label: 'Add to queue (next)',
-    play: Play.NEXT,
-  },
-];
-
 export const CardControls = ({
   itemData,
   itemType,
@@ -122,7 +112,7 @@ export const CardControls = ({
   itemData: any;
   itemType: LibraryItem;
 }) => {
-  const playButtonBehavior = useSettingsStore((state) => state.player.playButtonBehavior);
+  const playButtonBehavior = usePlayButtonBehavior();
 
   const handlePlay = (e: MouseEvent<HTMLButtonElement>, playType?: Play) => {
     e.preventDefault();
@@ -132,10 +122,15 @@ export const CardControls = ({
         id: [itemData.id],
         type: itemType,
       },
-      play: playType || playButtonBehavior,
+      playType: playType || playButtonBehavior,
     });
   };
 
+  const handleContextMenu = useHandleGeneralContextMenu(
+    itemType,
+    itemType === LibraryItem.ALBUM ? ALBUM_CONTEXT_MENU_ITEMS : ARTIST_CONTEXT_MENU_ITEMS,
+  );
+
   return (
     <GridCardControlsContainer>
       <BottomControls>
@@ -160,39 +155,21 @@ export const CardControls = ({
               )}
             </FavoriteWrapper>
           </SecondaryButton>
-          <DropdownMenu
-            withinPortal
-            position="bottom-start"
+          <SecondaryButton
+            p={5}
+            sx={{ svg: { fill: 'white !important' } }}
+            variant="subtle"
+            onClick={(e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              handleContextMenu(e, [itemData]);
+            }}
           >
-            <DropdownMenu.Target>
-              <SecondaryButton
-                p={5}
-                sx={{ svg: { fill: 'white !important' } }}
-                variant="subtle"
-                onClick={(e) => {
-                  e.preventDefault();
-                  e.stopPropagation();
-                }}
-              >
-                <RiMore2Fill
-                  color="white"
-                  size={20}
-                />
-              </SecondaryButton>
-            </DropdownMenu.Target>
-            <DropdownMenu.Dropdown>
-              {PLAY_TYPES.filter((type) => type.play !== playButtonBehavior).map((type) => (
-                <DropdownMenu.Item
-                  key={`playtype-${type.play}`}
-                  onClick={(e: MouseEvent<HTMLButtonElement>) => handlePlay(e, type.play)}
-                >
-                  {type.label}
-                </DropdownMenu.Item>
-              ))}
-              <DropdownMenu.Item disabled>Add to playlist</DropdownMenu.Item>
-              <DropdownMenu.Item disabled>Refresh metadata</DropdownMenu.Item>
-            </DropdownMenu.Dropdown>
-          </DropdownMenu>
+            <RiMore2Fill
+              color="white"
+              size={20}
+            />
+          </SecondaryButton>
         </Group>
       </BottomControls>
     </GridCardControlsContainer>

src/renderer/components/card/card-rows.tsx

@@ -21,7 +21,7 @@ const Row = styled.div<{ $secondary?: boolean }>`
 
 interface CardRowsProps {
   data: any;
-  rows: CardRow<Album | Artist | AlbumArtist>[];
+  rows: CardRow<Album>[] | CardRow<Artist>[] | CardRow<AlbumArtist>[];
 }
 
 export const CardRows = ({ data, rows }: CardRowsProps) => {
@@ -39,6 +39,7 @@ export const CardRows = ({ data, rows }: CardRowsProps) => {
                   {itemIndex > 0 && (
                     <Text
                       $noSelect
+                      $secondary
                       sx={{
                         display: 'inline-block',
                         padding: '0 2px 0 1px',
@@ -59,7 +60,7 @@ export const CardRows = ({ data, rows }: CardRowsProps) => {
                       row.route!.slugs?.reduce((acc, slug) => {
                         return {
                           ...acc,
-                          [slug.slugProperty]: data[slug.idProperty],
+                          [slug.slugProperty]: data[row.property][itemIndex][slug.idProperty],
                         };
                       }, {}),
                     )}
@@ -134,7 +135,7 @@ export const ALBUM_CARD_ROWS: { [key: string]: CardRow<Album> } = {
     arrayProperty: 'name',
     property: 'albumArtists',
     route: {
-      route: AppRoute.LIBRARY_ALBUMARTISTS_DETAIL,
+      route: AppRoute.LIBRARY_ALBUM_ARTISTS_DETAIL,
       slugs: [{ idProperty: 'id', slugProperty: 'albumArtistId' }],
     },
   },
@@ -142,7 +143,7 @@ export const ALBUM_CARD_ROWS: { [key: string]: CardRow<Album> } = {
     arrayProperty: 'name',
     property: 'artists',
     route: {
-      route: AppRoute.LIBRARY_ALBUMARTISTS_DETAIL,
+      route: AppRoute.LIBRARY_ALBUM_ARTISTS_DETAIL,
       slugs: [{ idProperty: 'id', slugProperty: 'albumArtistId' }],
     },
   },
@@ -166,7 +167,7 @@ export const ALBUM_CARD_ROWS: { [key: string]: CardRow<Album> } = {
     property: 'playCount',
   },
   rating: {
-    property: 'rating',
+    property: 'userRating',
   },
   releaseDate: {
     property: 'releaseDate',
@@ -195,7 +196,7 @@ export const ALBUMARTIST_CARD_ROWS: { [key: string]: CardRow<AlbumArtist> } = {
   name: {
     property: 'name',
     route: {
-      route: AppRoute.LIBRARY_ALBUMARTISTS_DETAIL,
+      route: AppRoute.LIBRARY_ALBUM_ARTISTS_DETAIL,
       slugs: [{ idProperty: 'id', slugProperty: 'albumArtistId' }],
     },
   },
@@ -203,7 +204,7 @@ export const ALBUMARTIST_CARD_ROWS: { [key: string]: CardRow<AlbumArtist> } = {
     property: 'playCount',
   },
   rating: {
-    property: 'rating',
+    property: 'userRating',
   },
   songCount: {
     property: 'songCount',

src/renderer/components/card/poster-card.tsx

@@ -0,0 +1,206 @@
+import { Center, Stack } from '@mantine/core';
+import { RiAlbumFill, RiPlayListFill, RiUserVoiceFill } from 'react-icons/ri';
+import { generatePath, Link } from 'react-router-dom';
+import { SimpleImg } from 'react-simple-img';
+import styled, { css } from 'styled-components';
+import { Album, AlbumArtist, Artist, LibraryItem } from '/@/renderer/api/types';
+import { CardRows } from '/@/renderer/components/card';
+import { Skeleton } from '/@/renderer/components/skeleton';
+import { GridCardControls } from '/@/renderer/components/virtual-grid/grid-card/grid-card-controls';
+import { CardRow, PlayQueueAddOptions, Play, CardRoute } from '/@/renderer/types';
+
+interface BaseGridCardProps {
+  controls: {
+    cardRows: CardRow<Album>[] | CardRow<Artist>[] | CardRow<AlbumArtist>[];
+    handleFavorite: (options: {
+      id: string[];
+      isFavorite: boolean;
+      itemType: LibraryItem;
+      serverId: string;
+    }) => void;
+    handlePlayQueueAdd: ((options: PlayQueueAddOptions) => void) | undefined;
+    itemType: LibraryItem;
+    playButtonBehavior: Play;
+    route: CardRoute;
+  };
+  data: any;
+  isLoading?: boolean;
+}
+
+const PosterCardContainer = styled.div<{ $isHidden?: boolean }>`
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  opacity: ${({ $isHidden }) => ($isHidden ? 0 : 1)};
+  pointer-events: auto;
+
+  .card-controls {
+    opacity: 0;
+  }
+`;
+
+const ImageContainerStyles = css`
+  position: relative;
+  display: flex;
+  align-items: center;
+  aspect-ratio: 1/1;
+  overflow: hidden;
+  background: var(--card-default-bg);
+  border-radius: var(--card-poster-radius);
+
+  &::before {
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 1;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(0deg, rgba(0, 0, 0, 100%) 35%, rgba(0, 0, 0, 0%) 100%);
+    opacity: 0;
+    transition: all 0.2s ease-in-out;
+    content: '';
+    user-select: none;
+  }
+
+  &:hover {
+    &::before {
+      opacity: 0.5;
+    }
+  }
+
+  &:hover .card-controls {
+    opacity: 1;
+  }
+`;
+
+const ImageContainer = styled(Link)<{ $isFavorite?: boolean }>`
+  ${ImageContainerStyles}
+`;
+
+const ImageContainerSkeleton = styled.div`
+  ${ImageContainerStyles}
+`;
+
+const Image = styled(SimpleImg)`
+  width: 100%;
+  max-width: 100%;
+  height: 100% !important;
+  max-height: 100%;
+  border: 0;
+
+  img {
+    height: 100%;
+    object-fit: cover;
+  }
+`;
+
+const DetailContainer = styled.div`
+  margin-top: 0.5rem;
+`;
+
+export const PosterCard = ({
+  data,
+  controls,
+  isLoading,
+  uniqueId,
+}: BaseGridCardProps & { uniqueId: string }) => {
+  if (!isLoading) {
+    const path = generatePath(
+      controls.route.route,
+      controls.route.slugs?.reduce((acc, slug) => {
+        return {
+          ...acc,
+          [slug.slugProperty]: data[slug.idProperty],
+        };
+      }, {}),
+    );
+
+    let Placeholder = RiAlbumFill;
+
+    switch (controls.itemType) {
+      case LibraryItem.ALBUM:
+        Placeholder = RiAlbumFill;
+        break;
+      case LibraryItem.ARTIST:
+        Placeholder = RiUserVoiceFill;
+        break;
+      case LibraryItem.ALBUM_ARTIST:
+        Placeholder = RiUserVoiceFill;
+        break;
+      case LibraryItem.PLAYLIST:
+        Placeholder = RiPlayListFill;
+        break;
+      default:
+        Placeholder = RiAlbumFill;
+        break;
+    }
+
+    return (
+      <PosterCardContainer key={`${uniqueId}-${data.id}`}>
+        <ImageContainer
+          $isFavorite={data?.userFavorite}
+          to={path}
+        >
+          {data?.imageUrl ? (
+            <Image
+              importance="auto"
+              placeholder={data?.imagePlaceholderUrl || 'var(--card-default-bg)'}
+              src={data?.imageUrl}
+            />
+          ) : (
+            <Center
+              sx={{
+                background: 'var(--placeholder-bg)',
+                borderRadius: 'var(--card-default-radius)',
+                height: '100%',
+                width: '100%',
+              }}
+            >
+              <Placeholder
+                color="var(--placeholder-fg)"
+                size={35}
+              />
+            </Center>
+          )}
+          <GridCardControls
+            handleFavorite={controls.handleFavorite}
+            handlePlayQueueAdd={controls.handlePlayQueueAdd}
+            itemData={data}
+            itemType={controls.itemType}
+          />
+        </ImageContainer>
+        <DetailContainer>
+          <CardRows
+            data={data}
+            rows={controls.cardRows}
+          />
+        </DetailContainer>
+      </PosterCardContainer>
+    );
+  }
+
+  return (
+    <PosterCardContainer key={`placeholder-${uniqueId}-${data.id}`}>
+      <Skeleton
+        visible
+        radius="sm"
+      >
+        <ImageContainerSkeleton />
+      </Skeleton>
+      <DetailContainer>
+        <Stack spacing="sm">
+          {controls.cardRows.map((row, index) => (
+            <Skeleton
+              key={`${index}-${row.arrayProperty}`}
+              visible
+              height={14}
+              radius="sm"
+            />
+          ))}
+        </Stack>
+      </DetailContainer>
+    </PosterCardContainer>
+  );
+};

src/renderer/components/checkbox/index.tsx

@@ -0,0 +1,32 @@
+import { forwardRef } from 'react';
+import { Checkbox as MantineCheckbox, CheckboxProps } from '@mantine/core';
+import styled from 'styled-components';
+
+const StyledCheckbox = styled(MantineCheckbox)`
+  & .mantine-Checkbox-input {
+    background-color: var(--input-bg);
+
+    &:checked {
+      background-color: var(--primary-color);
+      border-color: var(--primary-color);
+    }
+
+    &:hover:not(:checked) {
+      background-color: var(--primary-color);
+      opacity: 0.5;
+    }
+
+    transition: none;
+  }
+`;
+
+export const Checkbox = forwardRef<HTMLInputElement, CheckboxProps>(
+  ({ ...props }: CheckboxProps, ref) => {
+    return (
+      <StyledCheckbox
+        ref={ref}
+        {...props}
+      />
+    );
+  },
+);

src/renderer/components/context-menu/index.tsx

@@ -1,8 +1,7 @@
 import { forwardRef, ReactNode, Ref } from 'react';
-import { Portal } from '@mantine/core';
-import { motion } from 'framer-motion';
+import { Box, Group, UnstyledButton, UnstyledButtonProps } from '@mantine/core';
+import { motion, Variants } from 'framer-motion';
 import styled from 'styled-components';
-import { _Button } from '/@/renderer/components/button';
 
 interface ContextMenuProps {
   children: ReactNode;
@@ -19,40 +18,110 @@ const ContextMenuContainer = styled(motion.div)<Omit<ContextMenuProps, 'children
   z-index: 1000;
   min-width: ${({ minWidth }) => minWidth}px;
   max-width: ${({ maxWidth }) => maxWidth}px;
-  padding: 0.5rem;
   background: var(--dropdown-menu-bg);
-  border-radius: 5px;
+  border-radius: var(--dropdown-menu-border-radius);
   box-shadow: 2px 2px 10px 2px rgba(0, 0, 0, 40%);
+
+  button:first-child {
+    border-top-left-radius: var(--dropdown-menu-border-radius);
+    border-top-right-radius: var(--dropdown-menu-border-radius);
+  }
+
+  button:last-child {
+    border-bottom-right-radius: var(--dropdown-menu-border-radius);
+    border-bottom-left-radius: var(--dropdown-menu-border-radius);
+  }
 `;
 
-export const ContextMenuButton = styled(_Button)`
-  padding: 0.5rem;
+export const StyledContextMenuButton = styled(UnstyledButton)`
+  padding: var(--dropdown-menu-item-padding);
+  color: var(--dropdown-menu-fg);
+  font-weight: 500;
+  font-family: var(--content-font-family);
+  text-align: left;
   background: var(--dropdown-menu-bg);
+  border: none;
   cursor: default;
 
   & .mantine-Button-inner {
     justify-content: flex-start;
   }
 
+  &:hover {
+    background: var(--dropdown-menu-bg-hover);
+  }
+
   &:disabled {
     background: transparent;
+    opacity: 0.6;
   }
 `;
 
+export const ContextMenuButton = forwardRef(
+  (
+    {
+      children,
+      rightIcon,
+      leftIcon,
+      ...props
+    }: UnstyledButtonProps &
+      React.ComponentPropsWithoutRef<'button'> & {
+        leftIcon?: ReactNode;
+        rightIcon?: ReactNode;
+      },
+    ref: any,
+  ) => {
+    return (
+      <StyledContextMenuButton
+        {...props}
+        key={props.key}
+        ref={ref}
+        as="button"
+        disabled={props.disabled}
+        onClick={props.onClick}
+      >
+        <Group position="apart">
+          <Group spacing="md">
+            <Box>{leftIcon}</Box>
+            <Box mr="2rem">{children}</Box>
+          </Group>
+          <Box>{rightIcon}</Box>
+        </Group>
+      </StyledContextMenuButton>
+    );
+  },
+);
+
+const variants: Variants = {
+  closed: {
+    opacity: 0,
+    transition: {
+      duration: 0.1,
+    },
+  },
+  open: {
+    opacity: 1,
+    transition: {
+      duration: 0.1,
+    },
+  },
+};
+
 export const ContextMenu = forwardRef(
   ({ yPos, xPos, minWidth, maxWidth, children }: ContextMenuProps, ref: Ref<HTMLDivElement>) => {
     return (
-      <Portal>
-        <ContextMenuContainer
-          ref={ref}
-          maxWidth={maxWidth}
-          minWidth={minWidth}
-          xPos={xPos}
-          yPos={yPos}
-        >
-          {children}
-        </ContextMenuContainer>
-      </Portal>
+      <ContextMenuContainer
+        ref={ref}
+        animate="open"
+        initial="closed"
+        maxWidth={maxWidth}
+        minWidth={minWidth}
+        variants={variants}
+        xPos={xPos}
+        yPos={yPos}
+      >
+        {children}
+      </ContextMenuContainer>
     );
   },
 );

src/renderer/components/date-picker/index.tsx

@@ -37,7 +37,6 @@ const StyledDatePicker = styled(MantineDatePicker)<DatePickerProps>`
 export const DatePicker = ({ width, maxWidth, ...props }: DatePickerProps) => {
   return (
     <StyledDatePicker
-      withinPortal
       {...props}
       sx={{ maxWidth, width }}
     />

src/renderer/components/dropdown-menu/index.tsx

@@ -12,6 +12,7 @@ import styled from 'styled-components';
 type MenuProps = MantineMenuProps;
 type MenuLabelProps = MantineMenuLabelProps;
 interface MenuItemProps extends MantineMenuItemProps {
+  $danger?: boolean;
   $isActive?: boolean;
   children: React.ReactNode;
 }
@@ -21,17 +22,15 @@ type MenuDropdownProps = MantineMenuDropdownProps;
 const StyledMenu = styled(MantineMenu)<MenuProps>``;
 
 const StyledMenuLabel = styled(MantineMenu.Label)<MenuLabelProps>`
+  padding: 0.5rem;
   font-family: var(--content-font-family);
 `;
 
 const StyledMenuItem = styled(MantineMenu.Item)<MenuItemProps>`
-  padding: 0.8rem;
-  font-size: 0.9em;
+  position: relative;
+  padding: var(--dropdown-menu-item-padding);
+  font-size: var(--dropdown-menu-item-font-size);
   font-family: var(--content-font-family);
-  background-color: ${({ $isActive }) => {
-    if (!$isActive) return undefined;
-    return 'var(--dropdown-menu-bg-hover)';
-  }};
 
   &:disabled {
     opacity: 0.6;
@@ -41,44 +40,52 @@ const StyledMenuItem = styled(MantineMenu.Item)<MenuItemProps>`
     background-color: var(--dropdown-menu-bg-hover);
   }
 
-  & .mantine-Menu-itemIcon {
-    margin-right: 0.5rem;
-  }
-
   & .mantine-Menu-itemLabel {
-    color: var(--dropdown-menu-fg);
-    font-weight: 500;
-    font-size: 1em;
+    margin-right: 2rem;
+    margin-left: 1rem;
+    color: ${(props) => (props.$danger ? 'var(--danger-color)' : 'var(--dropdown-menu-fg)')};
   }
 
   & .mantine-Menu-itemRightSection {
     display: flex;
-    margin-left: 2rem !important;
   }
+
+  cursor: default;
 `;
 
 const StyledMenuDropdown = styled(MantineMenu.Dropdown)`
+  margin: 0;
+  padding: 0;
   background: var(--dropdown-menu-bg);
   border: var(--dropdown-menu-border);
   border-radius: var(--dropdown-menu-border-radius);
   filter: drop-shadow(0 0 5px rgb(0, 0, 0, 50%));
+
+  /* *:first-child {
+    border-top-left-radius: var(--dropdown-menu-border-radius);
+    border-top-right-radius: var(--dropdown-menu-border-radius);
+  }
+
+  *:last-child {
+    border-bottom-right-radius: var(--dropdown-menu-border-radius);
+    border-bottom-left-radius: var(--dropdown-menu-border-radius);
+  } */
 `;
 
 const StyledMenuDivider = styled(MantineMenu.Divider)`
-  margin: 0.3rem 0;
+  margin: 0;
+  padding: 0;
 `;
 
 export const DropdownMenu = ({ children, ...props }: MenuProps) => {
   return (
     <StyledMenu
       withinPortal
-      radius="sm"
       styles={{
         dropdown: {
           filter: 'drop-shadow(0 0 5px rgb(0, 0, 0, 50%))',
         },
       }}
-      transition="scale-y"
       {...props}
     >
       {children}
@@ -90,11 +97,12 @@ const MenuLabel = ({ children, ...props }: MenuLabelProps) => {
   return <StyledMenuLabel {...props}>{children}</StyledMenuLabel>;
 };
 
-const pMenuItem = ({ $isActive, children, ...props }: MenuItemProps) => {
+const pMenuItem = ({ $isActive, $danger, children, ...props }: MenuItemProps) => {
   return (
     <StyledMenuItem
+      $danger={$danger}
       $isActive={$isActive}
-      rightSection={$isActive && <RiArrowLeftSFill size={20} />}
+      rightSection={$isActive && <RiArrowLeftSFill size={15} />}
       {...props}
     >
       {children}

src/renderer/components/dropzone/index.tsx

@@ -1,33 +0,0 @@
-import type { DropzoneProps as MantineDropzoneProps } from '@mantine/dropzone';
-import { Dropzone as MantineDropzone } from '@mantine/dropzone';
-import styled from 'styled-components';
-
-export type DropzoneProps = MantineDropzoneProps;
-
-const StyledDropzone = styled(MantineDropzone)`
-  display: flex;
-  justify-content: center;
-  width: 100%;
-  height: 100%;
-  background: var(--input-bg);
-  border-radius: 5px;
-  opacity: 0.8;
-  transition: opacity 0.2s ease;
-
-  &:hover {
-    background: var(--input-bg);
-    opacity: 1;
-  }
-
-  & .mantine-Dropzone-inner {
-    display: flex;
-  }
-`;
-
-export const Dropzone = ({ children, ...props }: DropzoneProps) => {
-  return <StyledDropzone {...props}>{children}</StyledDropzone>;
-};
-
-Dropzone.Accept = StyledDropzone.Accept;
-Dropzone.Idle = StyledDropzone.Idle;
-Dropzone.Reject = StyledDropzone.Reject;

src/renderer/components/feature-carousel/index.tsx

@@ -6,20 +6,22 @@ import { AnimatePresence, motion } from 'framer-motion';
 import { RiArrowLeftSLine, RiArrowRightSLine } from 'react-icons/ri';
 import { Link, generatePath } from 'react-router-dom';
 import styled from 'styled-components';
-import type { Album } from '/@/renderer/api/types';
+import { Album, LibraryItem } from '/@/renderer/api/types';
 import { Button } from '/@/renderer/components/button';
 import { TextTitle } from '/@/renderer/components/text-title';
 import { Badge } from '/@/renderer/components/badge';
 import { AppRoute } from '/@/renderer/router/routes';
+import { usePlayQueueAdd } from '/@/renderer/features/player/hooks/use-playqueue-add';
+import { Play } from '/@/renderer/types';
 
 const Carousel = styled(motion.div)`
   position: relative;
-  height: 30vh;
+  height: 35vh;
   min-height: 250px;
-
   padding: 2rem;
   overflow: hidden;
   background: linear-gradient(180deg, var(--main-bg), rgba(25, 26, 28, 60%));
+  border-radius: 1rem;
 `;
 
 const Grid = styled.div`
@@ -27,8 +29,7 @@ const Grid = styled.div`
   grid-auto-columns: 1fr;
   grid-template-areas: 'image info';
   grid-template-rows: 1fr;
-  grid-template-columns: 225px 1fr;
-  gap: 0.5rem;
+  grid-template-columns: 200px minmax(0, 1fr);
   width: 100%;
   max-width: 100%;
   height: 100%;
@@ -47,6 +48,7 @@ const InfoColumn = styled.div`
   grid-area: info;
   align-items: flex-end;
   width: 100%;
+  max-width: 100%;
   padding-left: 1rem;
 `;
 
@@ -107,6 +109,7 @@ interface FeatureCarouselProps {
 }
 
 export const FeatureCarousel = ({ data }: FeatureCarouselProps) => {
+  const handlePlayQueueAdd = usePlayQueueAdd();
   const [itemIndex, setItemIndex] = useState(0);
   const [direction, setDirection] = useState(0);
 
@@ -115,12 +118,22 @@ export const FeatureCarousel = ({ data }: FeatureCarouselProps) => {
   const handleNext = (e: MouseEvent<HTMLButtonElement>) => {
     e.preventDefault();
     setDirection(1);
+    if (itemIndex === (data?.length || 0) - 1 || 0) {
+      setItemIndex(0);
+      return;
+    }
+
     setItemIndex((prev) => prev + 1);
   };
 
   const handlePrevious = (e: MouseEvent<HTMLButtonElement>) => {
     e.preventDefault();
     setDirection(-1);
+    if (itemIndex === 0) {
+      setItemIndex((data?.length || 0) - 1);
+      return;
+    }
+
     setItemIndex((prev) => prev - 1);
   };
 
@@ -145,34 +158,90 @@ export const FeatureCarousel = ({ data }: FeatureCarouselProps) => {
                 <Image
                   height={225}
                   placeholder="var(--card-default-bg)"
-                  radius="sm"
+                  radius="md"
                   src={data[itemIndex]?.imageUrl}
                   sx={{ objectFit: 'cover' }}
                   width={225}
                 />
               </ImageColumn>
               <InfoColumn>
-                <Stack sx={{ width: '100%' }}>
+                <Stack
+                  spacing="md"
+                  sx={{ width: '100%' }}
+                >
                   <TitleWrapper>
-                    <TextTitle fw="bold">{currentItem?.name}</TextTitle>
+                    <TextTitle
+                      lh="3.5rem"
+                      order={1}
+                      overflow="hidden"
+                      sx={{ fontSize: '3.5rem' }}
+                      weight={900}
+                    >
+                      {currentItem?.name}
+                    </TextTitle>
                   </TitleWrapper>
                   <TitleWrapper>
-                    {currentItem?.albumArtists.map((artist) => (
+                    {currentItem?.albumArtists.slice(0, 1).map((artist) => (
                       <TextTitle
                         key={`carousel-artist-${artist.id}`}
-                        fw="600"
-                        order={3}
+                        order={2}
+                        weight={600}
                       >
                         {artist.name}
                       </TextTitle>
                     ))}
                   </TitleWrapper>
                   <Group>
-                    {currentItem?.genres?.map((genre) => (
-                      <Badge key={`carousel-genre-${genre.id}`}>{genre.name}</Badge>
+                    {currentItem?.genres?.slice(0, 1).map((genre) => (
+                      <Badge
+                        key={`carousel-genre-${genre.id}`}
+                        size="lg"
+                      >
+                        {genre.name}
+                      </Badge>
                     ))}
-                    <Badge>{currentItem?.releaseYear}</Badge>
-                    <Badge>{currentItem?.songCount} tracks</Badge>
+                    <Badge size="lg">{currentItem?.releaseYear}</Badge>
+                    <Badge size="lg">{currentItem?.songCount} tracks</Badge>
+                  </Group>
+                  <Group position="apart">
+                    <Button
+                      size="lg"
+                      style={{ borderRadius: '5rem' }}
+                      variant="outline"
+                      onClick={(e) => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        if (!currentItem) return;
+
+                        handlePlayQueueAdd?.({
+                          byItemType: {
+                            id: [currentItem.id],
+                            type: LibraryItem.ALBUM,
+                          },
+                          playType: Play.NOW,
+                        });
+                      }}
+                    >
+                      Play
+                    </Button>
+                    <Group spacing="sm">
+                      <Button
+                        radius="lg"
+                        size="sm"
+                        variant="outline"
+                        onClick={handlePrevious}
+                      >
+                        <RiArrowLeftSLine size="2rem" />
+                      </Button>
+                      <Button
+                        radius="lg"
+                        size="sm"
+                        variant="outline"
+                        onClick={handleNext}
+                      >
+                        <RiArrowRightSLine size="2rem" />
+                      </Button>
+                    </Group>
                   </Group>
                 </Stack>
               </InfoColumn>
@@ -185,29 +254,6 @@ export const FeatureCarousel = ({ data }: FeatureCarouselProps) => {
           </Carousel>
         )}
       </AnimatePresence>
-      <Group
-        spacing="xs"
-        sx={{ bottom: 0, position: 'absolute', right: 0, zIndex: 20 }}
-      >
-        <Button
-          disabled={itemIndex === 0}
-          px="lg"
-          radius={100}
-          variant="subtle"
-          onClick={handlePrevious}
-        >
-          <RiArrowLeftSLine size={15} />
-        </Button>
-        <Button
-          disabled={itemIndex === (data?.length || 1) - 1}
-          px="lg"
-          radius={100}
-          variant="subtle"
-          onClick={handleNext}
-        >
-          <RiArrowRightSLine size={15} />
-        </Button>
-      </Group>
     </Wrapper>
   );
 };

src/renderer/components/grid-carousel/index.tsx

@@ -1,215 +1,278 @@
-import { createContext, useContext, useState, useCallback, useMemo } from 'react';
+import { isValidElement, ReactNode, useCallback, useMemo, useRef, useState } from 'react';
 import { Group, Stack } from '@mantine/core';
-import type { Variants } from 'framer-motion';
-import { AnimatePresence, motion } from 'framer-motion';
+import throttle from 'lodash/throttle';
 import { RiArrowLeftSLine, RiArrowRightSLine } from 'react-icons/ri';
-import { Button } from '/@/renderer/components/button';
-import { AppRoute } from '/@/renderer/router/routes';
-import type { CardRow } from '/@/renderer/types';
-import { LibraryItem, Play } from '/@/renderer/types';
 import styled from 'styled-components';
-import { AlbumCard } from '/@/renderer/components/card';
-import { usePlayQueueAdd } from '/@/renderer/features/player/hooks/use-playqueue-add';
+import { SwiperOptions, Virtual } from 'swiper';
+import 'swiper/css';
+import { Swiper, SwiperSlide } from 'swiper/react';
+import { Swiper as SwiperCore } from 'swiper/types';
+import { Album, AlbumArtist, Artist, LibraryItem, RelatedArtist } from '/@/renderer/api/types';
+import { Button } from '/@/renderer/components/button';
+import { PosterCard } from '/@/renderer/components/card/poster-card';
+import { TextTitle } from '/@/renderer/components/text-title';
+import { usePlayQueueAdd } from '/@/renderer/features/player';
+import { useCreateFavorite, useDeleteFavorite } from '/@/renderer/features/shared';
+import { usePlayButtonBehavior } from '/@/renderer/store';
+import { CardRoute, CardRow } from '/@/renderer/types';
 
-interface GridCarouselProps {
-  cardRows: CardRow<any>[];
-  children: React.ReactElement;
-  containerWidth: number;
-  data: any[] | undefined;
-  loading?: boolean;
-  pagination?: {
-    handleNextPage?: () => void;
-    handlePreviousPage?: () => void;
-    hasNextPage?: boolean;
-    hasPreviousPage?: boolean;
-    itemsPerPage?: number;
-  };
-  uniqueId: string;
-}
+const getSlidesPerView = (windowWidth: number) => {
+  if (windowWidth < 400) return 2;
+  if (windowWidth < 700) return 3;
+  if (windowWidth < 900) return 4;
+  if (windowWidth < 1100) return 5;
+  if (windowWidth < 1300) return 6;
+  if (windowWidth < 1500) return 7;
+  if (windowWidth < 1920) return 8;
+  return 10;
+};
 
-const GridCarouselContext = createContext<any>({});
-
-const GridContainer = styled(motion.div)<{ height: number; itemsPerPage: number }>`
-  display: grid;
-  grid-auto-rows: 0;
-  grid-gap: 18px;
-  grid-template-rows: 1fr;
-  grid-template-columns: repeat(${(props) => props.itemsPerPage || 4}, minmax(0, 1fr));
-  height: ${(props) => props.height}px;
-  overflow: hidden;
+const CarouselContainer = styled(Stack)`
+  container-type: inline-size;
 `;
 
-const Wrapper = styled.div`
-  position: relative;
-  width: 100%;
-  height: 100%;
-  overflow: hidden;
-`;
-
-const variants: Variants = {
-  animate: (custom: { direction: number; loading: boolean }) => {
-    return {
-      opacity: custom.loading ? 0.5 : 1,
-      scale: custom.loading ? 0.95 : 1,
-      transition: {
-        opacity: { duration: 0.2 },
-        x: { damping: 30, stiffness: 300, type: 'spring' },
-      },
-      x: 0,
-    };
-  },
-  exit: (custom: { direction: number; loading: boolean }) => {
-    return {
-      opacity: 0,
-      transition: {
-        opacity: { duration: 0.2 },
-        x: { damping: 30, stiffness: 300, type: 'spring' },
-      },
-      x: custom.direction > 0 ? -1000 : 1000,
-    };
-  },
-  initial: (custom: { direction: number; loading: boolean }) => {
-    return {
-      opacity: 0,
-      x: custom.direction > 0 ? 1000 : -1000,
-    };
-  },
-};
-
-const Carousel = ({ data, cardRows }: any) => {
-  const { loading, pagination, gridHeight, imageSize, direction, uniqueId } =
-    useContext(GridCarouselContext);
-
-  const handlePlayQueueAdd = usePlayQueueAdd();
-
-  return (
-    <Wrapper>
-      <AnimatePresence
-        custom={{ direction, loading }}
-        initial={false}
-        mode="popLayout"
-      >
-        <GridContainer
-          key={`carousel-${uniqueId}-${data[0]?.id}`}
-          animate="animate"
-          custom={{ direction, loading }}
-          exit="exit"
-          height={gridHeight}
-          initial="initial"
-          itemsPerPage={pagination.itemsPerPage}
-          variants={variants}
-        >
-          {data?.map((item: any, index: number) => (
-            <AlbumCard
-              key={`card-${uniqueId}-${index}`}
-              controls={{
-                cardRows,
-                itemType: LibraryItem.ALBUM,
-                playButtonBehavior: Play.NOW,
-                route: {
-                  route: AppRoute.LIBRARY_ALBUMS_DETAIL,
-                  slugs: [{ idProperty: 'id', slugProperty: 'albumId' }],
-                },
-              }}
-              data={item}
-              handlePlayQueueAdd={handlePlayQueueAdd}
-              size={imageSize}
-            />
-          ))}
-        </GridContainer>
-      </AnimatePresence>
-    </Wrapper>
-  );
-};
-
-export const GridCarousel = ({
-  data,
-  loading,
-  cardRows,
-  pagination,
-  children,
-  containerWidth,
-  uniqueId,
-}: GridCarouselProps) => {
-  const [direction, setDirection] = useState(0);
-
-  const gridHeight = useMemo(
-    () => (containerWidth * 1.2 - 36) / (pagination?.itemsPerPage || 4),
-    [containerWidth, pagination?.itemsPerPage],
-  );
-
-  const imageSize = useMemo(() => gridHeight * 0.66, [gridHeight]);
-
-  const providerValue = useMemo(
-    () => ({
-      cardRows,
-      data,
-      direction,
-      gridHeight,
-      imageSize,
-      loading,
-      pagination,
-      setDirection,
-      uniqueId,
-    }),
-    [cardRows, data, direction, gridHeight, imageSize, loading, pagination, uniqueId],
-  );
-
-  return (
-    <GridCarouselContext.Provider value={providerValue}>
-      <Stack>
-        {children}
-        {data && (
-          <Carousel
-            cardRows={cardRows}
-            data={data}
-          />
-        )}
-      </Stack>
-    </GridCarouselContext.Provider>
-  );
-};
-
 interface TitleProps {
-  children?: React.ReactNode;
+  handleNext?: () => void;
+  handlePrev?: () => void;
+  label?: string | ReactNode;
+  pagination: {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+  };
 }
 
-const Title = ({ children }: TitleProps) => {
-  const { pagination, setDirection } = useContext(GridCarouselContext);
-
-  const handleNextPage = useCallback(() => {
-    setDirection(1);
-    pagination?.handleNextPage?.();
-  }, [pagination, setDirection]);
-
-  const handlePreviousPage = useCallback(() => {
-    setDirection(-1);
-    pagination?.handlePreviousPage?.();
-  }, [pagination, setDirection]);
-
+const Title = ({ label, handleNext, handlePrev, pagination }: TitleProps) => {
   return (
     <Group position="apart">
-      {children}
-      <Group>
+      {isValidElement(label) ? (
+        label
+      ) : (
+        <TextTitle
+          order={2}
+          weight={700}
+        >
+          {label}
+        </TextTitle>
+      )}
+
+      <Group spacing="sm">
         <Button
           compact
-          disabled={!pagination?.hasPreviousPage}
+          disabled={!pagination.hasPreviousPage}
+          size="lg"
           variant="default"
-          onClick={handlePreviousPage}
+          onClick={handlePrev}
         >
-          <RiArrowLeftSLine size={15} />
+          <RiArrowLeftSLine />
         </Button>
         <Button
           compact
+          disabled={!pagination.hasNextPage}
+          size="lg"
           variant="default"
-          onClick={handleNextPage}
+          onClick={handleNext}
         >
-          <RiArrowRightSLine size={15} />
+          <RiArrowRightSLine />
         </Button>
       </Group>
     </Group>
   );
 };
 
-GridCarousel.Title = Title;
-GridCarousel.Carousel = Carousel;
+interface SwiperGridCarouselProps {
+  cardRows: CardRow<Album>[] | CardRow<Artist>[] | CardRow<AlbumArtist>[];
+  data: Album[] | AlbumArtist[] | Artist[] | RelatedArtist[] | undefined;
+  isLoading?: boolean;
+  itemType: LibraryItem;
+  route: CardRoute;
+  swiperProps?: SwiperOptions;
+  title?: {
+    children?: ReactNode;
+    hasPagination?: boolean;
+    icon?: ReactNode;
+    label: string | ReactNode;
+  };
+  uniqueId: string;
+}
+
+export const SwiperGridCarousel = ({
+  cardRows,
+  data,
+  itemType,
+  route,
+  swiperProps,
+  title,
+  isLoading,
+  uniqueId,
+}: SwiperGridCarouselProps) => {
+  const swiperRef = useRef<SwiperCore | any>(null);
+  const playButtonBehavior = usePlayButtonBehavior();
+  const handlePlayQueueAdd = usePlayQueueAdd();
+
+  const [pagination, setPagination] = useState({
+    hasNextPage: (data?.length || 0) > Math.round(3),
+    hasPreviousPage: false,
+  });
+
+  const createFavoriteMutation = useCreateFavorite({});
+  const deleteFavoriteMutation = useDeleteFavorite({});
+
+  const handleFavorite = useCallback(
+    (options: { id: string[]; isFavorite: boolean; itemType: LibraryItem; serverId: string }) => {
+      const { id, itemType, isFavorite, serverId } = options;
+      if (isFavorite) {
+        deleteFavoriteMutation.mutate({
+          query: {
+            id,
+            type: itemType,
+          },
+          serverId,
+        });
+      } else {
+        createFavoriteMutation.mutate({
+          query: {
+            id,
+            type: itemType,
+          },
+          serverId,
+        });
+      }
+    },
+    [createFavoriteMutation, deleteFavoriteMutation],
+  );
+
+  const slides = useMemo(() => {
+    if (!data) return [];
+
+    return data.map((el) => (
+      <PosterCard
+        controls={{
+          cardRows,
+          handleFavorite,
+          handlePlayQueueAdd,
+          itemType,
+          playButtonBehavior,
+          route,
+        }}
+        data={el}
+        isLoading={isLoading}
+        uniqueId={uniqueId}
+      />
+    ));
+  }, [
+    cardRows,
+    data,
+    handleFavorite,
+    handlePlayQueueAdd,
+    isLoading,
+    itemType,
+    playButtonBehavior,
+    route,
+    uniqueId,
+  ]);
+
+  const handleNext = useCallback(() => {
+    const activeIndex = swiperRef?.current?.activeIndex || 0;
+    const slidesPerView = Math.round(Number(swiperProps?.slidesPerView || 4));
+    swiperRef?.current?.slideTo(activeIndex + slidesPerView);
+  }, [swiperProps?.slidesPerView]);
+
+  const handlePrev = useCallback(() => {
+    const activeIndex = swiperRef?.current?.activeIndex || 0;
+    const slidesPerView = Math.round(Number(swiperProps?.slidesPerView || 4));
+    swiperRef?.current?.slideTo(activeIndex - slidesPerView);
+  }, [swiperProps?.slidesPerView]);
+
+  const handleOnSlideChange = useCallback((e: SwiperCore) => {
+    const { slides, isEnd, isBeginning, params } = e;
+    if (isEnd || isBeginning) return;
+
+    setPagination({
+      hasNextPage: (params?.slidesPerView || 4) < slides.length,
+      hasPreviousPage: (params?.slidesPerView || 4) < slides.length,
+    });
+  }, []);
+
+  const handleOnZoomChange = useCallback((e: SwiperCore) => {
+    const { slides, isEnd, isBeginning, params } = e;
+    if (isEnd || isBeginning) return;
+
+    setPagination({
+      hasNextPage: (params.slidesPerView || 4) < slides.length,
+      hasPreviousPage: (params.slidesPerView || 4) < slides.length,
+    });
+  }, []);
+
+  const handleOnReachEnd = useCallback((e: SwiperCore) => {
+    const { slides, params } = e;
+
+    setPagination({
+      hasNextPage: false,
+      hasPreviousPage: (params.slidesPerView || 4) < slides.length,
+    });
+  }, []);
+
+  const handleOnReachBeginning = useCallback((e: SwiperCore) => {
+    const { slides, params } = e;
+
+    setPagination({
+      hasNextPage: (params.slidesPerView || 4) < slides.length,
+      hasPreviousPage: false,
+    });
+  }, []);
+
+  const handleOnResize = useCallback((e: SwiperCore) => {
+    if (!e) return;
+    const { width } = e;
+    const slidesPerView = getSlidesPerView(width);
+    if (!e.params) return;
+    e.params.slidesPerView = slidesPerView;
+  }, []);
+
+  const throttledOnResize = throttle(handleOnResize, 200);
+
+  return (
+    <CarouselContainer
+      className="grid-carousel"
+      spacing="md"
+    >
+      {title ? (
+        <Title
+          {...title}
+          handleNext={handleNext}
+          handlePrev={handlePrev}
+          pagination={pagination}
+        />
+      ) : null}
+      <Swiper
+        ref={swiperRef}
+        resizeObserver
+        modules={[Virtual]}
+        slidesPerView={4}
+        spaceBetween={20}
+        style={{ height: '100%', width: '100%' }}
+        onBeforeInit={(swiper) => {
+          swiperRef.current = swiper;
+        }}
+        onBeforeResize={handleOnResize}
+        onReachBeginning={handleOnReachBeginning}
+        onReachEnd={handleOnReachEnd}
+        onResize={throttledOnResize}
+        onSlideChange={handleOnSlideChange}
+        onZoomChange={handleOnZoomChange}
+        {...swiperProps}
+      >
+        {slides.map((slideContent, index) => {
+          return (
+            <SwiperSlide
+              key={`${uniqueId}-${slideContent?.props?.data?.id}-${index}`}
+              virtualIndex={index}
+            >
+              {slideContent}
+            </SwiperSlide>
+          );
+        })}
+      </Swiper>
+    </CarouselContainer>
+  );
+};

src/renderer/components/hover-card/index.tsx

@@ -0,0 +1,24 @@
+import { HoverCard as MantineHoverCard, HoverCardProps } from '@mantine/core';
+
+export const HoverCard = ({ children, ...props }: HoverCardProps) => {
+  return (
+    <MantineHoverCard
+      styles={{
+        dropdown: {
+          background: 'var(--dropdown-menu-bg)',
+          border: 'none',
+          borderRadius: 'var(--dropdown-menu-border-radius)',
+          boxShadow: '2px 2px 10px 2px rgba(0, 0, 0, 40%)',
+          margin: 0,
+          padding: 0,
+        },
+      }}
+      {...props}
+    >
+      {children}
+    </MantineHoverCard>
+  );
+};
+
+HoverCard.Target = MantineHoverCard.Target;
+HoverCard.Dropdown = MantineHoverCard.Dropdown;

src/renderer/components/index.ts

@@ -5,9 +5,7 @@ export * from './button';
 export * from './card';
 export * from './date-picker';
 export * from './dropdown-menu';
-export * from './dropzone';
 export * from './feature-carousel';
-export * from './grid-carousel';
 export * from './input';
 export * from './modal';
 export * from './page-header';
@@ -27,7 +25,10 @@ export * from './text';
 export * from './text-title';
 export * from './toast';
 export * from './tooltip';
-export * from './virtual-grid';
-export * from './virtual-table';
 export * from './motion';
 export * from './context-menu';
+export * from './query-builder';
+export * from './rating';
+export * from './hover-card';
+export * from './option';
+export * from './checkbox';

src/renderer/components/input/index.tsx

@@ -76,6 +76,7 @@ const StyledTextInput = styled(MantineTextInput)<TextInputProps>`
   }
 
   & .mantine-TextInput-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -83,6 +84,10 @@ const StyledTextInput = styled(MantineTextInput)<TextInputProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 
@@ -123,6 +128,7 @@ const StyledNumberInput = styled(MantineNumberInput)<NumberInputProps>`
   }
 
   & .mantine-NumberInput-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -130,6 +136,10 @@ const StyledNumberInput = styled(MantineNumberInput)<NumberInputProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 
@@ -152,6 +162,7 @@ const StyledPasswordInput = styled(MantinePasswordInput)<PasswordInputProps>`
   }
 
   & .mantine-PasswordInput-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -159,6 +170,10 @@ const StyledPasswordInput = styled(MantinePasswordInput)<PasswordInputProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 
@@ -181,6 +196,7 @@ const StyledFileInput = styled(MantineFileInput)<FileInputProps>`
   }
 
   & .mantine-FileInput-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -188,6 +204,10 @@ const StyledFileInput = styled(MantineFileInput)<FileInputProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 
@@ -210,6 +230,7 @@ const StyledJsonInput = styled(MantineJsonInput)<JsonInputProps>`
   }
 
   & .mantine-JsonInput-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -217,6 +238,10 @@ const StyledJsonInput = styled(MantineJsonInput)<JsonInputProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 
@@ -235,6 +260,7 @@ const StyledTextarea = styled(MantineTextarea)<TextareaProps>`
   }
 
   & .mantine-Textarea-label {
+    margin-bottom: 0.5rem;
     font-family: var(--label-font-faimly);
   }
 
@@ -242,6 +268,10 @@ const StyledTextarea = styled(MantineTextarea)<TextareaProps>`
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   transition: width 0.3s ease-in-out;
 `;
 

src/renderer/components/modal/index.tsx

@@ -21,8 +21,6 @@ export interface ModalProps extends Omit<MantineModalProps, 'onClose'> {
 export const Modal = ({ children, handlers, ...rest }: ModalProps) => {
   return (
     <MantineModal
-      overlayBlur={2}
-      overlayOpacity={0.2}
       {...rest}
       onClose={handlers.close}
     >

src/renderer/components/option/index.tsx

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { Flex, Group } from '@mantine/core';
+
+export const Option = ({ children }: any) => {
+  return (
+    <Group
+      grow
+      p="0.5rem"
+    >
+      {children}
+    </Group>
+  );
+};
+
+interface LabelProps {
+  children: ReactNode;
+}
+
+const Label = ({ children }: LabelProps) => {
+  return <Flex align="flex-start">{children}</Flex>;
+};
+
+interface ControlProps {
+  children: ReactNode;
+}
+
+const Control = ({ children }: ControlProps) => {
+  return <Flex justify="flex-end">{children}</Flex>;
+};
+
+Option.Label = Label;
+Option.Control = Control;

src/renderer/components/page-header/index.tsx

@@ -1,8 +1,10 @@
+import { useRef } from 'react';
 import { Flex, FlexProps } from '@mantine/core';
 import { AnimatePresence, motion, Variants } from 'framer-motion';
-import { useRef } from 'react';
 import styled from 'styled-components';
 import { useShouldPadTitlebar, useTheme } from '/@/renderer/hooks';
+import { useWindowSettings } from '/@/renderer/store/settings.store';
+import { Platform } from '/@/renderer/types';
 
 const Container = styled(motion(Flex))<{
   height?: string;
@@ -11,18 +13,23 @@ const Container = styled(motion(Flex))<{
   position: ${(props) => props.position || 'relative'};
   z-index: 2000;
   width: 100%;
-  height: ${(props) => props.height || '60px'};
+  height: ${(props) => props.height || '65px'};
+  background: var(--titlebar-bg);
 `;
 
-const Header = styled(motion.div)<{ $isHidden?: boolean; $padRight?: boolean }>`
+const Header = styled(motion.div)<{
+  $isDraggable?: boolean;
+  $isHidden?: boolean;
+  $padRight?: boolean;
+}>`
   position: relative;
   z-index: 15;
   width: 100%;
   height: 100%;
-  margin-right: ${(props) => props.$padRight && '170px'};
+  margin-right: ${(props) => (props.$padRight ? '140px' : '1rem')};
   user-select: ${(props) => (props.$isHidden ? 'none' : 'auto')};
   pointer-events: ${(props) => (props.$isHidden ? 'none' : 'auto')};
-  -webkit-app-region: drag;
+  -webkit-app-region: ${(props) => props.$isDraggable && 'drag'};
 
   button {
     -webkit-app-region: no-drag;
@@ -51,7 +58,7 @@ const BackgroundImageOverlay = styled.div<{ theme: 'light' | 'dark' }>`
   height: 100%;
   background: ${(props) =>
     props.theme === 'light'
-      ? 'linear-gradient(rgba(0, 0, 0, 20%), rgba(0, 0, 0, 20%))'
+      ? 'linear-gradient(rgba(255, 255, 255, 25%), rgba(255, 255, 255, 25%))'
       : 'linear-gradient(rgba(0, 0, 0, 50%), rgba(0, 0, 0, 50%))'};
 `;
 
@@ -65,6 +72,8 @@ export interface PageHeaderProps
 }
 
 const TitleWrapper = styled(motion.div)`
+  position: absolute;
+  display: flex;
   width: 100%;
   height: 100%;
 `;
@@ -85,6 +94,7 @@ export const PageHeader = ({
 }: PageHeaderProps) => {
   const ref = useRef(null);
   const padRight = useShouldPadTitlebar();
+  const { windowBarStyle } = useWindowSettings();
   const theme = useTheme();
 
   return (
@@ -95,10 +105,11 @@ export const PageHeader = ({
       {...props}
     >
       <Header
+        $isDraggable={windowBarStyle === Platform.WEB}
         $isHidden={isHidden}
         $padRight={padRight}
       >
-        <AnimatePresence>
+        <AnimatePresence initial={false}>
           {!isHidden && (
             <TitleWrapper
               animate="animate"

src/renderer/components/pagination/index.tsx

@@ -46,7 +46,6 @@ export const Pagination = ({ $hideDividers, ...props }: PaginationProps) => {
     <StyledPagination
       $hideDividers={$hideDividers}
       radius="xl"
-      size="md"
       {...props}
     />
   );

src/renderer/components/popover/index.tsx

@@ -27,7 +27,7 @@ export const Popover = ({ children, ...props }: PopoverProps) => {
           filter: 'drop-shadow(0 0 5px rgb(0, 0, 0, 50%))',
         },
       }}
-      transition="scale-y"
+      transitionProps={{ transition: 'fade' }}
       {...props}
     >
       {children}

src/renderer/components/query-builder/index.tsx

@@ -0,0 +1,218 @@
+import { Group, Stack } from '@mantine/core';
+import { Select } from '/@/renderer/components/select';
+import { AnimatePresence, motion } from 'framer-motion';
+import { RiAddFill, RiAddLine, RiDeleteBinFill, RiMore2Line, RiRestartLine } from 'react-icons/ri';
+import { Button } from '/@/renderer/components/button';
+import { DropdownMenu } from '/@/renderer/components/dropdown-menu';
+import { QueryBuilderOption } from '/@/renderer/components/query-builder/query-builder-option';
+import { QueryBuilderGroup, QueryBuilderRule } from '/@/renderer/types';
+
+const FILTER_GROUP_OPTIONS_DATA = [
+  {
+    label: 'Match all',
+    value: 'all',
+  },
+  {
+    label: 'Match any',
+    value: 'any',
+  },
+];
+
+type AddArgs = {
+  groupIndex: number[];
+  level: number;
+};
+
+type DeleteArgs = {
+  groupIndex: number[];
+  level: number;
+  uniqueId: string;
+};
+interface QueryBuilderProps {
+  data: Record<string, any>;
+  filters: { label: string; type: string; value: string }[];
+  groupIndex: number[];
+  level: number;
+  onAddRule: (args: AddArgs) => void;
+  onAddRuleGroup: (args: AddArgs) => void;
+  onChangeField: (args: any) => void;
+  onChangeOperator: (args: any) => void;
+  onChangeType: (args: any) => void;
+  onChangeValue: (args: any) => void;
+  onClearFilters: () => void;
+  onDeleteRule: (args: DeleteArgs) => void;
+  onDeleteRuleGroup: (args: DeleteArgs) => void;
+  onResetFilters: () => void;
+  operators: {
+    boolean: { label: string; value: string }[];
+    date: { label: string; value: string }[];
+    number: { label: string; value: string }[];
+    string: { label: string; value: string }[];
+  };
+  uniqueId: string;
+}
+
+export const QueryBuilder = ({
+  data,
+  level,
+  onAddRule,
+  onDeleteRuleGroup,
+  onDeleteRule,
+  onAddRuleGroup,
+  onChangeType,
+  onChangeField,
+  operators,
+  onChangeOperator,
+  onChangeValue,
+  onClearFilters,
+  onResetFilters,
+  groupIndex,
+  uniqueId,
+  filters,
+}: QueryBuilderProps) => {
+  const handleAddRule = () => {
+    onAddRule({ groupIndex, level });
+  };
+
+  const handleAddRuleGroup = () => {
+    onAddRuleGroup({ groupIndex, level });
+  };
+
+  const handleDeleteRuleGroup = () => {
+    onDeleteRuleGroup({ groupIndex, level, uniqueId });
+  };
+
+  const handleChangeType = (value: string | null) => {
+    onChangeType({ groupIndex, level, value });
+  };
+
+  return (
+    <Stack
+      ml={`${level * 10}px`}
+      spacing="sm"
+    >
+      <Group spacing="sm">
+        <Select
+          data={FILTER_GROUP_OPTIONS_DATA}
+          maxWidth={175}
+          size="sm"
+          value={data.type}
+          width="20%"
+          onChange={handleChangeType}
+        />
+        <Button
+          px={5}
+          size="sm"
+          tooltip={{ label: 'Add rule' }}
+          variant="default"
+          onClick={handleAddRule}
+        >
+          <RiAddLine size={20} />
+        </Button>
+        <DropdownMenu position="bottom-start">
+          <DropdownMenu.Target>
+            <Button
+              p={0}
+              size="sm"
+              variant="subtle"
+            >
+              <RiMore2Line size={20} />
+            </Button>
+          </DropdownMenu.Target>
+          <DropdownMenu.Dropdown>
+            <DropdownMenu.Item
+              icon={<RiAddFill />}
+              onClick={handleAddRuleGroup}
+            >
+              Add rule group
+            </DropdownMenu.Item>
+
+            {level > 0 && (
+              <DropdownMenu.Item
+                icon={<RiDeleteBinFill />}
+                onClick={handleDeleteRuleGroup}
+              >
+                Remove rule group
+              </DropdownMenu.Item>
+            )}
+            {level === 0 && (
+              <>
+                <DropdownMenu.Divider />
+                <DropdownMenu.Item
+                  $danger
+                  icon={<RiRestartLine color="var(--danger-color)" />}
+                  onClick={onResetFilters}
+                >
+                  Reset to default
+                </DropdownMenu.Item>
+                <DropdownMenu.Item
+                  $danger
+                  icon={<RiDeleteBinFill color="var(--danger-color)" />}
+                  onClick={onClearFilters}
+                >
+                  Clear filters
+                </DropdownMenu.Item>
+              </>
+            )}
+          </DropdownMenu.Dropdown>
+        </DropdownMenu>
+      </Group>
+      <AnimatePresence initial={false}>
+        {data?.rules?.map((rule: QueryBuilderRule) => (
+          <motion.div
+            key={rule.uniqueId}
+            animate={{ opacity: 1, x: 0 }}
+            exit={{ opacity: 0, x: -25 }}
+            initial={{ opacity: 0, x: -25 }}
+            transition={{ duration: 0.2, ease: 'easeInOut' }}
+          >
+            <QueryBuilderOption
+              data={rule}
+              filters={filters}
+              groupIndex={groupIndex || []}
+              level={level}
+              noRemove={data?.rules?.length === 1}
+              operators={operators}
+              onChangeField={onChangeField}
+              onChangeOperator={onChangeOperator}
+              onChangeValue={onChangeValue}
+              onDeleteRule={onDeleteRule}
+            />
+          </motion.div>
+        ))}
+      </AnimatePresence>
+      {data?.group && (
+        <AnimatePresence initial={false}>
+          {data.group?.map((group: QueryBuilderGroup, index: number) => (
+            <motion.div
+              key={group.uniqueId}
+              animate={{ opacity: 1, x: 0 }}
+              exit={{ opacity: 0, x: -25 }}
+              initial={{ opacity: 0, x: -25 }}
+              transition={{ duration: 0.2, ease: 'easeInOut' }}
+            >
+              <QueryBuilder
+                data={group}
+                filters={filters}
+                groupIndex={[...(groupIndex || []), index]}
+                level={level + 1}
+                operators={operators}
+                uniqueId={group.uniqueId}
+                onAddRule={onAddRule}
+                onAddRuleGroup={onAddRuleGroup}
+                onChangeField={onChangeField}
+                onChangeOperator={onChangeOperator}
+                onChangeType={onChangeType}
+                onChangeValue={onChangeValue}
+                onClearFilters={onClearFilters}
+                onDeleteRule={onDeleteRule}
+                onDeleteRuleGroup={onDeleteRuleGroup}
+                onResetFilters={onResetFilters}
+              />
+            </motion.div>
+          ))}
+        </AnimatePresence>
+      )}
+    </Stack>
+  );
+};

src/renderer/components/query-builder/query-builder-option.tsx

@@ -0,0 +1,239 @@
+import { Group } from '@mantine/core';
+import { useState } from 'react';
+import { RiSubtractLine } from 'react-icons/ri';
+import { Button } from '/@/renderer/components/button';
+import { NumberInput, TextInput } from '/@/renderer/components/input';
+import { Select } from '/@/renderer/components/select';
+import { QueryBuilderRule } from '/@/renderer/types';
+
+type DeleteArgs = {
+  groupIndex: number[];
+  level: number;
+  uniqueId: string;
+};
+
+interface QueryOptionProps {
+  data: QueryBuilderRule;
+  filters: { label: string; type: string; value: string }[];
+  groupIndex: number[];
+  level: number;
+  noRemove: boolean;
+  onChangeField: (args: any) => void;
+  onChangeOperator: (args: any) => void;
+  onChangeValue: (args: any) => void;
+  onDeleteRule: (args: DeleteArgs) => void;
+  operators: {
+    boolean: { label: string; value: string }[];
+    date: { label: string; value: string }[];
+    number: { label: string; value: string }[];
+    string: { label: string; value: string }[];
+  };
+}
+
+const QueryValueInput = ({ onChange, type, ...props }: any) => {
+  const [numberRange, setNumberRange] = useState([0, 0]);
+
+  switch (type) {
+    case 'string':
+      return (
+        <TextInput
+          size="sm"
+          onChange={onChange}
+          {...props}
+        />
+      );
+    case 'number':
+      return (
+        <NumberInput
+          size="sm"
+          onChange={onChange}
+          {...props}
+          defaultValue={props.defaultValue && Number(props.defaultValue)}
+        />
+      );
+    case 'date':
+      return (
+        <TextInput
+          size="sm"
+          onChange={onChange}
+          {...props}
+        />
+      );
+
+    case 'dateRange':
+      return (
+        <>
+          <NumberInput
+            {...props}
+            defaultValue={props.defaultValue && Number(props.defaultValue?.[0])}
+            maxWidth={81}
+            width="10%"
+            onChange={(e) => {
+              const newRange = [e || 0, numberRange[1]];
+              setNumberRange(newRange);
+              onChange(newRange);
+            }}
+          />
+          <NumberInput
+            {...props}
+            defaultValue={props.defaultValue && Number(props.defaultValue?.[1])}
+            maxWidth={81}
+            width="10%"
+            onChange={(e) => {
+              const newRange = [numberRange[0], e || 0];
+              setNumberRange(newRange);
+              onChange(newRange);
+            }}
+          />
+        </>
+      );
+
+    case 'boolean':
+      return (
+        <Select
+          data={[
+            { label: 'true', value: 'true' },
+            { label: 'false', value: 'false' },
+          ]}
+          onChange={onChange}
+          {...props}
+        />
+      );
+
+    default:
+      return <></>;
+  }
+};
+
+export const QueryBuilderOption = ({
+  data,
+  filters,
+  level,
+  onDeleteRule,
+  operators,
+  groupIndex,
+  noRemove,
+  onChangeField,
+  onChangeOperator,
+  onChangeValue,
+}: QueryOptionProps) => {
+  const { field, operator, uniqueId, value } = data;
+
+  const handleDeleteRule = () => {
+    onDeleteRule({ groupIndex, level, uniqueId });
+  };
+
+  const handleChangeField = (e: any) => {
+    onChangeField({ groupIndex, level, uniqueId, value: e });
+  };
+
+  const handleChangeOperator = (e: any) => {
+    onChangeOperator({ groupIndex, level, uniqueId, value: e });
+  };
+
+  const handleChangeValue = (e: any) => {
+    const isDirectValue =
+      typeof e === 'string' ||
+      typeof e === 'number' ||
+      typeof e === 'undefined' ||
+      typeof e === null;
+
+    if (isDirectValue) {
+      return onChangeValue({
+        groupIndex,
+        level,
+        uniqueId,
+        value: e,
+      });
+    }
+
+    // const isDate = e instanceof Date;
+
+    // if (isDate) {
+    //   return onChangeValue({
+    //     groupIndex,
+    //     level,
+    //     uniqueId,
+    //     value: dayjs(e).format('YYYY-MM-DD'),
+    //   });
+    // }
+
+    const isArray = Array.isArray(e);
+
+    if (isArray) {
+      return onChangeValue({
+        groupIndex,
+        level,
+        uniqueId,
+        value: e,
+      });
+    }
+
+    return onChangeValue({
+      groupIndex,
+      level,
+      uniqueId,
+      value: e.currentTarget.value,
+    });
+  };
+
+  const fieldType = filters.find((f) => f.value === field)?.type;
+  const operatorsByFieldType = operators[fieldType as keyof typeof operators];
+  const ml = (level + 1) * 10;
+
+  return (
+    <Group
+      ml={ml}
+      spacing="sm"
+    >
+      <Select
+        searchable
+        data={filters}
+        maxWidth={170}
+        size="sm"
+        value={field}
+        width="25%"
+        onChange={handleChangeField}
+      />
+      <Select
+        searchable
+        data={operatorsByFieldType || []}
+        disabled={!field}
+        maxWidth={170}
+        size="sm"
+        value={operator}
+        width="25%"
+        onChange={handleChangeOperator}
+      />
+      {field ? (
+        <QueryValueInput
+          defaultValue={value}
+          maxWidth={170}
+          size="sm"
+          type={operator === 'inTheRange' ? 'dateRange' : fieldType}
+          width="25%"
+          onChange={handleChangeValue}
+        />
+      ) : (
+        <TextInput
+          disabled
+          defaultValue={value}
+          maxWidth={170}
+          size="sm"
+          width="25%"
+          onChange={handleChangeValue}
+        />
+      )}
+      <Button
+        disabled={noRemove}
+        px={5}
+        size="sm"
+        tooltip={{ label: 'Remove rule' }}
+        variant="default"
+        onClick={handleDeleteRule}
+      >
+        <RiSubtractLine size={20} />
+      </Button>
+    </Group>
+  );
+};

src/renderer/components/rating/index.tsx

@@ -0,0 +1,33 @@
+/* eslint-disable jsx-a11y/no-static-element-interactions */
+import { MouseEvent } from 'react';
+import { Rating as MantineRating, RatingProps as MantineRatingProps } from '@mantine/core';
+import styled from 'styled-components';
+import { Tooltip } from '/@/renderer/components/tooltip';
+
+interface RatingProps extends Omit<MantineRatingProps, 'onClick'> {
+  onClick: (e: MouseEvent<HTMLDivElement>, value: number | undefined) => void;
+}
+
+const StyledRating = styled(MantineRating)`
+  & .mantine-Rating-symbolBody {
+    svg {
+      stroke: var(--main-fg-secondary);
+    }
+  }
+`;
+
+export const Rating = ({ onClick, ...props }: RatingProps) => {
+  // const debouncedOnClick = debounce(onClick, 100);
+
+  return (
+    <Tooltip
+      label="Double click to clear"
+      openDelay={1000}
+    >
+      <StyledRating
+        {...props}
+        onDoubleClick={(e) => onClick(e, props.value)}
+      />
+    </Tooltip>
+  );
+};

src/renderer/components/scroll-area/index.tsx

@@ -5,6 +5,8 @@ import { useMergedRef, useTimeout } from '@mantine/hooks';
 import { motion, useScroll } from 'framer-motion';
 import styled from 'styled-components';
 import { PageHeader, PageHeaderProps } from '/@/renderer/components/page-header';
+import { useWindowSettings } from '/@/renderer/store/settings.store';
+import { Platform } from '/@/renderer/types';
 
 interface ScrollAreaProps extends MantineScrollAreaProps {
   children: React.ReactNode;
@@ -26,16 +28,26 @@ const StyledScrollArea = styled(MantineScrollArea)`
   }
 `;
 
-const StyledNativeScrollArea = styled.div`
+const StyledNativeScrollArea = styled.div<{ scrollBarOffset?: string; windowBarStyle?: Platform }>`
   height: 100%;
-  overflow-y: overlay;
+  overflow-y: overlay !important;
 
   &::-webkit-scrollbar-track {
-    margin-top: 35px;
+    margin-top: ${(props) =>
+      props.windowBarStyle === Platform.WINDOWS ||
+      props.windowBarStyle === Platform.MACOS ||
+      props.windowBarStyle === Platform.LINUX
+        ? '0px'
+        : props.scrollBarOffset || '65px'};
   }
 
   &::-webkit-scrollbar-thumb {
-    margin-top: 35px;
+    margin-top: ${(props) =>
+      props.windowBarStyle === Platform.WINDOWS ||
+      props.windowBarStyle === Platform.MACOS ||
+      props.windowBarStyle === Platform.LINUX
+        ? '0px'
+        : props.scrollBarOffset || '65px'};
   }
 `;
 
@@ -54,17 +66,33 @@ export const ScrollArea = forwardRef(({ children, ...props }: ScrollAreaProps, r
 interface NativeScrollAreaProps {
   children: React.ReactNode;
   debugScrollPosition?: boolean;
+  noHeader?: boolean;
   pageHeaderProps?: PageHeaderProps & { offset?: any; target?: any };
+  scrollBarOffset?: string;
+  scrollHideDelay?: number;
+  style?: React.CSSProperties;
 }
 
 export const NativeScrollArea = forwardRef(
   (
-    { children, pageHeaderProps, debugScrollPosition, ...props }: NativeScrollAreaProps,
+    {
+      children,
+      pageHeaderProps,
+      debugScrollPosition,
+      scrollBarOffset,
+      scrollHideDelay,
+      noHeader,
+      ...props
+    }: NativeScrollAreaProps,
     ref: Ref<HTMLDivElement>,
   ) => {
+    const { windowBarStyle } = useWindowSettings();
     const [hideScrollbar, setHideScrollbar] = useState(false);
     const [hideHeader, setHideHeader] = useState(true);
-    const { start, clear } = useTimeout(() => setHideScrollbar(true), 1000);
+    const { start, clear } = useTimeout(
+      () => setHideScrollbar(true),
+      scrollHideDelay !== undefined ? scrollHideDelay * 1000 : 0,
+    );
 
     const containerRef = useRef(null);
     const mergedRef = useMergedRef(ref, containerRef);
@@ -103,15 +131,19 @@ export const NativeScrollArea = forwardRef(
 
     return (
       <>
-        <PageHeader
-          isHidden={hideHeader}
-          position="absolute"
-          style={{ opacity: scrollYProgress as any }}
-          {...pageHeaderProps}
-        />
+        {!noHeader && (
+          <PageHeader
+            isHidden={hideHeader}
+            position="absolute"
+            style={{ opacity: scrollYProgress as any }}
+            {...pageHeaderProps}
+          />
+        )}
         <StyledNativeScrollArea
           ref={mergedRef}
           className={hideScrollbar ? 'hide-scrollbar' : undefined}
+          scrollBarOffset={scrollBarOffset}
+          windowBarStyle={windowBarStyle}
           onMouseEnter={() => {
             setHideScrollbar(false);
             clear();

src/renderer/components/search-input/index.tsx

@@ -1,8 +1,10 @@
 import { ChangeEvent, KeyboardEvent } from 'react';
-import { TextInputProps } from '@mantine/core';
+import { ActionIcon, TextInputProps } from '@mantine/core';
 import { useFocusWithin, useHotkeys, useMergedRef } from '@mantine/hooks';
-import { RiSearchLine } from 'react-icons/ri';
+import { RiCloseFill, RiSearchLine } from 'react-icons/ri';
 import { TextInput } from '/@/renderer/components/input';
+import { useSettingsStore } from '/@/renderer/store';
+import { shallow } from 'zustand/shallow';
 
 interface SearchInputProps extends TextInputProps {
   initialWidth?: number;
@@ -18,18 +20,12 @@ export const SearchInput = ({
 }: SearchInputProps) => {
   const { ref, focused } = useFocusWithin();
   const mergedRef = useMergedRef<HTMLInputElement>(ref);
+  const binding = useSettingsStore((state) => state.hotkeys.bindings.localSearch, shallow);
 
   const isOpened = focused || ref.current?.value;
   const showIcon = !isOpened || (openedWidth || 100) > 100;
 
-  useHotkeys([
-    [
-      'ctrl+F',
-      () => {
-        ref.current.select();
-      },
-    ],
-  ]);
+  useHotkeys([[binding.hotkey, () => ref.current.select()]]);
 
   const handleEscape = (e: KeyboardEvent<HTMLInputElement>) => {
     if (e.code === 'Escape') {
@@ -43,9 +39,22 @@ export const SearchInput = ({
     <TextInput
       ref={mergedRef}
       {...props}
-      icon={showIcon && <RiSearchLine size={15} />}
+      icon={showIcon && <RiSearchLine />}
+      rightSection={
+        isOpened ? (
+          <ActionIcon
+            onClick={() => {
+              ref.current.value = '';
+              ref.current.focus();
+            }}
+          >
+            <RiCloseFill />
+          </ActionIcon>
+        ) : null
+      }
+      size="md"
       styles={{
-        icon: { svg: { fill: 'var(--btn-default-fg)' } },
+        icon: { svg: { fill: 'var(--titlebar-fg)' } },
         input: {
           backgroundColor: isOpened ? 'inherit' : 'transparent !important',
           border: 'none !important',
@@ -53,7 +62,7 @@ export const SearchInput = ({
           padding: isOpened ? '10px' : 0,
         },
       }}
-      width={isOpened ? openedWidth || 150 : initialWidth || 50}
+      width={isOpened ? openedWidth || 150 : initialWidth || 35}
       onChange={onChange}
       onKeyDown={handleEscape}
     />

src/renderer/components/segmented-control/index.tsx

@@ -17,6 +17,10 @@ const StyledSegmentedControl = styled(MantineSegmentedControl)<MantineSegmentedC
     opacity: 0.6;
   }
 
+  & [data-disabled='true'] {
+    opacity: 0.6;
+  }
+
   & .mantine-SegmentedControl-active {
     color: var(--input-active-fg);
     background-color: var(--input-active-bg);

src/renderer/components/select/index.tsx

@@ -10,7 +10,7 @@ interface SelectProps extends MantineSelectProps {
   width?: number | string;
 }
 
-interface MultiSelectProps extends MantineMultiSelectProps {
+export interface MultiSelectProps extends MantineMultiSelectProps {
   maxWidth?: number | string;
   width?: number | string;
 }
@@ -20,7 +20,7 @@ const StyledSelect = styled(MantineSelect)`
     background: var(--input-bg);
   }
 
-  & .mantine-Select-disabled {
+  & [data-disabled='true'] {
     background: var(--input-bg);
     opacity: 0.6;
   }
@@ -64,8 +64,7 @@ export const Select = ({ width, maxWidth, ...props }: SelectProps) => {
         },
       }}
       sx={{ maxWidth, width }}
-      transition="pop"
-      transitionDuration={100}
+      transitionProps={{ duration: 100, transition: 'fade' }}
       {...props}
     />
   );
@@ -76,8 +75,8 @@ const StyledMultiSelect = styled(MantineMultiSelect)`
     background: var(--input-select-bg);
   }
 
-  & .mantine-MultiSelect-disabled {
-    background: var(--input-select-bg);
+  & [data-disabled='true'] {
+    background: var(--input-bg);
     opacity: 0.6;
   }
 
@@ -126,8 +125,7 @@ export const MultiSelect = ({ width, maxWidth, ...props }: MultiSelectProps) =>
         },
       }}
       sx={{ maxWidth, width }}
-      transition="pop"
-      transitionDuration={100}
+      transitionProps={{ duration: 100, transition: 'fade' }}
       {...props}
     />
   );

src/renderer/components/skeleton/index.tsx

@@ -3,35 +3,8 @@ import { Skeleton as MantineSkeleton } from '@mantine/core';
 import styled from 'styled-components';
 
 const StyledSkeleton = styled(MantineSkeleton)`
-  @keyframes run {
-    0% {
-      left: 0;
-      transform: translateX(-100%);
-    }
-
-    80% {
-      transform: translateX(100%);
-    }
-
-    100% {
-      transform: translateX(100%);
-    }
-  }
-
-  &::before {
-    background: var(--skeleton-bg);
-  }
-
   &::after {
-    position: absolute;
-    background: linear-gradient(90deg, transparent, var(--skeleton-bg), transparent);
-    transform: translateX(-100%);
-    animation-name: run;
-    animation-duration: 1.5s;
-    animation-timing-function: linear;
-    animation-iteration-count: infinite;
-    content: '';
-    inset: 0;
+    background: var(--placeholder-bg);
   }
 `;
 

src/renderer/components/slider/index.tsx

@@ -10,6 +10,10 @@ const StyledSlider = styled(MantineSlider)`
     background-color: var(--slider-track-bg);
   }
 
+  & .mantine-Slider-bar {
+    background-color: var(--primary-color);
+  }
+
   & .mantine-Slider-thumb {
     width: 1rem;
     height: 1rem;

src/renderer/components/spinner/index.tsx

@@ -1,3 +1,4 @@
+import { Center } from '@mantine/core';
 import type { IconType } from 'react-icons';
 import { RiLoader5Fill } from 'react-icons/ri';
 import styled from 'styled-components';
@@ -5,6 +6,7 @@ import { rotating } from '/@/renderer/styles';
 
 interface SpinnerProps extends IconType {
   color?: string;
+  container?: boolean;
   size?: number;
 }
 
@@ -14,6 +16,20 @@ export const SpinnerIcon = styled(RiLoader5Fill)`
 `;
 
 export const Spinner = ({ ...props }: SpinnerProps) => {
+  if (props.container) {
+    return (
+      <Center
+        h="100%"
+        w="100%"
+      >
+        <SpinnerIcon
+          color={props.color}
+          size={props.size}
+        />
+      </Center>
+    );
+  }
+
   return <SpinnerIcon {...props} />;
 };