Files
jellytau/src/routes/search/+page.svelte
T
dtourolle 1b70926c36
🏗️ Build and Test JellyTau / Run Tests (push) Successful in 20m34s
Publish Documentation / Build & publish docs to gitea-pages (push) Successful in 6m6s
Traceability Validation / Check Requirement Traces (push) Successful in 18s
Build & Release / Run Tests (push) Successful in 20m26s
🏗️ Build and Test JellyTau / Android Compile Check (push) Successful in 10m3s
Build & Release / Build Linux (push) Successful in 37m59s
Build & Release / Build Windows (push) Successful in 23m0s
Build & Release / Build Android (push) Successful in 40m26s
Build & Release / Create Release (push) Successful in 1m20s
feat(offline): play downloaded video, and drain the offline sync queue (0.4.6)
Bundles this session's work plus the concurrent search/offline/player changes.
Every gate passes on the combined tree: 885 frontend tests, 610 Rust tests,
clippy clean, boundary clean, trace coverage 86%.

Offline video playback — four separate defects, each of which alone stopped it:

  DR-133  A completed download's file_path is already absolute (the worker
          rewrites it on completion), but the player rooted it a second time and
          handed the webview /data/user/0/app//data/user/0/app/videos/x.mp4.
  DR-134  The asset protocol was never enabled: no protocol-asset feature and no
          assetProtocol config, so convertFileSrc produced URLs nothing answered.
          Also silently defeated the cached-thumbnail path, which fails soft to
          the server copy and hid it whenever the server was reachable.
  DR-137  Tauri's asset protocol answers a range-less request by reading the
          whole file into memory, and only advertises Accept-Ranges from inside
          its range branch, so the first request never learns ranges exist.
          Chromium gave up with PIPELINE_ERROR_READ after ~31s. Local media is
          now served by a loopback HTTP server: bounded 4 MiB chunks streamed
          from the file handle, every response length-delimited, and a range-less
          request answered with one chunk rather than the file. Confined by a
          per-session token and to the app data directory, because loopback is
          shared between apps on Android.
  DR-138  Release builds set usesCleartextTraffic=false, so Android rejected the
          request to that server before any I/O. A network-security-config
          exempts 127.0.0.1 only; a remote server must still be HTTPS.

Downloads:

  DR-135  download_item never records media_type and the reconnect resolver read
          that NULL as 'audio', so a movie queued from a media card had its URL
          resolved by get_audio_stream_url and completed as an audio-only
          transcode. The item's own type now decides.
  DR-136  Rows already downloaded that way are requeued on reconnect, since
          prevention alone leaves them reading "downloaded" and still unplayable.

Known limitation: a download taken at `original` quality is a byte copy of the
source, so it can be any container. One such file is an AVI holding XVID, which
the webview cannot play in any case — the media server serves it correctly and
Chromium refuses it. That needs either a transcoded download preset or the
native ExoPlayer surface work, and is not addressed here.

Also fixes two ID collisions between concurrent work: DR-143 defined twice
(search vs offline gate) and UT-131 defined twice (Episode Focus hero vs channel
cap). The search requirement is now DR-147 and the channel-cap test UT-141, with
their code references and matrix rows updated.
2026-08-09 16:38:07 +02:00

142 lines
5.1 KiB
Svelte

