Kaleido-Desktop/src/app/App.tsx
Elijah Kuntz 7d0803481b Port Kaleido Desktop to macOS
macOS (Apple silicon) now plays, browses and updates like Windows:

- Video: libmpv's render API draws into a CAOpenGLLayer beneath the
  WKWebView, with the miniplayer rectangle, HDR passthrough through
  extended dynamic range (PQ/BT.2020) and display-sleep prevention.
- Window: native traffic lights on the top bar's centre line, hidden
  with the player's controls; the page's caption buttons are Windows-only.
- Interface: macOS shortcut labels (⌘K, ⌘[, ⌃⌘F), Plex identifies the
  player as a Mac, and header values are kept ASCII (Mac computer names
  usually contain a curly apostrophe).
- The window appears without waiting for an animation frame, which
  WKWebView doesn't run in a hidden window.
- Credentials: release builds use the Keychain and are signed with a
  lasting self-signed certificate so access survives updates; debug
  builds keep tokens in a private file to avoid prompts on every rebuild.
- Bundling: scripts/fetch-libmpv.sh makes Homebrew's libmpv and its
  libraries self-contained; scripts/build.sh builds the .app, .dmg and
  signed update archive.

Releases now carry both platforms: publish-release.mjs uploads each
machine's build into one release, and update-manifest.mjs writes the
feed from that release's assets, refusing while a platform is missing.

The updater uses a new signing key (public key in tauri.conf.json), so
existing installs must be reinstalled once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:14:40 -07:00

268 lines
9.4 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 { isMac, 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') || (isMac && e.metaKey && e.key === '[')) {
e.preventDefault();
useRouter.getState().back();
} else if ((e.altKey && e.key === 'ArrowRight') || (isMac && e.metaKey && e.key === ']')) {
e.preventDefault();
useRouter.getState().forward();
} else if (e.key === 'F11' || (isMac && e.metaKey && e.ctrlKey && e.key.toLowerCase() === 'f')) {
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).
// WKWebView runs no animation frames until its window is shown, so a
// timeout stands in there.
let shown = false;
const show = () => {
if (!shown) win.show();
shown = true;
};
requestAnimationFrame(show);
const fallback = setTimeout(show, 150);
return () => clearTimeout(fallback);
}, []);
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>
);
}