sagadeck 1.2.0

package/src/studio/versions.js

@@ -0,0 +1,95 @@
+// Versões do deck: cada salvamento guarda uma cópia em .sagadeck/versoes/ (últimas 10,
+// sem duplicar salvamento idêntico). A pessoa compara lado a lado e restaura se quiser.
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+
+const MAX = 10;
+
+export function versionsDir(file) {
+  return path.join(path.dirname(path.resolve(file)), ".sagadeck", "versoes");
+}
+
+const stamp = (d = new Date()) =>
+  `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}-${String(d.getHours()).padStart(2, "0")}${String(d.getMinutes()).padStart(2, "0")}${String(d.getSeconds()).padStart(2, "0")}`;
+
+// fotografa o YAML atual; nunca quebra o salvamento (best-effort)
+export function snapshotVersion(file, text) {
+  try {
+    if (!file || typeof text !== "string" || !text.trim()) return null;
+    const dir = versionsDir(file);
+    fs.mkdirSync(dir, { recursive: true });
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml")).sort();
+    if (files.length) {
+      const last = fs.readFileSync(path.join(dir, files[files.length - 1]), "utf8");
+      if (last === text) return null; // nada mudou desde a última
+    }
+    let name = `${stamp()}.yaml`;
+    for (let n = 2; fs.existsSync(path.join(dir, name)); n++) name = `${stamp()}-${n}.yaml`;
+    fs.writeFileSync(path.join(dir, name), text, "utf8");
+    for (const old of files.slice(0, Math.max(0, files.length + 1 - MAX))) {
+      try { fs.unlinkSync(path.join(dir, old)); } catch {}
+    }
+    return name;
+  } catch { return null; }
+}
+
+export function listVersions(file) {
+  try {
+    const dir = versionsDir(file);
+    return fs.readdirSync(dir).filter((f) => f.endsWith(".yaml")).sort().reverse().map((name) => {
+      const st = fs.statSync(path.join(dir, name));
+      return { name, at: new Date(st.mtimeMs).toISOString(), bytes: st.size };
+    });
+  } catch { return []; }
+}
+
+export function readVersion(file, name) {
+  const raw = String(name || "");
+  if (raw.includes("..") || raw.includes("/") || raw.includes("\\")) throw new Error("Versão inválida.");
+  const base = path.basename(raw);
+  if (!/^[\w.-]+\.yaml$/.test(base)) throw new Error("Versão inválida.");
+  try { return fs.readFileSync(path.join(versionsDir(file), base), "utf8"); }
+  catch { throw new Error("Versão não encontrada."); }
+}
+
+// quais slides mudaram entre duas listas (por índice; adicionado/removido conta como mudança)
+export function diffSlides(a, b) {
+  const A = Array.isArray(a) ? a : [], B = Array.isArray(b) ? b : [];
+  const n = Math.max(A.length, B.length), changed = [];
+  for (let i = 0; i < n; i++) {
+    if (JSON.stringify(A[i] ?? null) !== JSON.stringify(B[i] ?? null)) changed.push(i);
+  }
+  return changed;
+}
+
+export async function versionRoutes({ req, res, pathname, W, readJSON }) {
+  const send = (status, data) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(JSON.stringify(data)); };
+  if (pathname === "/api/versions" && req.method === "GET") {
+    if (!W?.file) return send(400, { error: "Abra uma apresentação primeiro." }), true;
+    send(200, { versions: listVersions(W.file) });
+    return true;
+  }
+  if (pathname === "/api/versions/show" && req.method === "POST") {
+    if (!W?.file) return send(400, { error: "Abra uma apresentação primeiro." }), true;
+    try {
+      const b = await readJSON(req);
+      const yaml = readVersion(W.file, b.name);
+      const spec = YAML.parse(yaml) || {};
+      send(200, { yaml, slides: Array.isArray(spec.slides) ? spec.slides : [], theme: spec.theme || null, palette: spec.palette || null });
+    } catch (e) { send(400, { error: e.message }); }
+    return true;
+  }
+  if (pathname === "/api/versions/restore" && req.method === "POST") {
+    if (!W?.file) return send(400, { error: "Abra uma apresentação primeiro." }), true;
+    try {
+      const b = await readJSON(req);
+      const yaml = readVersion(W.file, b.name);
+      snapshotVersion(W.file, fs.readFileSync(W.file, "utf8")); // o estado atual vira versão antes de voltar
+      fs.writeFileSync(W.file, yaml, "utf8");
+      send(200, { ok: true });
+    } catch (e) { send(400, { error: e.message }); }
+    return true;
+  }
+  return false;
+}

