primocode 8.42.2 → 9.0.0

package/lib/estudio/assets.js

@@ -0,0 +1,343 @@
+/**
+ * assets.js — de onde vêm os ícones, as imagens, o som e as fontes.
+ *
+ *   "Ícones: trocar a fonte de ícones atual, que está genérica demais.
+ *    Integrar uma biblioteca de ícones boa e autêntica. Imagens: buscar
+ *    imagens e PNGs na internet, remover fundo quando necessário. Trilha e
+ *    efeitos sonoros buscados na internet, não apenas os que já existem."
+ *
+ * ── O QUE HAVIA ──────────────────────────────────────────────────────────
+ * Um `icones.js` de 120 linhas com uns poucos desenhos feitos à mão, e nada
+ * mais: sem imagem, sem som, sem fonte além das seis embutidas no pacote. O
+ * resultado é o que foi descrito — genérico, porque o repertório inteiro
+ * cabia num arquivo de 120 linhas.
+ *
+ * ── POR QUE ESTAS FONTES, E NÃO PEXELS/FREESOUND ─────────────────────────
+ * As três usadas aqui funcionam SEM CHAVE NENHUMA, e isso não é detalhe: o
+ * produto promete que a pessoa instala e usa. Um estúdio que só busca imagem
+ * depois de a pessoa criar conta em dois serviços é um estúdio que não busca
+ * imagem.
+ *
+ *   · Iconify — mais de 200 mil ícones de 150 coleções (Lucide, Phosphor,
+ *     Material, Simple Icons com as marcas). Um SVG por requisição, sem
+ *     cadastro. É o fim do pacote genérico.
+ *   · Openverse — imagem e áudio com licença aberta, de Flickr, Wikimedia,
+ *     Freesound e outros, com a atribuição junto. Sem cadastro.
+ *   · Google Fonts — o leque de fontes, sem cadastro.
+ *
+ * Pexels e Freesound entram por cima QUANDO houver chave (PEXELS_API_KEY,
+ * FREESOUND_API_KEY): a qualidade de foto do Pexels é melhor. Sem a chave, o
+ * Openverse atende — em vez de o estúdio não atender.
+ *
+ * ── A LICENÇA VAI JUNTO, SEMPRE ──────────────────────────────────────────
+ * Toda mídia baixada guarda um `.licenca.json` ao lado, com autor, licença e
+ * de onde veio. Não é burocracia: material aberto quase sempre exige crédito,
+ * e descobrir isso depois de publicar o vídeo é tarde. Com o arquivo ao lado,
+ * o agente consegue montar os créditos sem adivinhar.
+ *
+ * ── NADA DISSO ENTRA NO RENDER PELA REDE ─────────────────────────────────
+ * Tudo é BAIXADO para a pasta do projeto antes. Render que busca imagem na
+ * internet falha no meio, depois de vinte minutos de trabalho — e falha de
+ * novo amanhã, quando o link morrer.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { URL } = require('url');
+
+const PRAZO = 20000;
+
+function pegar(url, { json = false, binario = false, cabecalhos = {} } = {}) {
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const req = https.get({
+            hostname: u.hostname,
+            path: u.pathname + u.search,
+            headers: {
+                // O Openverse recusa quem não se identifica, e com razão.
+                'User-Agent': 'PrimoCode-Studio/1.0 (+https://github.com/ConectaPrimoAI/primocode)',
+                Accept: json ? 'application/json' : '*/*',
+                ...cabecalhos,
+            },
+        }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return resolve(pegar(new URL(res.headers.location, url).toString(), { json, binario, cabecalhos }));
+            }
+            if (res.statusCode >= 400) {
+                res.resume();
+                return reject(new Error(`HTTP ${res.statusCode} em ${u.hostname}`));
+            }
+            const pedacos = [];
+            res.on('data', (d) => pedacos.push(d));
+            res.on('end', () => {
+                const corpo = Buffer.concat(pedacos);
+                if (binario) return resolve(corpo);
+                const texto = corpo.toString('utf8');
+                if (!json) return resolve(texto);
+                try { resolve(JSON.parse(texto)); }
+                catch { reject(new Error('resposta não era JSON')); }
+            });
+        });
+        const relogio = setTimeout(() => req.destroy(new Error('a busca demorou demais')), PRAZO);
+        if (relogio.unref) relogio.unref();
+        req.on('close', () => clearTimeout(relogio));
+        req.on('error', reject);
+    });
+}
+
+function guardar(arquivo, dados, licenca) {
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    fs.writeFileSync(arquivo, dados);
+    if (licenca) {
+        fs.writeFileSync(arquivo + '.licenca.json', JSON.stringify(licenca, null, 2), 'utf8');
+    }
+    return arquivo;
+}
+
+// ── ícones ───────────────────────────────────────────────────────────────
+
+/* As coleções que valem a pena, na ordem em que costumam servir. Não é uma
+   lista fechada: qualquer coleção do Iconify funciona, isto é só o que o
+   agente vê quando não sabe o que pedir. */
+const COLECOES = [
+    ['lucide', 'traço limpo e moderno, o padrão para interface'],
+    ['phosphor', 'traço com peso ajustável, boa para destaque'],
+    ['solar', 'cheios e arredondados, bons em tamanho grande'],
+    ['tabler', 'traço fino e técnico'],
+    ['material-symbols', 'os do Google, para produto Android/web'],
+    ['simple-icons', 'as MARCAS — pix, whatsapp, spotify, github'],
+    ['fluent-emoji-flat', 'emoji desenhado, quando o assunto pede leveza'],
+    ['game-icons', 'ilustrativos, para assunto fora do corporativo'],
+];
+
+/**
+ * Baixa um ícone e devolve o SVG.
+ *
+ * O SVG vem com `currentColor` no traço para a cor ser decidida na cena — um
+ * ícone com cor cravada no arquivo obriga a baixar de novo para mudar de cor.
+ */
+async function icone(nome, { pasta = null } = {}) {
+    const m = String(nome || '').match(/^([a-z0-9-]+):([a-z0-9-]+)$/i);
+    if (!m) return { ok: false, error: 'o ícone é "coleção:nome", como "lucide:zap"' };
+    const url = `https://api.iconify.design/${m[1]}/${m[2]}.svg?color=currentColor`;
+    try {
+        const svg = await pegar(url);
+        if (!/^<svg/i.test(svg.trim())) {
+            return { ok: false, error: `"${nome}" não existe. Procure com estudio_icones.` };
+        }
+        if (pasta) guardar(path.join(pasta, 'midia', 'icones', `${m[1]}-${m[2]}.svg`), svg);
+        return { ok: true, nome, svg };
+    } catch (e) {
+        return { ok: false, error: `não deu para baixar o ícone: ${e.message}` };
+    }
+}
+
+/** Procura ícones por palavra, em todas as coleções. */
+async function procurarIcones(termo, { limite = 24 } = {}) {
+    try {
+        const r = await pegar(
+            `https://api.iconify.design/search?query=${encodeURIComponent(termo)}&limit=${limite}`,
+            { json: true });
+        return { ok: true, icones: r.icons || [], colecoes: COLECOES };
+    } catch (e) {
+        return { ok: false, error: e.message, colecoes: COLECOES };
+    }
+}
+
+/** Baixa todos os ícones que o plano usa, de uma vez. */
+async function iconesDoPlano(plano, pasta) {
+    const nomes = new Set();
+    for (const cena of plano.cenas || []) {
+        for (const el of cena.elementos || []) if (el.tipo === 'icone' && el.nome) nomes.add(el.nome);
+    }
+    const mapa = {};
+    const faltaram = [];
+    for (const nome of nomes) {
+        const r = await icone(nome, { pasta });
+        if (r.ok) mapa[nome] = r.svg;
+        else faltaram.push({ nome, motivo: r.error });
+    }
+    return { mapa, faltaram };
+}
+
+// ── imagens ──────────────────────────────────────────────────────────────
+
+function extensaoDe(url, padrao) {
+    const m = String(url).split('?')[0].match(/\.([a-z0-9]{2,5})$/i);
+    return m ? '.' + m[1].toLowerCase() : padrao;
+}
+
+/**
+ * A extensão pelos PRIMEIROS BYTES, não pela URL.
+ *
+ * O Jamendo entrega mp3 numa URL sem extensão nenhuma ("?trackid=…&
+ * format=mp32"), e o Openverse repassa essa URL como está. Pela URL o arquivo
+ * era salvo como `.jpg` — e um `.jpg` que na verdade é um mp3 entra no plano,
+ * passa pelo validador (o arquivo existe!) e só quebra lá na frente, dentro
+ * do Remotion, com um erro que não fala de download nenhum.
+ *
+ * Os bytes não mentem. A URL é o palpite de reserva, para o formato que não
+ * tiver assinatura conhecida aqui.
+ */
+function extensaoPorConteudo(bytes) {
+    if (!bytes || bytes.length < 12) return null;
+    const c = bytes.subarray(0, 12);
+    const quatro = c.subarray(0, 4).toString('latin1');
+    if (c.subarray(0, 3).toString('latin1') === 'ID3' || (c[0] === 0xff && (c[1] & 0xe0) === 0xe0)) return '.mp3';
+    if (quatro === 'OggS') return '.ogg';
+    if (quatro === 'fLaC') return '.flac';
+    // RIFF é container: WAVE é som, WEBP é imagem — os bytes 8..11 dizem qual.
+    if (quatro === 'RIFF') {
+        const tipo = c.subarray(8, 12).toString('latin1');
+        return tipo === 'WEBP' ? '.webp' : tipo === 'WAVE' ? '.wav' : null;
+    }
+    if (c[0] === 0x89 && quatro.slice(1) === 'PNG') return '.png';
+    if (c[0] === 0xff && c[1] === 0xd8) return '.jpg';
+    if (c.subarray(0, 3).toString('latin1') === 'GIF') return '.gif';
+    if (c[0] === 0x00 && c[1] === 0x00 && c[2] === 0x01 && c[3] === 0x00) return '.ico';
+    // ftyp no offset 4: MP4 e M4A dividem o container; o `brand` separa.
+    if (c.subarray(4, 8).toString('latin1') === 'ftyp') {
+        return /^(M4A|mp42|isom|iso2|mp41)/.test(c.subarray(8, 12).toString('latin1')) ? '.mp4' : '.mp4';
+    }
+    const inicio = bytes.subarray(0, 400).toString('utf8').trimStart();
+    if (/^<(\?xml|svg)/i.test(inicio)) return '.svg';
+    return null;
+}
+
+/**
+ * Procura imagem. Pexels na frente quando há chave; Openverse sempre.
+ *
+ * @returns {{ok, imagens: Array<{url, titulo, autor, licenca, creditos, fonte}>}}
+ */
+async function procurarImagens(termo, { quantas = 8, transparente = false } = {}) {
+    const chave = process.env.PEXELS_API_KEY;
+    if (chave && !transparente) {
+        try {
+            const r = await pegar(
+                `https://api.pexels.com/v1/search?query=${encodeURIComponent(termo)}&per_page=${quantas}`,
+                { json: true, cabecalhos: { Authorization: chave } });
+            const imagens = (r.photos || []).map((p) => ({
+                url: p.src.original, titulo: p.alt || termo, autor: p.photographer,
+                licenca: 'Pexels', creditos: `Foto de ${p.photographer} (Pexels)`, fonte: 'pexels',
+                largura: p.width, altura: p.height,
+            }));
+            if (imagens.length) return { ok: true, imagens };
+        } catch { /* cai para o Openverse */ }
+    }
+
+    try {
+        // `license_type=commercial` corta o que não pode ser usado em peça de
+        // marca — que é o caso de quase todo vídeo feito aqui.
+        const r = await pegar(
+            `https://api.openverse.org/v1/images/?q=${encodeURIComponent(termo)}`
+            + `&page_size=${quantas}&license_type=commercial`
+            + (transparente ? '&extension=png' : ''),
+            { json: true });
+        const imagens = (r.results || []).map((x) => ({
+            url: x.url, titulo: x.title || termo, autor: x.creator,
+            licenca: x.license, creditos: x.attribution, fonte: 'openverse',
+            largura: x.width, altura: x.height,
+        }));
+        return { ok: true, imagens };
+    } catch (e) {
+        return { ok: false, error: `não deu para procurar imagem: ${e.message}`, imagens: [] };
+    }
+}
+
+// ── som ──────────────────────────────────────────────────────────────────
+
+/**
+ * Procura música ou efeito sonoro.
+ *
+ * `duracaoMin` existe para separar as duas coisas sem o usuário dizer: um
+ * "whoosh" tem menos de dois segundos, uma trilha tem mais de trinta.
+ */
+async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0 } = {}) {
+    try {
+        let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
+            + `&page_size=${quantas}&license_type=commercial`;
+        if (duracaoMin) url += `&length=${duracaoMin < 30 ? 'short' : 'medium'}`;
+        const r = await pegar(url, { json: true });
+        const sons = (r.results || [])
+            .filter((x) => !duracaoMax || !x.duration || x.duration / 1000 <= duracaoMax)
+            .map((x) => ({
+                url: x.url, titulo: x.title || termo, autor: x.creator,
+                licenca: x.license, creditos: x.attribution, fonte: 'openverse',
+                segundos: x.duration ? Math.round(x.duration / 1000) : null,
+            }));
+        return { ok: true, sons };
+    } catch (e) {
+        return { ok: false, error: `não deu para procurar som: ${e.message}`, sons: [] };
+    }
+}
+
+// ── baixar ───────────────────────────────────────────────────────────────
+
+/**
+ * Traz a mídia para a pasta do projeto.
+ *
+ * O `relativo` que volta é o que entra no plano — sempre relativo à pasta do
+ * projeto, nunca absoluto: caminho absoluto quebra quando o projeto é movido
+ * ou aberto em outra máquina.
+ */
+async function baixar(item, { pasta, nome = null, sub = 'midia' } = {}) {
+    if (!item || !item.url) return { ok: false, error: 'sem endereço para baixar' };
+    try {
+        const dados = await pegar(item.url, { binario: true });
+        const ext = extensaoPorConteudo(dados) || extensaoDe(item.url, '.jpg');
+        const limpo = (nome || String(item.titulo || 'midia'))
+            .normalize('NFD').replace(/[̀-ͯ]/g, '')
+            .replace(/[^a-z0-9]+/gi, '-').toLowerCase().slice(0, 40);
+        const destino = path.join(pasta, sub, `${limpo || 'midia'}-${Date.now().toString(36)}${ext}`);
+        guardar(destino, dados, {
+            titulo: item.titulo, autor: item.autor, licenca: item.licenca,
+            creditos: item.creditos, origem: item.url, fonte: item.fonte, quando: new Date().toISOString(),
+        });
+        return {
+            ok: true,
+            arquivo: destino,
+            relativo: path.relative(pasta, destino).replace(/\\/g, '/'),
+            bytes: dados.length,
+            creditos: item.creditos || null,
+        };
+    } catch (e) {
+        return { ok: false, error: `não deu para baixar: ${e.message}` };
+    }
+}
+
+// ── fontes ───────────────────────────────────────────────────────────────
+
+/* O leque. Antes eram seis arquivos .woff2 no pacote; agora é o Google Fonts
+   inteiro. Esta lista não LIMITA nada — qualquer família do Google Fonts
+   funciona no plano. Ela existe porque um modelo que não conhece o catálogo
+   escreve "Inter" em tudo, e o resultado é o que se reclamou: tudo igual. */
+const FONTES = {
+    display: ['Anton', 'Bebas Neue', 'Archivo Black', 'Oswald', 'Teko', 'Alfa Slab One',
+        'Bungee', 'Righteous', 'Bowlby One', 'Passion One', 'Ultra', 'Rubik Mono One'],
+    grotesca: ['Inter', 'Manrope', 'Plus Jakarta Sans', 'Outfit', 'Sora', 'Space Grotesk',
+        'DM Sans', 'Figtree', 'Onest', 'Geist', 'Satoshi', 'General Sans'],
+    serifa: ['Playfair Display', 'Fraunces', 'Instrument Serif', 'DM Serif Display',
+        'Libre Baskerville', 'Lora', 'Cormorant Garamond', 'Spectral', 'Newsreader'],
+    tecnica: ['JetBrains Mono', 'IBM Plex Mono', 'Space Mono', 'Azeret Mono', 'Martian Mono'],
+    manuscrita: ['Caveat', 'Kalam', 'Permanent Marker', 'Shadows Into Light', 'Gloria Hallelujah'],
+    condensada: ['Barlow Condensed', 'Archivo Narrow', 'Saira Condensed', 'Fjalla One', 'Roboto Condensed'],
+};
+
+/** A fonte existe no Google Fonts? Erra-se o nome com facilidade. */
+async function conferirFonte(familia) {
+    const url = `https://fonts.googleapis.com/css2?family=${encodeURIComponent(familia).replace(/%20/g, '+')}`;
+    try { await pegar(url); return { ok: true, familia }; }
+    catch { return { ok: false, error: `"${familia}" não existe no Google Fonts.` }; }
+}
+
+module.exports = {
+    extensaoPorConteudo,
+    pegar, guardar,
+    icone, procurarIcones, iconesDoPlano, COLECOES,
+    procurarImagens, procurarSom, baixar,
+    FONTES, conferirFonte,
+};