<script lang="ts">
import { library } from "$lib/stores/library";
import { goto } from "$app/navigation";
import { page } from "$app/stores";
import Search from "$lib/components/Search.svelte";
import SearchResults from "$lib/components/search/SearchResults.svelte";
import SearchScopeChips from "$lib/components/search/SearchScopeChips.svelte";
import {
parseSearchScope,
searchRouteUrl,
seedFromSearchUrl,
type SearchScope,
type SearchSeed,
} from "$lib/utils/searchScope";
import { episodeFocusHref } from "$lib/components/library/seriesNavigation";
import type { MediaItem } from "$lib/api/types";
// `?q=` / `?scope=` seed the page so the header search bar can hand a query
// over by navigating here — /search is the only surface that renders results,
// so every other search affordance routes into it.
// TRACES: UR-049 | DR-063
let searchQuery = $state($page.url.searchParams.get("q") ?? "");
let scope = $state<SearchScope>(parseSearchScope($page.url.searchParams.get("scope")));
// The URL is *consumed*, not continuously reconciled: `applied` records the
// seed already taken, so the user's typing and chip picks stand until a real
// navigation brings a different one. It is a plain `let` on purpose — as
// `$state` it would be a dependency of the effect that writes it and the
// effect would re-run itself.
//
// Reading `$library.searchQuery` here instead (the previous shape) made every
// search re-run this effect, which then re-asserted the URL's query over
// whatever had been typed since — the input snapped back a keystroke later.
// TRACES: UR-049 | DR-063, DR-064, DR-147
let applied: SearchSeed | null = null;
$effect(() => {
const seed = seedFromSearchUrl($page.url.searchParams, applied);
if (!seed) return;
applied = seed;
searchQuery = seed.query;
scope = seed.scope;
if (seed.query.trim()) {
library.search(seed.query, seed.scope);
} else {
library.clearSearch();
}
});
async function handleSearch(query: string) {
if (query.trim()) {
await library.search(query, scope);
} else {
library.clearSearch();
}
}
// Chips write the scope to the URL so the header bar (which searches with
// whatever scope the URL carries) and this page cannot disagree about it.
// Applied optimistically as well, so the chip highlights on click rather than
// a navigation later.
// TRACES: UR-049 | DR-064, DR-147
async function handleScopeChange(next: SearchScope) {
scope = next;
applied = { query: searchQuery, scope: next };
await goto(searchRouteUrl(searchQuery, next), {
replaceState: true,
keepFocus: true,
noScroll: true,
});
if (searchQuery.trim()) {
await library.search(searchQuery, next);
}
}
function handleItemClick(item: MediaItem) {
switch (item.type) {
case "Audio":
// Navigate to album page if available, otherwise detail page
if (item.albumId) {
goto(`/library/${item.albumId}`);
} else {
goto(`/library/${item.id}`);
}
break;
case "MusicAlbum":
case "MusicArtist":
case "Series":
case "Movie":
// Navigate to detail page to show metadata and cast
goto(`/library/${item.id}`);
break;
case "Episode":
// Tap opens, it does not play (ux-flows §5B.1/§5B.5) — a search hit
// went straight to the player, so it was the one episode entry point
// with no way to reach download, cast or the rest of the episode.
// TRACES: UR-058 | DR-142
goto(episodeFocusHref(item));
break;
default:
goto(`/library/${item.id}`);
break;
}
}
</script>
<div class="max-w-6xl mx-auto">
<h1 class="text-2xl font-bold mb-6">Search</h1>
<!-- Search input. On md+ the header bar owns the input (it is present on this
route too), so rendering one here as well would put two search boxes on
the same screen; below md the header has none and this is the only one. -->
<div class="mb-6 space-y-3">
<div class="md:hidden">
<Search
bind:value={searchQuery}
placeholder="Search your library..."
onSearch={handleSearch}
/>
</div>
<SearchScopeChips {scope} onChange={handleScopeChange} />
</div>
<!-- Search Results -->
{#if searchQuery.trim()}
<SearchResults
results={$library.searchResults}
loading={$library.loadingCount > 0}
{scope}
onItemClick={handleItemClick}
/>
{:else}
<div class="text-center text-gray-400 mt-12">
<svg class="w-16 h-16 mx-auto mb-4 text-gray-600" fill="currentColor" viewBox="0 0 24 24">
<path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/>
</svg>
<p>Search your entire library</p>
<p class="text-sm text-gray-500 mt-2">Find music, movies, shows, and more</p>
</div>
{/if}
</div>