Kaleido-Desktop/src/app/App.tsx
Elijah 43c168da95 Address the first beta's bugs and requested changes
Startup now uses the Android iris animation, and playback can continue
in a corner miniplayer while browsing (the video is drawn into a corner
rectangle beneath a matching hole in the page). The player keeps the
window controls, hides its chrome when the pointer leaves, and gains
audio/subtitle tracks, audio sync, source bitrate and playback details
in its options. Subtitles can be styled in Settings with a live preview.
Categories replace Collections, the A–Z rail magnifies, descriptions
expand in place, downloads can be removed in bulk, and search keeps its
results while typing.

Fixes scroll jank from per-card and scrolling backdrop blurs, the hidden
colour wash, the cubic volume curve, loud theme music, the search focus
ring, a stray nav indicator, Continue Watching previews and the TV Shows
header overlap. Removes the star rating, the duplicate Settings menu
entry and the server settings' Show advanced switch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 18:06:54 -07:00

259 lines
9 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { lazy, Suspense, useEffect, useLayoutEffect, useRef, useState } from 'react';
import { QueryClientProvider } from '@tanstack/react-query';
import { queryClient, invalidateLibrary } from './queries';
import { useSession } from './session';
import { useRouter, navigate, type Route } from './router';
import { useSettings } from './settings';
import { TopBar } from './TopBar';
import { MenuHost, ToastHost, ConfirmHost } from '../ui/overlays';
import { HoverPreviewHost } from '../ui/HoverPreview';
import { PageLoader } from '../ui/primitives';
import { Splash } from '../screens/Splash';
import { SignIn } from '../screens/SignIn';
import { ServerPicker } from '../screens/ServerPicker';
import { win } from '../platform/native';
import { usePlayer } from '../player/store';
import { PlayerOverlay } from '../player/PlayerOverlay';
import { DialogHost } from '../screens/dialogs/DialogHost';
import { useDownloads } from '../downloads/store';
import { libraryRevision } from '../plex/api';
import { checkForUpdate } from './updater';
import { Home } from '../screens/Home';
import { SectionScreen } from '../screens/Section';
import { ItemScreen } from '../screens/Item';
const Search = lazy(() => import('../screens/Search'));
const Downloads = lazy(() => import('../screens/Downloads'));
const Settings = lazy(() => import('../screens/settings/Settings'));
const Person = lazy(() => import('../screens/Person'));
const HubScreen = lazy(() => import('../screens/HubScreen'));
function Screen({ route }: { route: Route }) {
switch (route.name) {
case 'home':
return <Home />;
case 'section':
return <SectionScreen kind={route.kind} tab={route.tab} genre={route.genre} genreTitle={route.genreTitle} />;
case 'item':
return <ItemScreen id={route.id} />;
case 'person':
return <Person id={route.id} title={route.title} thumb={route.thumb} />;
case 'hub':
return <HubScreen hubKey={route.key} title={route.title} />;
case 'search':
return <Search initial={route.query} />;
case 'downloads':
return <Downloads />;
case 'settings':
return <Settings mode={route.mode} tab={route.tab} />;
}
}
/** One scroll container per history entry; its position is restored on Back. */
function Page({ onScrolled }: { onScrolled: (top: number) => void }) {
const entry = useRouter((s) => s.current);
const ref = useRef<HTMLDivElement>(null);
useLayoutEffect(() => {
const el = ref.current;
if (!el) return;
const target = entry.scroll;
el.scrollTop = target;
onScrolled(target);
if (!target) return;
// Content may still be loading; keep trying briefly until it is tall enough.
let tries = 0;
const t = setInterval(() => {
if (!ref.current || tries++ > 30) return clearInterval(t);
ref.current.scrollTop = target;
if (Math.abs(ref.current.scrollTop - target) < 2) clearInterval(t);
}, 50);
return () => clearInterval(t);
}, [entry]);
return (
<div
ref={ref}
className="main-scroll"
data-route={entry.route.name}
onScroll={(e) => {
const top = (e.target as HTMLDivElement).scrollTop;
entry.scroll = top;
onScrolled(top);
}}
>
<Suspense fallback={<PageLoader />}>
<main className="page-enter" key={entry.id}>
<Screen route={entry.route} />
</main>
</Suspense>
</div>
);
}
function useGlobalShortcuts() {
useEffect(() => {
const isTyping = (t: EventTarget | null) => t instanceof HTMLElement && (t.isContentEditable || ['INPUT', 'TEXTAREA', 'SELECT'].includes(t.tagName));
const playerFull = () => usePlayer.getState().open && !usePlayer.getState().mini;
const onKey = (e: KeyboardEvent) => {
if (playerFull()) return;
if ((e.ctrlKey || e.metaKey) && (e.key === 'k' || e.key === 'f')) {
e.preventDefault();
navigate({ name: 'search' });
} else if (e.altKey && e.key === 'ArrowLeft') {
e.preventDefault();
useRouter.getState().back();
} else if (e.altKey && e.key === 'ArrowRight') {
e.preventDefault();
useRouter.getState().forward();
} else if (e.key === 'F11') {
e.preventDefault();
win.isFullscreen().then((fs) => win.setFullscreen(!fs));
} else if ((e.key === 'Escape' || e.key === 'Backspace') && !isTyping(e.target) && !document.querySelector('.menu-layer, .dialog-layer')) {
if (e.key === 'Escape' && document.fullscreenElement) return;
useRouter.getState().back();
} else if ((e.ctrlKey || e.metaKey) && e.key === ',') {
e.preventDefault();
navigate({ name: 'settings', mode: 'app', tab: 'general' });
}
};
// Mouse back/forward buttons.
const onMouse = (e: MouseEvent) => {
if (playerFull()) return;
if (e.button === 3) {
e.preventDefault();
useRouter.getState().back();
} else if (e.button === 4) {
e.preventDefault();
useRouter.getState().forward();
}
};
window.addEventListener('keydown', onKey);
window.addEventListener('mouseup', onMouse);
return () => {
window.removeEventListener('keydown', onKey);
window.removeEventListener('mouseup', onMouse);
};
}, []);
}
/** Refreshes browsing when the server's libraries change. */
function useLibrarySync() {
const server = useSession((s) => s.server);
useEffect(() => {
if (!server) return;
let last = '';
let stopped = false;
const tick = async () => {
if (stopped || document.hidden || (usePlayer.getState().open && !usePlayer.getState().mini)) return;
try {
const rev = await libraryRevision(server);
if (last && rev !== last) invalidateLibrary();
last = rev;
} catch {
/* transient */
}
};
tick();
const t = setInterval(tick, 20000);
const onVisible = () => !document.hidden && tick();
document.addEventListener('visibilitychange', onVisible);
return () => {
stopped = true;
clearInterval(t);
document.removeEventListener('visibilitychange', onVisible);
};
}, [server]);
}
function Shell() {
const [scrolled, setScrolled] = useState(false);
const playerOpen = usePlayer((s) => s.open && !s.mini);
const startPage = useSettings.getState().startPage;
useGlobalShortcuts();
useLibrarySync();
useEffect(() => {
if (startPage !== 'home') useRouter.getState().reset(startPage === 'movies' ? { name: 'section', kind: 'movie', tab: 'discover' } : { name: 'section', kind: 'show', tab: 'discover' });
useDownloads.getState().init().then(() => useDownloads.getState().resumeInterrupted());
const t = setTimeout(() => checkForUpdate(false), 8000);
return () => clearTimeout(t);
}, []);
return (
<>
<div className="app-shell" aria-hidden={playerOpen}>
<TopBar solid={scrolled} />
<Page onScrolled={(top) => setScrolled(top > 24)} />
</div>
<PlayerOverlay />
</>
);
}
function OfflineShell() {
const error = useSession((s) => s.error);
const init = useSession((s) => s.init);
useEffect(() => {
useDownloads.getState().init();
useRouter.getState().reset({ name: 'downloads' });
}, []);
return (
<>
<div className="app-shell offline">
<div className="offline-banner" data-tauri-drag-region>
<span>{error || 'You’re offline.'}</span>
<button className="btn text" onClick={() => init()}>
Try again
</button>
</div>
<div className="main-scroll">
<Suspense fallback={<PageLoader />}>
<Downloads offline />
</Suspense>
</div>
</div>
<PlayerOverlay />
</>
);
}
export function App() {
const status = useSession((s) => s.status);
const hasServer = useSession((s) => !!s.server);
const reducedMotion = useSettings((s) => s.reducedMotion);
const [splashDone, setSplashDone] = useState(false);
useEffect(() => {
useSession.getState().init();
// The window appears once the first frame is painted (no white flash).
requestAnimationFrame(() => win.show());
}, []);
useEffect(() => {
document.documentElement.classList.toggle('reduced-motion', reducedMotion);
}, [reducedMotion]);
// Switching servers or users starts browsing fresh.
const serverId = useSession((s) => s.server?.machineId);
useEffect(() => {
if (serverId) useRouter.getState().reset({ name: 'home' });
}, [serverId]);
let body;
if (status === 'loading') body = null;
else if (status === 'signed-out') body = <SignIn />;
else if (status === 'choose-server' || (status === 'connecting' && !hasServer)) body = <ServerPicker />;
else if (status === 'offline') body = <OfflineShell />;
else body = <Shell />;
return (
<QueryClientProvider client={queryClient}>
{body}
{(!splashDone || status === 'loading') && <Splash ready={status !== 'loading'} onDone={() => setSplashDone(true)} />}
<HoverPreviewHost />
<DialogHost />
<MenuHost />
<ConfirmHost />
<ToastHost />
</QueryClientProvider>
);
}