feat(search): queue pasted share links from Live Search and mobile search

Implement share-link detection in search (track, queue, album, artist,
composer): enqueue tracks/queues without interrupting playback; preview
album/artist/composer without switching the active server; queue preview
modal with scrollable track list. Based on community PR #551.

Co-authored-by: Daniel Wagner <daniel.iuser@icloud.com>

src/hooks/useShareQueuePreview.ts

@@ -0,0 +1,56 @@
+import { useEffect, useState } from 'react';
+import type { SubsonicSong } from '../api/subsonicTypes';
+import {
+  resolveShareSearchPayload,
+  type ShareSearchResolveResult,
+} from '../utils/share/enqueueShareSearchPayload';
+import type { QueueableShareSearchPayload } from '../utils/share/shareSearch';
+
+export type ShareQueuePreviewState =
+  | { status: 'idle' }
+  | { status: 'loading' }
+  | { status: 'ok'; songs: SubsonicSong[]; total: number; skipped: number }
+  | { status: 'error'; result: Exclude<ShareSearchResolveResult, { type: 'ok' }> };
+
+const IDLE: ShareQueuePreviewState = { status: 'idle' };
+
+export function useShareQueuePreview(
+  payload: Extract<QueueableShareSearchPayload, { k: 'queue' }> | null,
+  open: boolean,
+): ShareQueuePreviewState {
+  const [state, setState] = useState<ShareQueuePreviewState>(IDLE);
+
+  useEffect(() => {
+    if (!open || !payload) {
+      setState(IDLE);
+      return;
+    }
+
+    let cancelled = false;
+    setState({ status: 'loading' });
+
+    void resolveShareSearchPayload(payload)
+      .then(result => {
+        if (cancelled) return;
+        if (result.type === 'ok') {
+          setState({
+            status: 'ok',
+            songs: result.songs,
+            total: result.total,
+            skipped: result.skipped,
+          });
+          return;
+        }
+        setState({ status: 'error', result });
+      })
+      .catch(() => {
+        if (!cancelled) setState({ status: 'error', result: { type: 'error' } });
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [open, payload]);
+
+  return state;
+}

src/hooks/useShareSearch.ts

@@ -0,0 +1,98 @@
+import { useCallback, useMemo, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { useAuthStore } from '../store/authStore';
+import {
+  activateShareSearchServer,
+  enqueueShareSearchPayload,
+} from '../utils/share/enqueueShareSearchPayload';
+import type { ServerProfile } from '../store/authStoreTypes';
+import { findServerIdForShareUrl } from '../utils/share/shareLink';
+import { shareServerOriginLabel } from '../utils/share/shareServerOriginLabel';
+import { parseShareSearchText } from '../utils/share/shareSearch';
+import { useShareSearchPreview } from './useShareSearchPreview';
+
+export function useShareSearch(query: string, onSuccess?: () => void) {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  const servers = useAuthStore(s => s.servers);
+  const activeServerId = useAuthStore(s => s.activeServerId);
+  const shareMatch = useMemo(() => parseShareSearchText(query), [query]);
+  const shareServerLabel = useMemo(
+    () => shareServerOriginLabel(shareMatch, servers, activeServerId),
+    [shareMatch, servers, activeServerId],
+  );
+  const shareCoverServer = useMemo((): ServerProfile | null => {
+    if (!shareMatch || shareMatch.type === 'unsupported') return null;
+    const serverId = findServerIdForShareUrl(servers, shareMatch.payload.srv);
+    if (!serverId || serverId === activeServerId) return null;
+    return servers.find(s => s.id === serverId) ?? null;
+  }, [shareMatch, servers, activeServerId]);
+  const preview = useShareSearchPreview(shareMatch);
+  const [shareQueueBusy, setShareQueueBusy] = useState(false);
+
+  const canQueueShareMatch =
+    shareMatch?.type === 'queueable' &&
+    (shareMatch.payload.k === 'queue' ||
+      (!preview.shareTrackResolving && !!preview.shareTrackSong));
+
+  const canOpenShareAlbum =
+    shareMatch?.type === 'album' && !!preview.shareAlbum && !preview.shareAlbumResolving;
+  const canOpenShareArtist =
+    shareMatch?.type === 'artist' && !!preview.shareArtist && !preview.shareArtistResolving;
+  const canOpenShareComposer =
+    shareMatch?.type === 'composer' && !!preview.shareComposer && !preview.shareComposerResolving;
+
+  const hasShareKeyboardTarget =
+    canQueueShareMatch || canOpenShareAlbum || canOpenShareArtist || canOpenShareComposer;
+
+  const openShareAlbum = useCallback(() => {
+    if (shareMatch?.type !== 'album' || !preview.shareAlbum) return;
+    if (!activateShareSearchServer(shareMatch.payload.srv, t)) return;
+    navigate(`/album/${preview.shareAlbum.id}`);
+    onSuccess?.();
+  }, [shareMatch, preview.shareAlbum, navigate, t, onSuccess]);
+
+  const openShareArtist = useCallback(() => {
+    if (shareMatch?.type !== 'artist' || !preview.shareArtist) return;
+    if (!activateShareSearchServer(shareMatch.payload.srv, t)) return;
+    navigate(`/artist/${preview.shareArtist.id}`);
+    onSuccess?.();
+  }, [shareMatch, preview.shareArtist, navigate, t, onSuccess]);
+
+  const openShareComposer = useCallback(() => {
+    if (shareMatch?.type !== 'composer' || !preview.shareComposer) return;
+    if (!activateShareSearchServer(shareMatch.payload.srv, t)) return;
+    navigate(`/composer/${preview.shareComposer.id}`);
+    onSuccess?.();
+  }, [shareMatch, preview.shareComposer, navigate, t, onSuccess]);
+
+  const enqueueShareMatch = useCallback(async () => {
+    if (shareMatch?.type !== 'queueable' || shareQueueBusy) return false;
+    if (shareMatch.payload.k === 'track' && (!preview.shareTrackSong || preview.shareTrackResolving)) {
+      return false;
+    }
+    setShareQueueBusy(true);
+    const ok = await enqueueShareSearchPayload(shareMatch.payload, t);
+    setShareQueueBusy(false);
+    if (ok) onSuccess?.();
+    return ok;
+  }, [shareMatch, shareQueueBusy, preview.shareTrackSong, preview.shareTrackResolving, t, onSuccess]);
+
+  return {
+    shareMatch,
+    shareServerLabel,
+    shareCoverServer,
+    shareQueueBusy,
+    canQueueShareMatch,
+    canOpenShareAlbum,
+    canOpenShareArtist,
+    canOpenShareComposer,
+    hasShareKeyboardTarget,
+    openShareAlbum,
+    openShareArtist,
+    openShareComposer,
+    enqueueShareMatch,
+    ...preview,
+  };
+}

src/hooks/useShareSearchPreview.ts

@@ -0,0 +1,137 @@
+import { useEffect, useState } from 'react';
+import type { SubsonicAlbum, SubsonicArtist, SubsonicSong } from '../api/subsonicTypes';
+import {
+  resolveShareSearchAlbum,
+  resolveShareSearchArtist,
+  resolveShareSearchPayload,
+} from '../utils/share/enqueueShareSearchPayload';
+import type { ShareSearchMatch } from '../utils/share/shareSearch';
+
+export interface ShareSearchPreviewState {
+  shareTrackSong: SubsonicSong | null;
+  shareTrackResolving: boolean;
+  shareTrackUnavailable: boolean;
+  shareAlbum: SubsonicAlbum | null;
+  shareAlbumResolving: boolean;
+  shareAlbumUnavailable: boolean;
+  shareArtist: SubsonicArtist | null;
+  shareArtistResolving: boolean;
+  shareArtistUnavailable: boolean;
+  shareComposer: SubsonicArtist | null;
+  shareComposerResolving: boolean;
+  shareComposerUnavailable: boolean;
+}
+
+const EMPTY_PREVIEW: ShareSearchPreviewState = {
+  shareTrackSong: null,
+  shareTrackResolving: false,
+  shareTrackUnavailable: false,
+  shareAlbum: null,
+  shareAlbumResolving: false,
+  shareAlbumUnavailable: false,
+  shareArtist: null,
+  shareArtistResolving: false,
+  shareArtistUnavailable: false,
+  shareComposer: null,
+  shareComposerResolving: false,
+  shareComposerUnavailable: false,
+};
+
+export function useShareSearchPreview(shareMatch: ShareSearchMatch | null): ShareSearchPreviewState {
+  const [preview, setPreview] = useState<ShareSearchPreviewState>(EMPTY_PREVIEW);
+
+  useEffect(() => {
+    let cancelled = false;
+    setPreview(EMPTY_PREVIEW);
+
+    if (shareMatch?.type === 'queueable' && shareMatch.payload.k === 'track') {
+      setPreview({ ...EMPTY_PREVIEW, shareTrackResolving: true });
+      void resolveShareSearchPayload(shareMatch.payload)
+        .then(result => {
+          if (cancelled) return;
+          setPreview({
+            ...EMPTY_PREVIEW,
+            shareTrackSong: result.type === 'ok' ? (result.songs[0] ?? null) : null,
+            shareTrackUnavailable: result.type !== 'ok' || result.songs.length === 0,
+          });
+        })
+        .finally(() => {
+          if (!cancelled) {
+            setPreview(current => ({ ...current, shareTrackResolving: false }));
+          }
+        });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    if (shareMatch?.type === 'artist') {
+      setPreview({ ...EMPTY_PREVIEW, shareArtistResolving: true });
+      void resolveShareSearchArtist(shareMatch.payload)
+        .then(result => {
+          if (cancelled) return;
+          setPreview({
+            ...EMPTY_PREVIEW,
+            shareArtist: result.type === 'ok' ? result.artist : null,
+            shareArtistUnavailable: result.type !== 'ok',
+          });
+        })
+        .finally(() => {
+          if (!cancelled) {
+            setPreview(current => ({ ...current, shareArtistResolving: false }));
+          }
+        });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    if (shareMatch?.type === 'composer') {
+      setPreview({ ...EMPTY_PREVIEW, shareComposerResolving: true });
+      void resolveShareSearchArtist(shareMatch.payload)
+        .then(result => {
+          if (cancelled) return;
+          setPreview({
+            ...EMPTY_PREVIEW,
+            shareComposer: result.type === 'ok' ? result.artist : null,
+            shareComposerUnavailable: result.type !== 'ok',
+          });
+        })
+        .finally(() => {
+          if (!cancelled) {
+            setPreview(current => ({ ...current, shareComposerResolving: false }));
+          }
+        });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    if (shareMatch?.type === 'album') {
+      setPreview({ ...EMPTY_PREVIEW, shareAlbumResolving: true });
+      void resolveShareSearchAlbum(shareMatch.payload)
+        .then(result => {
+          if (cancelled) return;
+          setPreview({
+            ...EMPTY_PREVIEW,
+            shareAlbum: result.type === 'ok' ? result.album : null,
+            shareAlbumUnavailable: result.type !== 'ok',
+          });
+        })
+        .finally(() => {
+          if (!cancelled) {
+            setPreview(current => ({ ...current, shareAlbumResolving: false }));
+          }
+        });
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    return () => {
+      cancelled = true;
+    };
+  }, [shareMatch]);
+
+  return preview;
+}