"use client"; // Propriedades do editor de cortes: o painel da direita mostra as propriedades DO QUE ESTÁ SELECIONADO (um // trecho, um texto, um zoom, uma narração, palavras, ou uma camada inteira: vídeo, legenda, áudio…), no formato // "rótulo · controle · valor em azul" dos editores de vídeo. Fluxos maiores abrem em modal: Exportar (prévia real, // capa, render), IA sugere, Nova narração e Atalhos. Tudo que muda o projeto entra no desfazer e no autosave. import { useEffect, useState, type ReactNode } from "react"; import { HOOK_ANIM_LABEL, MODE_LABEL, clipperCall, hookOf, type Aspect, type CamDetect, type Clip, type CutSettings, type FrameSize, type HookAnim, type LayoutMode, type Rect, type SettingsPayload, } from "./clipper-client"; import { FontPicker } from "./clip-editor-fonts"; import { RESOLVED_MODE_LABEL, chatDefault, clamp, clockTenths, cutAt, editLayout, keepRange, newHook, newId, outputDuration, produce, removeRange, resolvedMode, round3, sessionClock, splitAt, toOutput, toSession, toggleChat, zoomFocusDefault, type CaptionPreset, type EditBundle, type EditProject, type EditWord, type Frame, type LayerKey, type Narration, type Selection, type Suggestion, type TextOverlay, type ZoomOverlay, } from "./clip-editor-model"; import { Btn, Check, ColorDot, Hint, Hot, Keycap, Modal, Pick, PropRow, PropSection, RectFields, RowButton, Scrub, fieldClass } from "./clip-editor-ui"; import { InsetProps, InsetsLayer, ReframeKeyProps, ReframeLayer, type KeyframeControl } from "./clip-editor-keyframes"; import { SourceTargetToggle } from "./clip-editor-source"; import { CheckIcon, DownloadIcon, MicIcon, PlayIcon, PlusIcon, ScissorsIcon, SparkIcon, TrashIcon, WandIcon } from "./icons"; import { clampRect } from "./rect-geometry"; import { Spinner, cx, fileUrl } from "./ui"; import { askConfirm } from "./confirm-dialog"; type Update = (fn: (p: EditProject) => EditProject, key?: string) => void; type Notice = (ok: boolean, text: string) => void; export type ModalKind = "export" | "ai" | "narration" | "keys" | null; export type InspectorProps = { bundle: EditBundle; project: EditProject; cfg: CutSettings; playhead: number; selection: Selection; onProject: Update; onSelect: (s: Selection) => void; onSeek: (t: number) => void; onNotice: Notice; /** Troca a janela da gravação (gera outro proxy). */ onWindow: (lo: number, hi: number) => Promise; onModal: (m: ModalKind) => void; clip: Clip; /** Câmera e área do jogo no monitor "Fonte" (o mesmo estado nos dois lugares). */ source: SourceControl; /** Formato efetivo do corte (quadro do vídeo e dos textos). */ frame: Frame; /** Fontes que o serviço aceita (as empacotadas em `fontFiles`) e quadros de cada formato. */ catalog: EditorCatalog; /** Keyframe do enquadramento no playhead e inserção nova (desenhada na Fonte). */ keyframes: KeyframeControl; }; /** Retângulo da camada Câmera em edição na Fonte. */ type CamTarget = "cam" | "game"; /** O que o editor lê da rota de settings da sessão (o pacote do editor não traz). */ export type EditorCatalog = { loaded: boolean; fonts: string[]; fontFiles: Record; frames: Record | null; /** Tamanho da gravação original (sessão › capture), para a prévia recortar como o FFmpeg. null = desconhecido. */ source: { w: number; h: number } | null; }; const ASPECT_LABEL: Record = { vertical: "Vertical 9:16", horizontal: "Horizontal 16:9" }; /** Ligação entre Propriedades e o monitor "Fonte". */ export type SourceControl = { /** Retângulo em edição (Câmera ou Área do jogo). */ target: CamTarget; onTarget: (t: CamTarget) => void; /** "Editar na fonte" ligado: a Fonte aparece mesmo em tela estreita ou escondida, com o retângulo focado. */ editing: boolean; onEdit: (on: boolean, which?: CamTarget) => void; /** Depois de gravar câmera/jogo na sessão: atualiza a configuração da sessão que o editor tem em memória. */ onSessionLayout: (layout: CutSettings["layout"]) => void; }; const sec = (v: number) => `${v.toFixed(1).replace(".", ",")} s`; const pct = (v: number) => `${Math.round(v * 100)}%`; const LAYER_TITLE: Record = { video: "Vídeo", camera: "Câmera e layout", captions: "Legenda", texts: "Textos", zooms: "Zoom", audio: "Áudio da live", narration: "Narração", music: "Música e efeitos", progress: "Barra de progresso", cover: "Capa", chat: "Chat na tela", reframe: "Enquadramento do jogo", insets: "Inserções", }; /** Título do painel (o que está selecionado) + o corpo certo. */ export function Properties(props: InspectorProps) { const { selection: sel, project } = props; let title = "Vídeo"; let body: ReactNode = ; if (sel?.kind === "cut" && project.cuts[sel.index]) { title = `Trecho ${sel.index + 1}`; body = ; } else if (sel?.kind === "range") { title = "Trecho selecionado"; body = ; } else if (sel?.kind === "words") { title = sel.from === sel.to ? "Palavra" : `${sel.to - sel.from + 1} palavras`; body = ; } else if (sel?.kind === "overlay") { const o = project.overlays.find((x) => x.id === sel.id); if (o?.kind === "zoom") { title = "Zoom"; body = ; } else if (o?.kind === "inset") { title = sel.key !== undefined ? `Inserção · keyframe ${sel.key + 1}` : "Inserção"; body = ; } else if (o) { title = o.kind === "hook" ? "Gancho" : "Texto"; body = ; } } else if (sel?.kind === "reframe" && project.reframe?.keys[sel.key]) { title = "Enquadramento · keyframe"; body = ; } else if (sel?.kind === "narration") { const n = project.audio.narration.find((x) => x.id === sel.id); if (n) { title = "Narração"; body = ; } } else if (sel?.kind === "layer") { title = LAYER_TITLE[sel.layer]; body = { video: , camera: , chat: , captions: , texts: , zooms: , audio: , narration: , music: , progress: , cover: , reframe: , insets: }[sel.layer]; } return (
{title} corte #{props.clip.id}
{body}
); } /* ---------------- Vídeo (o corte inteiro) ---------------- */ function VideoProps({ bundle, project, cfg, playhead, onProject, onSelect, onSeek, onNotice, onWindow, frame, catalog, clip }: InspectorProps) { const [busy, setBusy] = useState(false); const horizontal = frame.aspect === "horizontal"; const sessionAspect: Aspect = bundle.settings.format?.aspect ?? clip.aspect ?? "vertical"; const sizeOf = (a: Aspect) => { const f = catalog.frames?.[a]; return f ? `${f.width}×${f.height}` : a === "vertical" ? "1080×1920" : "1920×1080"; }; const { lo, hi } = project.source; const total = outputDuration(project.cuts); const first = project.cuts[0]; const last = project.cuts[project.cuts.length - 1]; async function startEarlier(seconds: number) { const target = Math.max(0, first.start - seconds); if (target < lo) { setBusy(true); const ok = await onWindow(Math.max(0, target - 15), hi); setBusy(false); if (!ok) return; } onProject((p) => produce(p, (d) => { d.cuts[0].start = round3(target); d.source.lo = Math.min(d.source.lo, d.cuts[0].start); })); onSeek(target); onNotice(true, `Início recuado ${seconds} s.`); } async function grow(side: "before" | "after") { const nlo = side === "before" ? Math.max(0, lo - 30) : lo; const nhi = side === "after" ? Math.min(bundle.sessionDurationS, hi + 30) : hi; if (nhi - nlo > bundle.limits.maxWindowS) return onNotice(false, `A janela vai até ${bundle.limits.maxWindowS / 60} min.`); setBusy(true); await onWindow(nlo, nhi); setBusy(false); } return ( <> onProject((p) => produce(p, (d) => { if (v) d.settings = { ...d.settings, format: { aspect: v as Aspect } }; else { const { format: _drop, ...rest } = d.settings; d.settings = rest; } }))}> {(["vertical", "horizontal"] as Aspect[]).map((a) => )} cfg.duration.maxS + 0.05 ? "!text-[#e2b340]" : undefined}>{sec(total)}em {project.cuts.length} trecho(s) {total < cfg.duration.minS - 0.05 && Abaixo do mínimo configurado ({cfg.duration.minS} s). A edição é livre; os cortes automáticos saem com pelo menos {cfg.duration.minS + 1} s.} {total > cfg.duration.maxS + 0.05 && Acima do máximo configurado ({cfg.duration.maxS} s).} onProject((p) => produce(p, (d) => { d.settings = { ...d.settings, layout: { ...(d.settings.layout ?? {}) } }; if (v) d.settings.layout!.mode = v as LayoutMode; else delete d.settings.layout!.mode; }))}> {(horizontal ? HORIZONTAL_MODES : ["auto", "cam_top", "blur", "game_only"] as LayoutMode[]).map((m) => )} {horizontal ? No horizontal o corte mostra o quadro inteiro (ou a área do jogo marcada, em tela cheia); “Câmera inteira” mostra só o streamer. Câmera em cima e desfoque ficam para o vertical. : A posição da câmera deste corte se ajusta na camada “Câmera” ou direto no monitor “Fonte”; o padrão da sessão fica em “Configurar corte”.} {[20, 10, 5, 2].map((s) => void startEarlier(s)}>−{s} s)} { if (cutAt(project.cuts, playhead) < 0) return onNotice(false, "O playhead está num trecho fora do corte."); onProject((p) => ({ ...p, cuts: removeRange(p.cuts, p.cuts[0].start, playhead) })); }}>Começar aqui { if (cutAt(project.cuts, playhead) < 0) return onNotice(false, "O playhead está num trecho fora do corte."); onProject((p) => ({ ...p, cuts: removeRange(p.cuts, playhead, p.cuts[p.cuts.length - 1].end) })); }}>Terminar aqui onProject((p) => ({ ...p, cuts: keepRange(p.cuts, Math.min(playhead, last.end), Math.max(playhead, last.end)) }))}>Até o playhead {sessionClock(lo)}–{sessionClock(hi)}{Math.round(hi - lo)} s void grow("before")}>{busy && }+30 s antes = bundle.sessionDurationS} onClick={() => void grow("after")}>+30 s depois A timeline mostra a janela inteira: o que está apagado ficou fora do corte e volta com “Manter”. {project.cuts.map((c, i) => ( ))} ); } function CutProps(props: InspectorProps & { index: number }) { const { project, playhead, onProject, onSelect, onSeek, index } = props; const c = project.cuts[index]; const prev = project.cuts[index - 1], next = project.cuts[index + 1]; const nudge = (edge: "start" | "end", d: number) => onProject((p) => produce(p, (draft) => { const cut = draft.cuts[index]; if (edge === "start") cut.start = round3(clamp(cut.start + d, prev ? prev.end : p.source.lo, cut.end - 0.2)); else cut.end = round3(clamp(cut.end + d, cut.start + 0.2, next ? next.start : p.source.hi)); }), `nudge-${edge}-${index}`); const inside = playhead > c.start + 0.2 && playhead < c.end - 0.2; return ( <> {clockTenths(toOutput(c.start, project.cuts).t)}duração{sec(c.end - c.start)} {sessionClock(c.start)} {[-1, -0.1, 0.1, 1].map((d) => nudge("start", d)}>{d > 0 ? "+" : "−"}{Math.abs(d).toString().replace(".", ",")})} {sessionClock(c.end)} {[-1, -0.1, 0.1, 1].map((d) => nudge("end", d)}>{d > 0 ? "+" : "−"}{Math.abs(d).toString().replace(".", ",")})} Também dá para arrastar as bordas do clipe na timeline. Layout onProject((p) => produce(p, (d) => { d.cuts[index].mode = m; }))} /> {props.frame.aspect === "horizontal" ? "No horizontal: “Quadro inteiro” mostra o jogo em tela cheia e “Câmera inteira” só o streamer. Divida o trecho (S) para trocar no meio." : "“Câmera inteira” mostra só o streamer na tela toda; “Só o jogo” tira a câmera. Divida o trecho (S) para trocar no meio."} onProject((p) => produce(p, (d) => { if (v) d.cuts[index].muted = true; else delete d.cuts[index].muted; }))} /> A narração e a música continuam tocando. Para mutar só um pedaço, divida o trecho antes.
onProject((p) => ({ ...p, cuts: splitAt(p.cuts, playhead) }))}> Dividir no playhead { onProject((p) => ({ ...p, cuts: p.cuts.filter((_, j) => j !== index) })); onSelect(null); }}> Tirar do corte onSeek(c.start)}>Ir ao início
Com a lâmina (C), clique no clipe para dividir em qualquer ponto; selecione o pedaço e aperte Delete.
); } function RangeProps({ project, onProject, onSelect, a, b }: InspectorProps & { a: number; b: number }) { const outside = cutAt(project.cuts, (a + b) / 2) < 0; return ( {sessionClock(a)}–{sessionClock(b)}{sec(b - a)} {outside ? "fora do corte" : "dentro do corte"}
{ onProject((p) => ({ ...p, cuts: keepRange(p.cuts, a, b) })); onSelect(null); }}>Manter no corte { onProject((p) => ({ ...p, cuts: removeRange(p.cuts, a, b) })); onSelect(null); }}>Tirar do corte
Shift + arrastar na régua seleciona qualquer trecho da gravação.
); } function WordProps({ project, onProject, onSelect, from, to }: InspectorProps & { from: number; to: number }) { const words = project.captions.words; const sel = words.slice(from, to + 1); if (!sel.length) return null; const a = sel[0].s, b = sel[sel.length - 1].e; const setWords = (fn: (ws: EditWord[]) => EditWord[], key?: string) => onProject((p) => produce(p, (d) => { d.captions.words = fn(d.captions.words); }), key); const inRange = (i: number) => i >= from && i <= to; const single = sel.length === 1 ? sel[0] : null; const nudge = (key: "s" | "e", d: number) => { if (!single) return; const next = { ...single, [key]: round3(single[key] + d) }; if (next.e - next.s >= 0.05) setWords((ws) => ws.map((x, i) => (i === from ? next : x)), `wt-${from}`); }; return ( <> {single ? ( setWords((ws) => ws.map((x, i) => (i === from ? { ...x, w: e.target.value } : x)), `ww-${from}`)} /> ) :

“{sel.map((w) => w.w).join(" ").slice(0, 140)}”

} {sessionClock(a)}{sec(b - a)} w.emph)} onChange={(v) => setWords((ws) => ws.map((w, i) => (inRange(i) ? { ...w, emph: v || undefined } : w)))} /> w.hidden)} onChange={(v) => setWords((ws) => ws.map((w, i) => (inRange(i) ? { ...w, hidden: v || undefined } : w)))} />
{single && ( {single.s.toFixed(2).replace(".", ",")} nudge("s", -0.05)}>−50 ms nudge("s", 0.05)}>+50 ms {single.e.toFixed(2).replace(".", ",")} nudge("e", -0.05)}>−50 ms nudge("e", 0.05)}>+50 ms )}
{ onProject((p) => ({ ...p, cuts: removeRange(p.cuts, a, b) })); onSelect(null); }}>Tirar do corte onProject((p) => ({ ...p, cuts: keepRange(p.cuts, a, b) }))}>Manter no corte {sel.length > 1 && { setWords((ws) => [...ws.slice(0, from), { s: a, e: b, w: sel.map((w) => w.w).join(" ") }, ...ws.slice(to + 1)]); onSelect({ kind: "words", from, to: from }); }}>Juntar numa só}
); } /* ---------------- Legenda ---------------- */ function CaptionProps({ bundle, project, cfg, onProject, catalog }: InspectorProps) { const cap = project.captions; const setStyle = (patch: Partial, key: string) => onProject((p) => produce(p, (d) => { Object.assign(d.captions.style, patch); }), key); return ( <> onProject((p) => produce(p, (d) => { d.captions.enabled = v; }))} /> onProject((p) => produce(p, (d) => { d.captions.preset = v as CaptionPreset; d.captions.style = {}; }))}> {bundle.presets.map((pr) => )} Trocar o estilo volta o tamanho e as palavras por bloco para o padrão dele. onProject((p) => produce(p, (d) => { d.captions.style = {}; }))}>Restaurar : null}> setStyle({ font: v }, "font")} collapsible /> setStyle({ size: v }, "size")} /> setStyle({ maxWords: v }, "maxWords")} /> setStyle({ outlineWidth: v }, "outline")} /> (cfg.caption.y === null ? "auto" : pct(v))} onChange={(v) => setStyle({ y: v }, "y")} /> {cfg.caption.y !== null && setStyle({ y: null }, "y-auto")}>Altura automática} setStyle({ uppercase: v }, "upper")} /> setStyle({ color: v }, "color")} /> setStyle({ highlight: v }, "hl")} /> setStyle({ outline: v }, "ol")} /> onProject((p) => produce(p, (d) => { d.captions.emphColor = v; }), "emph")} /> Corrija palavras e marque ênfase na Transcrição (duplo clique corrige). Para mudar a altura, arraste a legenda no vídeo. ); } /* ---------------- Textos ---------------- */ const EMOJIS = ["😂", "💀", "🔥", "😱", "👀", "🤯", "GG", "KKKK"]; export function newText(project: EditProject, playhead: number, text = "TEXTO", big = false): TextOverlay { const start = round3(clamp(playhead, project.source.lo, project.source.hi - 0.3)); return { id: newId("t"), kind: "text", text, start, end: round3(Math.min(project.source.hi, start + 1.5)), y: big ? 0.42 : 0.3, size: big ? 150 : 72, color: "#FFFFFF", box: null, anim: "pop" }; } export function newZoom(project: EditProject, playhead: number, aspect: Aspect = "vertical"): ZoomOverlay | null { const start = round3(clamp(playhead, project.source.lo, project.source.hi - 0.3)), end = round3(Math.min(project.source.hi, start + 1.5)); if (project.overlays.some((z) => z.kind === "zoom" && start < z.end && end > z.start)) return null; return { id: newId("z"), kind: "zoom", start, end, scale: 1.35, ...zoomFocusDefault(aspect), ramp: 0.2 }; } function TextsLayer({ project, cfg, frame, playhead, onProject, onSelect }: InspectorProps) { const hook = project.overlays.find((o): o is TextOverlay => o.kind === "hook"); const texts = project.overlays.filter((o): o is TextOverlay => o.kind === "text"); const add = (text?: string, big?: boolean) => { const o = newText(project, playhead, text, big); onProject((p) => ({ ...p, overlays: [...p.overlays, o] })); onSelect({ kind: "overlay", id: o.id }); }; return ( <> {hook ? onSelect({ kind: "overlay", id: hook.id })} /> : { const h = newHook(cfg, frame); onProject((p) => ({ ...p, overlays: [h, ...p.overlays] })); onSelect({ kind: "overlay", id: "hook" }); }}>Adicionar gancho} Os 2 primeiros segundos decidem: texto curto que promete o que o vídeo paga. add()}>No playhead}> {texts.map((o) => onSelect({ kind: "overlay", id: o.id })} />)}
{EMOJIS.map((e) => add(e, true)}>{e})}
No vídeo final o emoji sai em uma cor só (o FFmpeg não desenha emoji colorido).
); } function TextProps({ project, cfg, catalog, playhead, onProject, onSelect, onSeek, text: o }: InspectorProps & { text: TextOverlay }) { const hook = o.kind === "hook"; const banner = o.style === "banner"; const total = outputDuration(project.cuts); const hk = hookOf(cfg); const font = o.font ?? (banner ? hk.font : "Arial Black"); // Updater puro: o patch é calculado aqui fora (o React em dev roda o updater duas vezes). const set = (patch: Partial, key: string) => onProject((p) => ({ ...p, overlays: p.overlays.map((x) => (x.id === o.id ? { ...x, ...patch } as TextOverlay : x)) }), `${key}-${o.id}`); /** Simples ↔ tarja. Na tarja entram a cor da tarja, a fonte e a animação do gancho padrão (se o texto ainda não tinha). */ const setStyle = (style: "plain" | "banner") => onProject((p) => ({ ...p, overlays: p.overlays.map((x) => { if (x.id !== o.id || (x.kind !== "hook" && x.kind !== "text")) return x; if (style === "plain") { const { style: _drop, ...rest } = x; return rest as TextOverlay; } return { ...x, style: "banner", bg: x.bg ?? hk.bg, font: x.font ?? hk.font, anim: x.anim === "pop" ? hk.anim : x.anim } as TextOverlay; }), })); /** Início do gancho/texto em tempo da sessão (para "Ver a entrada"). */ const startS = hook ? toSession(o.start, project.cuts) : o.start; return ( <>