primocode 9.10.0 → 10.0.9

package/lib/video/delta.js

@@ -0,0 +1,90 @@
+/**
+ * delta.js — toda edição devolve O QUE MUDOU, não o projeto inteiro.
+ *
+ * Um corte de silêncio num vídeo de três minutos mexe em quarenta clipes.
+ * Devolver a linha do tempo inteira a cada passo enche o contexto do modelo
+ * em cinco edições; devolver "sumiram estes, estes andaram 45 quadros para a
+ * esquerda" cabe numa linha.
+ *
+ * O delta sai da COMPARAÇÃO do antes com o depois, e não de cada operação
+ * anotando o que fez. É de propósito: uma operação que esquece de anotar um
+ * clipe deslocado mentiria para o modelo, e ele planejaria o passo seguinte
+ * em cima de um quadro errado. Comparando, o delta é certo por construção.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+
+const MAX_LISTA = 12;
+
+function indexar(tl) {
+    const m = new Map();
+    tl.tracks.forEach((t, i) => t.clips.forEach((c) => m.set(c.id, { c, t: i, tid: t.id || i })));
+    return m;
+}
+
+// O clipe sem posição: se só a posição mudou, é deslocamento, não mudança.
+function semPosicao(c) {
+    const { startFrame, ...resto } = c;
+    return JSON.stringify(resto);
+}
+
+function diff(antes, depois, extra = {}) {
+    const a = indexar(antes);
+    const d = indexar(depois);
+    const added = [];
+    const removed = [];
+    const changed = [];
+    const deslocados = new Map();   // por quanto andou → ids
+
+    for (const [id, x] of d) {
+        const y = a.get(id);
+        if (!y) { added.push(T.compacto(depois, x.c, x.t)); continue; }
+        const mesmaCoisa = semPosicao(y.c) === semPosicao(x.c);
+        if (mesmaCoisa && y.tid === x.tid && y.c.startFrame === x.c.startFrame) continue;
+        if (mesmaCoisa && y.tid === x.tid) {
+            const by = x.c.startFrame - y.c.startFrame;
+            if (!deslocados.has(by)) deslocados.set(by, []);
+            deslocados.get(by).push(id);
+            continue;
+        }
+        changed.push(camposMudados(antes, depois, y, x));
+    }
+    for (const id of a.keys()) if (!d.has(id)) removed.push(id);
+
+    const out = { ok: true };
+    // Cinquenta legendas novas não cabem num delta: as primeiras e a conta.
+    if (added.length) out.added = added.slice(0, MAX_LISTA);
+    if (added.length > MAX_LISTA) out.addedMore = added.length - MAX_LISTA;
+    if (removed.length) out.removed = removed;
+    if (changed.length) out.changed = changed.slice(0, MAX_LISTA);
+    if (changed.length > MAX_LISTA) out.changedMore = changed.length - MAX_LISTA;
+    if (deslocados.size) out.shifted = [...deslocados].map(([by, ids]) => ({ by, ids }));
+    if (antes.tracks.map((t) => t.id).join() !== depois.tracks.map((t) => t.id).join()) out.tracks = depois.tracks.map((t) => t.type);
+    const d0 = T.duracao(antes);
+    const d1 = T.duracao(depois);
+    out.dur = d1;
+    if (d0 !== d1) out.durWas = d0;
+    if (antes.markers.length !== depois.markers.length) out.markers = depois.markers.length;
+    const assetsNovos = Object.keys(depois.assets).filter((k) => !antes.assets[k]);
+    if (assetsNovos.length) out.assets = assetsNovos.map((k) => ({ id: k, nome: depois.assets[k].nome, s: T.r2(depois.assets[k].seconds || 0) }));
+    if (!added.length && !removed.length && !changed.length && !deslocados.size && !assetsNovos.length && out.markers === undefined) out.nada = true;
+    return { ...out, ...extra };
+}
+
+/** Só as chaves da vista compacta que mudaram (e o id). */
+function camposMudados(antes, depois, y, x) {
+    const va = T.compacto(antes, y.c, y.t);
+    const vd = T.compacto(depois, x.c, x.t);
+    const o = { id: x.c.id };
+    for (const k of new Set([...Object.keys(va), ...Object.keys(vd)])) {
+        if (k === 'id') continue;
+        if (JSON.stringify(va[k]) !== JSON.stringify(vd[k])) o[k] = vd[k] === undefined ? null : vd[k];
+    }
+    // Mudou algo que a vista compacta não mostra (estilo do texto, keyframe…).
+    if (Object.keys(o).length === 1) o.props = true;
+    return o;
+}
+
+module.exports = { diff };

