sagadeck 1.2.0

package/src/portal-scene.js

@@ -0,0 +1,20 @@
+import {esc} from './markup.js';
+import {iconSVG} from './figures/icons.js';
+import {el} from './elements.js';
+
+export const portalExample={layout:'portal',title:'Entre. Descubra. Transforme.',caption:'Catálogo ilustrativo · funciona offline, sem login ou iframe de um portal real.',items:[
+ {title:'Documentos em movimento',icon:'files',text:'Uma pilha de documentos vira informação organizada.',beforeWord:'RUÍDO',afterWord:'CLAREZA',before:'Arquivos dispersos, leitura repetida, informação difícil de encontrar.',after:'As mesmas informações agora têm uma ordem e um caminho.',objects:[{label:'Documentos',icon:'files',shape:'sheet'},{label:'Leitura',icon:'scan-text'},{label:'Informação',icon:'database',shape:'column'},{label:'Busca',icon:'search',shape:'orb'},{label:'Resposta',icon:'message-square'}]},
+ {title:'Uma entrega, vários caminhos',icon:'truck',text:'Da fábrica até quem espera pelo pedido.',beforeWord:'DISTÂNCIA',afterWord:'CONEXÃO',before:'O pedido atravessa etapas que parecem desconectadas.',after:'Cada etapa tem seu lugar. A jornada fica visível.',objects:[{label:'Fábrica',icon:'factory'},{label:'Depósito',icon:'warehouse'},{label:'Rota',icon:'route'},{label:'Entrega',icon:'truck'}]},
+ {title:'Dentro de uma aplicação',icon:'app-window',text:'Atravesse a interface e revele o fluxo por trás dela.',beforeWord:'INTERFACE',afterWord:'SISTEMA',before:'Você vê a interface. O que acontece depois do clique?',after:'Pedido, processamento e resposta formam uma sequência.',objects:[{label:'Interface',icon:'app-window'},{label:'Requisição',icon:'send'},{label:'Serviço',icon:'server'},{label:'Resposta',icon:'check'}]}
+]};
+
+export function portalHTML(s,ctx,head){
+ const items=s.items||[];if(!items.length)throw new Error('portal: adicione pelo menos um elemento para explorar.');
+ return `<div class="L-portal" data-portal data-view="catalog" data-skin="${esc(['neon','editorial','industrial','aurora'].includes(s.skin)?s.skin:'neon')}">${head(s)}<div class="portal-stage"><div class="portal-atmosphere" aria-hidden="true"><div class="portal-orbit"></div><div class="portal-grid"></div></div>
+ <div class="portal-catalog"><div class="portal-sign">${esc(s.label||'ESCOLHA UM MUNDO PARA EXPLORAR')}</div><div class="portal-cards">${items.map((item,i)=>`<button class="portal-card" data-portal-enter="${i}" aria-label="Entrar em ${esc(item.title||'elemento')}"><span class="portal-card-art">${item.image?el({image:item.image,fit:'cover'},ctx):iconSVG(item.icon||'app-window',64)}</span><strong>${esc(item.title||`Elemento ${i+1}`)}</strong><span>${esc(item.text||'Explore esta cena.')}</span><small>Entrar ${iconSVG('arrow-up-right',20)}</small></button>`).join('')}</div></div>
+ <div class="portal-inside" hidden><div class="portal-scene-title"></div><div class="portal-floor-word" aria-hidden="true"></div><svg class="portal-paths" viewBox="0 0 1000 600" preserveAspectRatio="none" aria-hidden="true"></svg><div class="portal-objects"></div></div></div>
+ <div class="portal-controls"><button data-portal-back hidden>${iconSVG('arrow-left',20)} Voltar ao catálogo</button><button data-portal-transform hidden>${iconSVG('sparkles',20)} Transformar cenário</button><button data-portal-reset>Restaurar</button><output data-portal-description aria-live="polite">${esc(s.caption||'Escolha um elemento para entrar na cena.')}</output></div>
+ <script class="portal-model" type="application/json">${JSON.stringify(items.map(item=>({...item,objects:item.objects?.map(node=>({...node,glyph:iconSVG(node.icon||'box',30)}))}))).replace(/</g,'\\u003c')}</script></div>`;
+}
+
+export function portalDemo(){return{title:'Demo — mundos que se transformam',theme:'manual-noite',slides:[portalExample,{layout:'portal',title:'A ideia muda. A cena acompanha.',skin:'editorial',label:'UM NOVO CONTEXTO',caption:'O mesmo recurso aplicado a uma aula de processos.',items:[{...portalExample.items[2],title:'O caminho de uma solicitação',beforeWord:'POR QUÊ?',afterWord:'AGORA ENTENDI'}]}]};}

