MMnode/frontend/src/components/widgets/multitrack/TrackArea.tsx
Z User 8ede97ab11 feat: revert editor to pristine upstream, drop format label mapping and T2V==R2V, fix editor delivery
- frontend/src + messages restored byte-identical to upstream v1.3.3:
  format normalization shims, isMoxieEditorFormat gates, bundle marker,
  tooltip reword, and their tests all removed; editor bundle rebuilt from
  that pristine source so the editor behaves exactly like upstream
- format combo shows 'MiniMax' again (options=[MiniMax]); legacy queued
  'Moxie Multimedia' values still normalized to MiniMax at execution
- T2V resolves natively again: t2v stays t2v in h3_task_type,
  _multitrack_task_type and getMultiTrackTaskType; generation-mode t2v
  mapping and the zero-media cloud fallback removed (upstream behavior);
  Python tests and stub scripts updated accordingly
- editor delivery fix: core lets WEB_DIRECTORY overwrite the pack's
  EXTENSION_WEB_DIRS entry, so the /extensions listing never contained
  dist/release and a fresh browser never imported the editor (it only
  ever appeared from stale browser cache). web/js/editor-loader.js now
  imports the editor entry from the pack's own static mount, which
  serves index.js with no-cache (chunks stay cacheable); the
  /extensions/<pack>/index.js route was removed as a 404 trap
- shipped Moxie*.json templates carry format value MiniMax

Verified: frontend diff vs upstream = 0; bundle string checks + chunk
refs; vitest 565/566 (same pre-existing jsdom URL.revokeObjectURL env
failure); py_compile; test_t2v_r2v_and_loader.py ALL PASS;
test_rtx_upscale_integration.py ALL PASS
2026-09-27 21:24:56 +00:00

887 lines
36 KiB
TypeScript

