Release Kaleido Desktop 0.1.0-beta.12
All checks were successful
Validate Kaleido Desktop / validate (push) Successful in 1m22s

On Windows the miniplayer is now a window of its own (mini.rs, mini.html):
a borderless window owned by the main one that the video moves into
(VideoSurface::set_host swaps composition targets in one commit). Dragging
moves the whole window, so video and controls move together with no edge
flicker; release glides it to the nearest corner or the one it's flicked
towards, remembered, and it follows the main window. Its page mirrors the
player over events (mini:state / mini:action). Shown and hidden natively
without activation, so the main window keeps focus. macOS keeps the
in-page miniplayer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Elijah 2026-11-04 17:35:08 -07:00
parent c3d2f4b6a7
commit 8ed44c2fe4
22 changed files with 871 additions and 26 deletions

97
src/player/miniWindow.ts Normal file
View file

@ -0,0 +1,97 @@
/**
* The miniplayer as a window of its own (Windows, src-tauri/src/mini.rs): the
* video moves into it, so it drags as one piece. This side keeps its page
* (src/mini/) up to date and carries out its buttons; macOS keeps the
* in-page miniplayer (PlayerOverlay).
*/
import { hostOS, invoke, isNative, listen } from '../platform/native';
import { episodeLabel } from '../app/format';
import { MINI_CORNER_KEY, type MiniAction, type MiniState } from '../mini/types';
import type { Item } from '../plex/types';
export const separateMini = isNative && hostOS === 'windows';
export async function showMiniWindow() {
await invoke('mini_show', { corner: localStorage.getItem(MINI_CORNER_KEY) ?? 'br' });
}
/** Moves the video back to the main window; harmless when already there. */
export async function hideMiniWindow() {
await invoke('mini_hide').catch(() => {});
}
interface PlayerView {
open: boolean;
mini: boolean;
item: Item | null;
paused: boolean;
ended: boolean;
position: number;
duration: number;
firstFrame: boolean;
buffering: boolean;
error: string;
}
interface PlayerActions {
togglePause(): void;
seekBy(delta: number): void;
expand(): void;
close(): Promise<void>;
}
function view(st: PlayerView): MiniState {
const item = st.item;
return {
title: item ? (item.type === 'episode' ? item.grandparentTitle : item.title) : '',
subtitle: item?.type === 'episode' ? `${episodeLabel(item)} · ${item.title}` : '',
paused: st.paused,
ended: st.ended,
position: st.position,
duration: st.duration,
loading: !st.firstFrame && !st.error,
buffering: st.buffering,
error: !!st.error,
};
}
/** Mirrors the player into the miniplayer window and listens for its buttons. */
export function bridgeMiniWindow(store: { getState(): PlayerView & PlayerActions; subscribe(listener: (st: PlayerView, prev: PlayerView) => void): () => void }) {
if (!separateMini) return;
let lastSent = 0;
let pending: ReturnType<typeof setTimeout> | null = null;
const send = async () => {
pending = null;
lastSent = Date.now();
const st = store.getState();
if (!st.open) return;
const { emitTo } = await import('@tauri-apps/api/event');
emitTo('mini', 'mini:state', view(st)).catch(() => {});
};
store.subscribe((st, prev) => {
if (!st.open || !st.mini) return;
// Everything but the position goes straight away; the position a few times a second.
const a = view(st);
const b = view(prev);
const only = (Object.keys(a) as (keyof MiniState)[]).every((k) => k === 'position' || a[k] === b[k]);
if (!only || st.mini !== prev.mini) {
if (pending) clearTimeout(pending);
send();
} else if (!pending) {
pending = setTimeout(send, Math.max(0, 250 - (Date.now() - lastSent)));
}
});
listen<{ type: MiniAction }>('mini:action', ({ type }) => {
const st = store.getState();
if (type === 'ready') return send();
if (!st.open) return;
if (type === 'toggle') st.togglePause();
else if (type === 'back') st.seekBy(-10);
else if (type === 'forward') st.seekBy(10);
else if (type === 'expand') st.expand();
else if (type === 'close') st.close();
});
}