package/src/preferences.js

@@ -0,0 +1,61 @@
+// Preferências do sagadeck nesta máquina: ~/.sagadeck/preferencias.json (ou SAGADECK_PREFERENCIAS), ao lado do
+// ambientes.yaml e do identidades.yaml. Valem para o Studio inteiro; o deck (fit:, author…) vence quando define.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// Cada preferência: padrão e, para número, a faixa aceita (fora dela volta para o limite)
+export const PREF_SCHEMA = {
+  texto: {
+    minCodePt: { def: 10, min: 6, max: 24 },   // código encolhe até aqui (pt, como no PowerPoint; 1 pt = 2 px no slide)
+    minTextPt: { def: 6, min: 6, max: 30 },    // texto que "encolhe para caber" não passa daqui (6 pt: quase sem limite)
+    wrapCode: { def: true },                    // linha longa de código quebra em vez de encolher tudo
+  },
+  ia: {
+    perguntar: { def: true },  // pedido sem dizer para que serve o material: a IA pergunta antes de gerar
+    imagens: { def: true },    // gerar imagens quando o pedido pedir (desligado: só ícones, gráficos e diagramas)
+    pesquisa: { def: true },   // pesquisar na web quando o pedido precisar de informação recente ou de um artigo (a IA decide)
+    autor: { def: "" },        // nome na capa e no rodapé das apresentações novas (no lugar de "Seu Nome")
+    idioma: { def: "auto" },   // auto = o idioma do pedido
+  },
+  exportacao: {
+    pdfClaro: { def: false },   // PDF e impressão na versão clara do tema (quando o tema tem par claro/escuro)
+  },
+};
+
+export function preferencesFile(env = process.env, home = os.homedir()) {
+  return env.SAGADECK_PREFERENCIAS || path.join(home, ".sagadeck", "preferencias.json");
+}
+
+const defaults = () => Object.fromEntries(Object.entries(PREF_SCHEMA).map(([sec, items]) => [sec, Object.fromEntries(Object.entries(items).map(([k, v]) => [k, v.def]))]));
+
+// só as chaves conhecidas, cada uma no tipo e na faixa certos (arquivo editado à mão não quebra o Studio)
+function clean(raw) {
+  const out = defaults();
+  for (const [sec, items] of Object.entries(PREF_SCHEMA)) {
+    for (const [k, rule] of Object.entries(items)) {
+      const v = raw?.[sec]?.[k];
+      if (v === undefined || v === null || v === "") continue;
+      if (typeof rule.def === "boolean") out[sec][k] = v === true || v === "true";
+      else if (typeof rule.def === "number") { const n = Number(v); if (Number.isFinite(n)) out[sec][k] = Math.min(rule.max, Math.max(rule.min, n)); }
+      else out[sec][k] = String(v).slice(0, 200);
+    }
+  }
+  return out;
+}
+
+export function loadPreferences(file = preferencesFile()) {
+  try { return clean(JSON.parse(fs.readFileSync(file, "utf8"))); } catch { return defaults(); }
+}
+
+// patch: { texto: { minCodePt: 12 } } — junta com o que já está salvo e grava de forma atômica
+export function savePreferences(patch, file = preferencesFile()) {
+  const cur = loadPreferences(file);
+  const merged = Object.fromEntries(Object.keys(PREF_SCHEMA).map((sec) => [sec, { ...cur[sec], ...(patch?.[sec] || {}) }]));
+  const out = clean(merged);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(out, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, file);
+  return out;
+}

package/src/protect.js

