@kromatv/sdk 0.1.39-canary.3579809

package/types/ui/src/components/organisms/player/parts/subtitle-renderer/subtitle-renderer.d.ts

@@ -0,0 +1,32 @@
+import { type SubtitleAppearance } from '#ui/components/organisms/player/lib/subtitle-appearance';
+import type { PlayerSub } from '#ui/components/organisms/player/types';
+interface SubtitleRendererProps {
+    /** Absolute playback position in seconds. */
+    positionSec: number;
+    playing: boolean;
+    /** Bumped on every seek so the renderer can re-sync its cue search. */
+    seekNonce?: number;
+    subtitles: PlayerSub[];
+    activeIndex: number | null;
+    appearance: SubtitleAppearance;
+    /** When true the controls are visible, so lift the caption above them. */
+    raised: boolean;
+    /** The active track's WebVTT could not be fetched, or held zero cues. The
+     *  HOST decides what that means (mark the picker row unavailable, fall back
+     *  to off) - a renderer that swallows the failure leaves a settings row that
+     *  silently does nothing, which reads as a broken app. */
+    onTrackFailed?: (index: number) => void;
+}
+/**
+ * One position-driven subtitle renderer for web AND TV. It fetches the active
+ * track's WebVTT itself (cross-origin `<track>` cues never load when the app and
+ * media server differ in origin), caches the parsed cues per url, and renders the
+ * cue that contains the current position. The position is interpolated locally
+ * while playing so coarse engine clocks (AVPlay/timeupdate) stay in sync.
+ */
+export declare function SubtitleRenderer({ positionSec, playing, seekNonce, subtitles, activeIndex, appearance, raised, onTrackFailed, }: Readonly<SubtitleRendererProps>): import("react").JSX.Element | null;
+/** The cue band's DOM id, present only while a cue is on screen. A shell drawing
+ * the picture on a plane behind the page measures it to keep the band out of the
+ * plane's way. */
+export declare const SUBTITLE_LAYER_ID = "kroma-player-subtitles";
+export {};

package/types/ui/src/components/organisms/player/parts/surface-radius.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from 'react';
+import type { Animated } from 'react-native';
+export type SurfaceRadius = number | Animated.AnimatedInterpolation<number>;
+export declare function SurfaceRadiusProvider({ radius, children, }: Readonly<{
+    radius: SurfaceRadius;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** The radius the surface should round itself to; 0 when fullscreen. */
+export declare function useSurfaceRadius(): SurfaceRadius;

package/types/ui/src/components/organisms/player/parts/top-bar/index.d.ts

@@ -0,0 +1 @@
+export * from './top-bar';

package/types/ui/src/components/organisms/player/parts/top-bar/top-bar.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+/**
+ * Player top chrome (§ top chrome): a gradient bar holding the round back
+ * button, the title + subtitle, and an optional warning pill on the right (a
+ * transcode / unsupported-codec notice, say). Rendered over the video, so the
+ * bar itself is click-through and only the back button captures the pointer.
+ */
+export interface TopBarProps {
+    title: ReactNode;
+    subtitle?: ReactNode;
+    /** Pre-translated warning, or nothing to hide the pill. */
+    warn?: ReactNode;
+    onBack: () => void;
+    /** Whether the nav machine currently rests on the back button. */
+    backFocused?: boolean;
+    /** Host-supplied controls for the right edge (the web's "play on TV"). The
+     * TV passes none: it is the screen things are cast TO. */
+    actions?: ReactNode;
+    /** The chrome's scale (see ../lib/metrics). 1 on a television stage. */
+    scale?: number;
+}
+/** Memoized: its props never change on a playback tick, so the bar skips the
+ * ~4 Hz timeupdate re-renders of the surrounding chrome. */
+export declare const TopBar: import("react").MemoExoticComponent<({ title, subtitle, warn, onBack, backFocused, actions, scale, }: Readonly<TopBarProps>) => import("react").JSX.Element>;

package/types/ui/src/components/organisms/player/parts/transport/index.d.ts

@@ -0,0 +1 @@
+export * from './transport';

package/types/ui/src/components/organisms/player/parts/transport/transport.d.ts

@@ -0,0 +1,19 @@
+import type { LayoutChangeEvent } from 'react-native';
+import type { StoryboardTile } from '#ui/services/storyboard';
+import type { usePlayerNav } from '../../hooks/use-player-nav';
+import { type ChromeMetrics } from '../../lib/metrics';
+import type { Chapter, PlayerController } from '../../types';
+interface TransportProps {
+    controller: PlayerController;
+    chapters?: Chapter[];
+    tileAt: (sec: number) => StoryboardTile | null;
+    metrics: ChromeMetrics;
+    nav: ReturnType<typeof usePlayerNav>;
+    chromeShown: boolean;
+    /** The padding the up-next peek claims under the controls, in real pixels: it
+     *  is the sheet's own height and is never scaled. */
+    bottomInset: number;
+    onLayout: (event: LayoutChangeEvent) => void;
+}
+declare function Transport({ controller: c, chapters: rawChapters, tileAt, metrics, nav, chromeShown, bottomInset, onLayout, }: Readonly<TransportProps>): import("react").JSX.Element;
+export { Transport };

package/types/ui/src/components/organisms/player/parts/up-next-card/index.d.ts

@@ -0,0 +1 @@
+export * from './up-next-card';

package/types/ui/src/components/organisms/player/parts/up-next-card/up-next-card.d.ts

@@ -0,0 +1,37 @@
+import { type DimensionValue } from 'react-native';
+export interface UpNextItem {
+    id: string;
+    title: string;
+    subtitle?: string;
+    posterUrl?: string | null;
+    categoryLabel?: string;
+}
+export interface UpNextCardProps {
+    item: UpNextItem;
+    /** Handed the card's `item`, so one handler serves the whole sheet rather
+     *  than a closure per card. */
+    onActivate: (item: UpNextItem) => void;
+    /** The first card of an opening sheet takes the focus. */
+    autoFocus?: boolean;
+    /** False for the parked PEEK, which is a picture of the sheet rather than the
+     *  sheet: its cards must not be reachable while the remote drives the chrome. */
+    interactive?: boolean;
+    width?: DimensionValue;
+}
+export declare const UP_NEXT_COLUMNS = 3;
+export declare const UP_NEXT_GAP = 26;
+/** The width a card is actually DRAWN at, three across a 1920 stage once the
+ * sheet's padding and gaps are taken out - and so the width its artwork should
+ * be requested at. The hooks used to ask for no width at all, which serves the
+ * original: three full-size stills arrive and the rest of the sheet is still
+ * downloading, which on a television looks exactly like art that never loads. */
+export declare const UP_NEXT_ART_W: number;
+/**
+ * One card of the up-next sheet: a still with its caption on it.
+ *
+ * The card is a <Focusable>, so the ring, the lift over its neighbours and the
+ * scroll that brings it into view are the kit's, the same ones every tile in the
+ * product uses - the sheet used to run its own index, its own ring and its own
+ * scrolling, and each of the three drifted from the kit in its own way.
+ */
+export declare function UpNextCard({ item, onActivate, autoFocus, interactive, width, }: Readonly<UpNextCardProps>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/index.d.ts

@@ -0,0 +1 @@
+export * from './up-next-sheet';

package/types/ui/src/components/organisms/player/parts/up-next-sheet/sheet-header.d.ts

@@ -0,0 +1,6 @@
+/** The sheet's title row: the way out of an open sheet, and a pointer's way in. */
+export declare function SheetHeader({ open, title, onToggle, }: Readonly<{
+    open: boolean;
+    title: string;
+    onToggle: () => void;
+}>): import("react").JSX.Element;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/sheet-keys.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+export interface SheetKeysProps {
+    handle: Ref<PanelHandle> | undefined;
+    open: boolean;
+    onClose: () => void;
+}
+export declare function SheetKeys({ handle, open, onClose }: Readonly<SheetKeysProps>): null;

package/types/ui/src/components/organisms/player/parts/up-next-sheet/up-next-sheet.d.ts

@@ -0,0 +1,22 @@
+import { type Ref } from 'react';
+import type { PanelHandle } from '#ui/components/organisms/player/lib/nav';
+import { type UpNextItem } from '#ui/components/organisms/player/parts/up-next-card';
+export type { UpNextItem };
+export interface UpNextData {
+    nextEpisodes: UpNextItem[];
+    recommendations: UpNextItem[];
+}
+export interface UpNextSheetProps {
+    data: UpNextData;
+    open: boolean;
+    revealed: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    onPlay: (item: UpNextItem) => void;
+    ref?: Ref<PanelHandle>;
+}
+export declare const PEEK_HEIGHT = 150;
+/** One sliding sheet with two positions: parked as a non-focusable peek, or
+ * risen over a scrim into a scrollable grid the D-pad walks as one flat list. */
+declare function UpNextSheetBase({ data, open, revealed, onOpen, onClose, onPlay, ref, }: Readonly<UpNextSheetProps>): import("react").JSX.Element | null;
+export declare const UpNextSheet: import("react").MemoExoticComponent<typeof UpNextSheetBase>;

package/types/ui/src/components/organisms/player/player-chrome-state.d.ts

@@ -0,0 +1,12 @@
+import type { usePlayerNav } from './hooks/use-player-nav';
+import type { UpNextData } from './parts/up-next-sheet';
+declare function initialSettingsView(overlay: string | null): 'audio' | 'subtitles' | 'menu';
+declare function hasUpNext(data: UpNextData): boolean;
+declare function deriveChrome(nav: ReturnType<typeof usePlayerNav>, upNext: UpNextData, panelCovers: boolean, over?: boolean): {
+    settingsOpen: boolean;
+    sheetOpen: boolean;
+    settingsShrink: boolean;
+    peekVisible: boolean;
+    chromeShown: boolean;
+};
+export { deriveChrome, hasUpNext, initialSettingsView };

package/types/ui/src/components/organisms/player/player-faces.d.ts

@@ -0,0 +1,43 @@
+import type { ReactNode } from 'react';
+interface PlayerMediaProps {
+    /** The surface the controller drives: an in-page `<video>`, or the placeholder
+     *  a native plane draws behind. It rounds ITSELF (see `useSurfaceRadius`); a
+     *  rounded parent does not clip a hardware video layer. */
+    children: ReactNode;
+}
+/** The picture, under the whole chrome. */
+declare function Media({ children }: Readonly<PlayerMediaProps>): import("react").JSX.Element;
+interface PlayerActionsProps {
+    children: ReactNode;
+}
+/** The host's own controls, at the end of the top bar beside the warning pill
+ *  (the web's "play on TV"). A television passes none: it is the screen a film
+ *  is cast TO. */
+declare function Actions({ children }: Readonly<PlayerActionsProps>): import("react").JSX.Element;
+interface PlayerPanelProps {
+    children: ReactNode;
+}
+/** A region that takes the stage over: the "an admin stopped this" notice. While
+ *  one is mounted the chrome is locked: the picture stops taking presses, the
+ *  buffering spinner stays down, and only Back / OK get through, both meaning
+ *  leave. */
+declare function Panel({ children }: Readonly<PlayerPanelProps>): import("react").JSX.Element;
+interface PlayerTitleProps {
+    children: ReactNode;
+}
+/** What is playing, at the top left. `<Player.Root title>` is the same words as
+ *  a name for assistive tech and for the end card; this is what draws them. */
+declare function Title({ children }: Readonly<PlayerTitleProps>): import("react").JSX.Element;
+interface PlayerSubtitleProps {
+    children: ReactNode;
+}
+/** The line under the title: an episode number, a year. */
+declare function Subtitle({ children }: Readonly<PlayerSubtitleProps>): import("react").JSX.Element;
+interface PlayerWarningProps {
+    children: ReactNode;
+}
+/** A pill in the top bar for something the viewer should know about this
+ *  playback: a transcode, a fallback engine. Write none and none is drawn. */
+declare function Warning({ children }: Readonly<PlayerWarningProps>): import("react").JSX.Element;
+export type { PlayerActionsProps, PlayerMediaProps, PlayerPanelProps, PlayerSubtitleProps, PlayerTitleProps, PlayerWarningProps, };
+export { Actions, Media, Panel, Subtitle, Title, Warning };

package/types/ui/src/components/organisms/player/player-input.d.ts

@@ -0,0 +1,16 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { RemoteKey } from '#ui/lib/remote-keys';
+import type { usePlayerNav } from './hooks/use-player-nav';
+import type { PlayerController, PlayerFlags } from './types';
+declare function handleCreditsKey(key: RemoteKey, focus: 'play' | 'cancel', setFocus: Dispatch<SetStateAction<'play' | 'cancel'>>, onPlay: () => void, onCancel: () => void): boolean;
+declare function handlePostPlayKey(key: RemoteKey, focus: 'play' | 'home', setFocus: Dispatch<SetStateAction<'play' | 'home'>>, onPlay: () => void, onHome: () => void): void;
+declare function playerInputHandlers(nav: ReturnType<typeof usePlayerNav>, c: PlayerController, flags: PlayerFlags, locked: boolean): {
+    onPointerMove: (e: {
+        nativeEvent?: {
+            pointerType?: string;
+        };
+    }) => void;
+    onStagePress: () => void;
+    onStageLongPress: () => void;
+};
+export { handleCreditsKey, handlePostPlayKey, playerInputHandlers };

package/types/ui/src/components/organisms/player/player-parts.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import { Actions, Media, Panel, Subtitle, Title, Warning } from './player-faces';
+import { Credits, type PlayerCreditsProps, type PlayerPostPlayProps, type PlayerReportProps, type PlayerResumeProps, type PlayerSkipIntroProps, type PlayerSubtitlesProps, type PlayerTransportProps, type PlayerUpNextProps, PostPlay, Report, Resume, SkipIntro, Subtitles, Transport, UpNext } from './player-settings';
+export interface PlayerSlots {
+    media: ReactNode;
+    actions: ReactNode;
+    panel: ReactNode;
+    title: ReactNode;
+    subtitle: ReactNode;
+    warning: ReactNode;
+    transport?: PlayerTransportProps;
+    upNext?: PlayerUpNextProps;
+    credits?: PlayerCreditsProps;
+    postPlay?: PlayerPostPlayProps;
+    skipIntro?: PlayerSkipIntroProps;
+    resume?: PlayerResumeProps;
+    subtitles?: PlayerSubtitlesProps;
+    report?: PlayerReportProps;
+    rest: ReactNode[];
+}
+declare function sortSlots(children: ReactNode): PlayerSlots;
+export type { PlayerActionsProps, PlayerMediaProps, PlayerPanelProps, PlayerSubtitleProps, PlayerTitleProps, PlayerWarningProps, } from './player-faces';
+export { PlayerScope } from './player-scope';
+export type { PlayerCreditsProps, PlayerPostPlayProps, PlayerReportProps, PlayerResumeProps, PlayerSkipIntroProps, PlayerSubtitlesProps, PlayerTransportProps, PlayerUpNextProps, };
+export { Actions, Credits, Media, Panel, PostPlay, Report, Resume, SkipIntro, Subtitle, Subtitles, sortSlots, Title, Transport, UpNext, Warning, };

package/types/ui/src/components/organisms/player/player-root.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import { type View } from 'react-native';
+import type { PlayerCloseDetails, PlayerController, PlayerFlags } from './types';
+export interface PlayerRootProps {
+    controller: PlayerController;
+    flags: PlayerFlags;
+    /** What is playing, as a name for assistive tech and for the end card. It
+     *  draws nothing: `<Player.Title>` is what puts it on screen. */
+    title: string;
+    onCast?: () => void;
+    onClose: (details: PlayerCloseDetails) => void;
+    ref?: React.Ref<View>;
+    /** The parts. A `<Player.Media>`, then any of the faces (`Title`, `Subtitle`,
+     *  `Warning`, `Actions`, `Panel`) and the settings (`Transport`, `UpNext`,
+     *  `Credits`, `PostPlay`, `SkipIntro`, `Resume`, `Subtitles`, `Report`). Only
+     *  a DIRECT child takes its slot; anything else is drawn over the chrome, in
+     *  the order it was written. */
+    children?: ReactNode;
+}
+/**
+ * The unified player chrome (§14): one component for web + TV. The platform
+ * provides a {@link PlayerController} and feature flags; nothing here talks to an
+ * engine directly. It owns the stage, so give it the whole screen and exactly
+ * one `<Player.Media>`.
+ */
+declare function Root({ controller, flags, title, onCast, onClose, ref, children, }: Readonly<PlayerRootProps>): import("react").JSX.Element;
+export { Root };

package/types/ui/src/components/organisms/player/player-scope.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+/** What the Root renders around its parts: the context each part checks it sits
+ *  in, and the focus mirror the chrome's own focus needs. */
+declare function PlayerScope({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;
+declare function useSlot(part: string): void;
+export { PlayerScope, useSlot };

package/types/ui/src/components/organisms/player/player-settings.d.ts

@@ -0,0 +1,76 @@
+import type { StoryboardTile } from '#ui/services/storyboard';
+import type { SubtitleAppearance } from './lib/subtitle-appearance';
+import type { PlayerMarker, PlayerReportCategory } from './media-types';
+import type { CreditsCardItem } from './parts/credits-card';
+import type { PostPlayItem } from './parts/post-play';
+import type { SubtitleGenBundle } from './parts/settings-panel/settings/gen';
+import type { UpNextData, UpNextItem } from './parts/up-next-sheet';
+import type { Chapter } from './types';
+interface PlayerTransportProps {
+    /** Chapter stops on the scrub bar. */
+    chapters?: Chapter[];
+    /** The storyboard tile under the scrub head, by second. */
+    tileAt: (sec: number) => StoryboardTile | null;
+}
+/** The scrub bar and the control row. Written to give it a storyboard and
+ *  chapters; the row itself is the Root's, which sheds controls a narrow stage
+ *  has no room for and keeps the D-pad order honest. */
+declare function Transport(_: Readonly<PlayerTransportProps>): null;
+interface PlayerUpNextProps {
+    data: UpNextData;
+    onPlay?: (item: UpNextItem) => void;
+}
+/** The peeking sheet of what to watch next. */
+declare function UpNext(_: Readonly<PlayerUpNextProps>): null;
+interface PlayerCreditsProps {
+    /** Where the film's intro and credits are, so the card knows when to rise. */
+    markers?: readonly PlayerMarker[];
+    /** The episode the card offers. */
+    next?: CreditsCardItem | null;
+    /** Given one, the chrome also grows a "next" control. */
+    onPlay?: () => void;
+}
+/** The card that offers the next episode over the closing credits. */
+declare function Credits(_: Readonly<PlayerCreditsProps>): null;
+interface PlayerPostPlayProps {
+    /** The film offered when this one ends with no next episode queued. With none
+     *  the player leaves instead of parking on a dead frame. */
+    item: PostPlayItem | null;
+    /** Where the second action goes. Falls back to `<Player.Root onClose>`. */
+    onHome?: () => void;
+}
+/** The full-screen offer at the end of the film. */
+declare function PostPlay(_: Readonly<PlayerPostPlayProps>): null;
+interface PlayerSkipIntroProps {
+    /** Whether the film is inside its detected intro window. The pill is only
+     *  offered while this is true. */
+    active?: boolean;
+    onSkip: () => void;
+}
+/** The skip pill, over the bottom right of the stage. */
+declare function SkipIntro(_: Readonly<PlayerSkipIntroProps>): null;
+interface PlayerResumeProps {
+    /** The second playback opened on. Write the slot only where a film really did
+     *  resume. */
+    at: number;
+}
+/** The prompt that says a film opened where it was left, and offers the way back
+ *  to the beginning. It leaves on its own. */
+declare function Resume(_: Readonly<PlayerResumeProps>): null;
+interface PlayerSubtitlesProps {
+    appearance: SubtitleAppearance;
+    onAppearanceChange: (next: Partial<SubtitleAppearance>) => void;
+    /** Everything the panel needs to drive generation. */
+    gen: SubtitleGenBundle;
+}
+/** The subtitles half of the settings panel: the picked track, how it looks, and
+ *  generating a new one. */
+declare function Subtitles(_: Readonly<PlayerSubtitlesProps>): null;
+interface PlayerReportProps {
+    onReport: (category: PlayerReportCategory) => Promise<void>;
+}
+/** Reporting a problem with what is playing. The settings menu grows the row
+ *  only when this is written, so a surface with its own flow is unaffected. */
+declare function Report(_: Readonly<PlayerReportProps>): null;
+export type { PlayerCreditsProps, PlayerPostPlayProps, PlayerReportProps, PlayerResumeProps, PlayerSkipIntroProps, PlayerSubtitlesProps, PlayerTransportProps, PlayerUpNextProps, };
+export { Credits, PostPlay, Report, Resume, SkipIntro, Subtitles, Transport, UpNext };

package/types/ui/src/components/organisms/player/player.d.ts

@@ -0,0 +1,20 @@
+import { Actions, Credits as CreditsSlot, Media, Panel, PostPlay as PostPlaySlot, Report, Resume as ResumeSlot, SkipIntro as SkipIntroSlot, Subtitle, Subtitles, Title, Transport as TransportSlot, UpNext as UpNextSlot, Warning } from './player-parts';
+import { Root } from './player-root';
+declare const Player: {
+    Root: typeof Root;
+    Media: typeof Media;
+    Actions: typeof Actions;
+    Panel: typeof Panel;
+    Title: typeof Title;
+    Subtitle: typeof Subtitle;
+    Warning: typeof Warning;
+    Transport: typeof TransportSlot;
+    UpNext: typeof UpNextSlot;
+    Credits: typeof CreditsSlot;
+    PostPlay: typeof PostPlaySlot;
+    SkipIntro: typeof SkipIntroSlot;
+    Resume: typeof ResumeSlot;
+    Subtitles: typeof Subtitles;
+    Report: typeof Report;
+};
+export { Player };