package/src/studio/video-download.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { youtubeId } from '../video-player.js';
+
+export async function downloadYoutube(url, dir, {spawnProcess=spawn, timeoutMs=180000, ffmpeg: suppliedFfmpeg}={}) {
+  const id=youtubeId(url);if(!id)throw new Error('Informe um link válido do YouTube.');
+  const folder=path.join(dir,'videos');fs.mkdirSync(folder,{recursive:true});
+  const file=path.join(folder,`${id}-${crypto.randomBytes(4).toString('hex')}.mp4`);
+  const local = process.platform === 'win32' && process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA,'SagaDeck','tools','yt-dlp.exe') : '';
+  const executable=process.env.SAGADECK_YTDLP || (local && fs.existsSync(local) ? local : 'yt-dlp');
+  const bin = process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA,'SagaDeck','python','imageio_ffmpeg','binaries') : '';
+  const ffmpeg = suppliedFfmpeg !== undefined ? suppliedFfmpeg : process.env.SAGADECK_FFMPEG || (bin && fs.existsSync(bin) ? fs.readdirSync(bin).filter(n=>/^ffmpeg.*\.exe$/.test(n)).map(n=>path.join(bin,n))[0] : undefined);
+  // sem ffmpeg não dá para juntar vídeo+áudio: baixa só o vídeo (mudo, ideal para loop de fundo)
+  const fmt = ffmpeg ? 'bestvideo[ext=mp4][vcodec^=avc1][height<=720]+bestaudio[ext=m4a]/best[ext=mp4][height<=720]' : 'bv[ext=mp4][height<=720]';
+  const args=['--ignore-config','--no-playlist','--no-overwrites','--max-filesize','100M','--socket-timeout','15','--retries','1','--js-runtimes',`node:${process.execPath}`,'-f',fmt,'--merge-output-format','mp4',...(ffmpeg?['--ffmpeg-location',ffmpeg]:[]),'-o',file,'--',`https://www.youtube.com/watch?v=${id}`];
+  await new Promise((resolve,reject)=>{
+    const child=spawnProcess(executable,args,{cwd:dir,windowsHide:true,stdio:['ignore','ignore','pipe']});let error='',settled=false;
+    const finish=(e)=>{if(settled)return;settled=true;clearTimeout(timer);e?reject(e):resolve()};
+    const timer=setTimeout(()=>{child.kill();finish(new Error('O download excedeu três minutos.'))},timeoutMs);
+    child.stderr?.on('data',d=>{error=(error+d.toString()).slice(-2000)});
+    child.on('error',e=>finish(new Error(e.code==='ENOENT'?'yt-dlp não instalado. Configure SAGADECK_YTDLP com o caminho do executável.':e.message)));
+    child.on('close',code=>finish(code===0?null:new Error(error||`Download falhou (${code}).`)));
+  });
+  if(!fs.existsSync(file)||!fs.statSync(file).size)throw new Error('O YouTube não forneceu um arquivo MP4.');
+  if(fs.statSync(file).size>100*1024*1024){fs.unlinkSync(file);throw new Error('Use um vídeo menor que 100 MB.');}
+  return {url:path.relative(dir,file).replace(/\\/g,'/'),source:`https://www.youtube.com/watch?v=${id}`};
+}

package/src/studio/visual-keys.js

