- 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
1330 lines
56 KiB
TypeScript
1330 lines
56 KiB
TypeScript
import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
|
||
import { CloudUpload, Eye, Pencil, Plus, RotateCcw, Share2, Trash2 } from 'lucide-react'
|
||
import { Button } from '@/components/ui/button'
|
||
import {
|
||
Dialog,
|
||
DialogContent,
|
||
DialogDescription,
|
||
DialogFooter,
|
||
DialogHeader,
|
||
DialogTitle,
|
||
} from '@/components/ui/dialog'
|
||
import { Input } from '@/components/ui/input'
|
||
import { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
|
||
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
|
||
import {
|
||
ResizableHandle,
|
||
ResizablePanel,
|
||
ResizablePanelGroup,
|
||
type ResizablePanelGroupHandle,
|
||
} from '@/components/ui/resizable'
|
||
import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
|
||
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
|
||
import { MediaSelector } from '@/components/widgets/mediaSelector/MediaSelector'
|
||
import type { MediaTab } from '@/components/widgets/mediaSelector/MediaSelector'
|
||
import { useT } from '@/lib/i18n'
|
||
import { mediaContentToViewUrl } from '@/lib/media-url'
|
||
import { getSegmentTrackPresentation } from '@/lib/multitrack-segment-style'
|
||
import { computeSlotItems } from '@/lib/timeline-utils'
|
||
import {
|
||
applyCombinedTaskTexts,
|
||
formatMultiTrackDurationTimecode,
|
||
frameToSeconds,
|
||
getSelectedTaskUserPrompt,
|
||
getSelectedTaskUserPromptPatch,
|
||
getMultiTrackTaskType,
|
||
MULTITRACK_CONTINUITY_MODES,
|
||
MULTITRACK_DEFAULT_CONTINUITY_MODE,
|
||
MULTITRACK_DEFAULT_FRAME_RATE,
|
||
MULTITRACK_DEFAULT_REF_IMAGE_SIZE,
|
||
MULTITRACK_REF_IMAGE_SIZES,
|
||
MULTITRACK_TASK_MODES,
|
||
parseMultiTrackDurationTimecode,
|
||
segmentDuration,
|
||
} from '@/lib/multitrack-utils'
|
||
import { cn } from '@/lib/utils'
|
||
import {
|
||
createTaskImage,
|
||
activeTaskImages,
|
||
canEnableSharedTaskImage,
|
||
MAX_TASK_IMAGES,
|
||
sharedTaskImageUpdates,
|
||
splitSelectedTaskMedia,
|
||
taskImageIdentity,
|
||
taskImageReferenceIndex,
|
||
taskImageSlotNumber,
|
||
taskImagesFromContent,
|
||
uploadTaskImageFile,
|
||
} from '@/lib/task-image-utils'
|
||
import { invalidateMediaListCache } from '@/stores/media-list-store'
|
||
import type {
|
||
MultiTrack,
|
||
MultiTrackContinuityMode,
|
||
MultiTrackRefImageSize,
|
||
MultiTrackSegment,
|
||
MultiTrackSegmentContent,
|
||
MultiTrackSourceType,
|
||
MultiTrackTaskImage,
|
||
MultiTrackTaskMode,
|
||
MultiTrackUserPromptVariant,
|
||
} from '@/types/multitrack'
|
||
import { PanoramaImagePreview } from '@/components/widgets/panorama/PanoramaImagePreview'
|
||
import { PromptContentEditor, type PromptReferenceResource } from './PromptContentEditor'
|
||
|
||
type PromptTab = 'user' | 'system'
|
||
type EditMode = 'individual' | 'combined'
|
||
|
||
const TASK_IMAGE_PANEL_MIN_SIZE = 180
|
||
const TASK_IMAGE_PANEL_MAX_SIZE = '55%'
|
||
const TASK_PROMPT_PANEL_MIN_SIZE = 280
|
||
const TASK_EDITOR_PANEL_GAP = 16
|
||
const TASK_IMAGES_PANEL_ID = 'task-images-resizable-panel'
|
||
const TASK_PROMPT_PANEL_ID = 'task-prompt-resizable-panel'
|
||
|
||
interface TaskEditorPanelDrag {
|
||
pointerId: number
|
||
startClientX: number
|
||
startImageSize: number
|
||
groupWidth: number
|
||
}
|
||
|
||
interface TrackSegmentContentUpdate {
|
||
segmentId: string
|
||
patch: Partial<MultiTrackSegmentContent>
|
||
}
|
||
|
||
interface TaskSegmentEditorProps {
|
||
segment: MultiTrackSegment
|
||
node?: unknown
|
||
app?: unknown
|
||
trackSegments?: MultiTrackSegment[]
|
||
selectedSegments?: MultiTrackSegment[]
|
||
videoSegments?: MultiTrackSegment[]
|
||
mediaTracks?: MultiTrack[]
|
||
frameRate?: number
|
||
totalFrames?: number
|
||
imageIndexOffset?: number
|
||
format?: string
|
||
onContentChange: (patch: Partial<MultiTrackSegmentContent>) => void
|
||
onTrackSegmentsContentChange?: (updates: TrackSegmentContentUpdate[]) => void
|
||
onTrackSegmentsChange?: (segments: MultiTrackSegment[]) => void
|
||
onDurationChange?: (duration: number) => void
|
||
onOpenImagePreview?: (imageId: string) => void
|
||
}
|
||
|
||
interface SystemPromptResponse {
|
||
items?: SystemPromptOption[]
|
||
}
|
||
|
||
interface SystemPromptOption {
|
||
task_type?: string
|
||
system_prompt?: string
|
||
format?: string
|
||
modes?: MultiTrackTaskMode[]
|
||
}
|
||
|
||
let cachedSystemPromptOptions: SystemPromptOption[] | undefined
|
||
let systemPromptOptionsRequest: Promise<SystemPromptOption[]> | null = null
|
||
|
||
function taskImages(segment: MultiTrackSegment): MultiTrackTaskImage[] {
|
||
return taskImagesFromContent(segment.content.images)
|
||
}
|
||
|
||
function moveImage(images: MultiTrackTaskImage[], sourceId: string, targetId: string): MultiTrackTaskImage[] {
|
||
const sourceIndex = images.findIndex((item) => item.id === sourceId)
|
||
const targetIndex = images.findIndex((item) => item.id === targetId)
|
||
if (sourceIndex < 0 || targetIndex < 0 || sourceIndex === targetIndex) return images
|
||
|
||
const nextImages = [...images]
|
||
const [moved] = nextImages.splice(sourceIndex, 1)
|
||
nextImages.splice(targetIndex, 0, moved)
|
||
return nextImages
|
||
}
|
||
|
||
function imageDisplayName(image: MultiTrackTaskImage): string {
|
||
return image.file_name ?? image.file_path ?? image.local_path ?? image.url ?? image.slot_name ?? image.id
|
||
}
|
||
|
||
function imageSelectorValue(image: MultiTrackTaskImage | undefined): string {
|
||
if (!image) return ''
|
||
if (image.slot_name) return `__slot__:${image.slot_name}`
|
||
return image.file_path ?? image.local_path ?? image.url ?? ''
|
||
}
|
||
|
||
function imageSelectorTab(image: MultiTrackTaskImage | undefined): MediaTab {
|
||
if (image?.source_type === 'output') return 'outputs'
|
||
if (image?.source_type === 'local') return 'local'
|
||
if (image?.source_type === 'url') return 'url'
|
||
if (image?.source_type === 'slot') return 'slot'
|
||
return 'inputs'
|
||
}
|
||
|
||
function selectedImageSource(
|
||
filePath: string,
|
||
source?: 'input' | 'output' | 'local',
|
||
): MultiTrackSourceType {
|
||
if (source) return source
|
||
if (filePath.startsWith('__slot__:')) return 'slot'
|
||
if (filePath.startsWith('http://') || filePath.startsWith('https://')) return 'url'
|
||
return 'input'
|
||
}
|
||
|
||
function hasVideoInRange(segment: MultiTrackSegment, videoSegments: MultiTrackSegment[]): boolean {
|
||
return videoSegments.some((videoSegment) => (
|
||
videoSegment.content.media_type === 'video' &&
|
||
videoSegment.start_frame < segment.end_frame &&
|
||
videoSegment.end_frame > segment.start_frame
|
||
))
|
||
}
|
||
|
||
function getDefaultSystemPromptForSegment(
|
||
segment: MultiTrackSegment,
|
||
options: SystemPromptOption[],
|
||
videoSegments: MultiTrackSegment[],
|
||
format?: string,
|
||
): string {
|
||
const images = activeTaskImages(segment.content.images)
|
||
const taskType = getMultiTrackTaskType(
|
||
segment.content.task_mode ?? 'default',
|
||
images.length,
|
||
hasVideoInRange(segment, videoSegments),
|
||
)
|
||
const mode = segment.content.task_mode ?? 'default'
|
||
const promptTaskType = taskType === 'fl2v' || taskType === 'fmlf2v' ? 'i2v' : taskType
|
||
const formatMatch = options.find((option) => (
|
||
option.format === format
|
||
&& (option.modes?.includes(mode) || option.task_type === taskType)
|
||
))
|
||
return formatMatch?.system_prompt
|
||
?? options.find((option) => option.task_type === promptTaskType && option.format === undefined)?.system_prompt
|
||
?? ''
|
||
}
|
||
|
||
async function loadSystemPromptOptions(): Promise<SystemPromptOption[]> {
|
||
if (cachedSystemPromptOptions) return cachedSystemPromptOptions
|
||
if (!systemPromptOptionsRequest) {
|
||
systemPromptOptionsRequest = (async () => {
|
||
const response = await fetch('/easy-media/prompt/system-prompts')
|
||
if (!response.ok) {
|
||
throw new Error(`Failed to load system prompt options: ${response.status}`)
|
||
}
|
||
const result = await response.json() as SystemPromptResponse
|
||
const options = Array.isArray(result.items) ? result.items : []
|
||
cachedSystemPromptOptions = options
|
||
return options
|
||
})().catch((error: unknown) => {
|
||
systemPromptOptionsRequest = null
|
||
throw error
|
||
})
|
||
}
|
||
return systemPromptOptionsRequest
|
||
}
|
||
|
||
export function TaskSegmentEditor({
|
||
segment,
|
||
node,
|
||
app,
|
||
trackSegments,
|
||
selectedSegments,
|
||
videoSegments = [],
|
||
mediaTracks = [],
|
||
frameRate = MULTITRACK_DEFAULT_FRAME_RATE,
|
||
totalFrames,
|
||
imageIndexOffset = 0,
|
||
format,
|
||
onContentChange,
|
||
onTrackSegmentsContentChange,
|
||
onTrackSegmentsChange,
|
||
onDurationChange,
|
||
onOpenImagePreview,
|
||
}: Readonly<TaskSegmentEditorProps>) {
|
||
const t = useT()
|
||
const draggedImageIdRef = useRef<string | null>(null)
|
||
const [promptTab, setPromptTab] = useState<PromptTab>('user')
|
||
const [editMode, setEditMode] = useState<EditMode>('individual')
|
||
const [mediaSelectorOpen, setMediaSelectorOpen] = useState(false)
|
||
const [reselectImageId, setReselectImageId] = useState<string | null>(null)
|
||
const [isImageDragOver, setIsImageDragOver] = useState(false)
|
||
const [applyPromptToAllOpen, setApplyPromptToAllOpen] = useState(false)
|
||
const [systemPromptOptions, setSystemPromptOptions] = useState<SystemPromptOption[] | null>(cachedSystemPromptOptions ?? null)
|
||
const [systemPromptLoading, setSystemPromptLoading] = useState(false)
|
||
const [isDurationEditing, setIsDurationEditing] = useState(false)
|
||
const duration = frameToSeconds(segmentDuration(segment), frameRate)
|
||
const formattedDuration = formatMultiTrackDurationTimecode(duration, frameRate)
|
||
const [durationInput, setDurationInput] = useState(formattedDuration)
|
||
const images = taskImages(segment)
|
||
const slotItems = useMemo(
|
||
() => computeSlotItems(node, app, 'image'),
|
||
[node, app, mediaSelectorOpen],
|
||
)
|
||
const reselectImage = images.find((image) => image.id === reselectImageId)
|
||
const mode = segment.content.task_mode ?? 'default'
|
||
const continuityMode = segment.content.continuity_mode ?? MULTITRACK_DEFAULT_CONTINUITY_MODE
|
||
const refImageSize = segment.content.ref_image_size ?? MULTITRACK_DEFAULT_REF_IMAGE_SIZE
|
||
const editableSegments = useMemo(() => (
|
||
trackSegments && trackSegments.length > 0 ? trackSegments : [segment]
|
||
), [segment, trackSegments])
|
||
const combinedPromptValue = editableSegments.map((item) => (
|
||
getSelectedTaskUserPrompt(item.content)
|
||
)).join('|')
|
||
const [combinedPromptInput, setCombinedPromptInput] = useState(combinedPromptValue)
|
||
const taskIndex = Math.max(0, editableSegments.findIndex((item) => item.id === segment.id))
|
||
const firstTaskSegmentId = editableSegments.reduce((first, item) => (
|
||
item.start_frame < first.start_frame ? item : first
|
||
)).id
|
||
const hasSelectedContinuityTargets = selectedSegments?.some((item) => item.id !== firstTaskSegmentId) === true
|
||
const promptVariant: MultiTrackUserPromptVariant = segment.content.user_prompt_variant === 'b' ? 'b' : 'a'
|
||
const promptValue = editMode === 'combined'
|
||
? combinedPromptInput
|
||
: getSelectedTaskUserPrompt(segment.content)
|
||
const usesMiniMaxPromptPlaceholder = format === 'MiniMax'
|
||
const promptPlaceholder = usesMiniMaxPromptPlaceholder
|
||
? t('multitrack.minimaxPromptPlaceholder')
|
||
: t('multitrack.promptPlaceholder')
|
||
const segmentHasVideoInRange = hasVideoInRange(segment, videoSegments)
|
||
const systemPromptDefault = getDefaultSystemPromptForSegment(segment, systemPromptOptions ?? [], videoSegments, format)
|
||
const systemPromptValue = editMode === 'combined'
|
||
? editableSegments.map((item) => (
|
||
item.content.system_prompt ?? getDefaultSystemPromptForSegment(item, systemPromptOptions ?? [], videoSegments, format)
|
||
)).join('|')
|
||
: segment.content.system_prompt || systemPromptDefault
|
||
const promptResources = useMemo<PromptReferenceResource[]>(() => {
|
||
const imageResources = activeTaskImages(images).map((image, index) => ({
|
||
id: `image:${image.id}`,
|
||
type: 'image' as const,
|
||
index: index + 1,
|
||
label: t('multitrack.referencePicture', { n: index + 1 }),
|
||
detail: imageDisplayName(image),
|
||
token: `@${t('multitrack.referencePicture', { n: index + 1 })}`,
|
||
color: getSegmentTrackPresentation('task').backgroundColor,
|
||
thumbnailUrl: mediaContentToViewUrl({
|
||
source_type: image.source_type ?? 'input',
|
||
file_path: image.file_path,
|
||
local_path: image.local_path,
|
||
url: image.url,
|
||
slot_name: image.slot_name,
|
||
}) ?? undefined,
|
||
}))
|
||
const videoTracks = mediaTracks.filter((track) => (
|
||
track.type === 'video'
|
||
&& track.segments.some((item) => item.content.media_type === 'video')
|
||
))
|
||
const audioTracks = mediaTracks.filter((track) => (
|
||
track.type === 'audio'
|
||
&& track.segments.some((item) => item.content.media_type === 'audio')
|
||
))
|
||
const videoAudioResources = videoTracks.map((track, index) => {
|
||
const resourceIndex = index + 1
|
||
const label = t('multitrack.referenceAudioItem', { n: resourceIndex })
|
||
return {
|
||
id: `video-audio:${track.id}`,
|
||
type: 'audio' as const,
|
||
index: resourceIndex,
|
||
label,
|
||
detail: track.name,
|
||
token: `@${label}`,
|
||
color: getSegmentTrackPresentation('video').waveformColor
|
||
?? getSegmentTrackPresentation('video').backgroundColor,
|
||
}
|
||
})
|
||
const audioResources = audioTracks.map((track, index) => {
|
||
const resourceIndex = videoTracks.length + index + 1
|
||
const label = t('multitrack.referenceAudioItem', { n: resourceIndex })
|
||
return {
|
||
id: `audio:${track.id}`,
|
||
type: 'audio' as const,
|
||
index: resourceIndex,
|
||
label,
|
||
detail: track.name,
|
||
token: `@${label}`,
|
||
color: getSegmentTrackPresentation('audio').waveformColor
|
||
?? getSegmentTrackPresentation('audio').backgroundColor,
|
||
}
|
||
})
|
||
const videoResources = videoTracks.map((track, index) => {
|
||
const resourceIndex = index + 1
|
||
const label = t('multitrack.referenceVideoItem', { n: resourceIndex })
|
||
return {
|
||
id: `video:${track.id}`,
|
||
type: 'video' as const,
|
||
index: resourceIndex,
|
||
label,
|
||
detail: track.name,
|
||
token: `@${label}`,
|
||
color: getSegmentTrackPresentation('video').waveformColor
|
||
?? getSegmentTrackPresentation('video').backgroundColor,
|
||
}
|
||
})
|
||
return [...imageResources, ...videoAudioResources, ...audioResources, ...videoResources]
|
||
}, [images, mediaTracks, t])
|
||
|
||
useEffect(() => {
|
||
setDurationInput(formattedDuration)
|
||
}, [formattedDuration])
|
||
|
||
useEffect(() => {
|
||
setIsDurationEditing(false)
|
||
}, [segment.id])
|
||
|
||
useEffect(() => {
|
||
setCombinedPromptInput((current) => current === combinedPromptValue ? current : combinedPromptValue)
|
||
}, [combinedPromptValue])
|
||
|
||
function commitDuration() {
|
||
const nextDuration = parseMultiTrackDurationTimecode(durationInput, frameRate)
|
||
if (nextDuration === null) {
|
||
setDurationInput(formattedDuration)
|
||
setIsDurationEditing(false)
|
||
return
|
||
}
|
||
setDurationInput(formatMultiTrackDurationTimecode(nextDuration, frameRate))
|
||
setIsDurationEditing(false)
|
||
if (nextDuration !== duration) onDurationChange?.(nextDuration)
|
||
}
|
||
|
||
useEffect(() => {
|
||
if (promptTab !== 'system') return
|
||
if (systemPromptOptions !== null) return
|
||
let cancelled = false
|
||
setSystemPromptLoading(true)
|
||
loadSystemPromptOptions()
|
||
.then((options) => {
|
||
if (!cancelled) setSystemPromptOptions(options)
|
||
})
|
||
.catch((error: unknown) => {
|
||
console.error('[TaskSegmentEditor] failed to load system prompt options:', error)
|
||
if (!cancelled) setSystemPromptOptions([])
|
||
})
|
||
.finally(() => {
|
||
if (!cancelled) setSystemPromptLoading(false)
|
||
})
|
||
|
||
return () => {
|
||
cancelled = true
|
||
}
|
||
}, [promptTab, systemPromptOptions])
|
||
|
||
function hasDraggedImageFile(dataTransfer: DataTransfer): boolean {
|
||
const files = Array.from(dataTransfer.files)
|
||
if (files.some((file) => file.type.startsWith('image/'))) return true
|
||
return Array.from(dataTransfer.items ?? []).some((item) => item.kind === 'file' && item.type.startsWith('image/'))
|
||
}
|
||
|
||
function handleImageDragEnter(event: React.DragEvent<HTMLDivElement>) {
|
||
if (!event.dataTransfer || !hasDraggedImageFile(event.dataTransfer)) return
|
||
event.preventDefault()
|
||
setIsImageDragOver(true)
|
||
}
|
||
|
||
function handleImageDragOver(event: React.DragEvent<HTMLDivElement>) {
|
||
if (!event.dataTransfer || !hasDraggedImageFile(event.dataTransfer)) return
|
||
event.preventDefault()
|
||
setIsImageDragOver(true)
|
||
}
|
||
|
||
function handleImageDragLeave(event: React.DragEvent<HTMLDivElement>) {
|
||
const relatedTarget = event.relatedTarget
|
||
if (relatedTarget instanceof Node && event.currentTarget.contains(relatedTarget)) return
|
||
setIsImageDragOver(false)
|
||
}
|
||
|
||
async function handleDrop(event: React.DragEvent<HTMLDivElement | HTMLButtonElement>) {
|
||
event.preventDefault()
|
||
setIsImageDragOver(false)
|
||
if (!event.dataTransfer) return
|
||
const remainingSlots = MAX_TASK_IMAGES - images.length
|
||
if (remainingSlots <= 0) return
|
||
const files = Array.from(event.dataTransfer.files)
|
||
.filter((file) => file.type.startsWith('image/'))
|
||
.slice(0, remainingSlots)
|
||
if (files.length === 0) return
|
||
|
||
const results = await Promise.allSettled(files.map((file) => uploadTaskImageFile(file)))
|
||
const uploaded = results.flatMap((result) => {
|
||
if (result.status === 'fulfilled') return [result.value]
|
||
console.error('[TaskSegmentEditor] failed to upload task image:', result.reason)
|
||
return []
|
||
})
|
||
if (uploaded.length > 0) {
|
||
invalidateMediaListCache('inputs')
|
||
onContentChange({ images: [...images, ...uploaded] })
|
||
}
|
||
}
|
||
|
||
function handleSelectedMedia(filePath: string, source?: 'input' | 'output' | 'local') {
|
||
const remainingSlots = reselectImageId ? 1 : MAX_TASK_IMAGES - images.length
|
||
if (remainingSlots <= 0) return
|
||
const selectedPaths = splitSelectedTaskMedia(filePath).slice(0, remainingSlots)
|
||
const sourceType = selectedImageSource(filePath, source)
|
||
const nextImages = selectedPaths.map((path) => createTaskImage(path, sourceType))
|
||
if (nextImages.length === 0) return
|
||
if (reselectImageId) {
|
||
const replacement = { ...nextImages[0], id: reselectImageId }
|
||
if (reselectImage?.shared_reference === true && onTrackSegmentsContentChange) {
|
||
const oldIdentity = taskImageIdentity(reselectImage)
|
||
const unsharedUpdates = new Map(
|
||
sharedTaskImageUpdates(editableSegments, reselectImage, false)
|
||
.map((update) => [update.segmentId, update.images]),
|
||
)
|
||
const replacementSourceSegments = editableSegments.map((item) => ({
|
||
...item,
|
||
content: {
|
||
...item.content,
|
||
images: item.id === segment.id
|
||
? [replacement, ...(unsharedUpdates.get(item.id) ?? []).filter((image) => (
|
||
taskImageIdentity(image) !== oldIdentity
|
||
))]
|
||
: unsharedUpdates.get(item.id) ?? taskImages(item),
|
||
},
|
||
}))
|
||
onTrackSegmentsContentChange(
|
||
sharedTaskImageUpdates(replacementSourceSegments, replacement, true).map((update) => ({
|
||
segmentId: update.segmentId,
|
||
patch: { images: update.images },
|
||
})),
|
||
)
|
||
setReselectImageId(null)
|
||
setMediaSelectorOpen(false)
|
||
return
|
||
}
|
||
onContentChange({
|
||
images: images.map((image) => image.id === reselectImageId ? replacement : image),
|
||
})
|
||
} else {
|
||
onContentChange({ images: [...images, ...nextImages] })
|
||
}
|
||
setReselectImageId(null)
|
||
setMediaSelectorOpen(false)
|
||
}
|
||
|
||
function commitCombinedPrompt(value: string) {
|
||
const parts = value === '' ? [''] : value.split(/[||]/)
|
||
if (onTrackSegmentsChange) {
|
||
const trackEndFrame = editableSegments.reduce((max, item) => Math.max(max, item.end_frame), 0)
|
||
onTrackSegmentsChange(applyCombinedTaskTexts(
|
||
parts,
|
||
editableSegments,
|
||
totalFrames ?? trackEndFrame,
|
||
segment.color,
|
||
))
|
||
return
|
||
}
|
||
onTrackSegmentsContentChange?.(editableSegments.map((item, index) => ({
|
||
segmentId: item.id,
|
||
patch: getSelectedTaskUserPromptPatch(item.content, parts[index] ?? ''),
|
||
})))
|
||
}
|
||
|
||
function handlePromptChange(value: string) {
|
||
if (editMode === 'combined') {
|
||
setCombinedPromptInput(value)
|
||
commitCombinedPrompt(value)
|
||
return
|
||
}
|
||
onContentChange(getSelectedTaskUserPromptPatch(segment.content, value))
|
||
}
|
||
|
||
function handleSystemPromptChange(value: string) {
|
||
if (editMode === 'combined') {
|
||
const parts = value.split('|')
|
||
onTrackSegmentsContentChange?.(editableSegments.map((item, index) => ({
|
||
segmentId: item.id,
|
||
patch: { system_prompt: parts[index] ?? '' },
|
||
})))
|
||
return
|
||
}
|
||
onContentChange({ system_prompt: value })
|
||
}
|
||
|
||
function handleApplyPromptToAll() {
|
||
const patch = {
|
||
user_prompt: promptValue,
|
||
user_prompt_b: promptValue,
|
||
}
|
||
if (onTrackSegmentsContentChange) {
|
||
onTrackSegmentsContentChange(editableSegments.map((item) => ({
|
||
segmentId: item.id,
|
||
patch,
|
||
})))
|
||
} else {
|
||
onContentChange(patch)
|
||
}
|
||
setApplyPromptToAllOpen(false)
|
||
}
|
||
|
||
function handleDropdownContentChange(patch: Partial<MultiTrackSegmentContent>) {
|
||
if (!selectedSegments || selectedSegments.length <= 1 || !onTrackSegmentsContentChange) {
|
||
onContentChange(patch)
|
||
return
|
||
}
|
||
|
||
onTrackSegmentsContentChange(selectedSegments.map((item) => ({
|
||
segmentId: item.id,
|
||
patch: patch.continuity_mode !== undefined && item.id === firstTaskSegmentId
|
||
? { ...patch, continuity_mode: MULTITRACK_DEFAULT_CONTINUITY_MODE }
|
||
: patch,
|
||
})))
|
||
}
|
||
|
||
function handleDeleteImage(imageId: string) {
|
||
const image = images.find((item) => item.id === imageId)
|
||
if (image?.shared_reference === true && onTrackSegmentsContentChange) {
|
||
const identity = taskImageIdentity(image)
|
||
const updates = sharedTaskImageUpdates(editableSegments, image, false).map((update) => ({
|
||
segmentId: update.segmentId,
|
||
patch: {
|
||
images: update.segmentId === segment.id
|
||
? update.images.filter((item) => taskImageIdentity(item) !== identity)
|
||
: update.images,
|
||
},
|
||
}))
|
||
onTrackSegmentsContentChange(updates)
|
||
return
|
||
}
|
||
onContentChange({ images: images.filter((image) => image.id !== imageId) })
|
||
}
|
||
|
||
function handleSharedImageChange(image: MultiTrackTaskImage, enabled: boolean) {
|
||
if (enabled && !canEnableSharedTaskImage(editableSegments, image)) return
|
||
const updates = sharedTaskImageUpdates(editableSegments, image, enabled)
|
||
if (onTrackSegmentsContentChange) {
|
||
onTrackSegmentsContentChange(updates.map((update) => ({
|
||
segmentId: update.segmentId,
|
||
patch: { images: update.images },
|
||
})))
|
||
return
|
||
}
|
||
const current = updates.find((update) => update.segmentId === segment.id)
|
||
if (current) onContentChange({ images: current.images })
|
||
}
|
||
|
||
function handleMutedImageChange(imageId: string, muted: boolean) {
|
||
onContentChange({
|
||
images: images.map((image) => image.id === imageId ? { ...image, muted } : image),
|
||
})
|
||
}
|
||
|
||
const imageGridColumns = images.length > 0 && images.length < 4 ? 'grid-cols-2' : 'grid-cols-3'
|
||
const imagePickerSurfaceClass = isImageDragOver ? 'border-primary bg-accent/20' : 'border-border bg-muted/20'
|
||
const containerRef = useRef<HTMLDivElement>(null)
|
||
const editorContentRef = useRef<HTMLDivElement>(null)
|
||
const imageGridRef = useRef<HTMLDivElement>(null)
|
||
const imageDropZoneRef = useRef<HTMLDivElement>(null)
|
||
const panelGroupRef = useRef<ResizablePanelGroupHandle>(null)
|
||
const panelDragRef = useRef<TaskEditorPanelDrag | null>(null)
|
||
const [showEditModeToggle, setShowEditModeToggle] = useState(true)
|
||
const [imagePanelDefaultSize, setImagePanelDefaultSize] = useState<string | number>('40%')
|
||
const [imageCellWidth, setImageCellWidth] = useState(120)
|
||
|
||
useLayoutEffect(() => {
|
||
const content = editorContentRef.current
|
||
if (!content) return
|
||
|
||
const styles = globalThis.getComputedStyle(content)
|
||
const innerWidth = content.clientWidth
|
||
- Number.parseFloat(styles.paddingLeft)
|
||
- Number.parseFloat(styles.paddingRight)
|
||
const innerHeight = content.clientHeight
|
||
- Number.parseFloat(styles.paddingTop)
|
||
- Number.parseFloat(styles.paddingBottom)
|
||
if (innerWidth <= 0 || innerHeight <= 0) return
|
||
|
||
const maximumImageWidth = Math.min(
|
||
innerWidth * 0.55,
|
||
innerWidth - TASK_PROMPT_PANEL_MIN_SIZE - TASK_EDITOR_PANEL_GAP,
|
||
)
|
||
setImagePanelDefaultSize(Math.max(
|
||
TASK_IMAGE_PANEL_MIN_SIZE,
|
||
Math.min(innerHeight, maximumImageWidth),
|
||
))
|
||
}, [])
|
||
|
||
useLayoutEffect(() => {
|
||
const target = imageDropZoneRef.current ?? imageGridRef.current
|
||
if (!target) return
|
||
const update = () => {
|
||
const width = target.clientWidth
|
||
if (width <= 0) return
|
||
setImageCellWidth((prev) => (Math.abs(prev - width) > 1 ? width : prev))
|
||
}
|
||
update()
|
||
const observer = new ResizeObserver(update)
|
||
observer.observe(target)
|
||
return () => observer.disconnect()
|
||
}, [images.length])
|
||
|
||
const actionSharedSize = Math.round(Math.max(14, Math.min(imageCellWidth * 0.07, 28)))
|
||
const actionNormalSize = Math.round(Math.max(14, Math.min(imageCellWidth * 0.08, 32)))
|
||
const svgIconSize = Math.round(Math.max(10, Math.min(imageCellWidth * 0.05, 20)))
|
||
const textIconSize = Math.round(Math.max(10, Math.min(imageCellWidth * 0.06, 18)))
|
||
|
||
useEffect(() => {
|
||
const container = containerRef.current
|
||
if (!container) return
|
||
|
||
const observer = new ResizeObserver((entries) => {
|
||
const width = entries[0]?.contentRect.width ?? container.clientWidth
|
||
setShowEditModeToggle(width >= 600)
|
||
})
|
||
|
||
observer.observe(container)
|
||
// Initial check
|
||
setShowEditModeToggle(container.clientWidth >= 600)
|
||
|
||
return () => observer.disconnect()
|
||
}, [])
|
||
|
||
function handlePanelResizePointerDown(event: React.PointerEvent<HTMLDivElement>) {
|
||
if (event.button !== 0) return
|
||
event.preventDefault()
|
||
event.stopPropagation()
|
||
|
||
const layout = panelGroupRef.current?.getLayout()
|
||
const groupWidth = event.currentTarget.parentElement?.getBoundingClientRect().width ?? 0
|
||
const startImageSize = layout?.[TASK_IMAGES_PANEL_ID]
|
||
if (groupWidth <= 0 || startImageSize === undefined) return
|
||
|
||
panelDragRef.current = {
|
||
pointerId: event.pointerId,
|
||
startClientX: event.clientX,
|
||
startImageSize,
|
||
groupWidth,
|
||
}
|
||
event.currentTarget.setPointerCapture?.(event.pointerId)
|
||
}
|
||
|
||
function handlePanelResizePointerMove(event: React.PointerEvent<HTMLDivElement>) {
|
||
const drag = panelDragRef.current
|
||
if (!drag || drag.pointerId !== event.pointerId) return
|
||
event.preventDefault()
|
||
event.stopPropagation()
|
||
|
||
const imageSize = drag.startImageSize
|
||
+ ((event.clientX - drag.startClientX) / drag.groupWidth) * 100
|
||
panelGroupRef.current?.setLayout({
|
||
[TASK_IMAGES_PANEL_ID]: imageSize,
|
||
[TASK_PROMPT_PANEL_ID]: 100 - imageSize,
|
||
})
|
||
}
|
||
|
||
function finishPanelResize(event: React.PointerEvent<HTMLDivElement>) {
|
||
if (panelDragRef.current?.pointerId !== event.pointerId) return
|
||
event.preventDefault()
|
||
event.stopPropagation()
|
||
panelDragRef.current = null
|
||
if (event.currentTarget.hasPointerCapture?.(event.pointerId)) {
|
||
event.currentTarget.releasePointerCapture?.(event.pointerId)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<div
|
||
ref={containerRef}
|
||
data-capture-wheel="true"
|
||
className="task-segment-editor flex h-full min-h-24 w-full flex-col overflow-hidden rounded-sm bg-background text-foreground"
|
||
>
|
||
<div ref={editorContentRef} className="flex min-h-0 flex-1 p-4">
|
||
<ResizablePanelGroup
|
||
key={editMode}
|
||
groupRef={panelGroupRef}
|
||
orientation="horizontal"
|
||
className="min-h-0 min-w-0"
|
||
>
|
||
{editMode === 'individual' && (
|
||
<ResizablePanel
|
||
id={TASK_IMAGES_PANEL_ID}
|
||
defaultSize={imagePanelDefaultSize}
|
||
minSize={TASK_IMAGE_PANEL_MIN_SIZE}
|
||
maxSize={TASK_IMAGE_PANEL_MAX_SIZE}
|
||
>
|
||
<div
|
||
ref={imageDropZoneRef}
|
||
data-testid="task-image-drop-zone"
|
||
aria-label={t('multitrack.taskImageDropZone')}
|
||
className={cn(
|
||
'task-image-drop-zone flex h-full min-h-0 w-full items-center justify-center rounded-md border border-dashed transition-colors',
|
||
isImageDragOver ? 'border-primary bg-accent/20' : 'border-border bg-muted/30',
|
||
)}
|
||
onDragEnter={handleImageDragEnter}
|
||
onDragOver={handleImageDragOver}
|
||
onDragLeave={handleImageDragLeave}
|
||
onDrop={handleDrop}
|
||
>
|
||
<Popover
|
||
open={mediaSelectorOpen}
|
||
onOpenChange={(open) => {
|
||
setMediaSelectorOpen(open)
|
||
if (!open) setReselectImageId(null)
|
||
}}
|
||
>
|
||
{images.length === 0 ? (
|
||
<PopoverTrigger asChild>
|
||
<div
|
||
role="button"
|
||
tabIndex={0}
|
||
className={cn(
|
||
'task-image-picker-empty flex aspect-square h-full max-h-full min-h-24 min-w-24 max-w-full cursor-pointer flex-col items-center justify-center gap-1 rounded-md px-4 py-2 text-foreground shadow-sm transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring',
|
||
imagePickerSurfaceClass,
|
||
)}
|
||
aria-label={t('multitrack.taskImageDropZone')}
|
||
onClick={() => setReselectImageId(null)}
|
||
onKeyDown={(event) => {
|
||
if (event.key !== 'Enter' && event.key !== ' ') return
|
||
event.preventDefault()
|
||
setMediaSelectorOpen(true)
|
||
}}
|
||
>
|
||
<CloudUpload />
|
||
<span className="text-[10px] font-semibold mt-1">{t('multitrack.selectImage')}</span>
|
||
<span className="max-w-full whitespace-normal text-center text-[9px] text-muted-foreground">
|
||
{t('multitrack.imageDropHint')}
|
||
</span>
|
||
</div>
|
||
</PopoverTrigger>
|
||
) : (
|
||
<PopoverAnchor asChild>
|
||
<div
|
||
ref={imageGridRef}
|
||
data-testid="task-image-grid"
|
||
className={cn(
|
||
'task-image-grid relative grid h-full w-full auto-rows-max content-start gap-2 overflow-y-auto rounded-md p-3 transition-colors',
|
||
imageGridColumns,
|
||
imagePickerSurfaceClass,
|
||
)}
|
||
>
|
||
{images.map((image, index) => {
|
||
const imageUrl = mediaContentToViewUrl({
|
||
source_type: image.source_type ?? 'input',
|
||
file_path: image.file_path,
|
||
local_path: image.local_path,
|
||
url: image.url,
|
||
slot_name: image.slot_name,
|
||
})
|
||
const canShareImage = image.shared_reference === true
|
||
|| canEnableSharedTaskImage(editableSegments, image)
|
||
const actionSize = image.shared_reference ? actionSharedSize : actionNormalSize
|
||
const iconSvgStyle = { width: `${svgIconSize}px`, height: `${svgIconSize}px` }
|
||
const imageReferenceIndex = taskImageReferenceIndex(images, image.id, imageIndexOffset)
|
||
return (
|
||
<div
|
||
key={image.id}
|
||
draggable
|
||
data-testid={`task-image-${image.id}`}
|
||
className={`task-image-grid-item group/task-image relative flex aspect-square w-full self-start cursor-pointer items-center justify-center overflow-hidden rounded-md border bg-black ${
|
||
image.shared_reference
|
||
? (image.muted === true ? 'border-highlight opacity-50' : 'border-highlight')
|
||
: 'border-border'
|
||
}`}
|
||
role="button"
|
||
tabIndex={0}
|
||
aria-label={t('multitrack.reselectImage', { name: imageDisplayName(image) })}
|
||
onClick={() => {
|
||
setReselectImageId(image.id)
|
||
setMediaSelectorOpen(true)
|
||
}}
|
||
onKeyDown={(event) => {
|
||
if (event.target !== event.currentTarget) return
|
||
if (event.key !== 'Enter' && event.key !== ' ') return
|
||
event.preventDefault()
|
||
setReselectImageId(image.id)
|
||
setMediaSelectorOpen(true)
|
||
}}
|
||
onDragStart={() => {
|
||
draggedImageIdRef.current = image.id
|
||
}}
|
||
onDragOver={(event) => event.preventDefault()}
|
||
onDrop={() => {
|
||
const sourceId = draggedImageIdRef.current
|
||
draggedImageIdRef.current = null
|
||
if (!sourceId) return
|
||
onContentChange({ images: moveImage(images, sourceId, image.id) })
|
||
}}
|
||
>
|
||
{imageUrl && image.panorama_view ? (
|
||
<PanoramaImagePreview
|
||
imageId={image.id}
|
||
imageUrl={imageUrl}
|
||
alt={imageDisplayName(image)}
|
||
view={image.panorama_view}
|
||
className={cn(
|
||
'absolute inset-0 m-auto transition-opacity',
|
||
image.muted === true && 'opacity-40',
|
||
)}
|
||
/>
|
||
) : imageUrl ? (
|
||
<img
|
||
src={imageUrl}
|
||
alt={imageDisplayName(image)}
|
||
className={cn(
|
||
'absolute inset-0 h-full w-full object-contain transition-opacity',
|
||
image.muted === true && 'opacity-40',
|
||
)}
|
||
draggable={false}
|
||
/>
|
||
) : (
|
||
<div className="flex h-full w-full items-center justify-center px-2 text-center text-[8px] text-muted-foreground">
|
||
{image.source_type === 'slot'
|
||
? t('mediaSelector.slotImage', { n: taskImageSlotNumber(image, index) })
|
||
: imageDisplayName(image)}
|
||
</div>
|
||
)}
|
||
<div
|
||
data-testid={`task-image-overlay-${image.id}`}
|
||
aria-hidden="true"
|
||
className="pointer-events-none absolute inset-0 z-[5] bg-black/30 opacity-0 transition-opacity group-hover/task-image:opacity-100 group-focus-within/task-image:opacity-100"
|
||
/>
|
||
<div
|
||
data-testid={`task-image-actions-${image.id}`}
|
||
className="absolute right-0.5 top-1 z-10 flex gap-1 opacity-0 transition-opacity group-hover/task-image:opacity-100 group-focus-within/task-image:opacity-100"
|
||
>
|
||
<TooltipProvider>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant={image.shared_reference === true ? 'secondary' : 'ghost'}
|
||
data-testid={`task-image-shared-${image.id}`}
|
||
className={`h-auto w-auto cursor-pointer bg-background/70 hover:bg-background/90 ${image.shared_reference === true ? 'text-highlight' : 'text-muted-foreground'}`}
|
||
style={{ width: actionSize, height: actionSize }}
|
||
aria-label={image.shared_reference === true
|
||
? t('multitrack.disableSharedReference')
|
||
: t('multitrack.enableSharedReference')}
|
||
aria-pressed={image.shared_reference === true}
|
||
disabled={!canShareImage}
|
||
onClick={(event) => {
|
||
event.stopPropagation()
|
||
handleSharedImageChange(image, image.shared_reference !== true)
|
||
}}
|
||
>
|
||
<Share2 style={iconSvgStyle} />
|
||
</Button>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom" className="max-w-64">
|
||
{canShareImage
|
||
? t('multitrack.sharedImageReferenceTooltip')
|
||
: t('multitrack.sharedImageLimitTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<TooltipProvider>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant={image.muted === true ? 'secondary' : 'ghost'}
|
||
data-testid={`task-image-muted-${image.id}`}
|
||
className={`h-auto w-auto cursor-pointer bg-background/70 font-bold hover:bg-background/90 ${image.muted === true ? 'text-destructive hover:text-destructive' : 'text-muted-foreground'}`}
|
||
style={{ width: actionSize, height: actionSize, fontSize: textIconSize }}
|
||
aria-label={image.muted === true ? t('multitrack.includeImage') : t('multitrack.bypassImage')}
|
||
aria-pressed={image.muted === true}
|
||
onClick={(event) => {
|
||
event.stopPropagation()
|
||
handleMutedImageChange(image.id, image.muted !== true)
|
||
}}
|
||
>
|
||
M
|
||
</Button>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom">
|
||
{image.muted === true ? t('multitrack.includeImageTooltip') : t('multitrack.bypassImageTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<TooltipProvider>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="ghost"
|
||
className="h-auto w-auto cursor-pointer bg-background/70 text-muted-foreground font-bold hover:bg-background/90"
|
||
style={{ width: actionSize, height: actionSize }}
|
||
aria-label={t('multitrack.previewImage')}
|
||
disabled={!imageUrl}
|
||
onClick={(event) => {
|
||
event.stopPropagation()
|
||
onOpenImagePreview?.(image.id)
|
||
}}
|
||
>
|
||
<Eye style={iconSvgStyle} />
|
||
</Button>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom">{t('multitrack.previewImage')}</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<TooltipProvider>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="ghost"
|
||
className="h-auto w-auto cursor-pointer bg-background/70 text-destructive hover:bg-background/90 hover:text-destructive"
|
||
style={{ width: actionSize, height: actionSize }}
|
||
aria-label={t('multitrack.deleteImage')}
|
||
onClick={(event) => {
|
||
event.stopPropagation()
|
||
handleDeleteImage(image.id)
|
||
}}
|
||
>
|
||
<Trash2 style={iconSvgStyle} />
|
||
</Button>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom">{t('multitrack.deleteImage')}</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
</div>
|
||
{imageReferenceIndex !== null ? (
|
||
<span
|
||
data-testid={`task-image-index-${image.id}`}
|
||
className="absolute bottom-0 left-0 z-10 min-w-5 rounded-sm bg-black/50 px-1.5 py-0.5 text-center text-[9px] font-semibold leading-none text-white"
|
||
>
|
||
{imageReferenceIndex}
|
||
</span>
|
||
) : null}
|
||
</div>
|
||
)
|
||
})}
|
||
{images.length < MAX_TASK_IMAGES && (
|
||
<Button
|
||
type="button"
|
||
variant="outline"
|
||
className="task-image-grid-add aspect-square h-auto w-full self-start border-dashed text-muted-foreground"
|
||
aria-label={t('multitrack.selectImage')}
|
||
onClick={() => {
|
||
setReselectImageId(null)
|
||
setMediaSelectorOpen(true)
|
||
}}
|
||
>
|
||
<Plus className="h-7 w-7" />
|
||
</Button>
|
||
)}
|
||
</div>
|
||
</PopoverAnchor>
|
||
)}
|
||
<PopoverContent className="w-auto p-0" align="end">
|
||
<MediaSelector
|
||
key={reselectImageId ?? 'add-images'}
|
||
value={imageSelectorValue(reselectImage)}
|
||
mediaType="image"
|
||
defaultTab={imageSelectorTab(reselectImage)}
|
||
allowMultipleSelection={!reselectImageId}
|
||
maxSelectionCount={reselectImageId ? 1 : MAX_TASK_IMAGES - images.length}
|
||
slotItems={slotItems}
|
||
onChange={handleSelectedMedia}
|
||
/>
|
||
</PopoverContent>
|
||
</Popover>
|
||
</div>
|
||
</ResizablePanel>
|
||
)}
|
||
|
||
{editMode === 'individual' ? (
|
||
<ResizableHandle
|
||
withHandle
|
||
aria-label={t('multitrack.resizeTaskEditorPanels')}
|
||
className="mx-2 bg-transparent"
|
||
onPointerDown={handlePanelResizePointerDown}
|
||
onPointerMove={handlePanelResizePointerMove}
|
||
onPointerUp={finishPanelResize}
|
||
onPointerCancel={finishPanelResize}
|
||
onLostPointerCapture={() => {
|
||
panelDragRef.current = null
|
||
}}
|
||
/>
|
||
) : null}
|
||
|
||
<ResizablePanel
|
||
id={TASK_PROMPT_PANEL_ID}
|
||
minSize={editMode === 'individual' ? TASK_PROMPT_PANEL_MIN_SIZE : '100%'}
|
||
>
|
||
<div
|
||
data-testid="task-prompt-panel"
|
||
className="flex h-full min-h-0 min-w-0 flex-col overflow-hidden rounded-md border border-border bg-muted/30 shadow-sm"
|
||
>
|
||
{editMode === 'individual' && (
|
||
<div className="flex h-11 shrink-0 items-center px-2 justify-between">
|
||
<div className="flex h-7 items-center rounded-md bg-card p-1">
|
||
<Button
|
||
type="button"
|
||
variant="ghost"
|
||
className={cn(
|
||
'h-full rounded-sm px-3 py-1 text-[10px] shadow-none cursor-pointer',
|
||
promptTab === 'user' ? 'bg-background text-primary hover:bg-background/90 hover:text-primary' : 'text-muted-foreground',
|
||
)}
|
||
onClick={() => setPromptTab('user')}
|
||
>
|
||
{t('multitrack.userPrompt')}
|
||
</Button>
|
||
<Button
|
||
type="button"
|
||
variant="ghost"
|
||
className={cn(
|
||
'h-full rounded-sm px-3 py-1 text-[10px] shadow-none cursor-pointer',
|
||
promptTab === 'system' ? 'bg-background text-primary hover:bg-background/90 hover:text-primary' : 'text-muted-foreground',
|
||
)}
|
||
onClick={() => setPromptTab('system')}
|
||
>
|
||
{t('multitrack.systemPrompt')}
|
||
</Button>
|
||
</div>
|
||
{promptTab === 'user' ? (
|
||
<div className="flex items-center gap-1">
|
||
<Button
|
||
type="button"
|
||
variant="ghost"
|
||
className="h-7 px-2 text-[10px] text-highlight hover:bg-highlight/10 hover:text-highlight cursor-pointer hover:opacity-70"
|
||
onClick={() => setApplyPromptToAllOpen(true)}
|
||
>
|
||
{t('multitrack.applyPromptToAll')}
|
||
</Button>
|
||
<TooltipProvider delayDuration={300}>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<div aria-label={t('multitrack.userPromptVariantTooltip')}>
|
||
<Tabs
|
||
value={promptVariant}
|
||
onValueChange={(value) => onContentChange({
|
||
user_prompt_variant: value as MultiTrackUserPromptVariant,
|
||
})}
|
||
>
|
||
<TabsList className="h-7 bg-card p-1">
|
||
<TabsTrigger value="a" className="h-full min-w-7 px-2 text-[10px]">A</TabsTrigger>
|
||
<TabsTrigger value="b" className="h-full min-w-7 px-2 text-[10px]">B</TabsTrigger>
|
||
</TabsList>
|
||
</Tabs>
|
||
</div>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom" className="max-w-72">
|
||
{t('multitrack.userPromptVariantTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
</div>
|
||
) : Boolean(segment.content.system_prompt) && (
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="ghost"
|
||
className="h-7 w-7 text-muted-foreground [&_svg]:!size-3"
|
||
aria-label={t('multitrack.resetSystemPrompt')}
|
||
onClick={() => onContentChange({ system_prompt: '' })}
|
||
>
|
||
<RotateCcw />
|
||
</Button>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom">{t('multitrack.resetSystemPrompt')}</TooltipContent>
|
||
</Tooltip>
|
||
)}
|
||
</div>
|
||
)}
|
||
{editMode === 'combined' ? (
|
||
<div className="flex min-h-0 flex-1 flex-col gap-1 p-2">
|
||
<div className="relative h-full min-h-0 flex-1 overflow-hidden rounded-md bg-card">
|
||
<PromptContentEditor
|
||
ariaLabel={t('multitrack.prompt')}
|
||
placeholder={promptPlaceholder}
|
||
interactivePlaceholder={usesMiniMaxPromptPlaceholder}
|
||
testId="combined-prompt-highlight"
|
||
className="border-none bg-card shadow-none"
|
||
value={promptValue}
|
||
resources={promptResources}
|
||
mentionsEnabled
|
||
highlightPromptSemantics
|
||
highlightPipes
|
||
onChange={handlePromptChange}
|
||
/>
|
||
</div>
|
||
<p className="shrink-0 text-[9px] text-muted-foreground mt-1">{t('maintainTrack.combinedHint')}</p>
|
||
</div>
|
||
) : promptTab === 'user' ? (
|
||
<div className="relative h-full min-h-0 flex-1 overflow-hidden pb-2 px-2">
|
||
<PromptContentEditor
|
||
placeholder={promptPlaceholder}
|
||
interactivePlaceholder={usesMiniMaxPromptPlaceholder}
|
||
ariaLabel={t('multitrack.prompt')}
|
||
className="border-none bg-card shadow-none"
|
||
value={promptValue}
|
||
resources={promptResources}
|
||
mentionsEnabled
|
||
highlightPromptSemantics
|
||
onChange={handlePromptChange}
|
||
/>
|
||
</div>
|
||
) : (
|
||
<div className="relative h-full min-h-0 flex-1 overflow-hidden pb-2 px-2">
|
||
<div className="relative h-full min-h-0 overflow-hidden rounded-md bg-card">
|
||
<PromptContentEditor
|
||
ariaLabel={t('multitrack.systemPrompt')}
|
||
placeholder={systemPromptLoading ? t('multitrack.loadingSystemPrompt') : t('multitrack.systemPromptPlaceholder')}
|
||
className="border-none bg-card shadow-none"
|
||
value={systemPromptValue}
|
||
resources={promptResources}
|
||
highlightSystemVariables
|
||
onChange={handleSystemPromptChange}
|
||
/>
|
||
</div>
|
||
</div>
|
||
)}
|
||
</div>
|
||
</ResizablePanel>
|
||
</ResizablePanelGroup>
|
||
</div>
|
||
|
||
<div className="relative flex shrink-0 items-center justify-between border-t border-dashed border-border p-2">
|
||
<Tabs value={editMode} onValueChange={(value) => setEditMode(value as EditMode)} className={showEditModeToggle ? undefined : 'hidden'}>
|
||
<TabsList className="h-8 bg-card">
|
||
<TabsTrigger value="individual" className="text-[10px]">{t('multitrack.individualEdit')}</TabsTrigger>
|
||
<TabsTrigger value="combined" className="text-[10px]">{t('multitrack.combinedEdit')}</TabsTrigger>
|
||
</TabsList>
|
||
</Tabs>
|
||
|
||
<div className={cn(
|
||
showEditModeToggle ? 'absolute left-1/2 -translate-x-1/2' : 'flex items-center',
|
||
isDurationEditing && 'w-28'
|
||
)}>
|
||
{isDurationEditing ? (
|
||
<Input
|
||
autoFocus
|
||
aria-label={t('multitrack.duration')}
|
||
type="text"
|
||
inputMode="numeric"
|
||
placeholder="00:00:00"
|
||
className="tabular-nums"
|
||
value={durationInput}
|
||
onChange={(event) => setDurationInput(event.currentTarget.value)}
|
||
onBlur={commitDuration}
|
||
onKeyDown={(event) => {
|
||
if (event.key !== 'Enter') return
|
||
event.preventDefault()
|
||
commitDuration()
|
||
}}
|
||
/>
|
||
) : (
|
||
<div className="flex items-center gap-1 text-muted-foreground">
|
||
<div className="flex flex-col items-center">
|
||
<span className="text-[10px] text-primary">{t('multitrack.taskNumber', { n: taskIndex + 1 })}</span>
|
||
<span className="text-[10px] mt-0.5 tabular-nums">{formattedDuration}</span>
|
||
</div>
|
||
{onDurationChange && (
|
||
<Button
|
||
type="button"
|
||
variant="ghost"
|
||
size="icon"
|
||
className="h-5 w-5 cursor-pointer"
|
||
aria-label={t('multitrack.editTaskDuration')}
|
||
onClick={() => setIsDurationEditing(true)}
|
||
>
|
||
<Pencil className="h-3 w-3" />
|
||
</Button>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
|
||
<div className="flex items-center gap-2">
|
||
{format === 'MiniMax' && (taskIndex > 0 || hasSelectedContinuityTargets) && (
|
||
<Select
|
||
value={continuityMode}
|
||
onValueChange={(value) => handleDropdownContentChange({
|
||
continuity_mode: value as MultiTrackContinuityMode,
|
||
})}
|
||
>
|
||
<TooltipProvider delayDuration={300}>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<SelectTrigger aria-label={t('multitrack.continuityMode')} className="h-8 w-28 bg-card text-[10px]">
|
||
<SelectValue />
|
||
</SelectTrigger>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom" className="max-w-72">
|
||
{t('multitrack.continuityModeTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<SelectContent>
|
||
{MULTITRACK_CONTINUITY_MODES.map((continuityOption) => (
|
||
<SelectItem key={continuityOption} value={continuityOption}>
|
||
<span className="text-[10px]">{t(`multitrackContinuityModes.${continuityOption}`)}</span>
|
||
</SelectItem>
|
||
))}
|
||
</SelectContent>
|
||
</Select>
|
||
)}
|
||
{format === 'MiniMax' && ['ref','edit'].includes(mode) && (
|
||
<Select
|
||
value={refImageSize}
|
||
onValueChange={(value) => handleDropdownContentChange({ ref_image_size: value as MultiTrackRefImageSize })}
|
||
>
|
||
<TooltipProvider delayDuration={300}>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<SelectTrigger aria-label={t('multitrack.refImageSize')} className="h-8 w-20 bg-card text-[10px]">
|
||
<SelectValue />
|
||
</SelectTrigger>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom" className="max-w-72">
|
||
{t('multitrack.refImageSizeTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<SelectContent>
|
||
{MULTITRACK_REF_IMAGE_SIZES.map((refImageSizeOption) => (
|
||
<SelectItem key={refImageSizeOption} value={refImageSizeOption}>
|
||
<span className="text-[10px]">{t(`multitrackRefImageSizes.${refImageSizeOption}`)}</span>
|
||
</SelectItem>
|
||
))}
|
||
</SelectContent>
|
||
</Select>
|
||
)}
|
||
<Select value={mode} onValueChange={(value) => handleDropdownContentChange({ task_mode: value as MultiTrackTaskMode })}>
|
||
<TooltipProvider delayDuration={300}>
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<SelectTrigger aria-label={t('multitrack.taskMode')} className="h-8 w-24 bg-card text-[10px]">
|
||
<SelectValue />
|
||
</SelectTrigger>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="bottom" className="max-w-72">
|
||
{t('multitrack.taskModeTooltip')}
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</TooltipProvider>
|
||
<SelectContent>
|
||
{MULTITRACK_TASK_MODES.map((taskMode) => (
|
||
<SelectItem key={taskMode} value={taskMode}>
|
||
<span className="text-[10px]">
|
||
{t(`multitrackTaskModes.${getMultiTrackTaskType(taskMode, images.length, segmentHasVideoInRange)}`)}
|
||
</span>
|
||
</SelectItem>
|
||
))}
|
||
</SelectContent>
|
||
</Select>
|
||
</div>
|
||
</div>
|
||
<Dialog open={applyPromptToAllOpen} onOpenChange={setApplyPromptToAllOpen}>
|
||
<DialogContent className="max-w-md">
|
||
<DialogHeader>
|
||
<DialogTitle>{t('multitrack.applyPromptToAllTitle')}</DialogTitle>
|
||
<DialogDescription>
|
||
{t('multitrack.applyPromptToAllDescription')}
|
||
</DialogDescription>
|
||
</DialogHeader>
|
||
<DialogFooter>
|
||
<Button type="button" variant="outline" onClick={() => setApplyPromptToAllOpen(false)}>
|
||
{t('common.cancel')}
|
||
</Button>
|
||
<Button type="button" onClick={handleApplyPromptToAll}>
|
||
{t('multitrack.applyPromptToAllConfirm')}
|
||
</Button>
|
||
</DialogFooter>
|
||
</DialogContent>
|
||
</Dialog>
|
||
</div>
|
||
)
|
||
}
|