primocode 9.10.0 → 10.0.9

package/lib/estudio/glifos.js

@@ -0,0 +1,215 @@
+/**
+ * glifos.js — as letras de uma palavra como VETOR de verdade: o contorno, as
+ * âncoras e as alças, lidos da própria fonte TrueType.
+ *
+ * A cena do brand reveal que mais vende "feito por designer" é a palavra
+ * enorme em contorno, com os quadradinhos das âncoras, as alças de bezier e o
+ * cursor passeando. Isso só convence com os pontos REAIS da letra — pontos
+ * inventados em cima de um <text> denunciam na hora. Então o PrimoCode lê a
+ * fonte: a tabela glyf de um .ttf guarda cada contorno como pontos na curva
+ * (âncoras) e fora dela (controles de quadrática, as alças).
+ *
+ * Zero dependência: um leitor de TrueType de ~150 linhas (cmap formatos 4 e
+ * 12, loca, glyf simples e composto, hmtx). A fonte vem do Google Fonts
+ * (a API antiga devolve .ttf) e fica em cache; sem rede, `palavra()` devolve
+ * null e a peça "vetor" desenha o contorno do próprio texto, sem alças.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// ── o leitor ─────────────────────────────────────────────────────────────
+function tabelas(buf) {
+    const n = buf.readUInt16BE(4);
+    const t = {};
+    for (let i = 0; i < n; i++) {
+        const o = 12 + i * 16;
+        t[buf.toString('latin1', o, o + 4)] = { off: buf.readUInt32BE(o + 8), len: buf.readUInt32BE(o + 12) };
+    }
+    return t;
+}
+
+/** Caractere → índice do glifo (cmap 3/10 formato 12, ou 3/1 e 0/x formato 4). */
+function mapaDeCaracteres(buf, cmap) {
+    const n = buf.readUInt16BE(cmap.off + 2);
+    const subs = [];
+    for (let i = 0; i < n; i++) {
+        const o = cmap.off + 4 + i * 8;
+        subs.push({ plat: buf.readUInt16BE(o), enc: buf.readUInt16BE(o + 2), off: cmap.off + buf.readUInt32BE(o + 4) });
+    }
+    subs.sort((a, b) => buf.readUInt16BE(b.off) - buf.readUInt16BE(a.off));   // o formato 12 primeiro
+    for (const s of subs) {
+        const fmt = buf.readUInt16BE(s.off);
+        if (fmt === 12) {
+            const grupos = buf.readUInt32BE(s.off + 12);
+            return (cp) => {
+                for (let g = 0; g < grupos; g++) {
+                    const o = s.off + 16 + g * 12;
+                    const ini = buf.readUInt32BE(o), fim = buf.readUInt32BE(o + 4);
+                    if (cp >= ini && cp <= fim) return buf.readUInt32BE(o + 8) + (cp - ini);
+                }
+                return 0;
+            };
+        }
+        if (fmt === 4) {
+            const segs = buf.readUInt16BE(s.off + 6) / 2;
+            const fins = s.off + 14, inis = fins + segs * 2 + 2, deltas = inis + segs * 2, ranges = deltas + segs * 2;
+            return (cp) => {
+                for (let i = 0; i < segs; i++) {
+                    const fim = buf.readUInt16BE(fins + i * 2);
+                    if (cp > fim) continue;
+                    const ini = buf.readUInt16BE(inis + i * 2);
+                    if (cp < ini) return 0;
+                    const delta = buf.readInt16BE(deltas + i * 2), ro = buf.readUInt16BE(ranges + i * 2);
+                    if (!ro) return (cp + delta) & 0xffff;
+                    const g = buf.readUInt16BE(ranges + i * 2 + ro + (cp - ini) * 2);
+                    return g ? (g + delta) & 0xffff : 0;
+                }
+                return 0;
+            };
+        }
+    }
+    return () => 0;
+}
+
+/** Os contornos de um glifo: [[{x, y, on}]], já com os componentes do composto. */
+function contornos(f, gid, profundidade = 0) {
+    const a = f.loca(gid), b = f.loca(gid + 1);
+    if (b <= a || profundidade > 4) return [];
+    const buf = f.buf, o = f.glyf + a;
+    const nc = buf.readInt16BE(o);
+    if (nc < 0) {
+        // Composto: cada componente é outro glifo, deslocado (e às vezes escalado).
+        const saida = [];
+        let p = o + 10, flags;
+        do {
+            flags = buf.readUInt16BE(p); const g = buf.readUInt16BE(p + 2); p += 4;
+            let dx, dy;
+            if (flags & 1) { dx = buf.readInt16BE(p); dy = buf.readInt16BE(p + 2); p += 4; } else { dx = buf.readInt8(p); dy = buf.readInt8(p + 1); p += 2; }
+            let sx = 1, sy = 1;
+            if (flags & 8) { sx = sy = buf.readInt16BE(p) / 16384; p += 2; }
+            else if (flags & 0x40) { sx = buf.readInt16BE(p) / 16384; sy = buf.readInt16BE(p + 2) / 16384; p += 4; }
+            else if (flags & 0x80) { sx = buf.readInt16BE(p) / 16384; sy = buf.readInt16BE(p + 6) / 16384; p += 8; }
+            if (!(flags & 2)) { dx = 0; dy = 0; }   // pontos casados em vez de deslocamento: raro em fonte do Google
+            for (const c of contornos(f, g, profundidade + 1)) saida.push(c.map((q) => ({ x: q.x * sx + dx, y: q.y * sy + dy, on: q.on })));
+        } while (flags & 0x20);
+        return saida;
+    }
+    const fins = [];
+    for (let i = 0; i < nc; i++) fins.push(buf.readUInt16BE(o + 10 + i * 2));
+    const n = nc ? fins[nc - 1] + 1 : 0;
+    let p = o + 10 + nc * 2;
+    p += 2 + buf.readUInt16BE(p);                  // pula as instruções
+    const fl = [];
+    while (fl.length < n) {
+        const f0 = buf.readUInt8(p++); fl.push(f0);
+        if (f0 & 8) { let r = buf.readUInt8(p++); while (r-- > 0) fl.push(f0); }
+    }
+    const coord = (curto, igual) => {
+        const v = []; let atual = 0;
+        for (let i = 0; i < n; i++) {
+            const q = fl[i];
+            if (q & curto) { const d = buf.readUInt8(p++); atual += q & igual ? d : -d; }
+            else if (!(q & igual)) { atual += buf.readInt16BE(p); p += 2; }
+            v.push(atual);
+        }
+        return v;
+    };
+    const xs = coord(2, 16), ys = coord(4, 32);
+    const saida = [];
+    let ini = 0;
+    for (const fim of fins) {
+        const c = [];
+        for (let i = ini; i <= fim; i++) c.push({ x: xs[i], y: ys[i], on: Boolean(fl[i] & 1) });
+        saida.push(c);
+        ini = fim + 1;
+    }
+    return saida;
+}
+
+function abrirFonte(buf) {
+    const t = tabelas(buf);
+    if (!t.glyf || !t.loca || !t.head || !t.cmap || !t.hmtx || !t.hhea) throw new Error('não é uma fonte TrueType com contornos (glyf)');
+    const longo = buf.readInt16BE(t.head.off + 50) === 1;
+    const nMetr = buf.readUInt16BE(t.hhea.off + 34);
+    return {
+        buf, glyf: t.glyf.off,
+        porEm: buf.readUInt16BE(t.head.off + 18),
+        loca: (i) => (longo ? buf.readUInt32BE(t.loca.off + i * 4) : buf.readUInt16BE(t.loca.off + i * 2) * 2),
+        avanco: (g) => buf.readUInt16BE(t.hmtx.off + Math.min(g, nMetr - 1) * 4),
+        glifo: mapaDeCaracteres(buf, t.cmap),
+    };
+}
+
+const r1 = (n) => Math.round(n * 10) / 10;
+
+/**
+ * A palavra desenhada: {d, pontos: [[x, y, naCurva, contorno]], caixa: [x, y, w, h]}.
+ * Coordenadas em unidades da fonte, com y para baixo (como no SVG).
+ */
+function desenhar(buf, texto, { espacamento = 0 } = {}) {
+    const f = abrirFonte(buf);
+    let x = 0, nC = 0;
+    const d = [], pontos = [];
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const ch of String(texto)) {
+        const g = f.glifo(ch.codePointAt(0));
+        for (const c of contornos(f, g)) {
+            if (c.length < 2) continue;
+            const P = c.map((q) => ({ x: r1(q.x + x), y: r1(-q.y), on: q.on }));
+            for (const q of P) {
+                pontos.push([q.x, q.y, q.on ? 1 : 0, nC]);
+                if (q.x < minX) minX = q.x; if (q.x > maxX) maxX = q.x; if (q.y < minY) minY = q.y; if (q.y > maxY) maxY = q.y;
+            }
+            // Quadrática com pontos implícitos: entre dois controles seguidos mora uma âncora no meio.
+            let k0 = P.findIndex((q) => q.on);
+            let inicio = k0 >= 0 ? P[k0] : { x: r1((P[0].x + P[1].x) / 2), y: r1((P[0].y + P[1].y) / 2), on: true };
+            if (k0 < 0) k0 = 0;
+            const seg = [`M ${inicio.x} ${inicio.y}`];
+            let ctrl = null;
+            for (let j = 1; j <= P.length; j++) {
+                const q = P[(k0 + j) % P.length];
+                if (q.on) { seg.push(ctrl ? `Q ${ctrl.x} ${ctrl.y} ${q.x} ${q.y}` : `L ${q.x} ${q.y}`); ctrl = null; }
+                else if (ctrl) { const m = { x: r1((ctrl.x + q.x) / 2), y: r1((ctrl.y + q.y) / 2) }; seg.push(`Q ${ctrl.x} ${ctrl.y} ${m.x} ${m.y}`); ctrl = q; }
+                else ctrl = q;
+            }
+            if (ctrl) seg.push(`Q ${ctrl.x} ${ctrl.y} ${inicio.x} ${inicio.y}`);
+            d.push(seg.join(' ') + ' Z');
+            nC++;
+        }
+        x += f.avanco(g) + espacamento * f.porEm;
+    }
+    if (!pontos.length) return null;
+    return { d: d.join(' '), pontos, caixa: [r1(minX), r1(minY), r1(maxX - minX), r1(maxY - minY)], porEm: f.porEm };
+}
+
+// ── a fonte, do Google Fonts para o cache ────────────────────────────────
+const CACHE = path.join(os.homedir(), '.primocode', 'studio', 'cache-fontes');
+
+async function baixarFonte(familia, peso = 700) {
+    const nome = String(familia).replace(/[^a-z0-9]+/gi, '-').toLowerCase() + '-' + peso + '.ttf';
+    const arq = path.join(CACHE, nome);
+    if (fs.existsSync(arq)) return arq;
+    // A API antiga (css, não css2) devolve .ttf; a nova devolve woff2, que não tem a glyf crua.
+    const css = await (await fetch('https://fonts.googleapis.com/css?family=' + encodeURIComponent(familia) + ':' + peso, { signal: AbortSignal.timeout(10000) })).text();
+    const url = (css.match(/url\((https:[^)]+\.ttf)\)/) || [])[1];
+    if (!url) return null;
+    const bin = Buffer.from(await (await fetch(url, { signal: AbortSignal.timeout(15000) })).arrayBuffer());
+    fs.mkdirSync(CACHE, { recursive: true });
+    fs.writeFileSync(arq, bin);
+    return arq;
+}
+
+/** A palavra em vetor na fonte da marca, ou null (sem rede, fonte sem glyf, palavra vazia). */
+async function palavra(texto, { fonte = 'Plus Jakarta Sans', peso = 700 } = {}) {
+    if (!String(texto || '').trim()) return null;
+    try {
+        const arq = await baixarFonte(fonte, peso);
+        return arq ? desenhar(fs.readFileSync(arq), texto) : null;
+    } catch { return null; }
+}
+
+module.exports = { palavra, desenhar, abrirFonte, baixarFonte, CACHE };