@@ -0,0 +1,51 @@
+// Guarda de valores protegidos (segredos dos slides de API) no arquivo de ambientes.
+//
+// No Windows: DPAPI do usuário (ProtectedData, escopo CurrentUser). O texto vira "dpapi:BASE64" e só este usuário,
+// nesta máquina, consegue ler de volta — se o arquivo for copiado ou mandado para alguém, o segredo não vai junto.
+// O valor passa pelo stdin do PowerShell (nunca pela linha de comando, que outros processos conseguem ver).
+// Fora do Windows (ex.: o servidor Linux): fica como está, e o arquivo é gravado só para o dono (0600).
+import { execFileSync } from "node:child_process";
+
+export const PROTECTION = process.platform === "win32" ? "dpapi" : "arquivo";
+const PREFIX = "dpapi:";
+const cache = new Map(); // "dpapi:..." -> texto (decifrar custa um PowerShell; o mesmo valor, uma vez só)
+
+function powershell(script, input) {
+  return execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
+    { input, encoding: "utf8", windowsHide: true, maxBuffer: 1 << 24 }).trim();
+}
+
+// uma chamada para vários valores: entra e sai JSON (lista de strings)
+function dpapi(values, direction) {
+  const op = direction === "protect"
+    ? "[Convert]::ToBase64String([Security.Cryptography.ProtectedData]::Protect([Text.Encoding]::UTF8.GetBytes($v), $null, 'CurrentUser'))"
+    : "[Text.Encoding]::UTF8.GetString([Security.Cryptography.ProtectedData]::Unprotect([Convert]::FromBase64String($v), $null, 'CurrentUser'))";
+  const script = `Add-Type -AssemblyName System.Security; $in = [Console]::In.ReadToEnd() | ConvertFrom-Json; $out = @(); foreach ($v in @($in)) { $out += ${op} }; ConvertTo-Json -Compress -InputObject @($out)`;
+  const out = JSON.parse(powershell(script, JSON.stringify(values)));
+  return Array.isArray(out) ? out : [out];
+}
+
+export const isProtected = (v) => typeof v === "string" && v.startsWith(PREFIX);
+
+export function protect(plain) {
+  if (PROTECTION !== "dpapi") return String(plain);
+  const [b64] = dpapi([String(plain)], "protect");
+  const v = PREFIX + b64;
+  cache.set(v, String(plain));
+  return v;
+}
+
+export function unprotect(value) {
+  if (!isProtected(value)) return value;
+  if (!cache.has(value)) unprotectAll([value]);
+  return cache.get(value);
+}
+
+// decifra de uma vez todos os ainda não vistos (um PowerShell só ao abrir o arquivo)
+export function unprotectAll(values) {
+  const todo = [...new Set(values.filter((v) => isProtected(v) && !cache.has(v)))];
+  if (!todo.length) return;
+  if (PROTECTION !== "dpapi") throw new Error("Este valor foi protegido no Windows (DPAPI) e só pode ser lido lá, pelo mesmo usuário.");
+  const out = dpapi(todo.map((v) => v.slice(PREFIX.length)), "unprotect");
+  todo.forEach((v, i) => cache.set(v, out[i]));
+}

package/src/purpose.js

@@ -0,0 +1,24 @@
+// Para que serve o material (deck.purpose): quem decide é a IA, lendo o pedido (ou a pessoa, no Studio). Muda quanto
+// texto cabe num slide antes do fiscal "anti-sono" reclamar e o que a IA e a auto-correção fazem com o texto:
+// material de consulta/aula guarda a explicação NO slide; palestra e executiva deixam pouco texto e o resto em notes.
+// São dois usos: apresentar (letra grande, respiro, pouco texto, para não dar sono) ou estudar depois (o material é
+// enviado e vira fonte de estudo: conteúdo denso). aula, workshop e executiva são de decks antigos: continuam valendo,
+// mas nem o Studio nem a IA oferecem mais.
+export const PURPOSES = {
+  palestra: { label: "Para apresentar", hint: "letra grande e pouco texto: a apresentação fica dinâmica e não dá sono", maxWords: 40, dense: false },
+  consulta: { label: "Para estudar depois", hint: "o material vai ser enviado e usado como fonte de estudo: conteúdo denso", maxWords: 220, dense: true },
+  aula: { label: "Aula (antigo)", hint: "", maxWords: 160, dense: true, legacy: true },
+  workshop: { label: "Workshop (antigo)", hint: "", maxWords: 110, dense: false, legacy: true },
+  executiva: { label: "Executiva (antigo)", hint: "", maxWords: 40, dense: false, legacy: true },
+};
+
+const LAYOUT_WORDS = { onepage: 120, status: 90, solution: 140, calc: 90, algo: 60 }; // densos por natureza (uma página com tudo; exercício resolvido se revela aos poucos)
+
+// Limite de palavras na tela de um slide: o do slide > o do deck > o do propósito (ou do layout, se maior) > 40
+export function wordLimit(s = {}, spec = {}, layout = s.layout) {
+  if (s.maxWords) return s.maxWords;
+  if (spec.maxWords) return spec.maxWords;
+  return Math.max(PURPOSES[spec.purpose]?.maxWords || 0, LAYOUT_WORDS[layout] || 0) || 40;
+}
+
+export const isDense = (spec = {}) => !!PURPOSES[spec.purpose]?.dense;