primocode 10.0.0 → 10.1.0

package/lib/estudio/fluido.js

@@ -0,0 +1,283 @@
+/**
+ * fluido.js — o estilo FLUIDO: uma ideia por batida, muito respiro, e nada
+ * de corte. O elemento de uma batida VIRA o da próxima.
+ *
+ *   "Uma ideia por quadro, muito espaço vazio. Texto pequeno, caixa normal,
+ *    sans limpa. Movimento contínuo: um elemento se transforma no próximo."
+ *    — a referência de motion do Joel (05/10), os vídeos bons.
+ *
+ * Existe UMA forma que vive o vídeo inteiro (o "portador"): é o ponto da
+ * abertura, a pílula do título, o anel do número, a primeira pílula da lista,
+ * a linha que risca o "não", o cartão da citação e o primeiro círculo da
+ * marca no fim. Entre uma batida e outra ela muda de lugar, de tamanho, de
+ * raio e de preenchimento — o olho segue a forma, e o corte some.
+ *
+ * O texto entra palavra por palavra (stagger curto, ease-out forte, sem
+ * linear) e cada frase tem UM acento: uma palavra em serifa itálica na cor de
+ * acento. Fundo em gradiente grande e macio, de uma paleta curta (no máximo
+ * dois acentos e os neutros), clara ou escura.
+ *
+ * Proibido aqui, de propósito (é a lista do "cara de IA"): HUD, cantoneira,
+ * timecode, caixa na palavra-chave, neon, partícula e CAIXA ALTA.
+ *
+ * Puro: devolve a partitura (os testes olham) e o plano com UMA peça do kit
+ * (kit/fluido.jsx), que desenha a partitura quadro a quadro.
+ */
+
+'use strict';
+
+const { volumesDaTrilha } = require('./ritmo.js');
+
+const FPS = 30;
+const r2 = (n) => Math.round(n * 100) / 100;
+const POR_PALAVRA = 0.3, MINIMO = 0.8;   // o tempo de leitura: 0,3 s por palavra, nunca menos de 0,8 s
+const STAGGER = 0.07;                    // entre uma palavra e a próxima (a que a voz não diz)
+const ANTES = 0.12;                      // a batida troca isto antes da primeira palavra da frase
+
+/* As paletas: um fundo em três tons (o gradiente), a tinta, a tinta suave e
+   NO MÁXIMO dois acentos (o da palavra e o brilho difuso). */
+const PALETAS = {
+    noite: { escuro: true, fundo: ['#020615', '#061a5c', '#1240c9'], tinta: '#eef2ff', suave: '#9fb0d9', acentos: ['#8fb8ff', '#2f6bff'] },
+    breu: { escuro: true, fundo: ['#030304', '#0b0a12', '#2a2156'], tinta: '#f4f4f6', suave: '#8d8a9c', acentos: ['#b4a6ff', '#5b45ff'] },
+    lavanda: { escuro: false, fundo: ['#f5f4ff', '#e4e1ff', '#b9b2ff'], tinta: '#17153a', suave: '#6e6a92', acentos: ['#4a3ce0', '#8f86ff'] },
+    creme: { escuro: false, fundo: ['#fbf8f2', '#f2e8d8', '#e7c9a5'], tinta: '#1e1a15', suave: '#857a6c', acentos: ['#c2502a', '#f0a36b'] },
+};
+const ESCURAS = ['noite', 'breu'], CLARAS = ['lavanda', 'creme'];
+
+const hash = (s) => { let h = 2166136261; for (const c of String(s)) h = Math.imul(h ^ c.charCodeAt(0), 16777619); return h >>> 0; };
+
+/** A paleta: a pedida pelo nome; senão o tema (claro/escuro); senão a semente. */
+function paletaDe(roteiro, semente) {
+    const pedida = String(roteiro.paleta || '').toLowerCase();
+    const tema = String(roteiro.tema || '').toLowerCase();
+    const nome = PALETAS[pedida] ? pedida
+        : /claro|light/.test(tema) ? CLARAS[semente % 2]
+            : /escuro|dark/.test(tema) ? ESCURAS[semente % 2]
+                : Object.keys(PALETAS)[semente % 4];
+    const p = { nome, ...PALETAS[nome], acentos: [...PALETAS[nome].acentos] };
+    // A cor da marca vira o acento da palavra (e só ela: a paleta não cresce).
+    const dest = roteiro.marca && roteiro.marca.cores && roteiro.marca.cores.destaque;
+    if (/^#[0-9a-f]{6}$/i.test(dest || '')) p.acentos[0] = dest;
+    return p;
+}
+
+/* Caixa alta não entra: frase GRITADA vira caixa normal (sigla curta fica). */
+function caixaNormal(t) {
+    const s = String(t || '').trim();
+    const letras = s.replace(/[^A-Za-zÀ-ÿ]/g, '');
+    if (letras.length < 4 || letras !== letras.toUpperCase()) return s;
+    const m = s.toLowerCase();
+    return m.charAt(0).toUpperCase() + m.slice(1);
+}
+
+const VAZIAS = new Set('a o as os um uma de da do das dos e é em no na nos nas que com por para pra se seu sua você ao à mais muito isso este esta não sim'.split(' '));
+const limpa = (w) => w.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]/g, '');
+
+/** A frase em palavras, com UM acento: o destaque pedido, ou a palavra de mais peso. */
+function frase(texto, { destaque = '', semAcento = false } = {}) {
+    const ws = caixaNormal(texto).split(/\s+/).filter(Boolean);
+    let ac = -1;
+    if (!semAcento && ws.length > 1) {
+        const d = limpa(String(destaque).split(/\s+/)[0] || '');
+        if (d) ac = ws.findIndex((w) => limpa(w) === d);
+        if (ac < 0) {
+            // A palavra mais longa que não é vazia; no empate, a mais tarde (a frase termina nela).
+            let melhor = 0;
+            ws.forEach((w, i) => { const n = limpa(w).length; if (!VAZIAS.has(limpa(w)) && n >= 4 && n >= melhor) { melhor = n; ac = i; } });
+        }
+    }
+    return ws.map((t, i) => ({ t, acento: i === ac }));
+}
+
+const numeroDe = (v) => {
+    const m = String(v == null ? '' : v).match(/^(\D*)([\d.,]+)(.*)$/);
+    if (!m) return null;
+    const n = Number(m[2].replace(/\./g, '').replace(',', '.'));
+    return Number.isFinite(n) ? { antes: m[1], ate: n, depois: m[3], casas: /,\d/.test(m[2]) ? 1 : 0 } : null;
+};
+const itensDe = (p) => (p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
+const leitura = (n) => Math.max(MINIMO, POR_PALAVRA * n);
+
+/* A forma do portador em cada tipo de parte (kit/fluido.jsx dá o tamanho). */
+const FORMA = { abertura: 'ponto', titulo: 'pilula', numero: 'anel', lista: 'pilula', passos: 'ponto', contraste: 'linha', citacao: 'cartao', cta: 'marca' };
+const TIPO = { logo: 'abertura', imagem: 'titulo', produto: 'titulo', grafico: 'lista', cores: 'lista' };
+
+/**
+ * A partitura: as batidas, cada uma com as frases (e quando cada uma entra),
+ * a forma do portador e a transição. Sem áudio nem plano — é o que os testes olham.
+ */
+function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [] }) {
+    const partes = (roteiro.partes || []).filter((p) => p && typeof p === 'object');
+    const semente = Number.isFinite(roteiro.semente) ? roteiro.semente : hash(JSON.stringify(partes.map((p) => [p.tipo, p.titulo, p.valor])));
+    const paleta = paletaDe(roteiro, semente);
+    const marca = roteiro.marca || {};
+    const temVoz = tempos.length === partes.length && tempos.every((t) => t && t.ate > t.de);
+    /* O comando do terminal: o link da cta, se for comando; senão o nome da marca. */
+    const link = (partes.find((p) => p.tipo === 'cta') || {}).link || '';
+    const cmd = /^(npm|npx|pnpm|yarn|pip|brew|curl|git|bun)\b/.test(link) ? link : String(marca.nome || 'app').toLowerCase().replace(/\s+/g, '-');
+    let comCartao = 0;
+
+    const batidas = partes.map((p, i) => {
+        const tipo = TIPO[p.tipo] || (FORMA[p.tipo] ? p.tipo : 'titulo');
+        const titulo = p.titulo || p.texto || '';
+        const fr = [];
+        const poe = (papel, texto, o = {}) => { if (String(texto || '').trim()) fr.push({ id: `${i}-${fr.length}`, papel, palavras: frase(texto, o) }); };
+        const b = { i, tipo, forma: FORMA[tipo], transicao: p.corte === true && i > 0 ? 'corte' : 'morfa', frases: fr, lado: 'centro' };
+        /* O CARTÃO DE PRODUTO que flutua ao lado (terminal, chat, painel), feito
+           de forma e texto — e o texto vai para o outro lado. `ui: false` tira. */
+        const ui = p.ui === false ? null : typeof p.ui === 'string' ? p.ui
+            : tipo === 'titulo' || tipo === 'abertura' ? ['terminal', 'chat'][comCartao % 2] : tipo === 'numero' ? 'painel' : null;
+        if (ui) {
+            b.lado = comCartao++ % 2 ? 'dir' : 'esq';
+            b.ui = ui === 'terminal' ? { tipo: ui, linhas: ['$ ' + cmd, '✓ ' + caixaNormal(p.sub || titulo)] }
+                : ui === 'chat' ? { tipo: ui, pergunta: caixaNormal(titulo) }
+                    : { tipo: 'painel', rotulo: caixaNormal(p.rotulo || titulo), barras: [0, 1, 2, 3, 4, 5, 6].map((k) => r2(0.35 + ((semente >>> (k * 3)) % 7) / 10)) };
+        }
+        switch (tipo) {
+            case 'numero': {
+                b.numero = numeroDe(p.valor);
+                poe('numero', p.valor, { semAcento: true });
+                poe('rotulo', p.rotulo || titulo, { destaque: p.destaque });
+                break;
+            }
+            case 'lista': case 'passos':
+                poe('principal', titulo, { destaque: p.destaque });
+                itensDe(p).slice(0, tipo === 'passos' ? 6 : 4).forEach((it) => poe('item', it, { semAcento: true }));
+                break;
+            case 'contraste':
+                poe('nao', p.nao, { semAcento: true });
+                poe('sim', p.sim || titulo, { destaque: p.destaque });
+                break;
+            case 'citacao':
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('autor', p.autor ? `— ${p.autor}` : '', { semAcento: true });
+                break;
+            case 'cta':
+                b.marca = { nome: caixaNormal(marca.nome || titulo) };
+                poe('marca', b.marca.nome, { semAcento: true });
+                poe('principal', marca.nome ? titulo : '', { destaque: p.destaque });
+                poe('sub', p.link || p.sub, { semAcento: true });
+                break;
+            default:
+                poe('principal', titulo, { destaque: p.destaque });
+                poe('sub', p.sub, { semAcento: true });
+        }
+        return b;
+    });
+
+    /* ── o tempo: a VOZ manda. A batida troca na fronteira da frase (um
+       pouco antes da primeira palavra da parte) e cada palavra na tela
+       aparece no instante em que é dita (os tempos por palavra da narração).
+       A palavra que a voz não diz entra em cascata curta. Se o texto pede
+       mais leitura do que a frase deu, a batida estica e a próxima volta a
+       casar com a voz na primeira folga; o atraso medido vai na partitura. */
+    let atraso = 0, sincronia = 0;
+    batidas.forEach((b, i) => {
+        const tp = temVoz ? tempos[i] : null;
+        const deVoz = tp ? (i === 0 ? 0 : Math.max(0, tp.de - ANTES)) : null;
+        b.de = r2(i === 0 ? 0 : Math.max(batidas[i - 1].ate, deVoz == null ? 0 : deVoz));
+        if (deVoz != null) atraso = Math.max(atraso, r2(b.de - deVoz));
+        const ditas = ((tp && tp.palavras) || []).map((w) => ({ k: limpa(w.texto), de: w.de }));
+        let cursor = 0, livre = b.de + (b.tipo === 'cta' ? 0.55 : 0.12);
+        const fimVoz = tp ? (i < batidas.length - 1 ? tempos[i + 1].de - ANTES : tp.ate + 0.2) : 0;
+        for (const f of b.frases) {
+            /* Casa as palavras da tela com as faladas, na ordem. Tenta começar de
+               cada palavra (a frase da tela pode vir em outra ordem que a falada)
+               e fica com o casamento que acha mais palavras. */
+            const casa = (k, d) => d === k || (k.length >= 4 && d.length >= 4 && d.slice(0, 5) === k.slice(0, 5));
+            let ts = f.palavras.map(() => null), fim = cursor;
+            for (let ini = 0; ini < f.palavras.length; ini++) {
+                let c = cursor;
+                const tt = f.palavras.map((w, j) => {
+                    const k = limpa(w.t);
+                    if (j < ini || !k) return null;
+                    for (let q = c; q < Math.min(ditas.length, c + 12); q++) if (casa(k, ditas[q].k)) { c = q + 1; return ditas[q].de; }
+                    return null;
+                });
+                if (tt.filter((x) => x != null).length > ts.filter((x) => x != null).length) { ts = tt; fim = c; }
+            }
+            cursor = fim;
+            f.falada = ts.filter((x) => x != null).length >= f.palavras.length / 2;
+            const ach = ts.findIndex((x) => x != null);
+            /* O que a voz não diz entra cedo o bastante para ser lido antes de a
+               frase acabar (e nunca antes da batida). */
+            let t = ach >= 0 ? ts[ach] - ach * STAGGER
+                : tp ? Math.max(b.de + 0.25, Math.min(livre, fimVoz - leitura(f.palavras.length) - 0.05)) : livre;
+            f.palavras.forEach((w, j) => {
+                const falada = ts[j];
+                t = Math.max(b.de + 0.06, falada != null ? Math.max(t, falada - 0.05) : t);
+                w.em = r2(t);
+                if (falada != null) sincronia = Math.max(sincronia, r2(w.em - falada));
+                t += STAGGER;
+            });
+            f.de = f.palavras[0].em;
+            // O que não é dito (rótulo, item, link) entra logo depois do anterior.
+            livre = Math.max(livre, f.papel === 'item' && b.tipo === 'passos' ? f.de + leitura(f.palavras.length) * 0.8 : f.palavras[f.palavras.length - 1].em + 0.18);
+        }
+        /* O texto que a voz DIZ é lido junto com ela: fica até depois da última
+           palavra dita (e nunca menos de 0,8 s). O que a voz não diz pede 0,3 s por palavra. */
+        const precisa = Math.max(...b.frases.map((f) => f.de + (f.falada
+            ? Math.max(MINIMO, f.palavras[f.palavras.length - 1].em - f.de + 0.3) : leitura(f.palavras.length))), b.de + 0.9);
+        b.ate = r2(Math.max(precisa, fimVoz));
+    });
+    // A marca do fim segura um instante; o resto não espera.
+    const ult = batidas[batidas.length - 1];
+    ult.ate = r2(ult.ate + (ult.tipo === 'cta' ? 1.0 : 0.5));
+
+    return {
+        versao: 2, semente, fps: FPS, atraso, sincronia, largura, altura, duracao: ult.ate, paleta,
+        fontes: { texto: 'Inter', serifa: 'Instrument Serif', mono: 'JetBrains Mono' },
+        logo: marca.logo || null,
+        batidas,
+    };
+}
+
+/**
+ * @param {object} op
+ * @param {object} op.roteiro   { marca, paleta?: noite|breu|lavanda|creme, tema?: claro|escuro, partes }
+ * @param {Array}  op.tempos    [{de, ate, palavras}] por parte (da narração)
+ * @param {object} op.sons      os efeitos leves (sons-leves.js)
+ */
+function montarFluido({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null }) {
+    const partes = ((roteiro && roteiro.partes) || []).filter((p) => p && typeof p === 'object');
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const partitura = partituraDe({ roteiro: { ...roteiro, partes }, largura, altura, tempos });
+    const DUR = partitura.duracao;
+    /* O SOM segue o movimento (sons-leves.js, tudo sintetizado): whoosh em
+       cada transformação, pop quando pílula ou cartão assenta, clique na roda e
+       no terminal, um bolha discreto na palavra de acento, o riser que leva à
+       marca e o impacto quando ela trava. Baixo: a voz vem primeiro. */
+    const efeitos = [];
+    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
+    for (const b of partitura.batidas) {
+        if (b.i > 0 && b.tipo !== 'cta') som(b.de - 0.18, 'whoosh', 0.2);
+        if (b.ui) { som(b.de + 0.6, 'pop', 0.16); if (b.ui.tipo === 'terminal') b.ui.linhas.forEach((_, k) => som(b.de + 0.75 + k * 0.5, 'clique', 0.1)); }
+        for (const f of b.frases) {
+            if (f.papel === 'item') som(f.de - 0.06, b.tipo === 'passos' ? 'clique' : 'pop', 0.15);
+            const ac = f.palavras.find((w) => w.acento);
+            if (ac && f.papel !== 'item') som(ac.em, 'bolha', 0.09);
+        }
+        if (b.tipo === 'citacao') som(b.de + 0.3, 'pop', 0.14);
+        if (b.tipo === 'cta') { som(b.de - 0.75, 'riser', 0.2); som(b.de + 0.45, 'impacto', 0.26); som(b.de + 0.5, 'brilho', 0.16); }
+    }
+    const volumes = volumesDaTrilha(tempos.length === partes.length ? tempos : [], DUR, { alto: 0.55, baixo: 0.22 });
+    const P = partitura.paleta;
+    const plano = {
+        formato: { largura, altura, fps: FPS },
+        fundoGeral: P.fundo[0],
+        fontesVariaveis: { Inter: 'wght@300..700', 'Instrument Serif': 'ital@0;1', 'JetBrains Mono': 'wght@400;500' },
+        cenas: [{
+            duracao: DUR,
+            fundo: P.fundo[0],
+            elementos: [{ tipo: 'kit', peca: 'fluido', partitura, fonte: partitura.fontes.texto, fonteSerifa: partitura.fontes.serifa, fonteMono: partitura.fontes.mono }],
+        }],
+        audio: {
+            ...(narracao ? { narracao } : {}),
+            ...(trilha ? { trilha: { src: trilha, volumes, loop: true } } : {}),
+            efeitos,
+        },
+    };
+    return { ok: true, plano, partitura, resumo: { cenas: 1, batidas: partitura.batidas.length, segundos: DUR, fps: FPS, paleta: P.nome, atraso: partitura.atraso, sincronia: partitura.sincronia } };
+}
+
+module.exports = { montarFluido, partituraDe, caixaNormal, PALETAS, POR_PALAVRA, MINIMO };