import { useEffect, useRef, useState } from 'react'
import { Captions, Film, ListTree, Clapperboard, Layers2, Loader2, Music2, Plus, Trash2, Volume2 } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
import { useT } from '@/lib/i18n'
import { uploadInputMediaFile } from '@/lib/media-upload'
import { uploadTaskImageFile } from '@/lib/task-image-utils'
import { invalidateMediaListCache } from '@/stores/media-list-store'
import {
getSegmentDragPlaceholder,
getSegmentDragPreviewSegments,
getMultiTrackTrackHeight,
MULTITRACK_MEDIA_TRACK_LIMIT,
snapMultiTrackMoveStartTime,
snapTimeToFrame,
type SegmentDragPlaceholder,
} from '@/lib/multitrack-utils'
import type { MultiTrack, MultiTrackSegment, MultiTrackTaskImage, MultiTrackType } from '@/types/multitrack'
import type { MultiTrackSourceType, TrackData } from '@/types/multitrack'
import { MULTITRACK_LEFT_GUTTER, MULTITRACK_RIGHT_RESERVE } from './MultiTrackRuler'
import { MultiTrackSegmentBlock } from './MultiTrackSegmentBlock'
import { AudioTrack } from './AudioTrack'
import { VideoTrack } from './VideoTrack'
import { SubtitleTrack } from './SubtitleTrack'
import type { SubtitleRecognitionMethod } from '@/lib/subtitle-recognition'
import { getTrackSegmentGaps, TrackGapAddButton } from './TrackGapAddButton'
interface TrackAreaProps {
data: TrackData
node: unknown
app: unknown
width: number
currentTime: number
snapEnabled: boolean
canvasScale: number
selectedSegmentIds: Set<string>
taskOverview?: boolean
onAddVideo: (
trackId: string,
filePath: string,
sourceType: MultiTrackSourceType,
startFrame?: number,
endFrame?: number,
previewUrl?: string,
) => void
onAddAudio: (
trackId: string,
filePath: string,
sourceType: MultiTrackSourceType,
previewUrl?: string,
startFrame?: number,
endFrame?: number,
) => void
onReplaceAudio: (
trackId: string,
segmentId: string,
filePath: string,
sourceType: MultiTrackSourceType,
previewUrl?: string,
) => void
onAddTrack: (type: MultiTrackType) => void
onAddSubtitleSegment: (trackId: string, startFrame?: number, endFrame?: number) => void
onImportSubtitles?: (trackId: string, srtText: string, startFrame: number) => void
onReplaceVideo: (trackId: string, segmentId: string, filePath: string, sourceType: MultiTrackSourceType, previewUrl?: string) => void
onAddTaskSegment: (
trackId: string,
startFrame?: number,
endFrame?: number,
images?: MultiTrackTaskImage[],
) => void
onSelectSegment: (segmentId: string, mode?: 'replace' | 'toggle' | 'add') => void
onSelectSegments: (segmentIds: string[]) => void
onClearSelection: () => void
onDeleteSegment: (segmentId: string) => void
onDeleteTrack: (trackId: string) => void
onReorderTrack?: (sourceTrackId: string, targetTrackId: string) => void
onTrackVisibilityChange?: (trackId: string, visible: boolean) => void
onTrackAudioSettingsChange: (trackId: string, patch: Partial<Pick<MultiTrack, 'muted' | 'solo' | 'audio_locked'>>) => void
onSharedReferenceChange?: (trackId: string, segmentId: string, enabled: boolean) => void
onDistributeTaskSegments: (trackId: string) => void
onCloneTaskSegment: (trackId: string, segmentId: string) => void
canMergeSelectedTaskSegments?: boolean
onMergeSelectedTaskSegments?: () => void
onSplitTaskSegment?: (segmentId: string) => void
onResizeSegment: (segmentId: string, edge: 'start' | 'end', nextTime: number, brakeDistanceFrames?: number) => void
onResizeSegmentPreview: (segmentId: string, edge: 'start' | 'end', nextTime: number, brakeDistanceFrames?: number) => void
onMoveSegment: (segmentId: string, targetTrackId: string, nextStartTime: number) => void
onSmartSplit: (segmentId: string) => void
onSmartSplitTasks: (segmentId: string) => void
onRecognizeSubtitles?: (segmentId: string, method: SubtitleRecognitionMethod) => void
onEditSubtitleSegment?: (segmentId: string) => void
cutMode: boolean
onCutSegment: (segmentId: string, splitFrame: number) => void
format?: string
}
function TrackTypeIcon({ type }: Readonly<{ type: string }>) {
const Icon = type === 'video'
? Clapperboard
: type === 'audio'
? Volume2
: type === 'subtitle'
? Captions
: type === 'task'
? ListTree
: Layers2
return <Icon className="h-3.5 w-3.5 text-muted-foreground" />
}
function samePlaceholder(left: SegmentDragPlaceholder | null, right: SegmentDragPlaceholder | null): boolean {
if (left === right) return true
if (!left || !right) return false
return left.segmentId === right.segmentId &&
left.targetTrackId === right.targetTrackId &&
left.insertIndex === right.insertIndex &&
left.start_frame === right.start_frame &&
left.end_frame === right.end_frame
}
const AUDIO_EXTENSIONS = new Set(['mp3', 'wav', 'flac', 'ogg', 'm4a', 'aac', 'opus', 'wma'])
const VIDEO_EXTENSIONS = new Set(['mp4', 'webm', 'mov', 'mkv', 'avi', 'm4v'])
const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp', 'tif', 'tiff', 'avif'])
type ExternalMediaType = 'audio' | 'video' | 'image' | 'subtitle'
function externalMediaType(file: File): ExternalMediaType | null {
const extension = file.name.split('.').pop()?.toLowerCase() ?? ''
if (extension === 'srt') return 'subtitle'
if (file.type.startsWith('audio/')) return 'audio'
if (file.type.startsWith('video/')) return 'video'
if (file.type.startsWith('image/')) return 'image'
if (AUDIO_EXTENSIONS.has(extension)) return 'audio'
if (VIDEO_EXTENSIONS.has(extension)) return 'video'
if (IMAGE_EXTENSIONS.has(extension)) return 'image'
return null
}
function draggedMediaType(dataTransfer: DataTransfer): ExternalMediaType | null {
const file = firstDraggedFile(dataTransfer)
if (file) return externalMediaType(file)
for (const item of Array.from(dataTransfer.items)) {
if (item.kind !== 'file') continue
if (item.type === 'application/x-subrip') return 'subtitle'
if (item.type.startsWith('audio/')) return 'audio'
if (item.type.startsWith('video/')) return 'video'
if (item.type.startsWith('image/')) return 'image'
}
return null
}
function hasExternalFiles(dataTransfer: DataTransfer): boolean {
return Array.from(dataTransfer.types).includes('Files') ||
dataTransfer.files.length > 0 ||
Array.from(dataTransfer.items).some((item) => item.kind === 'file')
}
function firstDraggedFile(dataTransfer: DataTransfer): File | null {
const file = Array.from(dataTransfer.files)[0]
if (file) return file
for (const item of Array.from(dataTransfer.items)) {
if (item.kind !== 'file') continue
const itemFile = item.getAsFile()
if (itemFile) return itemFile
}
return null
}
interface ExternalDropSlot {
trackId: string
frame: number
}
interface ExternalUpload extends ExternalDropSlot {
fileName: string
}
export function TrackArea({
data,
node,
app,
width,
currentTime,
snapEnabled,
canvasScale,
selectedSegmentIds,
taskOverview = false,
onAddVideo,
onAddAudio,
onReplaceAudio,
onAddTrack,
onAddSubtitleSegment,
onImportSubtitles = () => {},
onReplaceVideo,
onAddTaskSegment,
onSelectSegment,
onSelectSegments,
onClearSelection,
onDeleteSegment,
onDeleteTrack,
onReorderTrack = () => {},
onTrackVisibilityChange = () => {},
onTrackAudioSettingsChange,
onSharedReferenceChange = () => {},
onDistributeTaskSegments,
onCloneTaskSegment,
canMergeSelectedTaskSegments = false,
onMergeSelectedTaskSegments,
onSplitTaskSegment = () => {},
onResizeSegment,
onResizeSegmentPreview,
onMoveSegment,
onSmartSplit,
onSmartSplitTasks,
onRecognizeSubtitles = () => {},
onEditSubtitleSegment = () => {},
cutMode,
onCutSegment,
format,
}: Readonly<TrackAreaProps>) {
const t = useT()
const trackAreaRef = useRef<HTMLDivElement>(null)
const marqueeStartRef = useRef<{ x: number, y: number } | null>(null)
const trackDragSourceRef = useRef<string | null>(null)
const marqueeMovedRef = useRef(false)
const suppressNextClickRef = useRef(false)
const suppressGlobalClickCleanupRef = useRef<(() => void) | null>(null)
const [dragPlaceholder, setDragPlaceholder] = useState<SegmentDragPlaceholder | null>(null)
const [externalDropSlot, setExternalDropSlot] = useState<ExternalDropSlot | null>(null)
const [externalUpload, setExternalUpload] = useState<ExternalUpload | null>(null)
const [marqueeRect, setMarqueeRect] = useState<{ left: number, top: number, width: number, height: number } | null>(null)
const safeLength = Math.max(data.total_length, 1)
const timelineWidth = Math.max(1, width - MULTITRACK_LEFT_GUTTER)
const playableWidth = Math.max(1, timelineWidth - MULTITRACK_RIGHT_RESERVE)
const playheadLeft = MULTITRACK_LEFT_GUTTER + (currentTime / safeLength) * playableWidth
const reserveLeft = MULTITRACK_LEFT_GUTTER + playableWidth
const addTrackHeight = 24
const tracksHeight = data.tracks.reduce((height, track) => height + getMultiTrackTrackHeight(track.type, taskOverview), 0)
const trackAreaHeight = tracksHeight + addTrackHeight
const firstVideoTrackId = data.tracks.find((track) => track.type === 'video')?.id
const videoTrackLimitReached = data.tracks.filter((track) => track.type === 'video').length >= MULTITRACK_MEDIA_TRACK_LIMIT
const audioTrackLimitReached = data.tracks.filter((track) => track.type === 'audio').length >= MULTITRACK_MEDIA_TRACK_LIMIT
const subtitleTrackLimitReached = data.tracks.filter((track) => track.type === 'subtitle').length >= MULTITRACK_MEDIA_TRACK_LIMIT
const trackBounds = data.tracks.reduce<Array<{ id: string, top: number, bottom: number }>>((bounds, track) => {
const top = bounds.at(-1)?.bottom ?? 0
bounds.push({ id: track.id, top, bottom: top + getMultiTrackTrackHeight(track.type, taskOverview) })
return bounds
}, [])
useEffect(() => {
return () => {
suppressGlobalClickCleanupRef.current?.()
}
}, [])
function targetTrackIdFromClientY(clientY: number): string | null {
const rect = trackAreaRef.current?.getBoundingClientRect()
if (!rect) return null
const y = (clientY - rect.top) / Math.max(canvasScale, 0.01)
return trackBounds.find((track) => y >= track.top && y < track.bottom)?.id ?? null
}
function localPoint(clientX: number, clientY: number): { x: number, y: number } | null {
const rect = trackAreaRef.current?.getBoundingClientRect()
if (!rect) return null
const scale = Math.max(canvasScale, 0.01)
return {
x: (clientX - rect.left) / scale,
y: (clientY - rect.top) / scale,
}
}
function clampedLocalPoint(clientX: number, clientY: number): { x: number, y: number } | null {
const point = localPoint(clientX, clientY)
if (!point) return null
return {
x: Math.max(0, Math.min(width, point.x)),
y: Math.max(0, Math.min(trackAreaHeight, point.y)),
}
}
function normalizedRect(start: { x: number, y: number }, end: { x: number, y: number }) {
return {
left: Math.min(start.x, end.x),
top: Math.min(start.y, end.y),
width: Math.abs(end.x - start.x),
height: Math.abs(end.y - start.y),
}
}
function segmentIntersectsRect(trackId: string, segment: MultiTrackSegment, rect: { left: number, top: number, width: number, height: number }): boolean {
const bounds = trackBounds.find((track) => track.id === trackId)
if (!bounds) return false
const left = MULTITRACK_LEFT_GUTTER + (segment.start_frame / safeLength) * playableWidth
const right = MULTITRACK_LEFT_GUTTER + (segment.end_frame / safeLength) * playableWidth
const top = bounds.top + 4
const bottom = bounds.bottom - 4
const rectRight = rect.left + rect.width
const rectBottom = rect.top + rect.height
return left < rectRight && right > rect.left && top < rectBottom && bottom > rect.top
}
function selectedIdsForRect(rect: { left: number, top: number, width: number, height: number }): string[] {
return data.tracks.flatMap((track) => (
track.segments
.filter((segment) => segmentIntersectsRect(track.id, segment, rect))
.map((segment) => segment.id)
))
}
function canStartMarquee(event: React.MouseEvent<HTMLDivElement>): boolean {
if (event.button !== 0 || cutMode) return false
const target = event.target as Element
return !target.closest('[data-multitrack-segment]') &&
!target.closest('button') &&
!target.closest('[role="button"]') &&
!target.closest('[data-radix-popper-content-wrapper]')
}
function suppressNextGlobalClick() {
suppressGlobalClickCleanupRef.current?.()
let timeoutId: ReturnType<typeof globalThis.setTimeout> | null = null
const handleClick = (event: MouseEvent) => {
event.preventDefault()
event.stopPropagation()
event.stopImmediatePropagation()
cleanup()
}
function cleanup() {
globalThis.removeEventListener('click', handleClick, true)
if (timeoutId !== null) globalThis.clearTimeout(timeoutId)
if (suppressGlobalClickCleanupRef.current === cleanup) suppressGlobalClickCleanupRef.current = null
}
suppressGlobalClickCleanupRef.current = cleanup
globalThis.addEventListener('click', handleClick, true)
timeoutId = globalThis.setTimeout(cleanup, 0)
}
function handleMarqueeMouseDown(event: React.MouseEvent<HTMLDivElement>) {
if (!canStartMarquee(event)) return
const point = localPoint(event.clientX, event.clientY)
if (!point || point.y > trackAreaHeight) return
event.preventDefault()
event.stopPropagation()
marqueeStartRef.current = point
marqueeMovedRef.current = false
function handleMove(moveEvent: MouseEvent) {
const start = marqueeStartRef.current
const current = clampedLocalPoint(moveEvent.clientX, moveEvent.clientY)
if (!start || !current) return
const rect = normalizedRect(start, current)
if (rect.width > 3 || rect.height > 3) marqueeMovedRef.current = true
setMarqueeRect(rect)
}
function handleUp(upEvent: MouseEvent) {
const start = marqueeStartRef.current
const current = clampedLocalPoint(upEvent.clientX, upEvent.clientY)
marqueeStartRef.current = null
setMarqueeRect(null)
globalThis.removeEventListener('mousemove', handleMove)
globalThis.removeEventListener('mouseup', handleUp)
if (!start || !current) return
if (!marqueeMovedRef.current) {
onClearSelection()
return
}
suppressNextClickRef.current = true
suppressNextGlobalClick()
const ids = selectedIdsForRect(normalizedRect(start, current))
onSelectSegments(ids)
}
globalThis.addEventListener('mousemove', handleMove)
globalThis.addEventListener('mouseup', handleUp)
}
function externalDropTarget(
clientX: number,
clientY: number,
mediaType: ExternalMediaType | null,
): ExternalDropSlot | null {
const rect = trackAreaRef.current?.getBoundingClientRect()
const trackId = targetTrackIdFromClientY(clientY)
const track = data.tracks.find((item) => item.id === trackId)
const acceptsMedia = mediaType === 'image' ? track?.type === 'task' : mediaType === track?.type
if (!rect || !track || !acceptsMedia) return null
const x = (clientX - rect.left) / Math.max(canvasScale, 0.01) - MULTITRACK_LEFT_GUTTER
const requestedFrame = Math.round((Math.max(0, Math.min(playableWidth, x)) / playableWidth) * safeLength)
const sortedSegments = [...track.segments].sort((left, right) => left.start_frame - right.start_frame)
const insertIndex = sortedSegments.filter((segment) => (
segment.start_frame + (segment.end_frame - segment.start_frame) / 2 < requestedFrame
)).length
const previousEnd = sortedSegments[insertIndex - 1]?.end_frame ?? 0
return {
trackId: track.id,
frame: mediaType === 'subtitle' ? requestedFrame : Math.max(requestedFrame, previousEnd),
}
}
function handleExternalDragOver(event: React.DragEvent<HTMLDivElement>) {
if (!hasExternalFiles(event.dataTransfer)) return
event.preventDefault()
event.stopPropagation()
event.dataTransfer.dropEffect = 'copy'
const target = externalDropTarget(event.clientX, event.clientY, draggedMediaType(event.dataTransfer))
setExternalDropSlot(target)
}
function trackFromDragEventTarget(target: EventTarget | null): MultiTrack | undefined {
if (!(target instanceof Element)) return undefined
const row = target.closest<HTMLElement>('[data-multitrack-track-id]')
return data.tracks.find((track) => track.id === row?.dataset.multitrackTrackId)
}
function handleTrackDragStart(event: React.DragEvent<HTMLDivElement>) {
if (!(event.target instanceof Element)) return
const handle = event.target.closest<HTMLElement>('[data-multitrack-track-drag-handle]')
const source = data.tracks.find((track) => track.id === handle?.dataset.multitrackTrackDragHandle)
if (!source || source.type === 'task') return
trackDragSourceRef.current = source.id
event.dataTransfer.effectAllowed = 'move'
event.dataTransfer.setData('application/x-easy-media-track', source.id)
}
function handleTrackDragOver(event: React.DragEvent<HTMLDivElement>) {
const sourceTrackId = trackDragSourceRef.current
const target = trackFromDragEventTarget(event.target)
if (!sourceTrackId || !target || target.type === 'task' || target.id === sourceTrackId) return
event.preventDefault()
event.stopPropagation()
event.dataTransfer.dropEffect = 'move'
}
function handleTrackDrop(event: React.DragEvent<HTMLDivElement>) {
const sourceTrackId = trackDragSourceRef.current
const target = trackFromDragEventTarget(event.target)
trackDragSourceRef.current = null
if (!sourceTrackId || !target || target.type === 'task' || target.id === sourceTrackId) return
event.preventDefault()
event.stopPropagation()
onReorderTrack(sourceTrackId, target.id)
}
async function handleExternalDrop(event: React.DragEvent<HTMLDivElement>) {
if (!hasExternalFiles(event.dataTransfer)) return
event.preventDefault()
event.stopPropagation()
const file = firstDraggedFile(event.dataTransfer)
const mediaType = file ? externalMediaType(file) : null
const target = externalDropTarget(event.clientX, event.clientY, mediaType)
setExternalDropSlot(null)
if (!file || !target) return
setExternalUpload({ ...target, fileName: file.name })
try {
if (mediaType === 'subtitle') {
onImportSubtitles(target.trackId, await file.text(), target.frame)
return
}
if (mediaType === 'image') {
const image = await uploadTaskImageFile(file)
invalidateMediaListCache('inputs')
onAddTaskSegment(target.trackId, target.frame, undefined, [image])
return
}
const filePath = await uploadInputMediaFile(file)
invalidateMediaListCache('inputs')
if (mediaType === 'video') {
onAddVideo(target.trackId, filePath, 'input', target.frame)
} else {
onAddAudio(target.trackId, filePath, 'input', undefined, target.frame)
}
} catch (error) {
console.error('[TrackArea] failed to process dropped media:', error)
} finally {
setExternalUpload(null)
}
}
function placeholderRect(placeholder: SegmentDragPlaceholder) {
const bounds = trackBounds.find((track) => track.id === placeholder.targetTrackId)
if (!bounds) return null
const left = MULTITRACK_LEFT_GUTTER + (placeholder.start_frame / safeLength) * playableWidth
const right = MULTITRACK_LEFT_GUTTER + (placeholder.end_frame / safeLength) * playableWidth
return {
left,
top: bounds.top + 4,
width: Math.max(2, right - left),
height: Math.max(2, bounds.bottom - bounds.top - 8),
}
}
function dragSnapBrakeDistanceFrames(): number {
return Math.max(1, Math.round((8 / playableWidth) * safeLength))
}
function snappedMoveStartTime(segmentId: string, nextStartTime: number): number {
return snapEnabled
? snapMultiTrackMoveStartTime(data, segmentId, nextStartTime, dragSnapBrakeDistanceFrames(), currentTime)
: snapTimeToFrame(nextStartTime, data.frame_rate)
}
function updateDragPlaceholder(segmentId: string, nextStartTime: number, clientY: number) {
const targetTrackId = targetTrackIdFromClientY(clientY)
if (!targetTrackId) {
setDragPlaceholder((current) => samePlaceholder(current, null) ? current : null)
return
}
const nextPlaceholder = getSegmentDragPlaceholder(
data.tracks,
segmentId,
targetTrackId,
snappedMoveStartTime(segmentId, nextStartTime),
data.frame_rate,
)
setDragPlaceholder((current) => samePlaceholder(current, nextPlaceholder) ? current : nextPlaceholder)
}
function handleMoveSegment(segmentId: string, fallbackTrackId: string, nextStartTime: number, clientY: number) {
const targetTrackId = targetTrackIdFromClientY(clientY)
setDragPlaceholder(null)
if (!targetTrackId) return
onMoveSegment(segmentId, targetTrackId ?? fallbackTrackId, snappedMoveStartTime(segmentId, nextStartTime))
}
const dragPlaceholderRect = dragPlaceholder ? placeholderRect(dragPlaceholder) : null
const dragPreviewSegments = dragPlaceholder
? getSegmentDragPreviewSegments(data.tracks, dragPlaceholder, data.frame_rate)
: null
function previewSegment(segment: MultiTrackSegment): MultiTrackSegment {
if (!dragPlaceholder || segment.id === dragPlaceholder.segmentId) {
return segment
}
return dragPreviewSegments?.find((item) => item.id === segment.id) ?? segment
}
return (
<div
ref={trackAreaRef}
className="relative shrink-0"
style={{ width, height: trackAreaHeight }}
data-multitrack-track-area
onDragOverCapture={handleExternalDragOver}
onDragLeave={(event) => {
const nextTarget = event.relatedTarget
if (!(nextTarget instanceof Node) || !event.currentTarget.contains(nextTarget)) setExternalDropSlot(null)
}}
onDropCapture={handleExternalDrop}
onDragStart={handleTrackDragStart}
onDragOver={handleTrackDragOver}
onDrop={handleTrackDrop}
onDragEnd={() => {
trackDragSourceRef.current = null
}}
onMouseDown={handleMarqueeMouseDown}
onClick={(event) => {
event.stopPropagation()
if (suppressNextClickRef.current) {
suppressNextClickRef.current = false
return
}
const target = event.target as Element
if (!target.closest('[data-multitrack-segment]') && !target.closest('button') && !target.closest('[role="button"]')) {
onClearSelection()
}
}}
>
<div
className="pointer-events-none absolute top-0 z-10 bg-black/30"
style={{ left: reserveLeft, width: MULTITRACK_RIGHT_RESERVE, height: tracksHeight }}
/>
<div className="absolute top-0 z-20 w-px bg-destructive" style={{ left: playheadLeft, height: tracksHeight }} />
{data.tracks.map((track) => {
if (track.type === 'video') {
return (
<VideoTrack
key={track.id}
track={{
...track,
segments: track.segments.map((segment) => previewSegment(segment)),
}}
totalLength={data.total_length}
frameRate={data.frame_rate}
width={playableWidth}
canvasScale={canvasScale}
selectedSegmentIds={selectedSegmentIds}
node={node}
app={app}
onAddVideo={onAddVideo}
onReplaceVideo={onReplaceVideo}
onSelectSegment={onSelectSegment}
onDeleteSegment={onDeleteSegment}
onCloneSegment={(segmentId) => onCloneTaskSegment(track.id, segmentId)}
onSmartSplit={onSmartSplit}
onSmartSplitTasks={onSmartSplitTasks}
onRecognizeSubtitles={onRecognizeSubtitles}
cutMode={cutMode}
onCutSegment={onCutSegment}
canDeleteTrack={track.id !== firstVideoTrackId}
onDeleteTrack={onDeleteTrack}
onTrackAudioSettingsChange={onTrackAudioSettingsChange}
onSharedReferenceChange={onSharedReferenceChange}
onResizeSegment={onResizeSegment}
onResizeSegmentPreview={onResizeSegmentPreview}
onMoveSegment={(segmentId, nextStartTime, clientY) => {
handleMoveSegment(segmentId, track.id, nextStartTime, clientY)
}}
onDragPreviewChange={updateDragPlaceholder}
getDragPreviewStart={snappedMoveStartTime}
onDragPreviewEnd={() => setDragPlaceholder(null)}
audioLockEnabled={format === 'MiniMax'}
/>
)
}
if (track.type === 'audio') {
return (
<AudioTrack
key={track.id}
track={{ ...track, segments: track.segments.map((segment) => previewSegment(segment)) }}
totalLength={data.total_length}
frameRate={data.frame_rate}
width={playableWidth}
canvasScale={canvasScale}
selectedSegmentIds={selectedSegmentIds}
node={node}
app={app}
onAddAudio={onAddAudio}
onReplaceAudio={onReplaceAudio}
onSelectSegment={onSelectSegment}
onDeleteSegment={onDeleteSegment}
onCloneSegment={(segmentId) => onCloneTaskSegment(track.id, segmentId)}
onDeleteTrack={onDeleteTrack}
onTrackAudioSettingsChange={onTrackAudioSettingsChange}
onSharedReferenceChange={onSharedReferenceChange}
onResizeSegment={onResizeSegment}
onResizeSegmentPreview={onResizeSegmentPreview}
onMoveSegment={(segmentId, nextStartTime, clientY) => handleMoveSegment(segmentId, track.id, nextStartTime, clientY)}
onDragPreviewChange={updateDragPlaceholder}
getDragPreviewStart={snappedMoveStartTime}
onDragPreviewEnd={() => setDragPlaceholder(null)}
onRecognizeSubtitles={onRecognizeSubtitles}
cutMode={cutMode}
onCutSegment={onCutSegment}
audioLockEnabled={format === 'MiniMax'}
/>
)
}
if (track.type === 'subtitle') {
return (
<SubtitleTrack
key={track.id}
track={{ ...track, segments: track.segments.map((segment) => previewSegment(segment)) }}
totalLength={data.total_length}
frameRate={data.frame_rate}
width={playableWidth}
canvasScale={canvasScale}
selectedSegmentIds={selectedSegmentIds}
onSelectSegment={onSelectSegment}
onAddSubtitleSegment={onAddSubtitleSegment}
onDeleteSegment={onDeleteSegment}
onCloneSegment={(segmentId) => onCloneTaskSegment(track.id, segmentId)}
onDeleteTrack={onDeleteTrack}
onTrackVisibilityChange={onTrackVisibilityChange}
onEditSubtitleSegment={onEditSubtitleSegment}
onResizeSegment={onResizeSegment}
onResizeSegmentPreview={onResizeSegmentPreview}
onMoveSegment={(segmentId, nextStartTime, clientY) => handleMoveSegment(segmentId, track.id, nextStartTime, clientY)}
onDragPreviewChange={updateDragPlaceholder}
getDragPreviewStart={snappedMoveStartTime}
onDragPreviewEnd={() => setDragPlaceholder(null)}
/>
)
}
return (
<div
key={track.id}
data-testid={`track-row-${track.id}`}
data-multitrack-track-id={track.id}
className="relative flex border-b border-border"
style={{ height: getMultiTrackTrackHeight(track.type, taskOverview) }}
>
<div
className="flex shrink-0 items-center justify-center border-r border-border"
style={{ width: MULTITRACK_LEFT_GUTTER }}
>
<TrackTypeIcon type={track.type} />
</div>
<div className="relative min-w-0 flex-1">
{track.segments.map((segment, index) => (
<MultiTrackSegmentBlock
key={segment.id}
trackType={track.type}
segmentIndex={index}
segment={previewSegment(segment)}
totalLength={data.total_length}
frameRate={data.frame_rate}
areaWidth={playableWidth}
canvasScale={canvasScale}
selected={selectedSegmentIds.has(segment.id)}
showTaskIndex={(data.task_markers ?? []).length === 0}
taskOverview={track.type === 'task' && taskOverview}
onSelect={onSelectSegment}
onDelete={onDeleteSegment}
onDistribute={track.type === 'task' ? () => onDistributeTaskSegments(track.id) : undefined}
onClone={track.type === 'task' ? (segmentId) => onCloneTaskSegment(track.id, segmentId) : undefined}
onMerge={track.type === 'task' && selectedSegmentIds.has(segment.id) && canMergeSelectedTaskSegments
? onMergeSelectedTaskSegments
: undefined}
onSplitTask={track.type === 'task' ? onSplitTaskSegment : undefined}
cutMode={cutMode}
onCut={onCutSegment}
onResize={onResizeSegment}
onResizePreview={onResizeSegmentPreview}
onMove={(segmentId, nextStartTime, clientY) => {
handleMoveSegment(segmentId, track.id, nextStartTime, clientY)
}}
onDragPreviewChange={updateDragPlaceholder}
getDragPreviewStart={snappedMoveStartTime}
onDragPreviewEnd={() => setDragPlaceholder(null)}
/>
))}
{track.type === 'task' ? (
<>
{getTrackSegmentGaps(track.segments).map((gap) => (
<TrackGapAddButton
key={`${gap.startFrame}-${gap.endFrame}`}
gap={gap}
totalLength={data.total_length}
width={playableWidth}
ariaLabel={t('multitrack.addTaskSegment')}
onClick={() => onAddTaskSegment(track.id, gap.startFrame, gap.endFrame)}
/>
))}
<Button
type="button"
variant="secondary"
size="icon"
className="absolute top-1/2 h-5 w-5 cursor-pointer"
style={{
left: track.segments.length === 0
? 6
: (track.segments.reduce((max, segment) => Math.max(max, segment.end_frame), 0) / safeLength) * playableWidth + 6,
transform: 'translateY(-50%)',
}}
aria-label={t('multitrack.addTaskSegment')}
onClick={(event) => {
event.stopPropagation()
onAddTaskSegment(track.id)
}}
>
<Plus className="h-2.5 w-2.5" />
</Button>
</>
) : (
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon"
className="absolute top-1/2 h-5 w-5 -translate-y-1/2 cursor-pointer text-destructive"
style={{
left: track.segments.length === 0
? 6
: (track.segments.reduce((max, segment) => Math.max(max, segment.end_frame), 0) / safeLength) * playableWidth + 6,
}}
aria-label={t('multitrack.deleteTrack', { name: track.name })}
onClick={() => onDeleteTrack(track.id)}
>
<Trash2 className="h-2.5 w-2.5" />
</Button>
</TooltipTrigger>
<TooltipContent>{t('multitrack.deleteTrack', { name: track.name })}</TooltipContent>
</Tooltip>
)}
</div>
</div>
)
})}
<div
className="flex items-center justify-center gap-1 border-b border-border text-[10px] text-muted-foreground"
style={{ height: addTrackHeight }}
>
<span>{t('multitrack.addTrack')}</span>
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon"
className="h-6 w-6 cursor-pointer disabled:cursor-not-allowed"
disabled={videoTrackLimitReached}
aria-label={t('multitrack.addVideoTrack')}
onClick={() => onAddTrack('video')}
>
<Film className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent>{t('multitrack.addVideoTrack')}</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon"
className="h-6 w-6 cursor-pointer disabled:cursor-not-allowed"
disabled={audioTrackLimitReached}
aria-label={t('multitrack.addAudioTrack')}
onClick={() => onAddTrack('audio')}
>
<Music2 className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent>{t('multitrack.addAudioTrack')}</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
type="button"
variant="ghost"
size="icon"
className="h-6 w-6 cursor-pointer disabled:cursor-not-allowed"
disabled={subtitleTrackLimitReached}
aria-label={t('multitrack.addSubtitleTrack')}
onClick={() => onAddTrack('subtitle')}
>
<Captions className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent>{t('multitrack.addSubtitleTrack')}</TooltipContent>
</Tooltip>
</div>
{dragPlaceholderRect ? (
<div
className="pointer-events-none absolute z-10 rounded border border-border bg-muted/60"
style={dragPlaceholderRect}
/>
) : null}
{marqueeRect ? (
<div
className="pointer-events-none absolute z-40 rounded border border-primary bg-primary/10"
style={marqueeRect}
/>
) : null}
{externalDropSlot ? (() => {
const bounds = trackBounds.find((track) => track.id === externalDropSlot.trackId)
if (!bounds) return null
return (
<div
data-testid="external-media-drop-slot"
className="pointer-events-none absolute z-30 w-1 rounded bg-primary"
style={{
left: MULTITRACK_LEFT_GUTTER + (externalDropSlot.frame / safeLength) * playableWidth,
top: bounds.top + 4,
height: bounds.bottom - bounds.top - 8,
}}
/>
)
})() : null}
{externalUpload ? (() => {
const bounds = trackBounds.find((track) => track.id === externalUpload.trackId)
if (!bounds) return null
return (
<div
role="status"
aria-live="polite"
className="pointer-events-none absolute z-40 flex max-w-48 items-center gap-1.5 rounded border border-border bg-background/95 px-2 py-1 text-[10px] text-foreground shadow-sm"
style={{
left: MULTITRACK_LEFT_GUTTER + (externalUpload.frame / safeLength) * playableWidth,
top: bounds.top + (bounds.bottom - bounds.top) / 2,
transform: 'translate(-50%, -50%)',
}}
>
<Loader2 className="h-3.5 w-3.5 shrink-0 animate-spin" />
<span className="truncate">{t('multitrack.externalMediaUploading', { name: externalUpload.fileName })}</span>
</div>
)
})() : null}
</div>
)
}