Compare commits
6 commits
| Author | SHA1 | Date | |
|---|---|---|---|
| b42f77a3aa | |||
| 1f9474c2fd | |||
| 0d423eb708 | |||
| 624f01f745 | |||
| 6775d29249 | |||
| 940fe0a6b6 |
15 changed files with 225 additions and 113 deletions
|
|
@ -1,5 +1,13 @@
|
|||
# Changelog
|
||||
|
||||
## 1.0.1
|
||||
|
||||
A quicker start, a Stop button, and recovery when the server drops out mid-video.
|
||||
|
||||
- Kaleido starts faster: the opening animation is shorter, so you reach your library in about a second.
|
||||
- The player has a Stop button, next to the forward controls, which closes the player completely instead of moving it to the miniplayer.
|
||||
- If your Plex server goes down while you're watching, the player waits for it once the buffered video runs out, then carries on from the same spot when the server is back. Before, it treated the video as finished and Play started it again from the beginning. Pressing Play while it waits tries to reconnect straight away.
|
||||
|
||||
## 1.0.0
|
||||
|
||||
Kaleido is out of beta. This release reworks the show and season pages and smooths out watching a series.
|
||||
|
|
|
|||
4
package-lock.json
generated
4
package-lock.json
generated
|
|
@ -1,12 +1,12 @@
|
|||
{
|
||||
"name": "kaleido-desktop",
|
||||
"version": "1.0.0",
|
||||
"version": "1.0.1",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "kaleido-desktop",
|
||||
"version": "1.0.0",
|
||||
"version": "1.0.1",
|
||||
"dependencies": {
|
||||
"@fontsource-variable/inter": "^5.3.0",
|
||||
"@tanstack/react-query": "^5.105.0",
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"name": "kaleido-desktop",
|
||||
"private": true,
|
||||
"version": "1.0.0",
|
||||
"version": "1.0.1",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
|
|
|
|||
2
src-tauri/Cargo.lock
generated
2
src-tauri/Cargo.lock
generated
|
|
@ -2173,7 +2173,7 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "kaleido"
|
||||
version = "1.0.0"
|
||||
version = "1.0.1"
|
||||
dependencies = [
|
||||
"fs2",
|
||||
"futures-util",
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "kaleido"
|
||||
version = "1.0.0"
|
||||
version = "1.0.1"
|
||||
description = "Kaleido — a Plex client for Windows"
|
||||
authors = ["Elijah"]
|
||||
edition = "2021"
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"productName": "Kaleido",
|
||||
"version": "1.0.0",
|
||||
"version": "1.0.1",
|
||||
"identifier": "tv.kaleido.desktop",
|
||||
"build": {
|
||||
"beforeDevCommand": "npm run dev",
|
||||
|
|
|
|||
|
|
@ -758,7 +758,7 @@ function MiniPlayer() {
|
|||
</button>
|
||||
</div>
|
||||
<div className="mini-center">
|
||||
{(loading || st.buffering) && !st.error ? (
|
||||
{(loading || st.buffering || st.reconnecting) && !st.error ? (
|
||||
<Spinner size={30} />
|
||||
) : st.error ? (
|
||||
<span className="mini-error">Playback stopped</span>
|
||||
|
|
@ -965,10 +965,12 @@ export function PlayerOverlay() {
|
|||
{!st.fullscreen && <WindowControls />}
|
||||
</div>
|
||||
|
||||
{(loading || st.buffering || st.seeking || preparing) && !st.error && (
|
||||
{(loading || st.buffering || st.seeking || preparing || st.reconnecting) && !st.error && (
|
||||
<div className="player-center">
|
||||
<Spinner size={44} />
|
||||
{preparing && (
|
||||
{st.reconnecting ? (
|
||||
<p className="player-preparing">Lost connection to {server?.name ?? 'the server'}</p>
|
||||
) : preparing && (
|
||||
<p className="player-preparing">
|
||||
Preparing {UPSCALING[st.enhance.active].label} upscaling
|
||||
<small>First time on this computer only</small>
|
||||
|
|
@ -1023,6 +1025,8 @@ export function PlayerOverlay() {
|
|||
</span>
|
||||
</div>
|
||||
<div className="player-controls-center">
|
||||
{/* Balances Stop on the other side, so play/pause stays centred. */}
|
||||
<span className="player-icon-spacer" aria-hidden="true" />
|
||||
{/* Both episode buttons stay for episodes (dimmed at either end) so play/pause holds its place. */}
|
||||
{item.type === 'episode' && (
|
||||
<button
|
||||
|
|
@ -1055,6 +1059,9 @@ export function PlayerOverlay() {
|
|||
<Icon name="skipNext" size={22} />
|
||||
</button>
|
||||
)}
|
||||
<button className="player-icon" aria-label="Stop playback" title="Stop" onClick={() => st.close()}>
|
||||
<Icon name="stop" size={19} />
|
||||
</button>
|
||||
</div>
|
||||
<div className="player-controls-right">
|
||||
<button className={`player-icon${panel === 'tracks' ? ' on' : ''}${st.subKey ? ' lit' : ''}`} aria-label="Audio and subtitles" onClick={() => setPanel(panel === 'tracks' ? '' : 'tracks')}>
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ interface PlayerView {
|
|||
duration: number;
|
||||
firstFrame: boolean;
|
||||
buffering: boolean;
|
||||
reconnecting: boolean;
|
||||
error: string;
|
||||
}
|
||||
|
||||
|
|
@ -50,7 +51,8 @@ function view(st: PlayerView): MiniState {
|
|||
position: st.position,
|
||||
duration: st.duration,
|
||||
loading: !st.firstFrame && !st.error,
|
||||
buffering: st.buffering,
|
||||
// Waiting for the server to come back shows as buffering.
|
||||
buffering: st.buffering || st.reconnecting,
|
||||
error: !!st.error,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ const harness = vi.hoisted(() => {
|
|||
const memory = new Map<string, string>();
|
||||
vi.stubGlobal('localStorage', { getItem: (k: string) => memory.get(k) ?? null, setItem: (k: string, v: string) => memory.set(k, v), removeItem: (k: string) => memory.delete(k) });
|
||||
vi.stubGlobal('document', Object.assign(new EventTarget(), { hidden: false, hasFocus: () => true, documentElement: { classList: { toggle: vi.fn() } } }));
|
||||
return { event: (_e: MpvEvent) => {}, next: [] as unknown[], focused: true };
|
||||
return { event: (_e: MpvEvent) => {}, next: [] as unknown[], focused: true, identity: vi.fn() };
|
||||
});
|
||||
|
||||
vi.mock('../platform/native', () => ({
|
||||
|
|
@ -20,7 +20,7 @@ vi.mock('./engine', () => ({ mpv: {
|
|||
} }));
|
||||
vi.mock('../app/session', async () => {
|
||||
const { create } = await import('zustand');
|
||||
return { useSession: create(() => ({ server: { machineId: 'test', token: 'test-only' }, connection: { local: true } })) };
|
||||
return { useSession: create(() => ({ server: { machineId: 'test', token: 'test-only', name: 'Test', get: harness.identity }, connection: { local: true } })) };
|
||||
});
|
||||
vi.mock('../downloads/store', () => ({ useDownloads: { getState: () => ({ items: [] }) } }));
|
||||
vi.mock('../app/queries', () => ({ invalidateLibrary: vi.fn() }));
|
||||
|
|
@ -42,7 +42,11 @@ const episode = (id = '1') => parseItem({ ratingKey: id, type: 'episode', title:
|
|||
Media: [{ Part: [{ key: '/video', Stream: [{ id: 'audio', streamType: 2 }] }] }],
|
||||
});
|
||||
const time = (position: number) => harness.event({ type: 'property', name: 'time-pos', value: position });
|
||||
const eof = () => harness.event({ type: 'end-file', reason: 'eof' });
|
||||
/** The stream ending at `position` (by default the real end of the 100 s episode). */
|
||||
const eof = (position = 99.6) => {
|
||||
usePlayer.setState({ position });
|
||||
harness.event({ type: 'end-file', reason: 'eof' });
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
vi.useFakeTimers();
|
||||
|
|
@ -226,3 +230,51 @@ describe('Up Next playback lifecycle', () => {
|
|||
expect(usePlayer.getState()).toMatchObject({ open: false, postPlay: false, countdown: null });
|
||||
});
|
||||
});
|
||||
|
||||
describe('Losing the server mid-stream', () => {
|
||||
it('waits for the server instead of ending when the stream is cut off early', () => {
|
||||
eof(42);
|
||||
expect(usePlayer.getState()).toMatchObject({ reconnecting: true, ended: false, postPlay: false });
|
||||
});
|
||||
it('resumes from where it stopped once the server answers again', async () => {
|
||||
const original = usePlayer.getState().play;
|
||||
const play = vi.fn().mockResolvedValue(undefined);
|
||||
usePlayer.setState({ play });
|
||||
harness.identity.mockRejectedValueOnce(new Error('unreachable'));
|
||||
eof(42);
|
||||
await vi.advanceTimersByTimeAsync(2000);
|
||||
expect(play).not.toHaveBeenCalled();
|
||||
expect(usePlayer.getState().reconnecting).toBe(true);
|
||||
harness.identity.mockResolvedValueOnce({});
|
||||
await vi.advanceTimersByTimeAsync(3000);
|
||||
expect(play).toHaveBeenCalledWith(expect.objectContaining({ id: '1' }), expect.objectContaining({ offsetMs: 42000, keepMini: true }));
|
||||
expect(usePlayer.getState().reconnecting).toBe(false);
|
||||
usePlayer.setState({ play: original });
|
||||
});
|
||||
it('tries straight away on Play instead of starting over', async () => {
|
||||
const original = usePlayer.getState().play;
|
||||
const play = vi.fn().mockResolvedValue(undefined);
|
||||
usePlayer.setState({ play });
|
||||
harness.identity.mockResolvedValueOnce({});
|
||||
eof(42);
|
||||
usePlayer.getState().togglePause();
|
||||
await vi.waitFor(() => expect(play).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ offsetMs: 42000 })));
|
||||
expect(mpv.command).not.toHaveBeenCalledWith('seek', '0.000', 'absolute+exact');
|
||||
usePlayer.setState({ play: original });
|
||||
});
|
||||
it('treats a second cut-off at the same place as the real end of the file', async () => {
|
||||
harness.identity.mockResolvedValueOnce({});
|
||||
eof(42);
|
||||
await vi.advanceTimersByTimeAsync(2000);
|
||||
usePlayer.setState({ firstFrame: true });
|
||||
eof(42.5);
|
||||
expect(usePlayer.getState()).toMatchObject({ reconnecting: false, ended: true });
|
||||
});
|
||||
it('stops waiting when the player is closed', async () => {
|
||||
eof(42);
|
||||
await usePlayer.getState().close();
|
||||
harness.identity.mockClear();
|
||||
await vi.advanceTimersByTimeAsync(10000);
|
||||
expect(harness.identity).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -36,6 +36,8 @@ export interface PlayOptions {
|
|||
quality?: Quality;
|
||||
/** Keep these track choices (UI keys) instead of applying the preferences again. */
|
||||
tracks?: { audioKey: string; subKey: string };
|
||||
/** Reloading the same title in place (after an outage): stay in the miniplayer if it's there. */
|
||||
keepMini?: boolean;
|
||||
}
|
||||
|
||||
interface PlayerState {
|
||||
|
|
@ -48,6 +50,8 @@ interface PlayerState {
|
|||
error: string;
|
||||
/** The server owner stopped this stream (error holds their message). */
|
||||
terminated: boolean;
|
||||
/** The stream was cut off before the end (the server went away); waiting for it to come back. */
|
||||
reconnecting: boolean;
|
||||
position: number;
|
||||
duration: number;
|
||||
cacheTime: number;
|
||||
|
|
@ -597,7 +601,7 @@ function onEvent(e: MpvEvent) {
|
|||
}
|
||||
break;
|
||||
case 'eof-reached':
|
||||
if (v === true) onEnded();
|
||||
if (v === true) onStreamEnd();
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
|
@ -618,11 +622,14 @@ function onEvent(e: MpvEvent) {
|
|||
// (Briefly: an unreachable server shouldn't hold up the error.)
|
||||
const failed = session;
|
||||
Promise.race([report('buffering'), new Promise<boolean>((r) => setTimeout(() => r(false), 3000))]).then((terminated) => {
|
||||
if (terminated || !usePlayer.getState().open || session !== failed) return;
|
||||
const now = usePlayer.getState();
|
||||
if (terminated || !now.open || session !== failed) return;
|
||||
// Partway through a stream that was playing, it's the connection that failed.
|
||||
if (cutShort(now)) return onStreamEnd();
|
||||
usePlayer.setState({ error: e.error ? `Playback failed: ${e.error}` : 'This video could not be played.' });
|
||||
fallbackAfterError();
|
||||
});
|
||||
} else if (e.reason === 'eof') onEnded();
|
||||
} else if (e.reason === 'eof') onStreamEnd();
|
||||
break;
|
||||
case 'log':
|
||||
noteMpvLog(e.level, e.prefix, e.text);
|
||||
|
|
@ -655,6 +662,63 @@ function maybeCredits(pos: number) {
|
|||
} else if (!st.postPlayDismissed) openPostPlay();
|
||||
}
|
||||
|
||||
/**
|
||||
* A streamed title stopping well short of its end means the connection went
|
||||
* (mpv plays out its buffer, then sees the cut-off stream as the end of the file).
|
||||
*/
|
||||
const CUT_SHORT_MARGIN = 15;
|
||||
let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
|
||||
/** Where the last cut-off happened, so a file that really does end early isn't retried forever. */
|
||||
let lastCutAt: number | null = null;
|
||||
|
||||
function cutShort(st: PlayerState) {
|
||||
return st.delivery?.mode !== 'local' && st.firstFrame && st.duration > 0 && st.position < st.duration - CUT_SHORT_MARGIN;
|
||||
}
|
||||
|
||||
/** The stream ran out: a real ending, or a lost connection to wait out. */
|
||||
function onStreamEnd() {
|
||||
const st = usePlayer.getState();
|
||||
if (!cutShort(st)) return onEnded();
|
||||
if (st.reconnecting || st.ended) return;
|
||||
// Cut off at the same place again once the server answered: the file itself ends there.
|
||||
if (lastCutAt !== null && Math.abs(st.position - lastCutAt) < 5) return onEnded();
|
||||
lastCutAt = st.position;
|
||||
usePlayer.setState({ reconnecting: true, buffering: false });
|
||||
keepAwake(false);
|
||||
scheduleReconnect(2000);
|
||||
}
|
||||
|
||||
function stopReconnecting() {
|
||||
if (reconnectTimer) clearTimeout(reconnectTimer);
|
||||
reconnectTimer = null;
|
||||
}
|
||||
|
||||
function scheduleReconnect(delay: number) {
|
||||
stopReconnecting();
|
||||
reconnectTimer = setTimeout(() => void tryReconnect(), delay);
|
||||
}
|
||||
|
||||
/** Resumes where the stream was cut off if the server answers; otherwise checks again shortly. */
|
||||
async function tryReconnect(): Promise<boolean> {
|
||||
stopReconnecting();
|
||||
const st = usePlayer.getState();
|
||||
const s = server();
|
||||
if (!st.open || !st.reconnecting || !st.item || !s) return false;
|
||||
const reachable = await s.get('/identity', undefined, { timeout: 4000 }).then(
|
||||
() => true,
|
||||
() => false,
|
||||
);
|
||||
const now = usePlayer.getState();
|
||||
if (!now.open || !now.reconnecting || now.item?.id !== st.item.id) return false;
|
||||
if (!reachable) {
|
||||
scheduleReconnect(3000);
|
||||
return false;
|
||||
}
|
||||
usePlayer.setState({ reconnecting: false });
|
||||
await now.play(now.item, { offsetMs: now.position * 1000, mediaIndex: now.mediaIndex, quality: now.quality, tracks: currentTracks(now), keepMini: true });
|
||||
return true;
|
||||
}
|
||||
|
||||
function onEnded() {
|
||||
const st = usePlayer.getState();
|
||||
if (st.ended) return;
|
||||
|
|
@ -677,6 +741,7 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
firstFrame: false,
|
||||
error: '',
|
||||
terminated: false,
|
||||
reconnecting: false,
|
||||
position: 0,
|
||||
duration: 0,
|
||||
cacheTime: 0,
|
||||
|
|
@ -720,6 +785,8 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
return;
|
||||
}
|
||||
const previous = get();
|
||||
stopReconnecting();
|
||||
if (previous.item?.id !== input.id) lastCutAt = null;
|
||||
// The previous title's reporting ends here, against its own server.
|
||||
if (reportTimer) clearInterval(reportTimer);
|
||||
reportTimer = null;
|
||||
|
|
@ -748,6 +815,7 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
firstFrame: false,
|
||||
error: '',
|
||||
terminated: false,
|
||||
reconnecting: false,
|
||||
position: (opts.offsetMs ?? 0) / 1000,
|
||||
lastSeek: 0,
|
||||
duration: input.duration / 1000,
|
||||
|
|
@ -769,7 +837,7 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
subKey: opts.tracks?.subKey ?? '__init',
|
||||
video: null,
|
||||
fullscreen: fullscreenNow,
|
||||
mini: false,
|
||||
mini: opts.keepMini ? previous.open && previous.mini : false,
|
||||
videoGamma: '',
|
||||
enhance: { ...previous.enhance, bypass: false, preparing: false },
|
||||
});
|
||||
|
|
@ -866,6 +934,9 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
offsetMs > 0 && delivery.mode !== 'transcode' ? `start=${(offsetMs / 1000).toFixed(2)}` : 'start=none',
|
||||
].join(',');
|
||||
await mpv.command('loadfile', delivery.url, 'replace', -1, fileOpts);
|
||||
// A file left paused at its end (keep-open) re-pauses as soon as it's unpaused
|
||||
// above, so a reload in place (after an outage) would open paused: unpause again.
|
||||
await mpv.set('pause', false);
|
||||
if (stale()) return;
|
||||
keepAwake(true);
|
||||
report('buffering');
|
||||
|
|
@ -884,6 +955,8 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
loadToken++;
|
||||
const st = get();
|
||||
stopCountdown();
|
||||
stopReconnecting();
|
||||
lastCutAt = null;
|
||||
if (reportTimer) clearInterval(reportTimer);
|
||||
reportTimer = null;
|
||||
if (st.item && !st.error) report('stopped');
|
||||
|
|
@ -901,7 +974,7 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
await mpv.command('stop').catch(() => {});
|
||||
await mpv.show(false).catch(() => {});
|
||||
}
|
||||
set({ open: false, mini: false, postPlay: false, item: null, delivery: null, error: '', terminated: false, countdown: null, nextUp: null, prevUp: null, firstFrame: false });
|
||||
set({ open: false, mini: false, postPlay: false, item: null, delivery: null, error: '', terminated: false, reconnecting: false, countdown: null, nextUp: null, prevUp: null, firstFrame: false });
|
||||
// Closing the full player hands back the window it found; closing the
|
||||
// miniplayer leaves browsing as it is, full screen or not.
|
||||
if (!st.mini) {
|
||||
|
|
@ -913,6 +986,13 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
|
||||
togglePause() {
|
||||
const st = get();
|
||||
// Play while the server is away: try it now rather than at the next check.
|
||||
if (st.reconnecting) {
|
||||
tryReconnect().then((resumed) => {
|
||||
if (!resumed && get().reconnecting) toast(`Still can’t reach ${server()?.name ?? 'the server'}.`);
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (st.ended) {
|
||||
st.seek(0);
|
||||
set({ ended: false });
|
||||
|
|
|
|||
|
|
@ -2,11 +2,11 @@ import { useEffect, useRef } from 'react';
|
|||
import { useSettings } from '../app/settings';
|
||||
|
||||
/**
|
||||
* The cold-start brand sequence: a kaleidoscope. A mirrored field of shards
|
||||
* turns and gathers into the mark's six facets; if startup is still going,
|
||||
* small shards keep circling the mark. Once startup is ready the camera flies
|
||||
* through the mark's open centre, revealing the app drawn beneath (which
|
||||
* settles from a slight zoom, `html.splash-arrival`).
|
||||
* The cold-start brand sequence, kept short because desktop startup is quick:
|
||||
* the mark's six facets spin in from a loose ring and snap together with a
|
||||
* ring pulse. If startup is still going, small shards circle the mark. Once
|
||||
* startup is ready the camera flies through the mark's open centre, revealing
|
||||
* the app drawn beneath (which settles from a slight zoom, `html.splash-arrival`).
|
||||
*/
|
||||
|
||||
type Point = { x: number; y: number };
|
||||
|
|
@ -51,7 +51,7 @@ const rad = (deg: number) => (deg * Math.PI) / 180;
|
|||
const PALETTE = ['#C3E8D3', '#71B9B0', '#3D7C7B', '#D0A977', '#E9D8AE', '#EEF2DD'];
|
||||
|
||||
// The brand mark's facets, centred on its 64-unit viewport, each with the
|
||||
// angle of its hexagon edge's outward normal and its centroid.
|
||||
// outward normal of its hexagon edge and its centroid.
|
||||
const FACETS = [
|
||||
[33, 4, 55.5, 17, 42.5, 24.5, 33, 19],
|
||||
[56.5, 19, 56.5, 45, 43.5, 37.5, 43.5, 26.5],
|
||||
|
|
@ -63,48 +63,46 @@ const FACETS = [
|
|||
const points: Point[] = [];
|
||||
for (let k = 0; k < pts.length; k += 2) points.push({ x: pts[k] - 32, y: pts[k + 1] - 32 });
|
||||
const centroid = { x: points.reduce((s, p) => s + p.x, 0) / 4, y: points.reduce((s, p) => s + p.y, 0) / 4 };
|
||||
return { points, centroid, color: PALETTE[i], angle: rad(-60 + 60 * i) };
|
||||
const angle = rad(-60 + 60 * i);
|
||||
return { points, centroid, color: PALETTE[i], normal: { x: Math.cos(angle), y: Math.sin(angle) } };
|
||||
});
|
||||
type Facet = (typeof FACETS)[number];
|
||||
|
||||
// Loose shards around each facet: angle offset from the facet's normal, starting
|
||||
// radius (px), size, palette offset and how far they tumble on the way in.
|
||||
const SHARDS = [
|
||||
{ angle: 20, radius: 170, scale: 0.42, color: 2, spin: 1.2 },
|
||||
{ angle: -20, radius: 170, scale: 0.42, color: 4, spin: -1.2 },
|
||||
{ angle: 36, radius: 320, scale: 0.3, color: 3, spin: 2.1 },
|
||||
{ angle: -36, radius: 320, scale: 0.3, color: 1, spin: -2.1 },
|
||||
{ angle: 8, radius: 420, scale: 0.2, color: 5, spin: 3 },
|
||||
{ angle: -8, radius: 420, scale: 0.2, color: 5, spin: -3 },
|
||||
];
|
||||
|
||||
// The inner hexagon traced by the facets' inner edges: the aperture the exit flies through.
|
||||
const INNER_RADIUS = 13.6;
|
||||
const MARK_BOX = 140;
|
||||
// Timeline (ms): the mark has formed at INTRO_END; the sequence then idles until startup is ready.
|
||||
const INTRO_END = 1700;
|
||||
const EXIT_MS = 640;
|
||||
// The mark is larger than the old lockup, so it zooms less to end the flight at the same size.
|
||||
// Timeline (ms): the last facet locks at INTRO_END; the sequence then idles until startup is ready.
|
||||
const FACET_STAGGER = 18;
|
||||
const FACET_MS = 350;
|
||||
const INTRO_END = FACET_STAGGER * 5 + FACET_MS;
|
||||
// Still waiting at this point: shards start circling and a sheen crosses the mark.
|
||||
const IDLE_START = 1100;
|
||||
// Keep in step with the `splash-arrival` animation in app.css.
|
||||
const EXIT_MS = 540;
|
||||
const FLIGHT_ZOOM = 30;
|
||||
|
||||
const INK = '#090a0c';
|
||||
const SEA_GLASS = [113, 185, 176];
|
||||
const LIGHT = [238, 242, 221];
|
||||
const rgba = (c: number[], a: number) => `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${Math.max(0, a)})`;
|
||||
|
||||
/** A facet turned `rot` about the mark centre, shrunk and spun about its own centroid, then offset. */
|
||||
function facetPath(ctx: CanvasRenderingContext2D, f: Facet, o: Point, unit: number, rot: number, scale: number, spin: number, offset: Point) {
|
||||
/**
|
||||
* Facet `f` around mark centre `o`, `unit` px per grid unit: pushed `out` along its
|
||||
* normal, shrunk and spun about its own centroid, then turned `rot` about the mark centre.
|
||||
*/
|
||||
function facetPath(ctx: CanvasRenderingContext2D, f: Facet, o: Point, unit: number, out = 0, scale = 1, spin = 0, rot = 0) {
|
||||
const cr = Math.cos(rot);
|
||||
const sr = Math.sin(rot);
|
||||
const cs = Math.cos(spin);
|
||||
const ss = Math.sin(spin);
|
||||
const cx = f.centroid.x + f.normal.x * out;
|
||||
const cy = f.centroid.y + f.normal.y * out;
|
||||
f.points.forEach((p, i) => {
|
||||
const rx = p.x - f.centroid.x;
|
||||
const ry = p.y - f.centroid.y;
|
||||
const x = f.centroid.x + (rx * cs - ry * ss) * scale;
|
||||
const y = f.centroid.y + (rx * ss + ry * cs) * scale;
|
||||
const px = o.x + (x * cr - y * sr) * unit + offset.x;
|
||||
const py = o.y + (x * sr + y * cr) * unit + offset.y;
|
||||
const rx = p.x + f.normal.x * out - cx;
|
||||
const ry = p.y + f.normal.y * out - cy;
|
||||
const x = cx + (rx * cs - ry * ss) * scale;
|
||||
const y = cy + (rx * ss + ry * cs) * scale;
|
||||
const px = o.x + (x * cr - y * sr) * unit;
|
||||
const py = o.y + (x * sr + y * cr) * unit;
|
||||
if (i === 0) ctx.moveTo(px, py);
|
||||
else ctx.lineTo(px, py);
|
||||
});
|
||||
|
|
@ -142,9 +140,6 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
|
|||
ctx.clearRect(0, 0, w, h);
|
||||
const zoom = q > 0 ? Math.exp(Math.log(FLIGHT_ZOOM) * Flight(q)) : 1;
|
||||
const unit = (MARK_BOX / 64) * zoom;
|
||||
const gather = Emphasized(phase(time, 0, 1450));
|
||||
// The whole field turns a little less than half a revolution as it gathers.
|
||||
const field = rad(-150) * (1 - Emphasized(phase(time, 0, 1550)));
|
||||
|
||||
// The surface: ink everywhere, with the aperture's centre cut away on exit.
|
||||
const hole = InOut(phase(q, 0.12, 0.5));
|
||||
|
|
@ -163,25 +158,7 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
|
|||
ctx.globalAlpha = 1;
|
||||
}
|
||||
|
||||
// The kaleidoscope's mirror lines, turning with the field.
|
||||
const lines = InOut(phase(time, 0, 450)) * (1 - Standard(phase(time, 1100, 1700)));
|
||||
if (lines > 0) {
|
||||
ctx.lineWidth = 1;
|
||||
for (let s = 0; s < 6; s++) {
|
||||
const a = field + rad(-90 + 60 * s);
|
||||
const end = { x: o.x + Math.cos(a) * 640, y: o.y + Math.sin(a) * 640 };
|
||||
const g = ctx.createLinearGradient(o.x, o.y, end.x, end.y);
|
||||
g.addColorStop(0, rgba(LIGHT, 0.2 * lines));
|
||||
g.addColorStop(1, rgba(LIGHT, 0));
|
||||
ctx.strokeStyle = g;
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(o.x, o.y);
|
||||
ctx.lineTo(end.x, end.y);
|
||||
ctx.stroke();
|
||||
}
|
||||
}
|
||||
|
||||
const bloom = 0.09 * InOut(phase(time, 200, 1000)) * (1 - Standard(phase(time, 1500, 2600)));
|
||||
const bloom = 0.09 * InOut(phase(time, 0, 260)) * (1 - Standard(phase(time, 420, 1100)));
|
||||
if (bloom > 0.001) {
|
||||
ctx.globalCompositeOperation = 'lighter';
|
||||
const g = ctx.createRadialGradient(o.x, o.y, 0, o.x, o.y, 300);
|
||||
|
|
@ -195,56 +172,36 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
|
|||
ctx.globalCompositeOperation = 'source-over';
|
||||
}
|
||||
|
||||
// Shards spiral inward, faster than the field turns, and vanish into the centre.
|
||||
ctx.globalCompositeOperation = 'screen';
|
||||
const inward = Emphasized(phase(time, 0, 1350));
|
||||
// The six facets spin in from a loose ring and lock into the mark.
|
||||
FACETS.forEach((f, s) => {
|
||||
SHARDS.forEach((d, j) => {
|
||||
const appear = Standard(phase(time, j * 50 + s * 25, j * 50 + s * 25 + 420));
|
||||
const vanish = Standard(phase(time, 750 + j * 45, 1350 + j * 45));
|
||||
if (appear <= 0 || vanish >= 1) return;
|
||||
const a = f.angle + rad(d.angle) + field * 1.5;
|
||||
const r = d.radius * (1 - 0.88 * inward);
|
||||
ctx.globalAlpha = appear * (1 - vanish) * 0.9;
|
||||
ctx.fillStyle = PALETTE[(s + d.color) % 6];
|
||||
ctx.beginPath();
|
||||
shardPath(ctx, f, { x: o.x + Math.cos(a) * r, y: o.y + Math.sin(a) * r }, unit * d.scale * (1 - 0.6 * vanish), field * 2 + d.spin * (1 - gather));
|
||||
ctx.fill();
|
||||
});
|
||||
});
|
||||
ctx.globalAlpha = 1;
|
||||
ctx.globalCompositeOperation = 'source-over';
|
||||
|
||||
// The six facets ride in from the field and lock into the mark.
|
||||
FACETS.forEach((f, s) => {
|
||||
const r = 240 * (1 - gather);
|
||||
const a = f.angle + field;
|
||||
ctx.globalAlpha = Standard(phase(time, s * 25, s * 25 + 420));
|
||||
const start = s * FACET_STAGGER;
|
||||
const p = Emphasized(phase(time, start, start + FACET_MS));
|
||||
ctx.globalAlpha = Standard(phase(time, start, start + 160));
|
||||
ctx.fillStyle = f.color;
|
||||
ctx.beginPath();
|
||||
facetPath(ctx, f, o, unit, field, mix(0.55, 1, gather), rad(-60) * (1 - gather), { x: Math.cos(a) * r, y: Math.sin(a) * r });
|
||||
facetPath(ctx, f, o, unit, 7 * (1 - p), mix(0.5, 1, p), rad(-45) * (1 - p), rad(-60) * (1 - p));
|
||||
ctx.fill();
|
||||
});
|
||||
ctx.globalAlpha = 1;
|
||||
|
||||
// A ring pulses out as the facets lock.
|
||||
const pulse = phase(time, 1380, 2050);
|
||||
const pulse = phase(time, 340, 900);
|
||||
if (pulse > 0 && pulse < 1) {
|
||||
ctx.strokeStyle = rgba(SEA_GLASS, 0.45 * (1 - pulse));
|
||||
ctx.strokeStyle = rgba(SEA_GLASS, 0.45 * (1 - pulse) * (1 - phase(q, 0, 0.3)));
|
||||
ctx.lineWidth = 1.5;
|
||||
ctx.beginPath();
|
||||
hexagon(ctx, o, (30 + 24 * EmphasizedDecelerate(pulse)) * unit);
|
||||
hexagon(ctx, o, (30 + 22 * EmphasizedDecelerate(pulse)) * unit);
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
// Still starting: small shards keep circling the mark.
|
||||
const idle = Standard(phase(time, 2300, 2900)) * (1 - phase(q, 0, 0.25));
|
||||
// Still starting: small shards circle the mark.
|
||||
const idle = Standard(phase(time, IDLE_START, IDLE_START + 600)) * (1 - phase(q, 0, 0.25));
|
||||
if (idle > 0) {
|
||||
ctx.globalCompositeOperation = 'screen';
|
||||
ctx.globalAlpha = 0.4 * idle;
|
||||
for (let s = 0; s < 6; s++) {
|
||||
for (const side of [-1, 1]) {
|
||||
const a = rad(-60 + 60 * s) + side * rad(11) + (time - 2300) * 0.00032;
|
||||
const a = rad(-60 + 60 * s) + side * rad(11) + (time - IDLE_START) * 0.00032;
|
||||
ctx.fillStyle = PALETTE[(s + (side > 0 ? 2 : 4)) % 6];
|
||||
ctx.beginPath();
|
||||
shardPath(ctx, FACETS[s], { x: o.x + Math.cos(a) * 50 * unit, y: o.y + Math.sin(a) * 50 * unit }, unit * 0.16, a * 2);
|
||||
|
|
@ -255,12 +212,12 @@ function draw(ctx: CanvasRenderingContext2D, w: number, h: number, time: number,
|
|||
ctx.globalCompositeOperation = 'source-over';
|
||||
}
|
||||
|
||||
// A band of light crosses the settled mark, then again every few seconds while it waits.
|
||||
const sheen = time < 1500 ? 0 : ((time - 1500) % 3600) / 900;
|
||||
// While it waits, a band of light crosses the mark every few seconds.
|
||||
const sheen = time < IDLE_START ? 0 : ((time - IDLE_START) % 3600) / 900;
|
||||
if (q === 0 && sheen > 0 && sheen < 1) {
|
||||
ctx.save();
|
||||
ctx.beginPath();
|
||||
FACETS.forEach((f) => facetPath(ctx, f, o, unit, 0, 1, 0, { x: 0, y: 0 }));
|
||||
FACETS.forEach((f) => facetPath(ctx, f, o, unit));
|
||||
ctx.clip();
|
||||
const reach = 40 * unit;
|
||||
const a = rad(36);
|
||||
|
|
@ -334,7 +291,7 @@ export function Splash({ ready, onDone }: { ready: boolean; onDone: () => void }
|
|||
cancelAnimationFrame(raf);
|
||||
window.removeEventListener('resize', size);
|
||||
// Let the arrival settle finish after the splash is gone.
|
||||
setTimeout(() => document.documentElement.classList.remove('splash-arrival'), 700);
|
||||
setTimeout(() => document.documentElement.classList.remove('splash-arrival'), EXIT_MS + 60);
|
||||
};
|
||||
}, [reduced]);
|
||||
|
||||
|
|
|
|||
|
|
@ -270,10 +270,11 @@ html.os-macos:not(.window-fullscreen) .topbar {
|
|||
pointer-events: none;
|
||||
}
|
||||
/* The app beneath settles from a slight zoom as the camera flies through the
|
||||
aperture (held for the first quarter of the exit, then decelerating). */
|
||||
aperture (held for the first quarter of the exit, then decelerating).
|
||||
The duration matches EXIT_MS in Splash.tsx. */
|
||||
html.splash-arrival .app-shell,
|
||||
html.splash-arrival .auth-screen {
|
||||
animation: splash-arrival 640ms linear both;
|
||||
animation: splash-arrival 540ms linear both;
|
||||
}
|
||||
@keyframes splash-arrival {
|
||||
0% {
|
||||
|
|
|
|||
|
|
@ -350,6 +350,10 @@ html.os-macos:not(.window-fullscreen) .player-top {
|
|||
.player-controls-center {
|
||||
gap: 10px;
|
||||
}
|
||||
.player-icon-spacer {
|
||||
width: 44px;
|
||||
height: 44px;
|
||||
}
|
||||
.player-icon:disabled {
|
||||
opacity: 0.32;
|
||||
pointer-events: none;
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ const PATHS: Record<string, string> = {
|
|||
arrowLeft: '<path d="M19 12H5m6-6-6 6 6 6"/>',
|
||||
play: '<path d="M7 4.8v14.4a.8.8 0 0 0 1.2.7l11.6-7.2a.8.8 0 0 0 0-1.4L8.2 4.1a.8.8 0 0 0-1.2.7Z" fill="currentColor" stroke="none"/>',
|
||||
pause: '<rect x="6" y="4.5" width="4" height="15" rx="1.2" fill="currentColor" stroke="none"/><rect x="14" y="4.5" width="4" height="15" rx="1.2" fill="currentColor" stroke="none"/>',
|
||||
stop: '<rect x="5.5" y="5.5" width="13" height="13" rx="1.6" fill="currentColor" stroke="none"/>',
|
||||
plus: '<path d="M12 5v14M5 12h14"/>',
|
||||
minus: '<path d="M5 12h14"/>',
|
||||
check: '<path d="m5 12.5 4.2 4.2L19 7"/>',
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
{
|
||||
"version": "0.1.0-beta.19",
|
||||
"notes": "Up Next fixes.\r\n\r\n- Up Next now opens every time the credits start: going back to the credits and seeking into the episode brings it back when they come round again, and it always opens when an episode reaches the end.\r\n- The back arrow and a full-screen button are back at the top of Up Next, so you can return to browsing (playback continues in the miniplayer) or leave full screen.\r\n- Click the show's logo to go to its page, with playback moving to the miniplayer.\r\n- The Play next episode countdown fills smoothly.\r\n- The episode rows are sized to fill the screen instead of leaving a gap at the bottom.\r\n- The backdrop now shows the next episode, and its description is easier to read over bright artwork.",
|
||||
"pub_date": "2026-11-12T19:57:48.627Z",
|
||||
"version": "1.0.1",
|
||||
"notes": "A quicker start, a Stop button, and recovery when the server drops out mid-video.\r\n\r\n- Kaleido starts faster: the opening animation is shorter, so you reach your library in about a second.\r\n- The player has a Stop button, next to the forward controls, which closes the player completely instead of moving it to the miniplayer.\r\n- If your Plex server goes down while you're watching, the player waits for it once the buffered video runs out, then carries on from the same spot when the server is back. Before, it treated the video as finished and Play started it again from the beginning. Pressing Play while it waits tries to reconnect straight away.",
|
||||
"pub_date": "2026-11-17T17:47:20.996Z",
|
||||
"platforms": {
|
||||
"windows-x86_64": {
|
||||
"signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUlVST1RiNHdFVm01NGJlc0gzYzRXWEVxdDZBeWI1ckRDZ3BwSGQrSTFxZm5RVSsvQi8yU3JOZFByTzBSY3VFUm1LU1U0YjRLU3l2cTZmakY5Nlg4K3Z4NnIxSjRXMW1Mb3dzPQp0cnVzdGVkIGNvbW1lbnQ6IHRpbWVzdGFtcDoxNzk0NTEzNDUzCWZpbGU6S2FsZWlkb18wLjEuMC1iZXRhLjE5X3g2NC1zZXR1cC5leGUJdmVyc2lvbjowLjEuMC1iZXRhLjE5CndMMnN3a28zdC92OHZ6eUVNSXNSV3dHWEJSczd5aFJ1bEpDSFVEUXRYUDRVNVhGeEw4eVIzZ014WW5CWlhIWVJzWFJYTDVFUzU4eVBwNStjZ1RmVkFnPT0K",
|
||||
"url": "https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/v0.1.0-beta.19/Kaleido_0.1.0-beta.19_x64-setup.exe"
|
||||
"signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUlVST1RiNHdFVm01NFZMQVRPVll0SHZPQWJWUlIyQnZEME10bldKUnYxSkhHWEJSWWxOT3FoVHp6NlNsU0dwdlg1UmUweGlEdzNoQnduSnora0dZempZS2ZWdFZLa3BIRkFJPQp0cnVzdGVkIGNvbW1lbnQ6IHRpbWVzdGFtcDoxNzk0OTM3NjI5CWZpbGU6S2FsZWlkb18xLjAuMV94NjQtc2V0dXAuZXhlCXZlcnNpb246MS4wLjEKeUI5aUJ4d3hONmVlNlBBWDFxQkFkYTV4WXU0eHIzb1ZKaVZjaDhpODhpbXdvL2RWRlhTRTBwQXJGV3hJYlg2RERnMDBhSFBRWHZDekxCRTVNNCtIRFE9PQo=",
|
||||
"url": "https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/v1.0.1/Kaleido_1.0.1_x64-setup.exe"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue