Complete the SPA-surface rebrand: SVG favicon (chicorytv-icon) served from web/public, description + theme-color meta, sidebar brand mark switched to the canonical transparent chicory-mark.svg per the design system lockup, and the Channel Builder default group ErsatzTV->ChicoryTV (tests updated). Legacy Blazor UI and backend strings intentionally untouched (product-wide rebrand = epic #59). closes #90 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2089 lines
78 KiB
TypeScript
2089 lines
78 KiB
TypeScript
import {
|
|
useCallback,
|
|
useEffect,
|
|
useLayoutEffect,
|
|
useRef,
|
|
useState,
|
|
type CSSProperties,
|
|
type ReactNode
|
|
} from 'react';
|
|
import {
|
|
Check,
|
|
ChevronDown,
|
|
ChevronRight,
|
|
ChevronUp,
|
|
Circle,
|
|
CircleCheck,
|
|
Eye,
|
|
Film,
|
|
FolderTree,
|
|
GripVertical,
|
|
Image as ImageIcon,
|
|
Info,
|
|
Layers,
|
|
Library,
|
|
LayoutGrid,
|
|
ListOrdered,
|
|
ListVideo,
|
|
Music,
|
|
Plus,
|
|
Radio,
|
|
Repeat,
|
|
Rows3,
|
|
Save,
|
|
Search,
|
|
Shuffle,
|
|
SlidersHorizontal,
|
|
Sparkles,
|
|
SquarePen,
|
|
Tv,
|
|
X
|
|
} from 'lucide-react';
|
|
import { navigateToPath } from '../routing';
|
|
import {
|
|
ApiError,
|
|
createChannelFromLineup,
|
|
createChannelTemplate,
|
|
getChannelTemplates,
|
|
getChannels,
|
|
getDefaultChannelTemplate,
|
|
getFFmpegProfiles,
|
|
getFillerPresets,
|
|
getLibraryBrowseItems,
|
|
getMediaSources,
|
|
getWatermarks,
|
|
messageFromError,
|
|
uploadArtwork,
|
|
type ChannelSummary,
|
|
type ChannelTemplate,
|
|
type CreateChannelFromLineupRequest,
|
|
type CreateChannelTemplateRequest,
|
|
type FFmpegProfile,
|
|
type FillerPreset,
|
|
type LibraryBrowseItem,
|
|
type LibraryBrowseMediaType,
|
|
type MediaSource,
|
|
type Watermark
|
|
} from '../api';
|
|
import {
|
|
Badge,
|
|
Button,
|
|
ChannelLogo,
|
|
Dialog,
|
|
ConfirmDialog,
|
|
IconButton,
|
|
Input,
|
|
Select,
|
|
Spinner,
|
|
Switch,
|
|
Tooltip
|
|
} from '../components';
|
|
|
|
// ---- Enum unions (hand-listed from generated v1.d.ts; keep in sync) --------
|
|
const PLAYBACK_ORDERS = [
|
|
'None',
|
|
'Chronological',
|
|
'Random',
|
|
'Shuffle',
|
|
'ShuffleInOrder',
|
|
'MultiEpisodeShuffle',
|
|
'SeasonEpisode',
|
|
'RandomRotation',
|
|
'Marathon'
|
|
] as const;
|
|
type PlaybackOrder = (typeof PLAYBACK_ORDERS)[number];
|
|
|
|
const STREAMING_MODES = [
|
|
'TransportStream',
|
|
'HttpLiveStreamingDirect',
|
|
'HttpLiveStreamingSegmenter',
|
|
'TransportStreamHybrid'
|
|
] as const;
|
|
type StreamingMode = (typeof STREAMING_MODES)[number];
|
|
|
|
const SUBTITLE_MODES = ['None', 'Forced', 'Default', 'Any'] as const;
|
|
type SubtitleMode = (typeof SUBTITLE_MODES)[number];
|
|
|
|
const STREAM_SELECTOR_MODES = ['Default', 'Custom', 'Troubleshooting'] as const;
|
|
type StreamSelectorMode = (typeof STREAM_SELECTOR_MODES)[number];
|
|
|
|
const MUSIC_VIDEO_CREDITS_MODES = ['None', 'GenerateSubtitles'] as const;
|
|
type MusicVideoCreditsMode = (typeof MUSIC_VIDEO_CREDITS_MODES)[number];
|
|
|
|
const SONG_VIDEO_MODES = ['Default', 'WithProgress'] as const;
|
|
type SongVideoMode = (typeof SONG_VIDEO_MODES)[number];
|
|
|
|
const IDLE_BEHAVIORS = ['StopOnDisconnect', 'KeepRunning'] as const;
|
|
type IdleBehavior = (typeof IDLE_BEHAVIORS)[number];
|
|
|
|
const FIXED_START_TIME_BEHAVIORS = ['Strict', 'Flexible'] as const;
|
|
type FixedStartTimeBehavior = (typeof FIXED_START_TIME_BEHAVIORS)[number];
|
|
|
|
const TRANSCODE_MODES = ['OnDemand'] as const;
|
|
type TranscodeMode = (typeof TRANSCODE_MODES)[number];
|
|
|
|
type PlayoutMode = 'Continuous' | 'OnDemand';
|
|
|
|
// Streaming mode friendly labels for chips / selects.
|
|
const STREAMING_MODE_LABELS: Record<StreamingMode, string> = {
|
|
TransportStream: 'MPEG-TS',
|
|
HttpLiveStreamingDirect: 'HLS Direct',
|
|
HttpLiveStreamingSegmenter: 'HLS Segmenter',
|
|
TransportStreamHybrid: 'MPEG-TS Hybrid'
|
|
};
|
|
|
|
// ---- Media-type presentation ----------------------------------------------
|
|
const TYPE_ICON: Record<LibraryBrowseMediaType, typeof Film> = {
|
|
Movie: Film,
|
|
TelevisionShow: Tv,
|
|
TelevisionSeason: Tv,
|
|
Artist: Music,
|
|
Collection: FolderTree,
|
|
SmartCollection: Sparkles,
|
|
MultiCollection: Layers,
|
|
RerunCollection: Repeat,
|
|
Playlist: ListVideo
|
|
};
|
|
|
|
const TYPE_LABEL: Record<LibraryBrowseMediaType, string> = {
|
|
Movie: 'Movie',
|
|
TelevisionShow: 'Show',
|
|
TelevisionSeason: 'Season',
|
|
Artist: 'Artist',
|
|
Collection: 'Collection',
|
|
SmartCollection: 'Smart',
|
|
MultiCollection: 'Multi',
|
|
RerunCollection: 'Rerun',
|
|
Playlist: 'Playlist'
|
|
};
|
|
|
|
const COLLECTION_MEDIA_TYPES: LibraryBrowseMediaType[] = [
|
|
'Collection',
|
|
'SmartCollection',
|
|
'MultiCollection',
|
|
'RerunCollection',
|
|
'Playlist'
|
|
];
|
|
|
|
// ---- Small pure helpers ----------------------------------------------------
|
|
const mono: CSSProperties = { fontFamily: 'var(--font-mono)', fontVariantNumeric: 'tabular-nums' };
|
|
|
|
// deterministic low-chroma poster hue from a title (ported from prototype)
|
|
function hueOf(value: string): number {
|
|
let hue = 0;
|
|
for (let index = 0; index < value.length; index += 1) {
|
|
hue = (hue * 31 + value.charCodeAt(index)) % 360;
|
|
}
|
|
return hue;
|
|
}
|
|
|
|
// Parse a .NET TimeSpan (`[d.]hh:mm:ss[.fffffff]`) or ISO8601 duration to seconds.
|
|
function parseDurationSeconds(value: string | null | undefined): number | null {
|
|
if (!value) {
|
|
return null;
|
|
}
|
|
|
|
const timeSpan = /^(?:(\d+)\.)?(\d{1,2}):(\d{2}):(\d{2})(?:\.\d+)?$/.exec(value);
|
|
if (timeSpan) {
|
|
const [, days, hours, minutes, seconds] = timeSpan;
|
|
return (
|
|
(days ? Number(days) * 86400 : 0) + Number(hours) * 3600 + Number(minutes) * 60 + Number(seconds)
|
|
);
|
|
}
|
|
|
|
const iso = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(value);
|
|
if (iso) {
|
|
const [, days, hours, minutes, seconds] = iso;
|
|
return (
|
|
(days ? Number(days) * 86400 : 0) +
|
|
(hours ? Number(hours) * 3600 : 0) +
|
|
(minutes ? Number(minutes) * 60 : 0) +
|
|
(seconds ? Number(seconds) : 0)
|
|
);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function formatDuration(totalSeconds: number): string {
|
|
const totalMinutes = Math.round(totalSeconds / 60);
|
|
const hours = Math.floor(totalMinutes / 60);
|
|
const minutes = totalMinutes % 60;
|
|
if (hours && minutes) {
|
|
return `${hours}h ${String(minutes).padStart(2, '0')}m`;
|
|
}
|
|
if (hours) {
|
|
return `${hours}h`;
|
|
}
|
|
return `${minutes}m`;
|
|
}
|
|
|
|
// Meta line for a browse item: duration and/or item count (both nullable -> omitted).
|
|
function itemMeta(item: LibraryBrowseItem): string {
|
|
const parts: string[] = [];
|
|
const durationSeconds = parseDurationSeconds(item.duration);
|
|
if (durationSeconds) {
|
|
parts.push(formatDuration(durationSeconds));
|
|
}
|
|
if (item.itemCount) {
|
|
parts.push(`${item.itemCount} items`);
|
|
}
|
|
return parts.join(' · ');
|
|
}
|
|
|
|
function lineupKey(item: LibraryBrowseItem): string {
|
|
return `${item.mediaType}:${item.id}`;
|
|
}
|
|
|
|
// The integer part of a channel number that parses; used for AUTO suggestion.
|
|
function suggestChannelNumber(channels: ChannelSummary[]): string {
|
|
let max = 0;
|
|
let seen = false;
|
|
for (const channel of channels) {
|
|
const parsed = Number.parseFloat(channel.number);
|
|
if (Number.isFinite(parsed)) {
|
|
seen = true;
|
|
max = Math.max(max, Math.floor(parsed));
|
|
}
|
|
}
|
|
return seen ? String(max + 1) : '1';
|
|
}
|
|
|
|
const NUMBER_PATTERN = /^[0-9]+(\.[0-9]{1,2})?$/;
|
|
|
|
// ---- Segmented control (builder-local, sliding highlight) ------------------
|
|
interface SegmentedOption<T extends string> {
|
|
value: T;
|
|
label?: string;
|
|
icon?: ReactNode;
|
|
title?: string;
|
|
}
|
|
|
|
function Segmented<T extends string>({
|
|
value,
|
|
options,
|
|
onChange
|
|
}: {
|
|
value: T;
|
|
options: SegmentedOption<T>[];
|
|
onChange: (next: T) => void;
|
|
}) {
|
|
const index = Math.max(
|
|
0,
|
|
options.findIndex((option) => option.value === value)
|
|
);
|
|
|
|
return (
|
|
<div className="ctv-builder-seg" role="group">
|
|
<div
|
|
className="ctv-builder-seg-thumb"
|
|
style={{
|
|
width: `calc((100% - 4px) / ${options.length})`,
|
|
transform: `translateX(${index * 100}%)`
|
|
}}
|
|
/>
|
|
{options.map((option) => {
|
|
const on = option.value === value;
|
|
return (
|
|
<button
|
|
key={option.value}
|
|
type="button"
|
|
aria-pressed={on}
|
|
title={option.title ?? option.label}
|
|
className={`ctv-builder-seg-btn ctv-press${on ? ' ctv-builder-seg-btn-on' : ''}`}
|
|
onClick={() => onChange(option.value)}
|
|
>
|
|
{option.icon}
|
|
{option.label}
|
|
</button>
|
|
);
|
|
})}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// ---- Poster placeholder ----------------------------------------------------
|
|
function Poster({ item, width, height, mini }: { item: LibraryBrowseItem; width: number | string; height: number; mini?: boolean }) {
|
|
const hue = hueOf(item.title);
|
|
const Icon = TYPE_ICON[item.mediaType] ?? Film;
|
|
|
|
return (
|
|
<div
|
|
className="ctv-builder-poster"
|
|
style={{
|
|
width,
|
|
height,
|
|
background: `linear-gradient(160deg, hsl(${hue} 24% 17%), hsl(${hue} 26% 12%))`
|
|
}}
|
|
>
|
|
{item.artwork ? (
|
|
<img src={item.artwork} alt="" loading="lazy" />
|
|
) : (
|
|
<div
|
|
style={{
|
|
position: 'absolute',
|
|
inset: 0,
|
|
backgroundImage: `repeating-linear-gradient(135deg, hsl(${hue} 22% 10% / .55) 0 1px, transparent 1px 9px)`
|
|
}}
|
|
/>
|
|
)}
|
|
<span
|
|
className="ctv-builder-poster-icon"
|
|
style={{ top: mini ? 4 : 7, left: mini ? 4 : 7, color: `hsl(${hue} 30% 68%)` }}
|
|
>
|
|
<Icon size={mini ? 12 : 15} aria-hidden="true" />
|
|
</span>
|
|
{!mini && (
|
|
<div className="ctv-builder-poster-scrim">
|
|
<div className="ctv-builder-poster-title">{item.title}</div>
|
|
{itemMeta(item) && <div className="ctv-builder-poster-meta">{itemMeta(item)}</div>}
|
|
</div>
|
|
)}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// ---- Library card ----------------------------------------------------------
|
|
function LibCard({
|
|
item,
|
|
added,
|
|
compact,
|
|
onAdd,
|
|
onDragStart,
|
|
onDragEnd
|
|
}: {
|
|
item: LibraryBrowseItem;
|
|
added: boolean;
|
|
compact: boolean;
|
|
onAdd: () => void;
|
|
onDragStart: () => void;
|
|
onDragEnd: () => void;
|
|
}) {
|
|
const meta = itemMeta(item);
|
|
|
|
if (compact) {
|
|
return (
|
|
<div
|
|
draggable
|
|
onDragStart={onDragStart}
|
|
onDragEnd={onDragEnd}
|
|
onDoubleClick={onAdd}
|
|
title="Double-click or drag to add"
|
|
className="ctv-builder-libcard-compact ctv-press"
|
|
style={
|
|
added
|
|
? {
|
|
background: 'color-mix(in srgb, var(--action-primary) 14%, transparent)',
|
|
borderColor: 'color-mix(in srgb, var(--action-primary) 35%, transparent)'
|
|
}
|
|
: undefined
|
|
}
|
|
>
|
|
<Poster item={item} width={30} height={40} mini />
|
|
<div style={{ flex: 1, minWidth: 0 }}>
|
|
<div className="ctv-builder-compact-title">{item.title}</div>
|
|
<div className="ctv-builder-compact-meta">
|
|
{TYPE_LABEL[item.mediaType]}
|
|
{meta && (
|
|
<>
|
|
{' · '}
|
|
<span style={mono}>{meta}</span>
|
|
</>
|
|
)}
|
|
</div>
|
|
</div>
|
|
<IconButton size="sm" title={added ? 'Added' : 'Add to lineup'} onClick={onAdd}>
|
|
{added ? (
|
|
<Check size={15} color="var(--action-primary)" aria-hidden="true" />
|
|
) : (
|
|
<Plus size={15} aria-hidden="true" />
|
|
)}
|
|
</IconButton>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
return (
|
|
<div
|
|
draggable
|
|
onDragStart={onDragStart}
|
|
onDragEnd={onDragEnd}
|
|
onDoubleClick={onAdd}
|
|
title="Double-click or drag to add"
|
|
className="ctv-builder-libcard ctv-lift"
|
|
>
|
|
<div
|
|
className="ctv-builder-libcard-poster"
|
|
style={added ? { boxShadow: '0 0 0 2px var(--action-primary)' } : undefined}
|
|
>
|
|
<Poster item={item} width="100%" height={150} />
|
|
{added && (
|
|
<div className="ctv-builder-added-check">
|
|
<Check size={14} aria-hidden="true" />
|
|
</div>
|
|
)}
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// ---- Library browse data hook ---------------------------------------------
|
|
interface BrowseState {
|
|
status: 'loading' | 'error' | 'success';
|
|
items: LibraryBrowseItem[];
|
|
totalCount: number;
|
|
error: string | null;
|
|
}
|
|
|
|
async function loadCollections(query: string): Promise<{ page: LibraryBrowseItem[]; totalCount: number }> {
|
|
const results = await Promise.all(
|
|
COLLECTION_MEDIA_TYPES.map((mediaType) => getLibraryBrowseItems({ query, mediaType, pageSize: 100 }))
|
|
);
|
|
const merged = results
|
|
.flatMap((result) => result.page)
|
|
.sort((left, right) => left.title.localeCompare(right.title, undefined, { sensitivity: 'base' }));
|
|
return { page: merged, totalCount: merged.length };
|
|
}
|
|
|
|
function useLibraryBrowse(source: 'library' | 'collections', query: string, libraryId: number | null) {
|
|
const [state, setState] = useState<BrowseState>({ status: 'loading', items: [], totalCount: 0, error: null });
|
|
const [loadingMore, setLoadingMore] = useState(false);
|
|
const reqRef = useRef(0);
|
|
const pageRef = useRef(0);
|
|
|
|
const runFetch = useCallback(
|
|
(pageNum: number, reqId: number, append: boolean) => {
|
|
const promise =
|
|
source === 'collections'
|
|
? loadCollections(query)
|
|
: getLibraryBrowseItems({
|
|
query: query || undefined,
|
|
libraryId: libraryId ?? undefined,
|
|
pageNum,
|
|
pageSize: 100
|
|
});
|
|
|
|
promise
|
|
.then((result) => {
|
|
if (reqRef.current !== reqId) {
|
|
return;
|
|
}
|
|
setState((prev) => ({
|
|
status: 'success',
|
|
error: null,
|
|
items: append ? [...prev.items, ...result.page] : result.page,
|
|
totalCount: result.totalCount
|
|
}));
|
|
})
|
|
.catch((error: unknown) => {
|
|
if (reqRef.current !== reqId) {
|
|
return;
|
|
}
|
|
setState({ status: 'error', items: [], totalCount: 0, error: messageFromError(error) });
|
|
})
|
|
.finally(() => {
|
|
if (reqRef.current === reqId && append) {
|
|
setLoadingMore(false);
|
|
}
|
|
});
|
|
},
|
|
[source, query, libraryId]
|
|
);
|
|
|
|
// Refetch when inputs change. Following the guide-hook pattern, setState only
|
|
// runs inside runFetch's async callbacks - the previous results stay visible
|
|
// until the new page resolves (initial 'loading' shows the first-load spinner).
|
|
useEffect(() => {
|
|
const reqId = reqRef.current + 1;
|
|
reqRef.current = reqId;
|
|
pageRef.current = 0;
|
|
runFetch(0, reqId, false);
|
|
}, [runFetch]);
|
|
|
|
const loadMore = useCallback(() => {
|
|
const nextPage = pageRef.current + 1;
|
|
pageRef.current = nextPage;
|
|
setLoadingMore(true);
|
|
runFetch(nextPage, reqRef.current, true);
|
|
}, [runFetch]);
|
|
|
|
const canLoadMore = source === 'library' && state.status === 'success' && state.items.length < state.totalCount;
|
|
|
|
return { state, loadingMore, loadMore, canLoadMore };
|
|
}
|
|
|
|
// ---- Builder support data (templates, pickers, channels) -------------------
|
|
interface BuilderData {
|
|
channels: ChannelSummary[];
|
|
templates: ChannelTemplate[];
|
|
defaultTemplate: ChannelTemplate | null;
|
|
ffmpegProfiles: FFmpegProfile[];
|
|
fillerPresets: FillerPreset[];
|
|
watermarks: Watermark[];
|
|
mediaSources: MediaSource[];
|
|
}
|
|
|
|
// ---- Effective settings ----------------------------------------------------
|
|
// Templates carry no playbackOrder; the Shuffle toggle *is* the template's
|
|
// declared shuffle intent (template.shuffleScheduleItems -> Shuffle/Chronological).
|
|
function templatePlaybackOrder(template: ChannelTemplate): PlaybackOrder {
|
|
return template.shuffleScheduleItems ? 'Shuffle' : 'Chronological';
|
|
}
|
|
|
|
// Advanced field keys wired into request.advanced (playbackOrder + playoutMode
|
|
// live in dedicated state and are ALWAYS sent, so they are excluded here).
|
|
const ADVANCED_KEYS = [
|
|
'fFmpegProfileId',
|
|
'watermarkId',
|
|
'fallbackFillerId',
|
|
'preRollFillerId',
|
|
'midRollFillerId',
|
|
'postRollFillerId',
|
|
'streamSelectorMode',
|
|
'streamSelector',
|
|
'preferredAudioLanguageCode',
|
|
'preferredAudioTitle',
|
|
'streamingMode',
|
|
'preferredSubtitleLanguageCode',
|
|
'subtitleMode',
|
|
'musicVideoCreditsMode',
|
|
'songVideoMode',
|
|
'transcodeMode',
|
|
'idleBehavior',
|
|
'randomStartPoint',
|
|
'shuffleScheduleItems',
|
|
'fixedStartTimeBehavior'
|
|
] as const;
|
|
type AdvancedKey = (typeof ADVANCED_KEYS)[number];
|
|
|
|
type Overrides = Partial<Record<AdvancedKey, unknown>>;
|
|
|
|
// The current effective value for an advanced field = user override (if any)
|
|
// else the selected template's value.
|
|
function effectiveValue(key: AdvancedKey, template: ChannelTemplate, overrides: Overrides): unknown {
|
|
if (key in overrides) {
|
|
return overrides[key];
|
|
}
|
|
return (template as unknown as Record<string, unknown>)[key];
|
|
}
|
|
|
|
// Sentinel select value meaning "inherit from the template" — the field is
|
|
// omitted from `advanced` entirely (not sent as null). The API cannot express
|
|
// clear-to-none, so there is no "None" choice; see #135.
|
|
const INHERIT = '__inherit__';
|
|
|
|
// ---- Main screen -----------------------------------------------------------
|
|
interface BuilderDataState {
|
|
status: 'loading' | 'error' | 'success';
|
|
data: BuilderData | null;
|
|
error: string | null;
|
|
}
|
|
|
|
export function ChannelBuilderScreen() {
|
|
const [state, setState] = useState<BuilderDataState>({ status: 'loading', data: null, error: null });
|
|
const mountedRef = useRef(true);
|
|
|
|
// Pure async loader: setState runs only in the .then/.catch callbacks, so the
|
|
// mount effect never triggers a synchronous state update ('loading' is the
|
|
// initial state). The Retry handler resets to loading itself (event handler).
|
|
const runLoad = useCallback(() => {
|
|
Promise.all([
|
|
getChannels(),
|
|
getChannelTemplates(),
|
|
getDefaultChannelTemplate(),
|
|
getFFmpegProfiles(),
|
|
getFillerPresets(),
|
|
getWatermarks(),
|
|
getMediaSources()
|
|
])
|
|
.then(([channels, templates, defaultTemplate, ffmpegProfiles, fillerPresets, watermarks, mediaSources]) => {
|
|
if (!mountedRef.current) {
|
|
return;
|
|
}
|
|
setState({
|
|
status: 'success',
|
|
data: { channels, templates, defaultTemplate, ffmpegProfiles, fillerPresets, watermarks, mediaSources },
|
|
error: null
|
|
});
|
|
})
|
|
.catch((error: unknown) => {
|
|
if (!mountedRef.current) {
|
|
return;
|
|
}
|
|
setState({ status: 'error', data: null, error: messageFromError(error) });
|
|
});
|
|
}, []);
|
|
|
|
useEffect(() => {
|
|
mountedRef.current = true;
|
|
runLoad();
|
|
return () => {
|
|
mountedRef.current = false;
|
|
};
|
|
}, [runLoad]);
|
|
|
|
const retry = () => {
|
|
setState({ status: 'loading', data: null, error: null });
|
|
runLoad();
|
|
};
|
|
|
|
const setData = useCallback((updater: (prev: BuilderData | null) => BuilderData | null) => {
|
|
setState((prev) => (prev.status === 'success' ? { ...prev, data: updater(prev.data) } : prev));
|
|
}, []);
|
|
|
|
if (state.status === 'loading') {
|
|
return (
|
|
<div className="ctv-builder">
|
|
<div className="ctv-dashboard-state" style={{ margin: 'auto' }}>
|
|
<Spinner size={20} tone="accent" />
|
|
<span>Loading channel builder</span>
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
if (state.status === 'error' || !state.data) {
|
|
return (
|
|
<div className="ctv-builder">
|
|
<div className="ctv-dashboard-error" style={{ margin: 'auto', textAlign: 'center' }}>
|
|
<span>Channel builder unavailable</span>
|
|
<strong>{state.error}</strong>
|
|
<div style={{ marginTop: 12 }}>
|
|
<Button variant="secondary" onClick={retry}>
|
|
Retry
|
|
</Button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
return <ChannelBuilder data={state.data} onDataChange={setData} />;
|
|
}
|
|
|
|
function ChannelBuilder({
|
|
data,
|
|
onDataChange
|
|
}: {
|
|
data: BuilderData;
|
|
onDataChange: (updater: (prev: BuilderData | null) => BuilderData | null) => void;
|
|
}) {
|
|
// ---- library browser state ----
|
|
const [source, setSource] = useState<'library' | 'collections'>('library');
|
|
const [searchInput, setSearchInput] = useState('');
|
|
const [query, setQuery] = useState('');
|
|
const [compact, setCompact] = useState(false);
|
|
const [libraryId, setLibraryId] = useState<number | null>(null);
|
|
|
|
// debounce search input -> query
|
|
useEffect(() => {
|
|
const timer = window.setTimeout(() => setQuery(searchInput.trim()), 280);
|
|
return () => window.clearTimeout(timer);
|
|
}, [searchInput]);
|
|
|
|
const browse = useLibraryBrowse(source, query, libraryId);
|
|
|
|
// ---- lineup ----
|
|
const [lineup, setLineup] = useState<LibraryBrowseItem[]>([]);
|
|
const addedKeys = new Set(lineup.map(lineupKey));
|
|
|
|
// drag state
|
|
const [dragLib, setDragLib] = useState<string | null>(null);
|
|
const [dragRow, setDragRow] = useState<number | null>(null);
|
|
const [overRow, setOverRow] = useState<number | null>(null);
|
|
|
|
// ---- rail: identity ----
|
|
const [name, setName] = useState('');
|
|
// AUTO number: max integer part of existing channel numbers + 1 (empty -> "1").
|
|
const suggestion = suggestChannelNumber(data.channels);
|
|
const [number, setNumber] = useState(() => suggestion);
|
|
|
|
// ---- rail: image ----
|
|
const [logoFile, setLogoFile] = useState<File | null>(null);
|
|
const [logoPreview, setLogoPreview] = useState<string | null>(null);
|
|
const [imageError, setImageError] = useState<string | null>(null);
|
|
const [separateOpen, setSeparateOpen] = useState(false);
|
|
const [dropOver, setDropOver] = useState(false);
|
|
const fileInputRef = useRef<HTMLInputElement>(null);
|
|
|
|
// ---- rail: template + settings ----
|
|
const initialTemplate = data.defaultTemplate ?? data.templates.find((t) => t.isDefault) ?? data.templates[0] ?? null;
|
|
const [templateId, setTemplateId] = useState<number | null>(initialTemplate?.id ?? null);
|
|
const template = data.templates.find((t) => t.id === templateId) ?? initialTemplate;
|
|
const [tplOpen, setTplOpen] = useState(false);
|
|
|
|
const [playbackOrder, setPlaybackOrder] = useState<PlaybackOrder>(
|
|
template ? templatePlaybackOrder(template) : 'Chronological'
|
|
);
|
|
const [playoutMode, setPlayoutMode] = useState<PlayoutMode>((template?.playoutMode as PlayoutMode) ?? 'Continuous');
|
|
const [overrides, setOverrides] = useState<Overrides>({});
|
|
const [group, setGroup] = useState('ChicoryTV');
|
|
const [categories, setCategories] = useState('');
|
|
|
|
const [advMode, setAdvMode] = useState<'closed' | 'view' | 'override'>('closed');
|
|
|
|
// ---- create/save flow ----
|
|
const [creating, setCreating] = useState(false);
|
|
const [createError, setCreateError] = useState<string | null>(null);
|
|
const [errorRowIndex, setErrorRowIndex] = useState<number | null>(null);
|
|
const creatingRef = useRef(false);
|
|
// Cache a successful artwork upload keyed by the File object, so retrying a
|
|
// failed create with the same image doesn't orphan a fresh upload each attempt.
|
|
const uploadedLogoRef = useRef<{ file: File; logo: CreateChannelFromLineupRequest['logo'] } | null>(null);
|
|
|
|
const [confirmClear, setConfirmClear] = useState(false);
|
|
const [confirmCancel, setConfirmCancel] = useState(false);
|
|
|
|
const [saveOpen, setSaveOpen] = useState(false);
|
|
const [saveName, setSaveName] = useState('');
|
|
const [saveDesc, setSaveDesc] = useState('');
|
|
const [saveBusy, setSaveBusy] = useState(false);
|
|
const [saveError, setSaveError] = useState<string | null>(null);
|
|
|
|
const railScrollRef = useRef<HTMLDivElement>(null);
|
|
|
|
// ---- derived ----
|
|
const shuffleOn = playbackOrder === 'Shuffle';
|
|
const alwaysOn = playoutMode === 'Continuous';
|
|
|
|
const applyTemplate = (next: ChannelTemplate) => {
|
|
setTemplateId(next.id);
|
|
setPlaybackOrder(templatePlaybackOrder(next));
|
|
setPlayoutMode(next.playoutMode as PlayoutMode);
|
|
setOverrides({});
|
|
setTplOpen(false);
|
|
};
|
|
|
|
// Any lineup mutation invalidates a server row-index highlight (it pointed at
|
|
// the pre-mutation array), so clear the stale create error whenever it changes.
|
|
const clearLineupError = () => {
|
|
setCreateError(null);
|
|
setErrorRowIndex(null);
|
|
};
|
|
|
|
const addItem = (item: LibraryBrowseItem) => {
|
|
clearLineupError();
|
|
setLineup((current) => (current.some((existing) => lineupKey(existing) === lineupKey(item)) ? current : [...current, item]));
|
|
};
|
|
|
|
const removeAt = (index: number) => {
|
|
clearLineupError();
|
|
setLineup((current) => current.filter((_, position) => position !== index));
|
|
};
|
|
|
|
// drop onto lineup container (append) or a row (insert at index)
|
|
const dropAt = (targetIndex: number | null) => {
|
|
clearLineupError();
|
|
setLineup((current) => {
|
|
if (dragRow != null) {
|
|
const next = current.slice();
|
|
const [moved] = next.splice(dragRow, 1);
|
|
next.splice(targetIndex ?? next.length, 0, moved);
|
|
return next;
|
|
}
|
|
if (dragLib != null) {
|
|
const item = browse.state.items.find((candidate) => lineupKey(candidate) === dragLib);
|
|
if (item && !current.some((existing) => lineupKey(existing) === dragLib)) {
|
|
const next = current.slice();
|
|
next.splice(targetIndex ?? next.length, 0, item);
|
|
return next;
|
|
}
|
|
}
|
|
return current;
|
|
});
|
|
setDragLib(null);
|
|
setDragRow(null);
|
|
setOverRow(null);
|
|
};
|
|
|
|
const totalDurationSeconds = lineup.reduce((sum, item) => sum + (parseDurationSeconds(item.duration) ?? 0), 0);
|
|
|
|
// ---- validation ----
|
|
const trimmedName = name.trim();
|
|
const numberValid = NUMBER_PATTERN.test(number.trim());
|
|
const numberUnique = !data.channels.some((channel) => channel.number === number.trim());
|
|
const numberError = !number.trim()
|
|
? null
|
|
: !numberValid
|
|
? 'Use digits, optionally with up to two decimals (e.g. 5 or 13.1).'
|
|
: !numberUnique
|
|
? 'That channel number is already in use.'
|
|
: null;
|
|
|
|
const rowErrorFor = (item: LibraryBrowseItem): string | null => {
|
|
if ((item.mediaType === 'RerunCollection' || item.mediaType === 'Playlist') && lineup.length > 1) {
|
|
return 'Only valid alone';
|
|
}
|
|
if (item.mediaType === 'MultiCollection' && !(playbackOrder === 'Shuffle' || playbackOrder === 'ShuffleInOrder')) {
|
|
return 'Requires Shuffle';
|
|
}
|
|
return null;
|
|
};
|
|
|
|
const rowErrors = lineup.map(rowErrorFor);
|
|
const firstRowErrorIndex = rowErrors.findIndex((error) => error != null);
|
|
const hasRowError = firstRowErrorIndex >= 0;
|
|
|
|
const createBlockedReason =
|
|
!trimmedName
|
|
? 'Name the channel and add at least one item'
|
|
: lineup.length === 0
|
|
? 'Add at least one item to the lineup'
|
|
: !group.trim()
|
|
? 'Channel group cannot be empty'
|
|
: numberError || !number.trim()
|
|
? 'Enter a valid, unique channel number'
|
|
: templateId == null
|
|
? 'Select a channel template'
|
|
: hasRowError
|
|
? `Fix lineup item ${firstRowErrorIndex + 1}: ${rowErrors[firstRowErrorIndex]}`
|
|
: null;
|
|
|
|
const canCreate = createBlockedReason == null;
|
|
|
|
// ---- image handling ----
|
|
const readImage = (file: File | undefined | null) => {
|
|
if (!file) {
|
|
return;
|
|
}
|
|
if (!file.type.startsWith('image/')) {
|
|
setImageError('Choose an image file.');
|
|
return;
|
|
}
|
|
if (file.size >= 30 * 1024 * 1024) {
|
|
setImageError('Image is too large (max 30 MB).');
|
|
return;
|
|
}
|
|
setImageError(null);
|
|
setLogoFile(file);
|
|
const reader = new FileReader();
|
|
reader.onload = () => setLogoPreview(typeof reader.result === 'string' ? reader.result : null);
|
|
reader.readAsDataURL(file);
|
|
};
|
|
|
|
// ---- advanced panel accordion height ----
|
|
const advFieldsRef = useRef<HTMLDivElement>(null);
|
|
const [advMaxHeight, setAdvMaxHeight] = useState(0);
|
|
// Measure the fields' natural height for the max-height accordion animation.
|
|
// Reading layout then writing state is the canonical useLayoutEffect use.
|
|
useLayoutEffect(() => {
|
|
const next = advMode === 'closed' ? 0 : (advFieldsRef.current?.scrollHeight ?? 0);
|
|
setAdvMaxHeight(next);
|
|
}, [advMode]);
|
|
|
|
// ---- create ----
|
|
const handleCreate = async () => {
|
|
if (creatingRef.current || !canCreate || templateId == null) {
|
|
return;
|
|
}
|
|
creatingRef.current = true;
|
|
setCreating(true);
|
|
setCreateError(null);
|
|
setErrorRowIndex(null);
|
|
|
|
try {
|
|
let logo: CreateChannelFromLineupRequest['logo'] = { path: '', contentType: '' };
|
|
if (logoFile) {
|
|
if (uploadedLogoRef.current?.file === logoFile) {
|
|
logo = uploadedLogoRef.current.logo;
|
|
} else {
|
|
const uploaded = await uploadArtwork(logoFile, 'logo');
|
|
logo = { path: uploaded.path, contentType: uploaded.contentType };
|
|
uploadedLogoRef.current = { file: logoFile, logo };
|
|
}
|
|
}
|
|
|
|
// advanced null/omitted = inherit template value (handler coalesces with ??);
|
|
// clear-to-none is not expressible — see #135. Overrides only ever holds
|
|
// real values (inherited fields are absent), so we copy present keys as-is.
|
|
const advanced: CreateChannelFromLineupRequest['advanced'] = { playbackOrder, playoutMode };
|
|
for (const key of ADVANCED_KEYS) {
|
|
if (key in overrides) {
|
|
(advanced as Record<string, unknown>)[key] = overrides[key];
|
|
}
|
|
}
|
|
|
|
const body: CreateChannelFromLineupRequest = {
|
|
name: trimmedName,
|
|
number: number.trim(),
|
|
group: group.trim(),
|
|
categories: categories.trim(),
|
|
logo,
|
|
isEnabled: true,
|
|
showInEpg: true,
|
|
templateId,
|
|
advanced,
|
|
lineup: lineup.map((item) => ({
|
|
mediaType: item.mediaType,
|
|
collectionType: item.collectionType,
|
|
collectionId: item.collectionId,
|
|
multiCollectionId: item.multiCollectionId,
|
|
smartCollectionId: item.smartCollectionId,
|
|
rerunCollectionId: item.rerunCollectionId,
|
|
mediaItemId: item.mediaItemId,
|
|
playlistId: item.playlistId
|
|
}))
|
|
};
|
|
|
|
await createChannelFromLineup(body);
|
|
navigateToPath('/app/channels');
|
|
} catch (error: unknown) {
|
|
let message = messageFromError(error);
|
|
if (error instanceof ApiError) {
|
|
if (error.status === 413) {
|
|
message = 'Image is too large (max 30 MB).';
|
|
}
|
|
const detail = error.detail;
|
|
const match = detail ? /lineup\[(\d+)\]/.exec(detail) : null;
|
|
if (match) {
|
|
setErrorRowIndex(Number(match[1]));
|
|
}
|
|
}
|
|
setCreateError(message);
|
|
creatingRef.current = false;
|
|
setCreating(false);
|
|
}
|
|
};
|
|
|
|
// ---- save template ----
|
|
const openSaveTemplate = () => {
|
|
setSaveName('');
|
|
setSaveDesc('');
|
|
setSaveError(null);
|
|
setSaveOpen(true);
|
|
setTplOpen(false);
|
|
};
|
|
|
|
const handleSaveTemplate = async () => {
|
|
if (saveBusy || !template) {
|
|
return;
|
|
}
|
|
if (!saveName.trim()) {
|
|
setSaveError('Give the template a name.');
|
|
return;
|
|
}
|
|
setSaveBusy(true);
|
|
setSaveError(null);
|
|
|
|
// Compose from the same effective-value helper the panel renders with, so
|
|
// what's saved equals what's shown. Overrides never hold null/'' (inherited
|
|
// fields are absent), so effectiveValue is exactly the displayed value.
|
|
const eff = <T,>(key: AdvancedKey): T => effectiveValue(key, template, overrides) as T;
|
|
|
|
try {
|
|
const requestBody: CreateChannelTemplateRequest = {
|
|
name: saveName.trim(),
|
|
description: saveDesc.trim(),
|
|
fFmpegProfileId: eff('fFmpegProfileId'),
|
|
watermarkId: eff('watermarkId'),
|
|
fallbackFillerId: eff('fallbackFillerId'),
|
|
preRollFillerId: eff('preRollFillerId'),
|
|
midRollFillerId: eff('midRollFillerId'),
|
|
postRollFillerId: eff('postRollFillerId'),
|
|
streamSelectorMode: eff('streamSelectorMode'),
|
|
streamSelector: eff('streamSelector'),
|
|
preferredAudioLanguageCode: eff('preferredAudioLanguageCode'),
|
|
preferredAudioTitle: eff('preferredAudioTitle'),
|
|
playoutSource: template.playoutSource,
|
|
// toggles are the source of truth for these two:
|
|
playoutMode,
|
|
streamingMode: eff('streamingMode'),
|
|
preferredSubtitleLanguageCode: eff('preferredSubtitleLanguageCode'),
|
|
subtitleMode: eff('subtitleMode'),
|
|
musicVideoCreditsMode: eff('musicVideoCreditsMode'),
|
|
musicVideoCreditsTemplate: template.musicVideoCreditsTemplate,
|
|
songVideoMode: eff('songVideoMode'),
|
|
transcodeMode: eff('transcodeMode'),
|
|
idleBehavior: eff('idleBehavior'),
|
|
shuffleScheduleItems: shuffleOn,
|
|
randomStartPoint: eff('randomStartPoint'),
|
|
fixedStartTimeBehavior: eff('fixedStartTimeBehavior')
|
|
};
|
|
|
|
const created = await createChannelTemplate(requestBody);
|
|
const templates = await getChannelTemplates();
|
|
onDataChange((prev) => (prev ? { ...prev, templates } : prev));
|
|
applyTemplate(created);
|
|
setSaveOpen(false);
|
|
} catch (error: unknown) {
|
|
setSaveError(messageFromError(error));
|
|
} finally {
|
|
setSaveBusy(false);
|
|
}
|
|
};
|
|
|
|
// ---- cancel ----
|
|
const dirty = lineup.length > 0 || trimmedName.length > 0 || logoFile != null;
|
|
const handleCancel = () => {
|
|
if (dirty) {
|
|
setConfirmCancel(true);
|
|
} else {
|
|
navigateToPath('/app/channels');
|
|
}
|
|
};
|
|
|
|
// ---- filter chips (library mode) ----
|
|
const libraryChips = data.mediaSources.flatMap((mediaSource) =>
|
|
mediaSource.libraries.map((lib) => ({ id: lib.id, name: lib.name }))
|
|
);
|
|
|
|
const showAuto = number.trim() === suggestion;
|
|
const items = browse.state.items;
|
|
const serverRowIndex = errorRowIndex;
|
|
|
|
return (
|
|
<div className="ctv-builder">
|
|
{/* toolbar */}
|
|
<div className="ctv-builder-toolbar">
|
|
<span className="ctv-builder-toolbar-tile">
|
|
<Plus size={19} aria-hidden="true" />
|
|
</span>
|
|
<div className="ctv-builder-toolbar-titles">
|
|
<div className="ctv-builder-title">New Channel</div>
|
|
<div className="ctv-builder-summary">
|
|
Build from your library — <span style={mono}>{lineup.length}</span> in lineup ·{' '}
|
|
<span style={mono}>{formatDuration(totalDurationSeconds)}</span>
|
|
</div>
|
|
</div>
|
|
<Button variant="ghost" onClick={handleCancel} disabled={creating}>
|
|
Cancel
|
|
</Button>
|
|
<Tooltip placement="bottom" label={canCreate ? 'Creates the channel, schedule & playout' : createBlockedReason}>
|
|
<Button
|
|
variant="primary"
|
|
disabled={!canCreate || creating}
|
|
loading={creating}
|
|
startIcon={<Check size={15} aria-hidden="true" />}
|
|
onClick={handleCreate}
|
|
>
|
|
Create Channel
|
|
</Button>
|
|
</Tooltip>
|
|
</div>
|
|
|
|
{createError && (
|
|
<div className="ctv-builder-error" role="alert">
|
|
<span>{createError}</span>
|
|
</div>
|
|
)}
|
|
|
|
{/* body */}
|
|
<div className="ctv-builder-body">
|
|
{/* LEFT — library browser */}
|
|
<section className="ctv-builder-col">
|
|
<div className="ctv-builder-col-head">
|
|
<div className="ctv-builder-headrow">
|
|
<Segmented
|
|
value={source}
|
|
onChange={(next) => {
|
|
setSource(next);
|
|
setLibraryId(null);
|
|
}}
|
|
options={[
|
|
{ value: 'library', label: 'Library', icon: <Library size={13} aria-hidden="true" /> },
|
|
{ value: 'collections', label: 'Collections', icon: <FolderTree size={13} aria-hidden="true" /> }
|
|
]}
|
|
/>
|
|
<span style={{ flex: 1 }} />
|
|
<Segmented
|
|
value={compact ? 'list' : 'grid'}
|
|
onChange={(next) => setCompact(next === 'list')}
|
|
options={[
|
|
{ value: 'grid', icon: <LayoutGrid size={13} aria-hidden="true" />, title: 'Poster grid' },
|
|
{ value: 'list', icon: <Rows3 size={13} aria-hidden="true" />, title: 'Compact list' }
|
|
]}
|
|
/>
|
|
</div>
|
|
<Input
|
|
size="sm"
|
|
value={searchInput}
|
|
onChange={(event) => setSearchInput(event.target.value)}
|
|
leadingIcon={<Search size={15} aria-hidden="true" />}
|
|
placeholder={source === 'collections' ? 'Search collections…' : 'Search shows & movies…'}
|
|
/>
|
|
{source === 'library' && libraryChips.length > 0 && (
|
|
<div className="ctv-builder-chiprow">
|
|
<button
|
|
type="button"
|
|
className={`ctv-builder-chip ctv-press${libraryId == null ? ' ctv-builder-chip-on' : ''}`}
|
|
onClick={() => setLibraryId(null)}
|
|
>
|
|
All
|
|
</button>
|
|
{libraryChips.map((chip) => (
|
|
<button
|
|
key={chip.id}
|
|
type="button"
|
|
className={`ctv-builder-chip ctv-press${libraryId === chip.id ? ' ctv-builder-chip-on' : ''}`}
|
|
onClick={() => setLibraryId(chip.id)}
|
|
>
|
|
{chip.name}
|
|
</button>
|
|
))}
|
|
</div>
|
|
)}
|
|
</div>
|
|
<div className="ctv-builder-scroll ctv-hide-sb">
|
|
<div className="ctv-builder-scroll-body">
|
|
{browse.state.status === 'loading' ? (
|
|
<div className="ctv-builder-empty">
|
|
<Spinner size={18} tone="accent" />
|
|
</div>
|
|
) : browse.state.status === 'error' ? (
|
|
<div className="ctv-builder-empty" role="alert">
|
|
{browse.state.error}
|
|
</div>
|
|
) : items.length === 0 ? (
|
|
<div className="ctv-builder-empty">No titles match.</div>
|
|
) : (
|
|
<>
|
|
<div className={compact ? 'ctv-builder-compact-list' : 'ctv-builder-grid'}>
|
|
{items.map((item) => (
|
|
<LibCard
|
|
key={lineupKey(item)}
|
|
item={item}
|
|
compact={compact}
|
|
added={addedKeys.has(lineupKey(item))}
|
|
onAdd={() => addItem(item)}
|
|
onDragStart={() => setDragLib(lineupKey(item))}
|
|
onDragEnd={() => {
|
|
if (dragLib != null) {
|
|
const dragged = items.find((candidate) => lineupKey(candidate) === dragLib);
|
|
if (dragged) {
|
|
addItem(dragged);
|
|
}
|
|
}
|
|
setDragLib(null);
|
|
setDragRow(null);
|
|
setOverRow(null);
|
|
}}
|
|
/>
|
|
))}
|
|
</div>
|
|
{browse.canLoadMore && (
|
|
<div className="ctv-builder-loadmore">
|
|
<Button variant="secondary" size="sm" loading={browse.loadingMore} onClick={browse.loadMore}>
|
|
Load more
|
|
</Button>
|
|
</div>
|
|
)}
|
|
</>
|
|
)}
|
|
</div>
|
|
</div>
|
|
</section>
|
|
|
|
{/* CENTER — lineup */}
|
|
<section
|
|
className="ctv-builder-col"
|
|
onDragOver={(event) => {
|
|
if (dragLib != null) {
|
|
event.preventDefault();
|
|
}
|
|
}}
|
|
onDrop={() => {
|
|
if (dragLib != null) {
|
|
dropAt(null);
|
|
}
|
|
}}
|
|
>
|
|
<div className="ctv-builder-col-head ctv-builder-col-head-row">
|
|
<span className="ctv-builder-eyebrow">Lineup</span>
|
|
<Badge tone={shuffleOn ? 'accent' : 'neutral'}>
|
|
<span style={{ display: 'inline-flex', alignItems: 'center', gap: 4 }}>
|
|
{shuffleOn ? <Shuffle size={11} aria-hidden="true" /> : <ListOrdered size={11} aria-hidden="true" />}
|
|
{shuffleOn ? 'Shuffled' : 'Sequential'}
|
|
</span>
|
|
</Badge>
|
|
<span style={{ flex: 1 }} />
|
|
{lineup.length > 0 && (
|
|
<button
|
|
type="button"
|
|
className="ctv-builder-linkbtn"
|
|
onClick={() => setConfirmClear(true)}
|
|
>
|
|
Clear
|
|
</button>
|
|
)}
|
|
</div>
|
|
<div className="ctv-builder-scroll ctv-hide-sb">
|
|
<div className="ctv-builder-scroll-body">
|
|
{lineup.length === 0 ? (
|
|
<div className={`ctv-builder-lineup-empty${dragLib != null ? ' ctv-builder-lineup-empty-over' : ''}`}>
|
|
<ListVideo size={26} aria-hidden="true" />
|
|
<div style={{ font: 'var(--text-sm)/1.5 var(--font-sans)', maxWidth: 240 }}>
|
|
This channel has no content yet. Double-click or drag titles from the library to build the lineup.
|
|
</div>
|
|
</div>
|
|
) : (
|
|
<div className="ctv-builder-lineup-list">
|
|
{lineup.map((item, index) => {
|
|
const rowError = rowErrors[index];
|
|
const serverError = serverRowIndex === index;
|
|
return (
|
|
<div
|
|
key={`${lineupKey(item)}-${index}`}
|
|
className={`ctv-builder-lineup-row ctv-lift${rowError || serverError ? ' ctv-builder-lineup-row-error' : ''}`}
|
|
style={{
|
|
opacity: dragRow === index ? 0.35 : 1,
|
|
boxShadow: overRow === index && dragRow !== index ? '0 -2px 0 var(--action-primary)' : 'none'
|
|
}}
|
|
draggable
|
|
onDragStart={() => setDragRow(index)}
|
|
onDragEnd={() => {
|
|
setDragRow(null);
|
|
setOverRow(null);
|
|
}}
|
|
onDragOver={(event) => {
|
|
event.preventDefault();
|
|
setOverRow(index);
|
|
}}
|
|
onDrop={(event) => {
|
|
event.stopPropagation();
|
|
dropAt(index);
|
|
}}
|
|
>
|
|
<span className="ctv-builder-grip" title="Drag to reorder">
|
|
<GripVertical size={16} aria-hidden="true" />
|
|
</span>
|
|
<span className="ctv-builder-order">
|
|
{shuffleOn ? (
|
|
<Shuffle size={13} color="var(--text-disabled)" aria-hidden="true" />
|
|
) : (
|
|
index + 1
|
|
)}
|
|
</span>
|
|
<Poster item={item} width={34} height={46} mini />
|
|
<div className="ctv-builder-row-main">
|
|
<div className="ctv-builder-row-title">{item.title}</div>
|
|
<div className="ctv-builder-row-sub">
|
|
{TYPE_LABEL[item.mediaType]}
|
|
{item.libraryName ? ` · ${item.libraryName}` : ''}
|
|
</div>
|
|
</div>
|
|
{rowError && (
|
|
<Badge tone="error">
|
|
<span>{rowError}</span>
|
|
</Badge>
|
|
)}
|
|
<span className="ctv-builder-row-dur" style={mono}>
|
|
{parseDurationSeconds(item.duration)
|
|
? formatDuration(parseDurationSeconds(item.duration) as number)
|
|
: ''}
|
|
</span>
|
|
<IconButton size="sm" title="Remove" onClick={() => removeAt(index)}>
|
|
<X size={15} aria-hidden="true" />
|
|
</IconButton>
|
|
</div>
|
|
);
|
|
})}
|
|
<div className="ctv-builder-lineup-hint">
|
|
<Plus size={14} aria-hidden="true" />
|
|
Double-click or drag more titles to add
|
|
</div>
|
|
</div>
|
|
)}
|
|
</div>
|
|
</div>
|
|
</section>
|
|
|
|
{/* RIGHT — settings rail */}
|
|
<aside className="ctv-builder-col ctv-builder-col-rail">
|
|
<div className="ctv-builder-scroll ctv-builder-rail-scroll ctv-hide-sb" ref={railScrollRef}>
|
|
{/* identity */}
|
|
<div className="ctv-builder-rail-block">
|
|
<Input
|
|
label="Channel name"
|
|
value={name}
|
|
onChange={(event) => setName(event.target.value)}
|
|
placeholder="e.g. Retro Cartoons"
|
|
/>
|
|
<Input
|
|
label="Number"
|
|
value={number}
|
|
onChange={(event) => setNumber(event.target.value)}
|
|
error={numberError}
|
|
trailing={showAuto ? <span className="ctv-builder-auto-chip">AUTO</span> : undefined}
|
|
/>
|
|
</div>
|
|
|
|
{/* image */}
|
|
<div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
|
|
<div
|
|
className={`ctv-builder-dropzone${dropOver ? ' ctv-builder-dropzone-over' : ''}`}
|
|
onDragOver={(event) => {
|
|
event.preventDefault();
|
|
setDropOver(true);
|
|
}}
|
|
onDragLeave={() => setDropOver(false)}
|
|
onDrop={(event) => {
|
|
event.preventDefault();
|
|
setDropOver(false);
|
|
readImage(event.dataTransfer.files && event.dataTransfer.files[0]);
|
|
}}
|
|
onClick={() => fileInputRef.current?.click()}
|
|
>
|
|
<ChannelLogo name={name || 'New Channel'} src={logoPreview} size={52} radius="var(--radius-sm)" />
|
|
<div style={{ flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column', justifyContent: 'center', gap: 3 }}>
|
|
<div style={{ font: 'var(--weight-medium) var(--text-xs)/1 var(--font-sans)', color: 'var(--text-primary)' }}>
|
|
{logoPreview ? 'Channel image set' : 'Drop channel image'}
|
|
</div>
|
|
<div style={{ font: 'var(--text-2xs)/1.35 var(--font-sans)', color: 'var(--text-secondary)' }}>
|
|
Used as both the guide logo and the on-screen bug.
|
|
</div>
|
|
</div>
|
|
<input
|
|
ref={fileInputRef}
|
|
type="file"
|
|
accept="image/*"
|
|
style={{ display: 'none' }}
|
|
onChange={(event) => readImage(event.target.files && event.target.files[0])}
|
|
/>
|
|
</div>
|
|
{imageError && (
|
|
<div style={{ font: 'var(--text-2xs)/1.35 var(--font-sans)', color: 'var(--status-error)' }} role="alert">
|
|
{imageError}
|
|
</div>
|
|
)}
|
|
|
|
<div className="ctv-builder-preview-grid">
|
|
<div className="ctv-builder-preview-tile">
|
|
<div className="ctv-builder-eyebrow" style={{ marginBottom: 8 }}>
|
|
Guide logo
|
|
</div>
|
|
<div style={{ display: 'flex', alignItems: 'center', gap: 9 }}>
|
|
<ChannelLogo name={name || 'New Channel'} src={logoPreview} size={30} radius="var(--radius-xs)" />
|
|
<div style={{ minWidth: 0 }}>
|
|
<div
|
|
style={{
|
|
font: 'var(--weight-medium) var(--text-2xs)/1.1 var(--font-sans)',
|
|
color: 'var(--text-primary)',
|
|
overflow: 'hidden',
|
|
textOverflow: 'ellipsis',
|
|
whiteSpace: 'nowrap'
|
|
}}
|
|
>
|
|
{name || 'New Channel'}
|
|
</div>
|
|
<div style={{ ...mono, font: '9px/1 var(--font-mono)', color: 'var(--text-disabled)' }}>listing</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div className="ctv-builder-preview-tile">
|
|
<div className="ctv-builder-eyebrow" style={{ marginBottom: 8 }}>
|
|
On-screen bug
|
|
</div>
|
|
<div
|
|
style={{
|
|
position: 'relative',
|
|
height: 42,
|
|
borderRadius: 'var(--radius-xs)',
|
|
overflow: 'hidden',
|
|
background: 'linear-gradient(160deg,#1a1d24,#0e1014)',
|
|
backgroundImage: 'repeating-linear-gradient(135deg, rgba(255,255,255,.03) 0 1px, transparent 1px 7px)'
|
|
}}
|
|
>
|
|
<div style={{ position: 'absolute', bottom: 5, right: 5, opacity: 0.9 }}>
|
|
<ChannelLogo name={name || 'New Channel'} src={logoPreview} size={22} radius="3px" />
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<button type="button" className="ctv-builder-disclosure" onClick={() => setSeparateOpen((open) => !open)}>
|
|
{separateOpen ? <ChevronDown size={13} aria-hidden="true" /> : <ChevronRight size={13} aria-hidden="true" />}
|
|
Set logo & bug separately
|
|
</button>
|
|
{separateOpen && (
|
|
<div className="ctv-builder-sep-grid">
|
|
<Button
|
|
size="sm"
|
|
variant="secondary"
|
|
startIcon={<ImageIcon size={14} aria-hidden="true" />}
|
|
onClick={() => fileInputRef.current?.click()}
|
|
>
|
|
Logo image
|
|
</Button>
|
|
<Tooltip label="Separate bug image coming with watermark upload support">
|
|
<Button size="sm" variant="secondary" disabled startIcon={<ImageIcon size={14} aria-hidden="true" />}>
|
|
Bug image
|
|
</Button>
|
|
</Tooltip>
|
|
</div>
|
|
)}
|
|
</div>
|
|
|
|
{/* friendly toggles */}
|
|
<div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
|
|
{/* div, not label: the Switch is a labelable <button>, so a wrapping
|
|
label would forward its activation AND bubble the click, firing
|
|
the toggle twice. The row's onClick is the single toggle source. */}
|
|
<div
|
|
className="ctv-builder-toggle-row"
|
|
onClick={() => setPlaybackOrder(shuffleOn ? 'Chronological' : 'Shuffle')}
|
|
>
|
|
<div style={{ flex: 1 }}>
|
|
<div style={{ display: 'flex', alignItems: 'center', gap: 7 }}>
|
|
<span className="ctv-builder-toggle-label">Shuffle</span>
|
|
{template && playbackOrder !== templatePlaybackOrder(template) && (
|
|
<span className="ctv-builder-overrides-tag">overrides template</span>
|
|
)}
|
|
</div>
|
|
<div className="ctv-builder-toggle-help">
|
|
{shuffleOn ? 'Plays in a random order.' : 'Plays in sequence (chronological).'}
|
|
</div>
|
|
</div>
|
|
{/* presentational - the row's onClick is the single toggle source */}
|
|
<Switch checked={shuffleOn} />
|
|
</div>
|
|
<div className="ctv-builder-hairline" />
|
|
<div
|
|
className={`ctv-builder-toggle-row ctv-builder-toggle-live${alwaysOn ? ' ctv-builder-toggle-live-on' : ''}`}
|
|
onClick={() => setPlayoutMode(alwaysOn ? 'OnDemand' : 'Continuous')}
|
|
>
|
|
<span style={{ display: 'inline-flex', marginTop: 1, color: 'var(--ctv-live)', flex: '0 0 auto' }}>
|
|
<Radio size={16} aria-hidden="true" />
|
|
</span>
|
|
<div style={{ flex: 1 }}>
|
|
<div style={{ display: 'flex', alignItems: 'center', gap: 7 }}>
|
|
<span className="ctv-builder-toggle-label">Always playing</span>
|
|
{template && playoutMode !== template.playoutMode && (
|
|
<span className="ctv-builder-overrides-tag">overrides template</span>
|
|
)}
|
|
{alwaysOn && (
|
|
<span className="ctv-builder-live-pill">
|
|
<span style={{ width: 5, height: 5, borderRadius: '50%', background: 'var(--ctv-live)' }} />
|
|
LIVE
|
|
</span>
|
|
)}
|
|
</div>
|
|
<div className="ctv-builder-toggle-help">
|
|
Like live TV — advances on schedule even when nobody is watching.
|
|
</div>
|
|
</div>
|
|
{/* presentational - the row's onClick is the single toggle source */}
|
|
<Switch checked={alwaysOn} />
|
|
</div>
|
|
</div>
|
|
|
|
{/* channel template */}
|
|
<div>
|
|
<div className="ctv-builder-eyebrow" style={{ marginBottom: 8 }}>
|
|
Channel Template
|
|
</div>
|
|
{data.templates.length === 0 ? (
|
|
<div className="ctv-builder-tpl-empty">
|
|
No channel templates exist yet. Create one in Settings before building a channel — a template supplies
|
|
the required technical configuration.
|
|
</div>
|
|
) : (
|
|
<>
|
|
<button type="button" className="ctv-builder-tpl-button ctv-press" onClick={() => setTplOpen((open) => !open)}>
|
|
<span className="ctv-builder-tpl-tile">
|
|
<SlidersHorizontal size={15} aria-hidden="true" />
|
|
</span>
|
|
<div style={{ flex: 1, minWidth: 0 }}>
|
|
<div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
|
|
<span className="ctv-builder-tpl-name">{template?.name}</span>
|
|
{template && !template.isSystem && (
|
|
<Badge tone="neutral">Custom</Badge>
|
|
)}
|
|
</div>
|
|
<div className="ctv-builder-tpl-desc">{template?.description}</div>
|
|
</div>
|
|
{tplOpen ? <ChevronUp size={15} color="var(--text-disabled)" aria-hidden="true" /> : <ChevronDown size={15} color="var(--text-disabled)" aria-hidden="true" />}
|
|
</button>
|
|
|
|
{tplOpen && (
|
|
<div className="ctv-builder-tpl-list">
|
|
{data.templates.map((option) => {
|
|
const on = option.id === templateId;
|
|
return (
|
|
<button
|
|
key={option.id}
|
|
type="button"
|
|
className={`ctv-builder-tpl-option ctv-press${on ? ' ctv-builder-tpl-option-on' : ''}`}
|
|
onClick={() => applyTemplate(option)}
|
|
>
|
|
{on ? (
|
|
<CircleCheck size={15} color="var(--action-primary)" aria-hidden="true" />
|
|
) : (
|
|
<Circle size={15} color="var(--text-disabled)" aria-hidden="true" />
|
|
)}
|
|
<div style={{ flex: 1, minWidth: 0 }}>
|
|
<div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
|
|
<span className="ctv-builder-tpl-option-name">{option.name}</span>
|
|
{!option.isSystem && <Badge tone="neutral">Custom</Badge>}
|
|
</div>
|
|
<div className="ctv-builder-tpl-desc">{option.description}</div>
|
|
</div>
|
|
</button>
|
|
);
|
|
})}
|
|
<button type="button" className="ctv-builder-tpl-save" onClick={openSaveTemplate}>
|
|
<Save size={14} aria-hidden="true" />
|
|
Save current settings as template…
|
|
</button>
|
|
</div>
|
|
)}
|
|
|
|
{template && (
|
|
<div className="ctv-builder-config-chips">
|
|
{templateChips(template, data.ffmpegProfiles, playbackOrder, playoutMode).map((chip) => (
|
|
<span
|
|
key={chip}
|
|
className="ctv-builder-config-chip"
|
|
style={/\d/.test(chip) ? mono : undefined}
|
|
>
|
|
{chip}
|
|
</span>
|
|
))}
|
|
</div>
|
|
)}
|
|
</>
|
|
)}
|
|
</div>
|
|
|
|
{/* advanced */}
|
|
{template && (
|
|
<AdvancedPanel
|
|
template={template}
|
|
overrides={overrides}
|
|
setOverrides={setOverrides}
|
|
playbackOrder={playbackOrder}
|
|
setPlaybackOrder={setPlaybackOrder}
|
|
playoutMode={playoutMode}
|
|
setPlayoutMode={setPlayoutMode}
|
|
group={group}
|
|
setGroup={setGroup}
|
|
categories={categories}
|
|
setCategories={setCategories}
|
|
mode={advMode}
|
|
setMode={setAdvMode}
|
|
maxHeight={advMaxHeight}
|
|
fieldsRef={advFieldsRef}
|
|
scrollerRef={railScrollRef}
|
|
ffmpegProfiles={data.ffmpegProfiles}
|
|
fillerPresets={data.fillerPresets}
|
|
watermarks={data.watermarks}
|
|
/>
|
|
)}
|
|
</div>
|
|
</aside>
|
|
</div>
|
|
|
|
<ConfirmDialog
|
|
open={confirmClear}
|
|
title="Clear the lineup?"
|
|
message="This removes every item from the channel lineup."
|
|
confirmLabel="Clear lineup"
|
|
tone="danger"
|
|
onConfirm={() => {
|
|
clearLineupError();
|
|
setLineup([]);
|
|
setConfirmClear(false);
|
|
}}
|
|
onCancel={() => setConfirmClear(false)}
|
|
/>
|
|
|
|
<ConfirmDialog
|
|
open={confirmCancel}
|
|
title="Discard this channel?"
|
|
message="Your lineup and settings for this new channel will be discarded."
|
|
confirmLabel="Discard"
|
|
tone="danger"
|
|
onConfirm={() => {
|
|
setConfirmCancel(false);
|
|
navigateToPath('/app/channels');
|
|
}}
|
|
onCancel={() => setConfirmCancel(false)}
|
|
/>
|
|
|
|
<Dialog
|
|
open={saveOpen}
|
|
onClose={() => setSaveOpen(false)}
|
|
title="Save as channel template"
|
|
width={420}
|
|
footer={
|
|
<>
|
|
<Button variant="secondary" onClick={() => setSaveOpen(false)} disabled={saveBusy}>
|
|
Cancel
|
|
</Button>
|
|
<Button variant="primary" onClick={handleSaveTemplate} loading={saveBusy} disabled={saveBusy}>
|
|
Save template
|
|
</Button>
|
|
</>
|
|
}
|
|
>
|
|
<div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
|
|
<Input label="Template name" value={saveName} onChange={(event) => setSaveName(event.target.value)} placeholder="e.g. Retro Saturday AM" />
|
|
<Input label="Description" value={saveDesc} onChange={(event) => setSaveDesc(event.target.value)} placeholder="Optional one-line summary" />
|
|
{saveError && (
|
|
<div style={{ font: 'var(--text-xs)/1.4 var(--font-sans)', color: 'var(--status-error)' }} role="alert">
|
|
{saveError}
|
|
</div>
|
|
)}
|
|
</div>
|
|
</Dialog>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// Config chips derived from real template fields (4-6 chips).
|
|
function templateChips(
|
|
template: ChannelTemplate,
|
|
ffmpegProfiles: FFmpegProfile[],
|
|
playbackOrder: PlaybackOrder,
|
|
playoutMode: PlayoutMode
|
|
): string[] {
|
|
const chips: string[] = [];
|
|
chips.push(STREAMING_MODE_LABELS[template.streamingMode as StreamingMode] ?? template.streamingMode);
|
|
const profile = ffmpegProfiles.find((candidate) => candidate.id === template.fFmpegProfileId);
|
|
if (profile?.name) {
|
|
chips.push(profile.name);
|
|
}
|
|
chips.push(playbackOrder === 'Shuffle' || playbackOrder === 'ShuffleInOrder' ? 'Shuffle' : 'Sequential');
|
|
chips.push(playoutMode === 'Continuous' ? 'Always on' : 'On demand');
|
|
const fillers: string[] = [];
|
|
if (template.preRollFillerId != null) {
|
|
fillers.push('Pre');
|
|
}
|
|
if (template.midRollFillerId != null) {
|
|
fillers.push('Mid');
|
|
}
|
|
if (template.postRollFillerId != null) {
|
|
fillers.push('Post');
|
|
}
|
|
if (fillers.length > 0) {
|
|
chips.push(`${fillers.join('/')} filler`);
|
|
}
|
|
if (template.subtitleMode && template.subtitleMode !== 'None') {
|
|
chips.push(`Subtitles: ${template.subtitleMode}`);
|
|
}
|
|
return chips.slice(0, 6);
|
|
}
|
|
|
|
// ---- Advanced panel --------------------------------------------------------
|
|
function AdvancedPanel({
|
|
template,
|
|
overrides,
|
|
setOverrides,
|
|
playbackOrder,
|
|
setPlaybackOrder,
|
|
playoutMode,
|
|
setPlayoutMode,
|
|
group,
|
|
setGroup,
|
|
categories,
|
|
setCategories,
|
|
mode,
|
|
setMode,
|
|
maxHeight,
|
|
fieldsRef,
|
|
scrollerRef,
|
|
ffmpegProfiles,
|
|
fillerPresets,
|
|
watermarks
|
|
}: {
|
|
template: ChannelTemplate;
|
|
overrides: Overrides;
|
|
setOverrides: (updater: (prev: Overrides) => Overrides) => void;
|
|
playbackOrder: PlaybackOrder;
|
|
setPlaybackOrder: (next: PlaybackOrder) => void;
|
|
playoutMode: PlayoutMode;
|
|
setPlayoutMode: (next: PlayoutMode) => void;
|
|
group: string;
|
|
setGroup: (next: string) => void;
|
|
categories: string;
|
|
setCategories: (next: string) => void;
|
|
mode: 'closed' | 'view' | 'override';
|
|
setMode: (next: 'closed' | 'view' | 'override') => void;
|
|
maxHeight: number;
|
|
fieldsRef: React.RefObject<HTMLDivElement | null>;
|
|
scrollerRef: React.RefObject<HTMLDivElement | null>;
|
|
ffmpegProfiles: FFmpegProfile[];
|
|
fillerPresets: FillerPreset[];
|
|
watermarks: Watermark[];
|
|
}) {
|
|
const override = mode === 'override';
|
|
const overrideCount = Object.keys(overrides).length;
|
|
const fieldCount = ADVANCED_KEYS.length + 2; // + playbackOrder + playoutMode (toggled)
|
|
|
|
const setOverride = (key: AdvancedKey, value: unknown) => setOverrides((prev) => ({ ...prev, [key]: value }));
|
|
const removeOverride = (key: AdvancedKey) =>
|
|
setOverrides((prev) => {
|
|
const next = { ...prev };
|
|
delete next[key];
|
|
return next;
|
|
});
|
|
|
|
// Override selects: the first option is always "Inherit from template" (the
|
|
// INHERIT sentinel -> field omitted from the request). There is deliberately
|
|
// NO "None" option for filler/watermark ids: the create handler coalesces
|
|
// null with the template value, so clear-to-none is not expressible (#135).
|
|
const templateValueOf = (key: AdvancedKey): unknown => (template as unknown as Record<string, unknown>)[key];
|
|
const inheritOption = (inheritedLabel: string | null) => ({
|
|
value: INHERIT,
|
|
label: inheritedLabel ? `Inherit (${inheritedLabel})` : 'Inherit from template'
|
|
});
|
|
|
|
const idSelectOptions = (key: AdvancedKey, rows: Array<{ id: number; name: string | null }>) => {
|
|
const inherited = templateValueOf(key) as number | null;
|
|
return [
|
|
inheritOption(inherited == null ? null : fillerName(rows, inherited)),
|
|
...rows.map((row) => ({ value: String(row.id), label: row.name ?? `#${row.id}` }))
|
|
];
|
|
};
|
|
|
|
// Selected value for an override select: the override when present, else INHERIT.
|
|
const selValue = (key: AdvancedKey): string => (key in overrides ? String(overrides[key]) : INHERIT);
|
|
const onSelect = (key: AdvancedKey, map: (raw: string) => unknown) => (event: React.ChangeEvent<HTMLSelectElement>) => {
|
|
const raw = event.target.value;
|
|
if (raw === INHERIT) {
|
|
removeOverride(key);
|
|
} else {
|
|
setOverride(key, map(raw));
|
|
}
|
|
};
|
|
|
|
// Text inputs: empty string = inherit (field omitted); never send null or ''.
|
|
const textValue = (key: AdvancedKey): string => (key in overrides ? String(overrides[key] ?? '') : '');
|
|
const onText = (key: AdvancedKey) => (event: React.ChangeEvent<HTMLInputElement>) => {
|
|
const raw = event.target.value;
|
|
if (raw === '') {
|
|
removeOverride(key);
|
|
} else {
|
|
setOverride(key, raw);
|
|
}
|
|
};
|
|
const textPlaceholder = (key: AdvancedKey, fallback?: string): string | undefined => {
|
|
const inherited = templateValueOf(key);
|
|
return inherited ? `Inherit: ${String(inherited)}` : fallback;
|
|
};
|
|
|
|
const boolValue = (key: AdvancedKey): boolean => Boolean(effectiveValue(key, template, overrides));
|
|
|
|
// Opening a panel scrolls the rail so the Advanced header sits near the top
|
|
// (ported from the prototype ChannelBuilder.jsx toggle()).
|
|
const rootRef = useRef<HTMLDivElement>(null);
|
|
const toggleMode = (next: 'view' | 'override') => {
|
|
const nextMode = mode === next ? 'closed' : next;
|
|
setMode(nextMode);
|
|
if (nextMode !== 'closed' && scrollerRef.current && rootRef.current) {
|
|
const scroller = scrollerRef.current;
|
|
const root = rootRef.current;
|
|
requestAnimationFrame(() => {
|
|
const target = scroller.scrollTop + root.getBoundingClientRect().top - scroller.getBoundingClientRect().top - 20;
|
|
scroller.scrollTo({ top: Math.max(0, target), behavior: 'smooth' });
|
|
});
|
|
}
|
|
};
|
|
|
|
return (
|
|
<div className="ctv-builder-adv" ref={rootRef}>
|
|
<div className="ctv-builder-adv-head">
|
|
<SlidersHorizontal size={16} color="var(--text-secondary)" aria-hidden="true" />
|
|
<span className="ctv-builder-adv-head-title">Advanced</span>
|
|
<span style={{ flex: 1 }} />
|
|
<span className="ctv-builder-adv-count">
|
|
{fieldCount} fields{overrideCount > 0 ? ` · ${overrideCount} overridden` : ''} · {template.name}
|
|
</span>
|
|
</div>
|
|
<div className="ctv-builder-adv-tabs">
|
|
<button
|
|
type="button"
|
|
className={`ctv-builder-adv-tab ctv-press${override ? ' ctv-builder-adv-tab-on' : ''}`}
|
|
onClick={() => toggleMode('override')}
|
|
>
|
|
<SquarePen size={14} aria-hidden="true" />
|
|
{override ? 'Overriding' : 'Override settings'}
|
|
</button>
|
|
<button
|
|
type="button"
|
|
className={`ctv-builder-adv-tab ctv-press${mode === 'view' ? ' ctv-builder-adv-tab-on' : ''}`}
|
|
onClick={() => toggleMode('view')}
|
|
>
|
|
<Eye size={14} aria-hidden="true" />
|
|
View defaults
|
|
</button>
|
|
</div>
|
|
<div className="ctv-builder-adv-panel" style={{ maxHeight }}>
|
|
<div className="ctv-builder-adv-fields" ref={fieldsRef}>
|
|
<div className="ctv-builder-adv-info">
|
|
<Info
|
|
size={13}
|
|
color={override ? 'var(--action-primary)' : 'var(--text-disabled)'}
|
|
aria-hidden="true"
|
|
/>
|
|
{override
|
|
? 'Editing these overrides the template for this channel only.'
|
|
: `Read-only — inherited from the ${template.name} template. Turn on Override to edit.`}
|
|
</div>
|
|
|
|
{override ? (
|
|
<>
|
|
<AdvGroup label="Streaming">
|
|
<Select
|
|
size="sm"
|
|
label="FFmpeg profile"
|
|
value={selValue('fFmpegProfileId')}
|
|
options={[
|
|
inheritOption(
|
|
ffmpegProfiles.find((p) => p.id === template.fFmpegProfileId)?.name ??
|
|
`#${template.fFmpegProfileId}`
|
|
),
|
|
...ffmpegProfiles.map((profile) => ({ value: String(profile.id), label: profile.name ?? `#${profile.id}` }))
|
|
]}
|
|
onChange={onSelect('fFmpegProfileId', Number)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Streaming mode"
|
|
value={selValue('streamingMode')}
|
|
options={[
|
|
inheritOption(STREAMING_MODE_LABELS[template.streamingMode as StreamingMode] ?? template.streamingMode),
|
|
...STREAMING_MODES.map((value) => ({ value, label: STREAMING_MODE_LABELS[value] }))
|
|
]}
|
|
onChange={onSelect('streamingMode', (raw) => raw as StreamingMode)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Transcode mode"
|
|
value={selValue('transcodeMode')}
|
|
options={[
|
|
inheritOption(template.transcodeMode),
|
|
...TRANSCODE_MODES.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('transcodeMode', (raw) => raw as TranscodeMode)}
|
|
/>
|
|
</AdvGroup>
|
|
|
|
<AdvGroup label="Filler">
|
|
<Select
|
|
size="sm"
|
|
label="Fallback filler"
|
|
value={selValue('fallbackFillerId')}
|
|
options={idSelectOptions('fallbackFillerId', fillerPresets)}
|
|
onChange={onSelect('fallbackFillerId', Number)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Pre-roll filler"
|
|
value={selValue('preRollFillerId')}
|
|
options={idSelectOptions('preRollFillerId', fillerPresets)}
|
|
onChange={onSelect('preRollFillerId', Number)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Mid-roll filler"
|
|
value={selValue('midRollFillerId')}
|
|
options={idSelectOptions('midRollFillerId', fillerPresets)}
|
|
onChange={onSelect('midRollFillerId', Number)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Post-roll filler"
|
|
value={selValue('postRollFillerId')}
|
|
options={idSelectOptions('postRollFillerId', fillerPresets)}
|
|
onChange={onSelect('postRollFillerId', Number)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Watermark"
|
|
value={selValue('watermarkId')}
|
|
options={idSelectOptions('watermarkId', watermarks)}
|
|
onChange={onSelect('watermarkId', Number)}
|
|
/>
|
|
</AdvGroup>
|
|
|
|
<AdvGroup label="Playback">
|
|
<Select
|
|
size="sm"
|
|
label="Playback order"
|
|
value={playbackOrder}
|
|
options={[...PLAYBACK_ORDERS]}
|
|
onChange={(event) => setPlaybackOrder(event.target.value as PlaybackOrder)}
|
|
/>
|
|
<Input
|
|
size="sm"
|
|
label="Preferred audio language"
|
|
value={textValue('preferredAudioLanguageCode')}
|
|
onChange={onText('preferredAudioLanguageCode')}
|
|
placeholder={textPlaceholder('preferredAudioLanguageCode', 'e.g. eng')}
|
|
/>
|
|
<Input
|
|
size="sm"
|
|
label="Preferred subtitle language"
|
|
value={textValue('preferredSubtitleLanguageCode')}
|
|
onChange={onText('preferredSubtitleLanguageCode')}
|
|
placeholder={textPlaceholder('preferredSubtitleLanguageCode', 'e.g. eng')}
|
|
/>
|
|
<Input
|
|
size="sm"
|
|
label="Preferred audio title"
|
|
value={textValue('preferredAudioTitle')}
|
|
onChange={onText('preferredAudioTitle')}
|
|
placeholder={textPlaceholder('preferredAudioTitle')}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Subtitle mode"
|
|
value={selValue('subtitleMode')}
|
|
options={[
|
|
inheritOption(template.subtitleMode),
|
|
...SUBTITLE_MODES.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('subtitleMode', (raw) => raw as SubtitleMode)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Stream selector mode"
|
|
value={selValue('streamSelectorMode')}
|
|
options={[
|
|
inheritOption(template.streamSelectorMode),
|
|
...STREAM_SELECTOR_MODES.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('streamSelectorMode', (raw) => raw as StreamSelectorMode)}
|
|
/>
|
|
<Input
|
|
size="sm"
|
|
label="Stream selector"
|
|
value={textValue('streamSelector')}
|
|
onChange={onText('streamSelector')}
|
|
placeholder={textPlaceholder('streamSelector')}
|
|
/>
|
|
</AdvGroup>
|
|
|
|
<AdvGroup label="Behavior">
|
|
<Select
|
|
size="sm"
|
|
label="Playout mode"
|
|
value={playoutMode}
|
|
options={['Continuous', 'OnDemand']}
|
|
onChange={(event) => setPlayoutMode(event.target.value as PlayoutMode)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Music video credits"
|
|
value={selValue('musicVideoCreditsMode')}
|
|
options={[
|
|
inheritOption(template.musicVideoCreditsMode),
|
|
...MUSIC_VIDEO_CREDITS_MODES.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('musicVideoCreditsMode', (raw) => raw as MusicVideoCreditsMode)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Song video mode"
|
|
value={selValue('songVideoMode')}
|
|
options={[
|
|
inheritOption(template.songVideoMode),
|
|
...SONG_VIDEO_MODES.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('songVideoMode', (raw) => raw as SongVideoMode)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Idle behavior"
|
|
value={selValue('idleBehavior')}
|
|
options={[
|
|
inheritOption(template.idleBehavior),
|
|
...IDLE_BEHAVIORS.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('idleBehavior', (raw) => raw as IdleBehavior)}
|
|
/>
|
|
<Select
|
|
size="sm"
|
|
label="Fixed start time"
|
|
value={selValue('fixedStartTimeBehavior')}
|
|
options={[
|
|
inheritOption(template.fixedStartTimeBehavior),
|
|
...FIXED_START_TIME_BEHAVIORS.map((value) => ({ value, label: value }))
|
|
]}
|
|
onChange={onSelect('fixedStartTimeBehavior', (raw) => raw as FixedStartTimeBehavior)}
|
|
/>
|
|
<div className="ctv-builder-adv-switchrow">
|
|
<span>Random start point</span>
|
|
<Switch
|
|
checked={boolValue('randomStartPoint')}
|
|
onChange={(next) => setOverride('randomStartPoint', next)}
|
|
/>
|
|
</div>
|
|
<div className="ctv-builder-adv-switchrow">
|
|
<span>Shuffle schedule items</span>
|
|
<Switch
|
|
checked={boolValue('shuffleScheduleItems')}
|
|
onChange={(next) => setOverride('shuffleScheduleItems', next)}
|
|
/>
|
|
</div>
|
|
<Input size="sm" label="Group" value={group} onChange={(event) => setGroup(event.target.value)} error={group.trim() ? null : 'Required'} />
|
|
<Input size="sm" label="Categories" value={categories} onChange={(event) => setCategories(event.target.value)} placeholder="comma-separated" />
|
|
</AdvGroup>
|
|
</>
|
|
) : (
|
|
<>
|
|
<AdvGroup label="Streaming">
|
|
<ReadOnlyField label="FFmpeg profile" value={ffmpegProfiles.find((p) => p.id === template.fFmpegProfileId)?.name ?? `#${template.fFmpegProfileId}`} />
|
|
<ReadOnlyField label="Streaming mode" value={STREAMING_MODE_LABELS[template.streamingMode as StreamingMode] ?? template.streamingMode} />
|
|
<ReadOnlyField label="Transcode mode" value={template.transcodeMode} />
|
|
</AdvGroup>
|
|
<AdvGroup label="Filler">
|
|
<ReadOnlyField label="Fallback filler" value={fillerName(fillerPresets, template.fallbackFillerId)} />
|
|
<ReadOnlyField label="Pre-roll filler" value={fillerName(fillerPresets, template.preRollFillerId)} />
|
|
<ReadOnlyField label="Mid-roll filler" value={fillerName(fillerPresets, template.midRollFillerId)} />
|
|
<ReadOnlyField label="Post-roll filler" value={fillerName(fillerPresets, template.postRollFillerId)} />
|
|
<ReadOnlyField label="Watermark" value={fillerName(watermarks, template.watermarkId)} />
|
|
</AdvGroup>
|
|
<AdvGroup label="Playback">
|
|
<ReadOnlyField label="Playback order" value={playbackOrder} />
|
|
<ReadOnlyField label="Preferred audio language" value={template.preferredAudioLanguageCode ?? 'Not set'} />
|
|
<ReadOnlyField label="Preferred subtitle language" value={template.preferredSubtitleLanguageCode ?? 'Not set'} />
|
|
<ReadOnlyField label="Subtitle mode" value={template.subtitleMode} />
|
|
<ReadOnlyField label="Stream selector mode" value={template.streamSelectorMode} />
|
|
</AdvGroup>
|
|
<AdvGroup label="Behavior">
|
|
<ReadOnlyField label="Playout mode" value={playoutMode === 'Continuous' ? 'Always on' : 'On demand'} />
|
|
<ReadOnlyField label="Music video credits" value={template.musicVideoCreditsMode} />
|
|
<ReadOnlyField label="Song video mode" value={template.songVideoMode} />
|
|
<ReadOnlyField label="Idle behavior" value={template.idleBehavior} />
|
|
<ReadOnlyField label="Fixed start time" value={template.fixedStartTimeBehavior} />
|
|
<ReadOnlyField label="Group" value={group} />
|
|
</AdvGroup>
|
|
</>
|
|
)}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function AdvGroup({ label, children }: { label: string; children: ReactNode }) {
|
|
return (
|
|
<div>
|
|
<div className="ctv-builder-eyebrow" style={{ marginBottom: 8 }}>
|
|
{label}
|
|
</div>
|
|
<div className="ctv-builder-adv-grid">{children}</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function ReadOnlyField({ label, value }: { label: string; value: string }) {
|
|
return (
|
|
<div className="ctv-builder-adv-readonly">
|
|
<div className="ctv-builder-adv-readonly-key">{label}</div>
|
|
<div className="ctv-builder-adv-readonly-value" style={/\d/.test(value) ? mono : undefined}>
|
|
{value}
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function fillerName(rows: Array<{ id: number; name: string | null }>, id: number | null): string {
|
|
if (id == null) {
|
|
return 'None';
|
|
}
|
|
const row = rows.find((candidate) => candidate.id === id);
|
|
return row?.name ?? `#${id}`;
|
|
}
|