Files
ersatztv/web/src/builder/ChannelBuilder.tsx
T
timothyandClaude Fable 5 ef88e93256
Build ErsatzTV Image / Build & test (.NET) (pull_request) Successful in 4m27s
Build ErsatzTV Image / EF migration integrity (SQLite + MySql) (pull_request) Successful in 4m45s
Build ErsatzTV Image / Build & push image (amd64) (pull_request) Has been skipped
feat(web): ChicoryTV rebrand (#90)
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>
2026-07-07 10:05:39 +02:00

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 &amp; 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}`;
}