@@ -0,0 +1,52 @@
+// Ajustes visuais (visualEdits) presos ao objeto certo, venha a mudança de onde vier (a pessoa, o formulário, a IA):
+//   - migração: chave antiga (grupo-N, pela ordem) vira a chave pelo conteúdo (grupo~impressão), deck antigo sem perda
+//   - continuidade: o texto de um objeto mudou (a chave pelo conteúdo muda junto): se no grupo sumiu exatamente um
+//     objeto e apareceu exatamente um, o ajuste passa para ele. Inserir ou apagar OUTRO objeto não mexe em nada.
+import { renderSlide } from "../build.js";
+
+const LEGACY = /^[\w-]+-\d+$/;
+function keysOf(slide, i, spec) {
+  try {
+    const { html } = renderSlide(slide, i, spec);
+    return [...html.matchAll(/data-vkey="([^"]+)"(?: data-vkey-old="([^"]+)")?/g)].map((m) => ({ key: m[1], old: m[2] || null }));
+  } catch { return null; }
+}
+const groupOf = (k) => String(k).split("~")[0];
+const content = (s) => { if (!s || typeof s !== "object") return ""; const { visualEdits, uid, review, ...rest } = s; return JSON.stringify(rest); };
+
+export function migrateLegacyKeys(spec) {
+  let moved = 0;
+  (spec?.slides || []).forEach((s, i) => {
+    const ve = s?.visualEdits;
+    if (!ve || !Object.keys(ve).some((k) => LEGACY.test(k) && !k.includes("~"))) return;
+    const keys = keysOf(s, i, spec);
+    if (!keys) return;
+    const next = { ...ve };
+    for (const { key, old } of keys) if (old && next[old] && !next[key]) { next[key] = next[old]; delete next[old]; moved++; }
+    s.visualEdits = next;
+  });
+  return moved;
+}
+
+export function carryVisualEdits(prev, next) {
+  let carried = 0;
+  const before = new Map((prev?.slides || []).filter((s) => s?.uid).map((s, i) => [s.uid, { s, i }]));
+  (next?.slides || []).forEach((s, i) => {
+    const ve = s?.visualEdits;
+    const p = s?.uid && before.get(s.uid);
+    if (!ve || !p || content(p.s) === content(s)) return;
+    const a = keysOf(p.s, p.i, prev), b = keysOf(s, i, next);
+    if (!a || !b) return;
+    const nowKeys = new Set(b.map((x) => x.key)), wasKeys = new Set(a.map((x) => x.key));
+    const out = { ...ve };
+    for (const k of Object.keys(ve)) {
+      if (nowKeys.has(k) || !k.includes("~")) continue;
+      const g = groupOf(k);
+      const gone = [...wasKeys].filter((x) => groupOf(x) === g && !nowKeys.has(x));
+      const came = [...nowKeys].filter((x) => groupOf(x) === g && !wasKeys.has(x));
+      if (gone.length === 1 && came.length === 1 && gone[0] === k && !out[came[0]]) { out[came[0]] = out[k]; delete out[k]; carried++; }
+    }
+    s.visualEdits = out;
+  });
+  return carried;
+}

package/src/studio/workspaces.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import fs from "node:fs";
+import { loadSpec } from "../build.js";
+export function scopePreviewHTML(html, req) {
+  const tab = String(req.headers['x-sagadeck-workspace'] || new URL(req.url, 'http://localhost').searchParams.get('_workspace') || '').slice(0, 100);
+  if (!tab) return html;
+  const value = JSON.stringify(tab).replace(/</g, '\\u003c');
+  return html.replace(/<head>/i, `<head><script>(function(){const id=${value},original=window.fetch.bind(window);window.fetch=(input,options)=>{const u=new URL(typeof input==='string'||input instanceof URL?input:input.url,location.href);if(u.origin!==location.origin)return original(input,options);const headers=new Headers(options?.headers||input?.headers);headers.set('x-sagadeck-workspace',id);return original(input,{...options,headers})}})();</script>`);
+}
+export function workspaceResolver({ opts, USER_HEADER, workspaces, newWorkspace }) {
+  function freshWorkspace(W) {
+    if (W.file && fs.existsSync(W.file)) {
+      const stat = fs.statSync(W.file); if (!stat.isFile()) return W;
+      const stamp = W.file+'|'+stat.mtimeMs+'|'+stat.size;
+      if (W.diskStamp !== stamp) { W.spec = loadSpec(W.file); W.diskStamp = stamp; }
+    }
+    return W;
+  }
+  function workspaceOf(req) {
+    const user = opts.multiuser ? String(req.headers[USER_HEADER] || "").trim() : "";
+    if (opts.multiuser && !user) return null;
+    if (!workspaces.has(user)) workspaces.set(user, newWorkspace(user));
+    const base = workspaces.get(user);
+    const tab = String(req.headers['x-sagadeck-workspace'] || new URL(req.url, 'http://localhost').searchParams.get('_workspace') || '').slice(0, 100);
+    if (!tab) return freshWorkspace(base);
+    const key = JSON.stringify([user, tab]);
+    if (!workspaces.has(key)) workspaces.set(key, { ...base, spec: structuredClone(base.spec), aiChats: new Map(), contextDocs: new Map() });
+    return freshWorkspace(workspaces.get(key));
+  }
+  return workspaceOf;
+}
+
+  const sameFile = (a, b) => { const n = (x) => path.resolve(String(x)); return process.platform === "win32" ? n(a).toLowerCase() === n(b).toLowerCase() : n(a) === n(b); };
+  export function staleTab(body, W, res) {
+    if (!body?.expectFile || !W.file || sameFile(body.expectFile, W.file)) return false;
+    res.writeHead(409, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ error: "Outra aba ou aparelho abriu outra apresentação neste Studio. Recarregue a página para continuar; esta mudança não foi gravada.", stale: true, file: W.file }));
+    return true;
+  }

