primocode 10.4.7 → 10.6.0

package/lib/estudio/colecao.js

@@ -0,0 +1,218 @@
+/**
+ * colecao.js — a biblioteca completa do Estúdio: o que existe para pôr num vídeo.
+ *
+ *   "tem que ter uma biblioteca completa de ícones, pra ele poder pegar os
+ *    ícones 3D, 2D, animações, também efeitos sonoros e músicas, também
+ *    fontes de texto" (Joel, 11/10)
+ *
+ * O 2D (Iconify), a imagem e o som (Openverse), a trilha e as fontes já
+ * existiam (assets.js, biblioteca.js, sons-leves.js). Faltavam duas coisas, e
+ * as duas entram aqui:
+ *
+ *   · ÍCONE 3D — o Fluent Emoji 3D da Microsoft (licença MIT): mais de 1.500 objetos
+ *     renderizados em 3D, de "coffee" a "rocket". O índice mora no pacote
+ *     (dados/fluent-3d.json), então PROCURAR não usa rede; só o PNG escolhido
+ *     desce, do CDN do jsDelivr.
+ *   · ANIMAÇÃO PRONTA — o Noto Emoji animado do Google (CC BY 4.0): 881
+ *     animações em Lottie (vetor, nítido em qualquer tamanho), tocadas quadro
+ *     a quadro pela peça kit/animacao.jsx. Índice também no pacote.
+ *
+ * E `cardapio()` junta TUDO numa resposta só, para a IA saber o que existe
+ * antes de escolher — a escolha é dela (nada entra no vídeo sozinho).
+ *
+ * A licença anda junto: cada download grava o .json ao lado (fonte, licença,
+ * crédito), como no acervo.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DADOS = path.join(__dirname, 'dados');
+const CDN_FLUENT = 'https://cdn.jsdelivr.net/gh/microsoft/fluentui-emoji@main/assets/';
+const LOTTIE_NOTO = (cp) => `https://fonts.gstatic.com/s/e/notoemoji/latest/${cp}/lottie.json`;
+const GIF_NOTO = (cp) => `https://fonts.gstatic.com/s/e/notoemoji/latest/${cp}/512.gif`;
+
+let _fluent = null, _noto = null;
+const fluent = () => (_fluent = _fluent || JSON.parse(fs.readFileSync(path.join(DADOS, 'fluent-3d.json'), 'utf8')));
+const noto = () => (_noto = _noto || JSON.parse(fs.readFileSync(path.join(DADOS, 'noto-animado.json'), 'utf8')));
+
+/* As duas bibliotecas são em inglês. A IA costuma mandar o termo em inglês,
+   mas a pessoa fala português: as palavras mais comuns de vídeo têm par. */
+const PT_EN = {
+    cafe: 'coffee', 'café': 'coffee', pao: 'bread', 'pão': 'bread', padaria: 'bread', dinheiro: 'money', grana: 'money', moeda: 'coin',
+    foguete: 'rocket', coracao: 'heart', 'coração': 'heart', fogo: 'fire', ideia: 'light bulb', lampada: 'light bulb', 'lâmpada': 'light bulb',
+    estrela: 'star', relogio: 'clock', 'relógio': 'clock', tempo: 'hourglass', celular: 'mobile phone', telefone: 'telephone',
+    computador: 'laptop', notebook: 'laptop', robo: 'robot', 'robô': 'robot', livro: 'books', escola: 'school', carro: 'car',
+    casa: 'house', comida: 'food', pizza: 'pizza', musica: 'musical note', 'música': 'musical note', foto: 'camera', camera: 'camera',
+    'câmera': 'camera', mundo: 'globe', terra: 'globe', chave: 'key', cadeado: 'locked', seguranca: 'shield', 'segurança': 'shield',
+    escudo: 'shield', grafico: 'chart', 'gráfico': 'chart', alvo: 'direct hit', trofeu: 'trophy', 'troféu': 'trophy', medalha: 'medal',
+    presente: 'gift', festa: 'party', sol: 'sun', chuva: 'rain', raio: 'high voltage', energia: 'high voltage', bateria: 'battery',
+    email: 'envelope', mensagem: 'speech balloon', conversa: 'speech balloon', pergunta: 'question', ok: 'check mark', certo: 'check mark',
+    errado: 'cross mark', aviso: 'warning', dinossauro: 'dinosaur', gato: 'cat', cachorro: 'dog', planta: 'seedling', arvore: 'tree',
+    'árvore': 'tree', sorriso: 'smile', feliz: 'smile', triste: 'sad', bravo: 'angry', amor: 'heart', rindo: 'joy', pensando: 'thinking',
+    surpreso: 'surprised', cerebro: 'brain', 'cérebro': 'brain', olho: 'eye', mao: 'hand', 'mão': 'hand', joinha: 'thumbs up',
+    palmas: 'clapping', aplauso: 'clapping', calendario: 'calendar', 'calendário': 'calendar', saco: 'money bag', banco: 'bank',
+    cartao: 'credit card', 'cartão': 'credit card', loja: 'shopping', compras: 'shopping cart', voto: 'ballot box', ferramenta: 'hammer',
+    // Comida, objeto e veículo: o que vira personagem ou peça da cena 3D (mundo.js).
+    hamburguer: 'hamburger', 'hambúrguer': 'hamburger', batata: 'potato', 'batata frita': 'french fries', sorvete: 'ice cream', bolo: 'birthday cake',
+    chocolate: 'chocolate bar', maca: 'red apple', 'maçã': 'red apple', uva: 'grapes', morango: 'strawberry', abacaxi: 'pineapple', melancia: 'watermelon',
+    cenoura: 'carrot', ovo: 'egg', queijo: 'cheese wedge', leite: 'glass of milk', cerveja: 'beer mug', vinho: 'wine glass', suco: 'beverage box',
+    refrigerante: 'cup with straw', sanduiche: 'sandwich', 'sanduíche': 'sandwich', sushi: 'sushi', 'cachorro-quente': 'hot dog', pipoca: 'popcorn',
+    rosquinha: 'doughnut', donut: 'doughnut', biscoito: 'cookie', abacate: 'avocado', coco: 'coconut', taco: 'taco', croissant: 'croissant',
+    barraca: 'tent', fogueira: 'fire', palmeira: 'palm tree', violao: 'guitar', 'violão': 'guitar', guitarra: 'guitar', bola: 'soccer ball',
+    bicicleta: 'bicycle', moto: 'motorcycle', aviao: 'airplane', 'avião': 'airplane', trem: 'locomotive', onibus: 'bus', 'ônibus': 'bus',
+    navio: 'ship', helicoptero: 'helicopter', 'helicóptero': 'helicopter', lapis: 'pencil', 'lápis': 'pencil', caneta: 'pen', mochila: 'backpack',
+    chapeu: 'top hat', 'chapéu': 'top hat', oculos: 'glasses', 'óculos': 'glasses', televisao: 'television', 'televisão': 'television', tv: 'television',
+    microfone: 'microphone', fone: 'headphone', 'guarda-chuva': 'umbrella', cogumelo: 'mushroom', semaforo: 'vertical traffic light',
+    'semáforo': 'vertical traffic light', ampulheta: 'hourglass', lua: 'crescent moon', nuvem: 'cloud', arco_iris: 'rainbow', 'arco-íris': 'rainbow',
+    flor: 'blossom', rosa: 'rose', girassol: 'sunflower', 'cacto': 'cactus', vulcao: 'volcano', 'vulcão': 'volcano', castelo: 'castle',
+    fantasma: 'ghost', alien: 'alien', 'alienígena': 'alien', et: 'alien', unicornio: 'unicorn', 'unicórnio': 'unicorn', dragao: 'dragon', 'dragão': 'dragon',
+    // Bichos que o kit/mundo.jsx não monta de blocos: vêm do ícone 3D (a lula fica de fora: é o presidente).
+    polvo: 'octopus', baleia: 'whale', caranguejo: 'crab', borboleta: 'butterfly', abelha: 'honeybee', cobra: 'snake', jacare: 'crocodile',
+    'jacaré': 'crocodile', crocodilo: 'crocodile', formiga: 'ant', aranha: 'spider', camelo: 'camel', zebra: 'zebra', hipopotamo: 'hippopotamus',
+    'hipopótamo': 'hippopotamus', rinoceronte: 'rhinoceros', canguru: 'kangaroo', coala: 'koala', preguica: 'sloth', 'preguiça': 'sloth',
+    joaninha: 'lady beetle', caracol: 'snail', minhoca: 'worm', morcego: 'bat', esquilo: 'chipmunk', rato: 'mouse', hamster: 'hamster',
+    lagosta: 'lobster', camarao: 'shrimp', 'camarão': 'shrimp', flamingo: 'flamingo', pavao: 'peacock', 'pavão': 'peacock', cisne: 'swan',
+    aguia: 'eagle', 'águia': 'eagle', peru: 'turkey', lhama: 'llama', gorila: 'gorilla', orangotango: 'orangutan', bufalo: 'water buffalo',
+    engrenagem: 'gear', ciencia: 'test tube', 'ciência': 'test tube', saude: 'hospital', 'saúde': 'hospital', remedio: 'pill', 'remédio': 'pill',
+};
+
+const norm = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9 ]+/g, ' ').trim();
+
+function termos(termo) {
+    const cru = String(termo || '').toLowerCase().trim();
+    const out = new Set([norm(cru)]);
+    for (const w of cru.split(/\s+/)) if (PT_EN[w]) out.add(PT_EN[w]);
+    if (PT_EN[cru]) out.add(PT_EN[cru]);
+    return [...out].filter(Boolean);
+}
+
+// A nota de um nome contra a busca: palavra inteira vale mais que pedaço.
+function nota(nome, ts) {
+    const n = ' ' + norm(nome) + ' ';
+    let melhor = 0;
+    for (const t of ts) {
+        if (n.trim() === t) melhor = Math.max(melhor, 100);
+        else if (n.includes(' ' + t + ' ')) melhor = Math.max(melhor, 60 - n.length * 0.1);
+        else {
+            const ws = t.split(' ').filter((w) => w.length > 2);
+            const achou = ws.filter((w) => n.includes(' ' + w)).length;
+            if (achou) melhor = Math.max(melhor, (achou / ws.length) * 40 - n.length * 0.1);
+        }
+    }
+    return melhor;
+}
+
+/** Os ícones 3D (Fluent) que casam com o termo. */
+function procurarIcones3d(termo, { quantas = 10 } = {}) {
+    const ts = termos(termo);
+    if (!ts.length) return { ok: false, error: 'diga o que procurar (termo), de preferência em inglês: "coffee", "rocket".' };
+    // O nome manda; as palavras-chave do metadata (coffee em "hot beverage") e o grupo ajudam.
+    const achados = fluent().map(([nome, p, kw = '', grupo = '']) => ({ nome, p, grupo, n: Math.max(nota(nome, ts), nota(kw, ts) * 0.8, nota(grupo, ts) * 0.3) })).filter((x) => x.n > 0)
+        .sort((a, b) => b.n - a.n).slice(0, quantas);
+    return {
+        ok: true, termo, total: achados.length,
+        icones: achados.map((x) => ({ id: 'fluent3d:' + x.nome, nome: x.nome, grupo: x.grupo, url: CDN_FLUENT + encodeURI(x.p), licenca: 'MIT', fonte: 'Microsoft Fluent Emoji 3D' })),
+        comoUsar: 'baixe com acao:icones3d id:"fluent3d:<nome>" (precisa do id do projeto) — volta um elemento {tipo:"imagem"} pronto, PNG transparente de 256 px em 3D.',
+    };
+}
+
+/** As animações prontas (Noto animado, Lottie) que casam com o termo. */
+function procurarAnimacoes(termo, { quantas = 10 } = {}) {
+    const ts = termos(termo);
+    if (!ts.length) return { ok: false, error: 'diga o que procurar (termo): "fire", "party", "thinking"…' };
+    const achados = noto().map(([cp, tags, cat]) => ({ cp, tags, cat, n: Math.max(nota(tags, ts), nota(cat, ts) * 0.5) }))
+        .filter((x) => x.n > 0).sort((a, b) => b.n - a.n).slice(0, quantas);
+    return {
+        ok: true, termo, total: achados.length,
+        animacoes: achados.map((x) => ({ id: 'noto:' + x.cp, nome: x.tags, categoria: x.cat, lottie: LOTTIE_NOTO(x.cp), gif: GIF_NOTO(x.cp),
+            licenca: 'CC BY 4.0', creditos: 'Noto Emoji Animation, Google (CC BY 4.0)' })),
+        comoUsar: 'baixe com acao:animacoes id:"noto:<código>" (precisa do id do projeto) — volta um elemento {tipo:"kit", peca:"animacao"} pronto, que toca quadro a quadro.',
+    };
+}
+
+async function baixarUrl(url, destino) {
+    const r = await fetch(url, { headers: { 'user-agent': 'primocode-estudio' } });
+    if (!r.ok) return { ok: false, error: `${r.status} ao baixar ${url}` };
+    const buf = Buffer.from(await r.arrayBuffer());
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.writeFileSync(destino, buf);
+    return { ok: true, bytes: buf.length };
+}
+
+/**
+ * Baixa um item da biblioteca para a pasta do projeto e devolve o elemento pronto.
+ * @param {string} id  "fluent3d:<nome>" ou "noto:<código>"
+ */
+async function baixar(id, { pasta, largura = 1920, altura = 1080 } = {}) {
+    if (!pasta) return { ok: false, error: 'para baixar é preciso dizer em qual projeto (id).' };
+    const [tipo, chave0] = String(id || '').split(/:(.+)/);
+    const chave = String(chave0 || '').trim().toLowerCase();
+    const lado = Math.round(Math.min(largura, altura) * 0.32);
+    if (tipo === 'fluent3d') {
+        const item = fluent().find(([nome]) => nome === chave);
+        if (!item) return { ok: false, error: `não há o ícone 3D "${chave}" — procure com acao:icones3d termo:"…".` };
+        const arquivo = chave.replace(/[^a-z0-9]+/g, '-') + '.png';
+        const destino = path.join(pasta, 'midia', 'icones3d', arquivo);
+        if (!fs.existsSync(destino)) {
+            const r = await baixarUrl(CDN_FLUENT + encodeURI(item[1]), destino);
+            if (!r.ok) return r;
+            fs.writeFileSync(destino.replace(/\.png$/, '.json'), JSON.stringify({ fonte: 'Microsoft Fluent Emoji 3D', licenca: 'MIT', url: CDN_FLUENT + encodeURI(item[1]) }, null, 2));
+        }
+        const src = path.relative(pasta, destino).replace(/\\/g, '/');
+        return { ok: true, src, licenca: 'MIT',
+            elemento: { tipo: 'imagem', src, x: Math.round((largura - lado) / 2), y: Math.round((altura - lado) / 2), largura: lado, altura: lado, ajuste: 'contain' } };
+    }
+    if (tipo === 'noto') {
+        const item = noto().find(([cp]) => cp === chave);
+        if (!item) return { ok: false, error: `não há a animação "${chave}" — procure com acao:animacoes termo:"…".` };
+        const destino = path.join(pasta, 'midia', 'animacoes', chave + '.json');
+        if (!fs.existsSync(destino)) {
+            const r = await baixarUrl(LOTTIE_NOTO(chave), destino);
+            if (!r.ok) return r;
+            fs.writeFileSync(destino.replace(/\.json$/, '.licenca.json'), JSON.stringify({ fonte: 'Noto Emoji Animation (Google)', licenca: 'CC BY 4.0', url: LOTTIE_NOTO(chave) }, null, 2));
+        }
+        const src = path.relative(pasta, destino).replace(/\\/g, '/');
+        return { ok: true, src, licenca: 'CC BY 4.0', creditos: 'Noto Emoji Animation, Google (CC BY 4.0)',
+            elemento: { tipo: 'kit', peca: 'animacao', src, loop: true, x: Math.round((largura - lado) / 2), y: Math.round((altura - lado) / 2), largura: lado, altura: lado } };
+    }
+    return { ok: false, error: 'id da biblioteca é "fluent3d:<nome>" ou "noto:<código>".' };
+}
+
+/**
+ * O CARDÁPIO: tudo o que a biblioteca tem, numa resposta. A IA lê isto e
+ * escolhe pelo assunto do vídeo — a regra da casa é que todo elemento tenha a
+ * ver com o que a fala diz.
+ */
+function cardapio() {
+    let fontes = 0, sons = [];
+    try { fontes = Object.keys(require('./biblioteca.js').FONTES || {}).length; } catch { /* sem a lista */ }
+    try { sons = Object.keys(require('./sons-leves.js').EFEITOS || {}); } catch { /* sem a lista */ }
+    return {
+        ok: true,
+        icones2d: { quantos: '200 mil+ (Iconify: Material, Lucide, Phosphor, marcas…)', acao: 'icones', exemplo: 'termo:"bread"' },
+        icones3d: { quantos: fluent().length, fonte: 'Microsoft Fluent Emoji 3D (MIT)', acao: 'icones3d', exemplo: 'termo:"coffee" → id:"fluent3d:hot beverage"' },
+        animacoes: { quantas: noto().length, fonte: 'Noto Emoji animado do Google, Lottie (CC BY 4.0)', acao: 'animacoes', exemplo: 'termo:"fire" → id:"noto:1f525"' },
+        personagens3d: 'o estilo personagem (voxel): bonecos de blocos e o mascote, com a câmera de cinema — estudio_roteiro estilo:"personagem"',
+        efeitosSonoros: { sintetizados: sons, internet: 'acao:efeito termo:"whoosh" (Openverse, licença aberta, até 6 s)' },
+        musicas: { internet: 'acao:trilha termo:"lofi" (Openverse, 30 s ou mais)', automatica: 'sem trilha pedida, o PrimoCode escolhe uma sem repetir as últimas' },
+        fontes: { quantas: fontes || 128, acao: 'fontes', nota: 'Google Fonts, por tipo (condensada, display, serifada, manuscrita…)' },
+        imagens: 'acao:imagem termo:"…" (Openverse e Wikimedia; Google com chave) — só quando a pessoa pediu imagem',
+    };
+}
+
+/** O ícone 3D que É a coisa (nota de palavra inteira), ou null: "pizza" acha, "joel" não. */
+function melhorIcone3d(termo, piso = 80) {
+    const ts = termos(termo);
+    if (!ts.length) return null;
+    let melhor = null;
+    for (const [nome, , kw = ''] of fluent()) {
+        const n = Math.max(nota(nome, ts), nota(kw, ts) * 0.8);
+        if (n >= piso && (!melhor || n > melhor.n || (n === melhor.n && nome.length < melhor.nome.length))) melhor = { nome, n };
+    }
+    return melhor ? 'fluent3d:' + melhor.nome : null;
+}
+
+module.exports = { melhorIcone3d, procurarIcones3d, procurarAnimacoes, baixar, cardapio, termos, PT_EN };