package/lib/video/edits.js

@@ -0,0 +1,379 @@
+/**
+ * edits.js — as edições, como funções puras sobre o json da linha do tempo.
+ *
+ * Nada aqui toca disco nem ffmpeg: entra timeline, sai timeline mexida (ou
+ * um erro dizendo por quê). É isso que deixa o ripple ser testado em
+ * milissegundos, e é isso que deixa a edição ser atômica — quem salva é o
+ * ops.js, e só se a função inteira terminou sem erro.
+ *
+ * ── O RIPPLE ─────────────────────────────────────────────────────────────
+ * Apagar um trecho [a, b) da linha do tempo faz, em cada clipe das faixas
+ * afetadas, uma de cinco coisas: nada (está antes), andar b−a para a
+ * esquerda (está depois), sumir (está dentro), perder a ponta (cruza uma
+ * borda) ou virar dois (o trecho está no meio dele). Com vários trechos, a
+ * conta vai do ÚLTIMO para o primeiro: assim apagar um trecho nunca muda a
+ * posição dos que ainda faltam apagar.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+const { erro } = T;
+
+// ── adicionar ────────────────────────────────────────────────────────────
+
+/**
+ * Um clipe a partir do que o modelo manda. Mídia: `asset` (id), `from`/`to`
+ * em SEGUNDOS da origem ou `dur` em quadros. Posição: `at` em quadros
+ * (padrão: o fim da faixa).
+ */
+function montarClipe(tl, spec) {
+    const tipo = spec.type || (spec.asset ? (T.acharAsset(tl, spec.asset).kind) : null);
+    if (!tipo) throw erro('clipe sem "asset" nem "type"');
+    const base = { ...spec, type: tipo };
+    if (spec.asset) {
+        const a = T.acharAsset(tl, spec.asset);
+        base.asset = a.id;
+        if (tipo !== 'image') {
+            const de = Number(spec.from || 0);
+            const speed = Number(spec.speed || 1);
+            base.trimStartFrame = T.quadros(tl, de);
+            let dur = spec.dur !== undefined ? Number(spec.dur) : null;
+            if (dur === null) {
+                const ate = spec.to !== undefined ? Number(spec.to) : a.seconds;
+                if (!(ate > de)) throw erro(`"to" (${ate}) precisa ser maior que "from" (${de})`);
+                dur = Math.round(T.quadros(tl, ate - de) / speed);
+            }
+            base.durationFrames = dur;
+        } else {
+            base.durationFrames = spec.dur !== undefined ? Number(spec.dur) : tl.fps * 3;
+        }
+    } else {
+        base.durationFrames = spec.dur !== undefined ? Number(spec.dur) : tl.fps * 2;
+    }
+    delete base.id;
+    return T.clipe(tl, base);
+}
+
+/* Sem faixa pedida e com posição: a primeira faixa do tipo onde o clipe
+   CABE sem sobrepor (a da legenda fica de fora). Não coube, faixa nova. */
+function faixaLivre(tl, c, at) {
+    const tipo = c.type === 'image' ? 'video' : c.type;
+    const livre = tl.tracks.findIndex((t) => t.type === tipo && t.role !== 'captions'
+        && !t.clips.some((x) => x.startFrame < at + c.durationFrames && T.fim(x) > at));
+    return livre >= 0 ? livre : 'new';
+}
+
+function adicionar(tl, spec) {
+    const c = montarClipe(tl, spec);
+    const pedida = spec.track === undefined && spec.at !== undefined ? faixaLivre(tl, c, Math.round(Number(spec.at))) : spec.track;
+    const ti = T.faixaPara(tl, c.type, pedida);
+    const faixa = tl.tracks[ti];
+    c.startFrame = spec.at !== undefined ? Math.round(Number(spec.at))
+        : faixa.clips.reduce((m, x) => Math.max(m, T.fim(x)), 0);
+    faixa.clips.push(c);
+    T.ordenar(tl);
+    return c;
+}
+
+// ── dividir e cortar ─────────────────────────────────────────────────────
+
+/** A parte [ps, pe) (quadros da linha do tempo) de um clipe, como clipe novo. */
+function pedaco(tl, c, ps, pe, id) {
+    const o = ps - c.startFrame;
+    const p = T.clone(c);
+    p.id = id;
+    p.startFrame = ps;
+    p.durationFrames = pe - ps;
+    if (c.type !== 'image' && c.type !== 'text') p.trimStartFrame = c.trimStartFrame + Math.round(o * (c.speed || 1));
+    if (o > 0) p.fadeIn = 0;
+    if (pe < T.fim(c)) p.fadeOut = 0;
+    for (const prop of Object.keys(p.keyframes || {})) {
+        p.keyframes[prop] = p.keyframes[prop].map((k) => ({ ...k, frame: k.frame - o }));
+    }
+    if (p.text) {
+        p.text.words = (p.text.words || []).filter((w) => w.e > o && w.f < pe - c.startFrame)
+            .map((w) => ({ ...w, f: Math.max(0, w.f - o), e: Math.min(pe - ps, w.e - o) }));
+    }
+    return p;
+}
+
+/** Divide no quadro `at` da linha do tempo. Devolve [esquerda, direita]. */
+function dividir(tl, ref, at) {
+    const { clip: c, track } = T.achar(tl, ref);
+    const f = Math.round(Number(at));
+    if (!(f > c.startFrame && f < T.fim(c))) throw erro(`o quadro ${f} não está dentro de ${c.id} (${c.startFrame}-${T.fim(c)})`);
+    const esq = pedaco(tl, c, c.startFrame, f, c.id);
+    const dir = pedaco(tl, c, f, T.fim(c), T.novoId(tl));
+    const faixa = tl.tracks[track];
+    faixa.clips.splice(faixa.clips.indexOf(c), 1, esq, dir);
+    return [esq, dir];
+}
+
+/** O que sobra de um clipe depois de apagar [a, b), já na posição nova. */
+function cortar(tl, c, a, b) {
+    const s = c.startFrame;
+    const e = T.fim(c);
+    const tam = b - a;
+    if (e <= a) return [c];
+    if (s >= b) { c.startFrame -= tam; return [c]; }
+    if (s >= a && e <= b) return [];
+    const partes = [];
+    if (s < a) partes.push(pedaco(tl, c, s, a, c.id));
+    if (e > b) {
+        const dir = pedaco(tl, c, b, e, partes.length ? T.novoId(tl) : c.id);
+        dir.startFrame = b - tam;
+        partes.push(dir);
+    }
+    // Texto não vira dois: a legenda que cruza o corte só encolhe.
+    if (partes.length === 2 && c.type === 'text') {
+        const [esq, dir] = partes;
+        esq.durationFrames += dir.durationFrames;
+        esq.text.words = esq.text.words.concat(dir.text.words.map((w) => ({ ...w, f: w.f + (a - s), e: w.e + (a - s) })));
+        esq.fadeOut = c.fadeOut;
+        return [esq];
+    }
+    return partes;
+}
+
+/** Junta trechos que se tocam ou se cruzam, em ordem. */
+function juntar(ranges) {
+    const lista = ranges.map(([a, b]) => [Math.round(a), Math.round(b)]).filter(([a, b]) => b > a && b > 0)
+        .map(([a, b]) => [Math.max(0, a), b]).sort((x, y) => x[0] - y[0]);
+    const out = [];
+    for (const r of lista) {
+        const ult = out[out.length - 1];
+        if (ult && r[0] <= ult[1]) ult[1] = Math.max(ult[1], r[1]);
+        else out.push([...r]);
+    }
+    return out;
+}
+
+/**
+ * Apaga os trechos e fecha o buraco. `tracks`: quais faixas (índices);
+ * padrão todas — o que mantém legenda e música no lugar da fala.
+ */
+function apagarTrechos(tl, ranges, { tracks } = {}) {
+    const lista = juntar(ranges);
+    const alvo = tracks ? new Set(tracks.map(Number)) : null;
+    for (const [a, b] of [...lista].reverse()) {
+        tl.tracks.forEach((t, i) => {
+            if (alvo && !alvo.has(i)) return;
+            t.clips = t.clips.flatMap((c) => cortar(tl, c, a, b));
+        });
+    }
+    T.ordenar(tl);
+    return { ranges: lista, removedFrames: lista.reduce((s, [a, b]) => s + (b - a), 0) };
+}
+
+/** Abre um buraco de `tam` quadros em `at` (o insert com ripple). */
+function abrirEspaco(tl, at, tam, { tracks } = {}) {
+    const alvo = tracks ? new Set(tracks.map(Number)) : null;
+    tl.tracks.forEach((t, i) => {
+        if (alvo && !alvo.has(i)) return;
+        for (const c of [...t.clips]) {
+            if (c.startFrame < at && T.fim(c) > at && c.type !== 'text') dividir(tl, c.id, at);
+        }
+        for (const c of t.clips) {
+            if (c.startFrame >= at) c.startFrame += tam;
+            else if (T.fim(c) > at) c.durationFrames += tam;   // texto que cruza: estica
+        }
+    });
+    T.ordenar(tl);
+}
+
+function inserir(tl, spec) {
+    const at = Math.round(Number(spec.at || 0));
+    const c = montarClipe(tl, spec);
+    abrirEspaco(tl, at, c.durationFrames, { tracks: spec.rippleTracks });
+    return adicionar(tl, { ...spec, at, dur: c.durationFrames, from: spec.from, asset: spec.asset });
+}
+
+function mover(tl, ref, { to, track }) {
+    const { clip: c, track: de } = T.achar(tl, ref);
+    if (to !== undefined) c.startFrame = Math.max(0, Math.round(Number(to)));
+    if (track !== undefined && Number(track) !== de) {
+        const para = T.faixaPara(tl, c.type, track === 'new' ? 'new' : Number(track));
+        const origem = tl.tracks.find((t) => t.clips.includes(c));
+        origem.clips.splice(origem.clips.indexOf(c), 1);
+        tl.tracks[para].clips.push(c);
+    }
+    T.ordenar(tl);
+    return c;
+}
+
+function remover(tl, refs, { ripple = false } = {}) {
+    const alvos = refs.map((r) => T.achar(tl, r));
+    const trechos = alvos.map(({ clip }) => [clip.startFrame, T.fim(clip)]);
+    for (const { clip } of alvos) {
+        const t = tl.tracks.find((x) => x.clips.includes(clip));
+        t.clips.splice(t.clips.indexOf(clip), 1);
+    }
+    if (ripple) {
+        // Só fecha o buraco onde NENHUMA faixa tem mais nada no trecho.
+        const livres = trechos.filter(([a, b]) => !T.todosOsClipes(tl).some(({ clip }) => clip.startFrame < b && T.fim(clip) > a));
+        if (livres.length) apagarTrechos(tl, livres);
+    }
+    limparFaixasVazias(tl);
+}
+
+function limparFaixasVazias(tl) {
+    tl.tracks = tl.tracks.filter((t) => t.clips.length || t.fixa);
+}
+
+// ── palavras → trechos ───────────────────────────────────────────────────
+
+/**
+ * Os trechos (quadros) das palavras pedidas. `mapa` é a transcrição já na
+ * linha do tempo: [{i, f, e}]. Palavras vizinhas apagadas juntas levam a
+ * pausa entre elas; palavra solta leva só ela.
+ */
+function trechosDasPalavras(mapa, indices) {
+    const quer = new Set(indices.map(Number));
+    const achadas = mapa.filter((w) => quer.has(w.i)).sort((a, b) => a.f - b.f);
+    const faltou = [...quer].filter((i) => !mapa.some((w) => w.i === i));
+    const ranges = [];
+    let atual = null;
+    for (const w of achadas) {
+        if (atual && w.i === atual.ultimo + 1 && w.f - atual.b <= 30) { atual.b = Math.max(atual.b, w.e); atual.ultimo = w.i; continue; }
+        if (atual) ranges.push([atual.a, atual.b]);
+        atual = { a: w.f, b: w.e, ultimo: w.i };
+    }
+    if (atual) ranges.push([atual.a, atual.b]);
+    return { ranges, faltou };
+}
+
+// ── propriedades e keyframes ─────────────────────────────────────────────
+
+function propriedades(tl, refs, props) {
+    const out = [];
+    for (const r of refs) {
+        const { clip } = T.achar(tl, r);
+        if (props.speed !== undefined && clip.type !== 'text' && clip.type !== 'image') {
+            // Mudar a velocidade mantém o trecho da origem: a duração é que muda.
+            const origem = T.consumo(clip);
+            clip.speed = Number(props.speed);
+            clip.durationFrames = Math.max(1, Math.round(origem / clip.speed));
+        }
+        const { speed, ...resto } = props;
+        T.aplicarProps(clip, resto);
+        if (props.dur !== undefined) clip.durationFrames = Math.round(Number(props.dur));
+        out.push(clip.id);
+    }
+    T.ordenar(tl);
+    return out;
+}
+
+/** Keyframes em quadro DA LINHA DO TEMPO; guardados relativos ao clipe. */
+function keyframes(tl, ref, prop, keys) {
+    const { clip } = T.achar(tl, ref);
+    if (!T.PROPS_ANIMAVEIS.includes(prop)) throw erro(`"${prop}" não anima (use ${T.PROPS_ANIMAVEIS.join('/')})`);
+    const lista = (keys || []).map((k) => {
+        const interp = k.interp || 'ease';
+        if (!T.INTERP.includes(interp)) throw erro(`interp "${interp}" (use ${T.INTERP.join('/')})`);
+        return { frame: Math.round(Number(k.frame)) - clip.startFrame, value: Number(k.value), interp };
+    }).sort((a, b) => a.frame - b.frame);
+    if (lista.length) clip.keyframes[prop] = lista;
+    else delete clip.keyframes[prop];
+    return clip;
+}
+
+// ── layouts ──────────────────────────────────────────────────────────────
+
+const CANTOS = { pip_tl: [0, 0], pip_tr: [1, 0], pip_bl: [0, 1], pip_br: [1, 1] };
+const LAYOUTS = ['full', 'side_by_side', 'top_bottom', 'grid2x2', 'grid3x3', ...Object.keys(CANTOS)];
+
+function aspecto(tl, c) {
+    const a = c.asset && tl.assets[c.asset];
+    return a && a.width && a.height ? a.width / a.height : 16 / 9;
+}
+
+function layout(tl, nome, refs, { size = 0.34, margin = 0.04 } = {}) {
+    if (!LAYOUTS.includes(nome)) throw erro(`layout "${nome}" (use ${LAYOUTS.join('/')})`);
+    const alvos = refs.map((r) => T.achar(tl, r));
+    const caixa = (x, [cx, cy, w, h]) => { x.clip.transform = { ...x.clip.transform, cx, cy, w, h }; x.clip.fit = x.clip.fit === 'contain' ? 'contain' : 'cover'; };
+    const avisos = [];
+    if (nome === 'full') alvos.forEach((x) => caixa(x, [0.5, 0.5, 1, 1]));
+    if (nome === 'side_by_side') alvos.slice(0, 2).forEach((x, i) => caixa(x, [0.25 + i * 0.5, 0.5, 0.5, 1]));
+    if (nome === 'top_bottom') alvos.slice(0, 2).forEach((x, i) => caixa(x, [0.5, 0.25 + i * 0.5, 1, 0.5]));
+    if (nome.startsWith('grid')) {
+        const n = nome === 'grid2x2' ? 2 : 3;
+        alvos.slice(0, n * n).forEach((x, i) => caixa(x, [(i % n + 0.5) / n, (Math.floor(i / n) + 0.5) / n, 1 / n, 1 / n]));
+    }
+    if (CANTOS[nome]) {
+        if (alvos.length < 2) throw erro('pip precisa de dois clipes: [principal, janelinha]');
+        caixa(alvos[0], [0.5, 0.5, 1, 1]);
+        const [qx, qy] = CANTOS[nome];
+        const w = size;
+        const h = (w * tl.width) / (aspecto(tl, alvos[1].clip) * tl.height);
+        const mx = margin;
+        const my = (margin * tl.width) / tl.height;
+        caixa(alvos[1], [qx ? 1 - mx - w / 2 : mx + w / 2, qy ? 1 - my - h / 2 : my + h / 2, w, h]);
+        if (alvos[1].track > alvos[0].track) avisos.push(`a janelinha ${alvos[1].clip.id} está numa faixa ABAIXO de ${alvos[0].clip.id} e fica escondida: move {"id":"${alvos[1].clip.id}","track":"new"}`);
+    }
+    return avisos;
+}
+
+// ── textos e legendas ────────────────────────────────────────────────────
+
+function textos(tl, lista) {
+    return lista.map((t) => {
+        if (!t.content && !(t.words || []).length) throw erro('texto sem "content"');
+        const at = Math.round(Number(t.at || 0));
+        return adicionar(tl, {
+            type: 'text', track: t.track, at, dur: t.dur !== undefined ? t.dur : tl.fps * 2,
+            content: t.content, style: t.style, animation: t.animation || 'popIn',
+            transform: { cx: t.cx !== undefined ? t.cx : 0.5, cy: t.cy !== undefined ? t.cy : 0.5, w: t.w || 0.9, h: t.h || 0.2 },
+            fadeIn: t.fadeIn, fadeOut: t.fadeOut, words: t.words,
+        });
+    });
+}
+
+const fimDeFrase = (s) => /[.!?…,;:]$/.test(String(s || '').trim());
+
+/**
+ * As legendas a partir da transcrição JÁ na linha do tempo (`mapa`, depois
+ * dos cortes). Quebra em `maxWords`, em pontuação e em pausa; cada legenda
+ * guarda o tempo de cada palavra, para a animação acender a palavra dita.
+ */
+function legendas(tl, mapa, { maxWords = 3, animation = 'highlightPop', style = {}, cy = 0.72, w = 0.86, maxGap = 12 } = {}) {
+    // Refazer a legenda substitui a anterior, em vez de empilhar duas.
+    for (const t of tl.tracks) t.clips = t.clips.filter((c) => !c.caption);
+    limparFaixasVazias(tl);
+    const ws = [...mapa].sort((a, b) => a.f - b.f);
+    const grupos = [];
+    let g = [];
+    ws.forEach((p, k) => {
+        g.push(p);
+        const prox = ws[k + 1];
+        if (!prox || g.length >= maxWords || fimDeFrase(p.texto) || prox.f - p.e > maxGap) { grupos.push(g); g = []; }
+    });
+    const faixa = tl.tracks.findIndex((t) => t.type === 'text' && t.role === 'captions');
+    let ti = faixa;
+    if (ti < 0) { ti = T.faixaPara(tl, 'text', 'new'); tl.tracks[ti].role = 'captions'; }
+    const criados = [];
+    grupos.forEach((grupo, k) => {
+        const at = grupo[0].f;
+        const prox = grupos[k + 1];
+        // Pausa curta até a próxima: a legenda fica até ela entrar (sem piscar).
+        const fala = grupo[grupo.length - 1].e;
+        let ate = fala + 4;
+        if (prox) ate = prox[0].f - fala <= maxGap ? prox[0].f : Math.min(ate, prox[0].f);
+        const dur = Math.max(1, ate - at);
+        const c = T.clipe(tl, {
+            type: 'text', startFrame: at, durationFrames: dur, content: grupo.map((p) => p.texto).join(' '),
+            style, animation, transform: { cx: 0.5, cy, w, h: 0.16 },
+            words: grupo.map((p) => ({ t: p.texto, f: Math.max(0, p.f - at), e: Math.min(dur, p.e - at) })),
+        });
+        c.caption = true;
+        tl.tracks[ti].clips.push(c);
+        criados.push(c);
+    });
+    T.ordenar(tl);
+    return criados;
+}
+
+module.exports = {
+    LAYOUTS, montarClipe, adicionar, dividir, cortar, juntar, apagarTrechos, abrirEspaco, inserir,
+    mover, remover, trechosDasPalavras, propriedades, keyframes, layout, textos, legendas, limparFaixasVazias,
+};