package/lib/estudio/hibrido.js

@@ -0,0 +1,165 @@
+/**
+ * hibrido.js — o cinema com o kit por cima: foto real que não para, e o
+ * motion que parece feito à mão.
+ *
+ *   "Deve funcionar como um mix da versão antiga (o reels da imersão) e a
+ *    última versão — trabalhar juntas, absurdas, coisas que nem parece que
+ *    foi IA que fez." (29/09)
+ *
+ * O que cada lado traz:
+ *   do cinema (cinema.js)  foto e vídeo REAIS ocupando a tela, escurecidos,
+ *                          trocando por baixo do mesmo texto; letra grossa em
+ *                          caixa alta com a palavra da tese no gradiente; o
+ *                          número que conta; a virada que bate no fundo; a
+ *                          marca só no fim.
+ *   do kit (kit/*.jsx)     a câmera que empurra e desliza em toda cena; a
+ *                          etiqueta da fonte que se digita; partículas no
+ *                          número e no fim; o HUD de motion designer; o
+ *                          líquido entre blocos; grão e vinheta.
+ *
+ * Três passos, e nenhum repete o que o cinema já faz:
+ *   traduzir(roteiro)      qualquer roteiro (vox, motion, composição) vira os
+ *                          tipos do cinema; o que o cinema não usa (a fonte, o
+ *                          destaque) fica guardado por parte.
+ *   termosDeBusca(roteiro) o que procurar de b-roll para cada parte.
+ *   enfeitar(plano, …)     o kit por cima do plano que o cinema montou.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const k = (t, v, e) => (e ? { t: r2(t), v, e } : { t: r2(t), v });
+const limpo = (x) => String(x || '').replace(/\s+/g, ' ').trim();
+
+/* O b-roll quando a parte não diz o que procurar. Genérico de propósito: é o
+   fundo que se move, não a prova — a prova é o texto e a foto da marca. */
+const BUSCA_PADRAO = ['technology abstract light', 'people working on laptop', 'hands typing keyboard close up',
+    'data center servers', 'city night timelapse', 'team meeting office', 'developer code screen', 'futuristic digital network'];
+
+/** O roteiro de qualquer estilo → o roteiro do cinema. Devolve {roteiro, extras}. */
+function traduzir(roteiro) {
+    const partes = (roteiro && roteiro.partes) || [];
+    const saida = [];
+    const extras = [];
+    // A virada: a parte marcada com climax, ou o último contraste antes do fim.
+    let iClimax = partes.findIndex((p) => p.climax);
+    if (iClimax < 0) {
+        for (let i = partes.length - 2; i > 0; i--) if (partes[i].tipo === 'contraste') { iClimax = i; break; }
+    }
+    partes.forEach((p, i) => {
+        const tipo = p.tipo || 'frase';
+        const marcar = [p.destaque, ...(p.marcar || [])].filter(Boolean);
+        const base = { fala: p.fala, ...(p.mudo ? { mudo: true } : {}), ...(p.falaForte ? { falaForte: p.falaForte } : {}), marcar };
+        let q;
+        // Os tipos que o cinema já conhece passam como estão.
+        if (['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'].includes(tipo)) q = { ...p };
+        else if (i === iClimax) q = { tipo: 'climax', linhas: [p.nao, p.sim].filter(Boolean).map(limpo), ...base };
+        // A abertura é o título, grande; o subtítulo vira a etiqueta digitada (a fonte).
+        else if (tipo === 'abertura') q = { tipo: 'montagem', linhas: [limpo(p.titulo)], ritmo: 0.6, ...base };
+        else if (tipo === 'titulo' || tipo === 'imagem') q = { tipo: 'montagem', linhas: [p.titulo || p.texto, p.sub].filter(Boolean).map(limpo), ...base };
+        else if (tipo === 'numero' || tipo === 'grafico') {
+            // "30% mais rápido": o cinema conta o número e escreve o resto embaixo.
+            q = { tipo: 'numeros', itens: [limpo(`${p.valor || ''} ${p.rotulo || p.titulo || ''}`)], ...base };
+        } else if (tipo === 'passos' || tipo === 'lista') {
+            /* Na escada, o item é o NOME ("Sonnet 4"); a data e o detalhe depois do
+               "·" ou do "—" estão na fala. Cinco itens de cinco palavras eram 7 s
+               de escada pela regra de 0,3 s por palavra. */
+            const itens = (p.itens || []).map((x) => limpo(typeof x === 'string' ? x : (x.titulo || x.texto || '')).split(/\s+[·—–-]\s+/)[0]).filter(Boolean);
+            q = { tipo: 'escada', itens: itens.slice(0, 5), ...(p.titulo ? { final: limpo(p.titulo) } : {}), ...base };
+        } else if (tipo === 'citacao') q = { tipo: 'frase', linhas: [`“${limpo(p.texto)}”`], ...base };
+        else if (tipo === 'contraste') q = { tipo: 'montagem', linhas: [p.nao, p.sim].filter(Boolean).map(limpo), ...base };
+        else if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') q = { tipo: 'final', linhas: [p.titulo || p.texto, p.link].filter(Boolean).map(limpo), ...base };
+        else q = { tipo: 'montagem', linhas: [p.titulo || p.texto || p.fala].filter(Boolean).map(limpo), ...base };
+        saida.push(q);
+        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '' });
+    });
+    return { roteiro: { ...roteiro, partes: saida, estilo: 'hibrido' }, extras };
+}
+
+/** O que procurar de b-roll para cada parte: a busca dela, a do roteiro, ou o padrão. */
+function termosDeBusca(roteiro, extras = []) {
+    const global = [].concat(roteiro.busca || []).filter(Boolean);
+    // Escopo fechado: só os termos da pessoa, nunca o padrão genérico.
+    const fechado = require('./referencias.js').atual().modo === 'fechado';
+    const lista = global.length ? global : fechado ? [] : BUSCA_PADRAO;
+    const termos = new Set();
+    (roteiro.partes || []).forEach((p, i) => {
+        const b = (extras[i] && extras[i].busca) || p.busca;
+        if (b) termos.add(String(b));
+    });
+    for (const t of lista) termos.add(t);
+    return [...termos].slice(0, 8);
+}
+
+/* A câmera de cada cena do cinema: empurra e desliza, alternando o lado. A
+   foto já se move por dentro (os movimentos do cinema); a câmera move o
+   CONJUNTO — é a soma dos dois que dá a profundidade. */
+function camera(d, i, deitado, forte) {
+    const lado = i % 2 ? 1 : -1;
+    const z = forte ? 1.14 : 1.07;
+    const desliza = (deitado ? 26 : 18);
+    return {
+        zoom: [k(0, 1.0), k(Math.max(0.3, d - 0.25), z, 'camera'), k(d, z + 0.04, 'acelera')],
+        x: [k(0, -lado * desliza), k(d, lado * desliza, 'camera')],
+        rotacao: [k(0, -lado * 0.35), k(d, lado * 0.35, 'camera')],
+    };
+}
+
+/** O kit por cima do plano do cinema. Mexe no plano recebido e o devolve. */
+function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura } = {}) {
+    if (!plano || !Array.isArray(plano.cenas)) return plano;
+    const W = largura || (plano.formato && plano.formato.largura) || 1920;
+    const H = altura || (plano.formato && plano.formato.altura) || 1080;
+    const deitado = W >= H;
+    const base = Math.min(W, H);
+    const M = Math.round(base * 0.08);
+    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : ['#2E81ED', '#9567DB'];
+    const ACENTO = (marca.cores && marca.cores.destaque) || grad[1];
+
+    /* As cenas do cinema não são uma por parte: o depoimento com três clipes
+       vira três cenas. O mapa cena → parte sai das partes já traduzidas. */
+    const parteDaCena = [];
+    partes.forEach((p, i) => {
+        const n = p.tipo === 'depoimento' ? Math.max(1, (p.clipes || []).length) : 1;
+        for (let q = 0; q < n; q++) parteDaCena.push(i);
+    });
+    plano.cenas.forEach((cena, c) => {
+        const iParte = parteDaCena[c] != null ? parteDaCena[c] : c;
+        const ex = extras[iParte] || {};
+        const d = cena.duracao || 2;
+        const tipo = ex.tipoOriginal || '';
+        const els = cena.elementos || (cena.elementos = []);
+        const forte = tipo === 'numero' || tipo === 'contraste' || tipo === 'abertura';
+        if (!cena.camera) cena.camera = camera(d, c, deitado, forte);
+
+        // A FONTE que se digita, com a barra do acento: vira prova, não enfeite.
+        if (ex.fonte && d > 1.4) {
+            els.push({ tipo: 'kit', peca: 'fonte', texto: String(ex.fonte).slice(0, 48), t: Math.min(0.9, d * 0.35),
+                x: M, y: Math.round(H - M * (deitado ? 1.1 : 2.6)), tamanho: Math.round(base * 0.016), cor: 'rgba(245,245,247,0.72)', corAcento: ACENTO });
+        }
+        // O NÚMERO estoura em partículas quando assenta.
+        if (tipo === 'numero' || tipo === 'grafico') {
+            els.push({ tipo: 'kit', peca: 'particulas', t: 0.45, x: Math.round(W / 2), y: Math.round(H * 0.42), raio: Math.round(base * 0.34), n: 46,
+                tamanho: Math.max(5, Math.round(base * 0.007)), cores: ['#ffffff', ACENTO, grad[0]] });
+        }
+        // O FIM: a marca entra com um brilho de partículas.
+        if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') {
+            els.push({ tipo: 'kit', peca: 'particulas', t: 0.2, x: Math.round(W / 2), y: Math.round(H * 0.36), raio: Math.round(base * 0.45), n: 60,
+                tamanho: Math.max(4, Math.round(base * 0.006)), cores: ['#ffffff', ACENTO], forma: 'circulo' });
+        }
+        /* O LÍQUIDO entre blocos: a cada três partes a passagem é a mancha que
+           cobre a tela, não o esmaecer. Mais que isso vira truque. */
+        if (c > 0 && iParte % 3 === 0 && cena.transicao && cena.transicao.tipo !== 'corte' && tipo !== 'cta') {
+            cena.transicao = { tipo: 'liquido', duracao: 0.5, cor: ACENTO };
+        }
+    });
+
+    // O HUD de motion designer: cantos, timecode e a marca.
+    plano.hud = plano.hud || { marca: String(marca.nome || '').toUpperCase().slice(0, 24) || undefined };
+    // O acabamento de filme um pouco mais presente que o do cinema.
+    plano.acabamento = { ...(plano.acabamento || {}), grao: Math.max(0.06, (plano.acabamento || {}).grao || 0), vinheta: Math.max(0.55, (plano.acabamento || {}).vinheta || 0) };
+    plano.estilo = 'hibrido';
+    return plano;
+}
+
+module.exports = { traduzir, termosDeBusca, enfeitar, BUSCA_PADRAO };