package/src/table.js

@@ -0,0 +1,93 @@
+// Tabela de verdade (não figura): cabeçalho na cor do tema, números alinhados à direita com algarismos de mesma
+// largura, linha zebrada, destaque de linha/coluna/célula e linha de total. Serve ao layout `table` e ao elemento
+// `table` em qualquer lugar (conteúdo, canvas, add). Estilos: faixa (padrão), zebra, linhas, colunas (cada coluna
+// com uma cor da paleta) e cartão.
+import { md, esc } from "./markup.js";
+import { parseCSV } from "./csv.js";
+import { col } from "./themes.js";
+
+const STYLES = new Set(["faixa", "zebra", "linhas", "colunas", "cartao"]);
+const ALIGN = new Set(["left", "center", "right"]);
+// "1.234,5", "40%", "R$ 12", "-3,2", "10 mm", "2.218,0 m³/s": número (alinha à direita)
+const NUMERIC = /^\s*[-+−]?\s*(R\$|US\$|€|\$)?\s*[-+−]?\d[\d.,\s]*(%|‰|[a-zA-Zµ°³²/]{0,6})?\s*$/;
+const colorVar = (c) => {
+  if (!c) return null;
+  const v = String(c).trim();
+  if (/^c[1-5]$/.test(v)) return `var(--c-${v})`;
+  if (["hi", "em", "fg", "muted", "line", "surface"].includes(v)) return `var(--${v})`;
+  if (/^#?[0-9a-f]{6}$/i.test(v)) return `#${v.replace("#", "")}`;
+  if (/^(accent|alert|ink|paper)$/.test(v)) return `var(--c-${v})`;
+  return null;
+};
+
+// a cor real (hex) no tom claro do tema e o texto que se lê em cima dela (branco ou a tinta do tema)
+function hexOf(theme, c) {
+  if (!theme) return null;
+  const tone = theme.tones?.light || {};
+  const v = !c ? tone.em : ["hi", "em"].includes(c) ? tone[c] : c;
+  const h = String(col(theme, v) || "").replace("#", "");
+  return /^[0-9a-f]{6}$/i.test(h) ? h : null;
+}
+function onColor(theme, hex) {
+  if (!hex) return null;
+  const [r, g, b] = [0, 2, 4].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255).map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4));
+  const L = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  return L > 0.42 ? "#16181d" : "#ffffff";
+}
+
+// o que veio (head/cols/header + rows; rows de objetos; csv colado) → { head: [...] | null, rows: [[...]] }
+export function tableModel(t = {}) {
+  let head = Array.isArray(t.head) ? t.head : Array.isArray(t.cols) && t.cols.every((c) => typeof c !== "number") ? t.cols : null;
+  let rows = Array.isArray(t.rows) ? t.rows : [];
+  if (typeof t.csv === "string" && t.csv.trim()) {
+    const parsed = parseCSV(t.csv).rows.filter((r) => r.some((c) => String(c).trim()));
+    if (!head && t.header !== false) { head = parsed[0]; rows = parsed.slice(1); } else rows = parsed;
+  }
+  if (rows.length && rows.every((r) => r && typeof r === "object" && !Array.isArray(r))) {
+    const keys = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+    head = head || keys;
+    rows = rows.map((r) => keys.map((k) => r[k] ?? ""));
+  }
+  if (!head && t.header === true && rows.length) { head = rows[0]; rows = rows.slice(1); }
+  rows = rows.map((r) => (Array.isArray(r) ? r : [r]).map((c) => (c == null ? "" : c)));
+  const n = Math.max(head?.length || 0, ...rows.map((r) => r.length), 0);
+  rows = rows.map((r) => [...r, ...Array(Math.max(0, n - r.length)).fill("")]);
+  if (head) head = [...head, ...Array(Math.max(0, n - head.length)).fill("")];
+  return { head, rows, n };
+}
+
+export function tableHTML(t = {}, { size, cls = "", style = "", theme } = {}) {
+  const { head, rows, n } = tableModel(t);
+  if (!n) throw new Error("tabela vazia: dê `rows` (lista de linhas) e, se quiser, `head` (os títulos das colunas)");
+  const kind = STYLES.has(t.style) ? t.style : "faixa";
+  // alinhamento: o pedido, senão número à direita e texto à esquerda (pela maioria da coluna)
+  const align = Array.from({ length: n }, (_, j) => {
+    const want = Array.isArray(t.align) ? t.align[j] : typeof t.align === "string" ? t.align : null;
+    if (ALIGN.has(want)) return want;
+    const vals = rows.map((r) => String(r[j]).trim()).filter(Boolean);
+    return vals.length && vals.filter((v) => NUMERIC.test(v)).length / vals.length >= 0.6 ? "right" : "left";
+  });
+  // letra pelo tamanho da tabela (o ajuste para caber ainda encolhe se faltar lugar)
+  const cells = rows.length * n;
+  const fs = Number(size || t.size) || (cells <= 12 ? 50 : cells <= 30 ? 44 : cells <= 60 ? 36 : cells <= 120 ? 28 : 22);
+  const hl = t.highlight || {};
+  const hlRows = new Set((Array.isArray(hl.rows) ? hl.rows : hl.row != null ? [hl.row] : Array.isArray(t.highlight) ? t.highlight : []).map(Number));
+  const hlCols = new Set((Array.isArray(hl.cols) ? hl.cols : hl.col != null ? [hl.col] : []).map(Number));
+  const hlCell = Array.isArray(hl.cell) ? hl.cell.map(Number) : null;
+  const total = t.total === true;
+  const color = colorVar(t.color);
+  // texto do cabeçalho legível sobre a cor (amarelo e dourado pedem texto escuro)
+  const on = onColor(theme, hexOf(theme, /^c[1-5]$|^#?[0-9a-f]{6}$|^(hi|em|accent|alert)$/i.test(String(t.color || "")) ? String(t.color) : null));
+  const vars = `${color ? `--tb-c:${color};` : ""}${on ? `--on-tb:${on};` : ""}font-size:${fs}px;`;
+  const kOn = (j) => (kind === "colunas" ? onColor(theme, hexOf(theme, `c${(j % 5) + 1}`)) : null);
+  const cell = (v, j, tag, extra = "") => `<${tag} class="${align[j] === "right" ? "num" : align[j] === "center" ? "mid" : ""}${extra}">${md(String(v))}</${tag}>`;
+  const wsum = Array.isArray(t.widths) ? t.widths.reduce((a, b) => a + (Number(b) || 1), 0) : 0;
+  const colgroup = Array.isArray(t.widths) && t.widths.length === n ? `<colgroup>${t.widths.map((w) => `<col style="width:${((100 * (Number(w) || 1)) / wsum).toFixed(2)}%">`).join("")}</colgroup>` : "";
+  const thead = head ? `<thead><tr>${head.map((h, j) => { const c = cell(h, j, "th", `${kind === "colunas" ? ` tb-k${(j % 5) + 1}` : ""}${hlCols.has(j + 1) ? " hl" : ""}`); return kOn(j) ? c.replace("<th ", `<th style="color:${kOn(j)}" `) : c; }).join("")}</tr></thead>` : "";
+  const tbody = `<tbody>${rows.map((r, i) => `<tr class="${hlRows.has(i + 1) ? "hl" : ""}${total && i === rows.length - 1 ? " tot" : ""}">${r.map((v, j) => cell(v, j, j === 0 && t.rowHeader ? "th" : "td", `${hlCols.has(j + 1) ? " hl" : ""}${hlCell && hlCell[0] === i + 1 && hlCell[1] === j + 1 ? " hlc" : ""}`)).join("")}</tr>`).join("")}</tbody>`;
+  // data-fit: não coube (colunas demais, conclusão ao lado), a letra encolhe até caber (src/runtime/fit.js)
+  return `<div class="dtable-wrap tb-${kind}${cls ? ` ${cls}` : ""}" data-fit data-fit-self style="${vars}${style}"><table class="dtable f-body">${colgroup}${thead}${tbody}</table></div>`;
+}
+
+export const TABLE_STYLES = [...STYLES];
+void esc;