@brianmsm/quarto-bento 0.0.0-stage → 0.1.0

package/distribution/runtime/src/render/shell.ts

@@ -0,0 +1,110 @@
+/** Offline shell with readable notices retained by native Bento self-save. */
+export const SHELL_NOTICES_ID = "qbento-third-party-notices";
+export interface ShellNotices {
+  schemaVersion: 1;
+  scope:
+    "project-license-and-pinned-bento-fonts-and-production-archive-notices";
+  files: {
+    path: string;
+    component?: "Quarto-Bento";
+    sha256: string;
+    text: string;
+  }[];
+}
+
+// The pinned Bento runtime puts a chart colour into a quoted tooltip style
+// attribute before assigning innerHTML. A native dropped document reaches that
+// renderer before Quarto-Bento can validate it, so guard the sink in the shell
+// bootstrap as well as at project ingress. Keep the upstream bytes pinned and
+// fail closed if the exact reviewed runtime changes.
+const tooltipColorSink = "background:${A.color};margin-right:5px";
+const escapedTooltipColorSink =
+  'background:${String(A.color).replaceAll("&","&amp;").replaceAll(\'"\',"&quot;").replaceAll("<","&lt;").replaceAll(">","&gt;")};margin-right:5px';
+const runtimeBootstrap = "    var js = inflate('bento-rt')";
+function guardNativeTooltip(shell: string): string {
+  if (shell.split(runtimeBootstrap).length !== 2) {
+    throw new Error("BENTO_TOOLTIP_PIN_MISMATCH: runtime bootstrap changed");
+  }
+  const patch = `    var js = inflate('bento-rt')
+    var qbentoTooltipSink = ${JSON.stringify(tooltipColorSink)}
+    if (js.split(qbentoTooltipSink).length !== 2) throw new Error('BENTO_TOOLTIP_PIN_MISMATCH: tooltip changed')
+    js = js.replace(qbentoTooltipSink, ${
+    JSON.stringify(escapedTooltipColorSink)
+  })`;
+  return shell.replace(runtimeBootstrap, patch);
+}
+
+async function sha256(text: string): Promise<string> {
+  return Array.from(
+    new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)),
+    ),
+    (n) => n.toString(16).padStart(2, "0"),
+  ).join("");
+}
+
+/** Keep the vendored shell unchanged; guard its pinned tooltip and add notices
+ * before its pristine capture.
+ * The inert data block is outside BentoDoc, never a runtime-owned transient.
+ * The pinned kernel therefore retains it through native serialization/save.
+ * The project's MIT license is labeled separately from pinned upstream texts.
+ * This carriage does not certify complete third-party coverage.
+ */
+export async function loadBentoShell(): Promise<string> {
+  const vendor = new URL("../../vendor/bento/", import.meta.url);
+  const pin = JSON.parse(
+    await Deno.readTextFile(new URL("pin.json", vendor)),
+  );
+  const readPinned = async (path: string, expected: unknown) => {
+    const text = await Deno.readTextFile(new URL(path, vendor));
+    const digest = await sha256(text);
+    if (typeof expected !== "string" || digest !== expected) {
+      throw new Error(
+        `BENTO_NOTICE_INTEGRITY: pinned bytes differ for ${path}`,
+      );
+    }
+    return { path, sha256: digest, text };
+  };
+  const [shell, ...files] = await Promise.all([
+    readPinned("shell.html", pin.shellSha256),
+    readPinned("LICENSE", pin.upstreamArtifacts?.license?.sha256),
+    readPinned(
+      "THIRD_PARTY_NOTICES.md",
+      pin.upstreamArtifacts?.thirdPartyNotices?.sha256,
+    ),
+    readPinned("FONT_NOTICES.md", pin.fontNotices?.sha256),
+    readPinned("runtime-licenses.json", pin.runtimeLicenseInventory?.sha256),
+    readPinned(
+      "font-licenses/fraunces-OFL.txt",
+      pin.fontLicenseArtifacts?.fraunces?.sha256,
+    ),
+    readPinned(
+      "font-licenses/instrument-sans-OFL.txt",
+      pin.fontLicenseArtifacts?.instrumentSans?.sha256,
+    ),
+  ]);
+  // This resource has the same relative path in the checkout, portable runtime
+  // and installed extension. Read lazily so importing the loader performs no I/O.
+  const projectLicense = await Deno.readTextFile(
+    new URL("../../LICENSE", import.meta.url),
+  );
+  const notices: ShellNotices = {
+    schemaVersion: 1,
+    scope:
+      "project-license-and-pinned-bento-fonts-and-production-archive-notices",
+    files: [...files, {
+      path: "Quarto-Bento/LICENSE",
+      component: "Quarto-Bento",
+      sha256: await sha256(projectLicense),
+      text: projectLicense,
+    }],
+  };
+  // Escaping '<' also makes future supplied text containing script-close tokens
+  // safe. JSON decoding recovers the full original text, including newlines.
+  const body = JSON.stringify(notices).replaceAll("<", "\\u003c");
+  return guardNativeTooltip(shell.text).replace(
+    /<head([^>]*)>/i,
+    (_match, attributes) =>
+      `<head${attributes}><script id="${SHELL_NOTICES_ID}" type="application/json">${body}</script>`,
+  );
+}

package/distribution/runtime/src/render/source-inline.ts

@@ -0,0 +1,169 @@
+import {
+  authoredImageData,
+  type AuthoredImageShape,
+  originalImageShape,
+} from "./images.ts";
+/** Read authored fragments with Pandoc only; never execute Quarto or infer output. */
+import type { SourceDocument } from "../source/mod.ts";
+import { mathToNativeHtml } from "./math.ts";
+import { renderList } from "./lists.ts";
+import { renderInline } from "./inline.ts";
+import type { Node } from "./types.ts";
+export interface SourceInlineProof {
+  sourceHash: string;
+  blockId: string;
+  kind: "heading" | "paragraph" | "list" | "math" | "code" | "image";
+  html: string;
+  image?: AuthoredImageShape & { data?: string };
+  code?: { content: string; grammarName: string | null };
+  readerId?: string;
+}
+export async function readSourceInline(
+  source: SourceDocument,
+  imageRoot?: string,
+): Promise<ReadonlyMap<string, SourceInlineProof>> {
+  const fragments = source.blocks.filter((block) =>
+    block.origin === "authored" && block.editable &&
+    ["heading", "paragraph", "list", "math", "code", "image"].includes(
+      block.kind,
+    )
+  );
+  const proofs = new Map<string, SourceInlineProof>();
+  if (!fragments.length) return proofs;
+  // Every fragment has an independent boundary. Heading order is retained so
+  // Pandoc's duplicate automatic identifiers match the original document.
+  const input = fragments.map((block, index) =>
+    `::: {#qbento-inline-proof-${index}}\n\n${block.raw}\n\n:::\n`
+  ).join("\n");
+  const process = new Deno.Command("quarto", {
+    args: ["pandoc", "--from", "markdown", "--to", "json"],
+    stdin: "piped",
+    stdout: "piped",
+    stderr: "piped",
+  }).spawn();
+  const output = process.output(), writer = process.stdin.getWriter();
+  await writer.write(new TextEncoder().encode(input));
+  await writer.close();
+  const result = await output;
+  if (!result.success) {
+    throw new Error(
+      "UNMAPPED_PROVENANCE: Pandoc could not read original authored fragments",
+    );
+  }
+  const parsed = JSON.parse(new TextDecoder().decode(result.stdout));
+  if (
+    !Array.isArray(parsed.blocks) || parsed.blocks.length !== fragments.length
+  ) {
+    throw new Error(
+      "UNMAPPED_PROVENANCE: original fragment reader boundaries differ",
+    );
+  }
+  for (const [index, block] of fragments.entries()) {
+    const wrapper = parsed.blocks[index] as Node;
+    const [attr, children] = wrapper.c as [
+      [string, string[], unknown[]],
+      Node[],
+    ];
+    if (
+      wrapper.t !== "Div" || attr[0] !== `qbento-inline-proof-${index}` ||
+      children.length !== 1
+    ) {
+      throw new Error(
+        "UNMAPPED_PROVENANCE: original fragment is not one faithful inline block",
+      );
+    }
+    const node = children[0];
+    if (block.kind === "image") {
+      const image = originalImageShape(node);
+      const data = imageRoot
+        ? await authoredImageData(image, imageRoot)
+        : undefined;
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "image",
+        html: image.captionHtml,
+        image: { ...image, ...(data ? { data } : {}) },
+      });
+    } else if (block.kind === "heading" && node.t === "Header") {
+      const [level, headerAttr, nodes] = node.c as [
+        number,
+        [string, string[], unknown[]],
+        Node[],
+      ];
+      if (level !== block.level) {
+        throw new Error("UNMAPPED_PROVENANCE: original heading level differs");
+      }
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "heading",
+        html: renderInline(nodes),
+        readerId: headerAttr[0],
+      });
+    } else if (block.kind === "code" && node.t === "CodeBlock") {
+      const [attributes, content] = node.c as [
+        [string, string[], unknown[]],
+        string,
+      ];
+      if (
+        attributes[1].length > 1 ||
+        content !== block.content.replace(/\r\n/g, "\n").replace(/\n$/, "")
+      ) {
+        throw new Error("UNMAPPED_PROVENANCE: original displayed code differs");
+      }
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "code",
+        html: "",
+        code: { content, grammarName: attributes[1][0] ?? null },
+      });
+    } else if (block.kind === "math" && node.t === "Para") {
+      const nodes = node.c as Node[];
+      const formula = nodes.length === 1 && nodes[0].t === "Math"
+        ? nodes[0].c as [{ t: string }, string]
+        : undefined;
+      if (
+        !formula || formula[0].t !== "DisplayMath" ||
+        mathToNativeHtml(formula[1]) !== mathToNativeHtml(block.content)
+      ) {
+        throw new Error(
+          "UNMAPPED_PROVENANCE: original display equation differs",
+        );
+      }
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "math",
+        html: mathToNativeHtml(formula[1]),
+      });
+    } else if (block.kind === "paragraph" && node.t === "Para") {
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "paragraph",
+        html: renderInline(node.c as Node[]),
+      });
+    } else if (
+      block.kind === "list" && ["BulletList", "OrderedList"].includes(node.t)
+    ) {
+      if (/^\s*(?:[-+*]|[0-9]+[.)])\s+\[[ xX]\](?:\s|$)/m.test(block.content)) {
+        throw new Error(
+          "UNSUPPORTED_LIST: task-list checkbox semantics need a dedicated native adapter",
+        );
+      }
+      proofs.set(block.id, {
+        sourceHash: source.hash,
+        blockId: block.id,
+        kind: "list",
+        html: renderList(node),
+      });
+    } else {
+      throw new Error(
+        "UNMAPPED_PROVENANCE: original fragment is not faithful supported text",
+      );
+    }
+  }
+  return proofs;
+}

package/distribution/runtime/src/render/table.ts

@@ -0,0 +1,220 @@
+/** Faithful rectangular plain-text subset of Pandoc tables -> pinned native Bento tables. */
+import type { Frame } from "./design.ts";
+import { escapeHtml } from "./html.ts";
+import type { Element, Node } from "./types.ts";
+export const TABLE_CODEC_VERSION = 1;
+export type TableAlign = "left" | "center" | "right";
+export interface PlainTable {
+  header: boolean;
+  columns: { width: number; align: TableAlign }[];
+  rows: { text: string; align: TableAlign }[][];
+}
+function fail(message: string): never {
+  throw new Error(`UNSUPPORTED_TABLE: ${message}`);
+}
+function array(value: unknown, length?: number): unknown[] {
+  if (
+    !Array.isArray(value) || length !== undefined && value.length !== length
+  ) {
+    fail("Malformed table structure.");
+  }
+  return value;
+}
+function attr(value: unknown, allowed: string[] = []) {
+  const [id, classes, pairs] = array(value, 3);
+  if (
+    id !== "" ||
+    array(classes).some((c) => typeof c !== "string" || !allowed.includes(c)) ||
+    array(pairs).length
+  ) {
+    fail("Cell, row and table attributes need an explicit supported mapping.");
+  }
+}
+function alignment(value: unknown, fallback: TableAlign = "left"): TableAlign {
+  const name = (value as Node)?.t;
+  if (name === "AlignDefault") return fallback;
+  if (name === "AlignLeft") return "left";
+  if (name === "AlignCenter") return "center";
+  if (name === "AlignRight") return "right";
+  return fail("Unknown column/cell alignment.");
+}
+function cellText(value: unknown): string {
+  const blocks = array(value);
+  if (!blocks.length) return "";
+  if (blocks.length !== 1) {
+    fail("Multiple paragraphs in a cell are not supported.");
+  }
+  const block = blocks[0] as Node;
+  if (!block || !["Plain", "Para"].includes(block.t)) {
+    fail("Cells must contain one plain-text paragraph.");
+  }
+  return array(block.c).map((value) => {
+    const node = value as Node;
+    if (node.t === "Str" && typeof node.c === "string") return node.c;
+    if (node.t === "Space") return " ";
+    return fail(
+      `Cell content ${node.t} needs a faithful rich-content adapter; no content was flattened.`,
+    );
+  }).join("");
+}
+export function plainTable(node: Node): PlainTable {
+  if (node.t !== "Table") fail("Expected a Pandoc Table node.");
+  const [attributes, caption, specs, head, bodies, foot] = array(node.c, 6);
+  attr(attributes, ["caption-top"]);
+  const [shortCaption, longCaption] = array(caption, 2);
+  if (shortCaption !== null || array(longCaption).length) {
+    fail("Captions need a supported semantic/visual mapping.");
+  }
+  const columns = array(specs).map((value) => {
+    const [align, widthValue] = array(value, 2), width = widthValue as Node;
+    if (!width || !["ColWidthDefault", "ColWidth"].includes(width.t)) {
+      fail("Unknown column width.");
+    }
+    const w = width.t === "ColWidthDefault" ? 1 : width.c;
+    if (typeof w !== "number" || !Number.isFinite(w) || w <= 0) {
+      fail("Column widths must be finite positive weights.");
+    }
+    return { width: w, align: alignment(align) };
+  });
+  if (!columns.length || columns.length > 200) {
+    fail("Use between 1 and 200 columns.");
+  }
+  const widthKinds = new Set(
+    array(specs).map((value) => (array(value, 2)[1] as Node).t),
+  );
+  if (widthKinds.size > 1) {
+    fail(
+      "Mixed automatic and explicit widths need an explicit layout decision.",
+    );
+  }
+  const [headAttr, headRows] = array(head, 2);
+  const [footAttr, footRows] = array(foot, 2);
+  attr(headAttr);
+  attr(footAttr);
+  if (array(headRows).length > 1 || array(footRows).length) {
+    fail("Multiple header rows and table footers are not supported.");
+  }
+  if (array(bodies).length !== 1) {
+    fail("Multiple table bodies are not supported.");
+  }
+  const [bodyAttr, rowHeads, intermediateHeads, bodyRows] = array(
+    array(bodies)[0],
+    4,
+  );
+  attr(bodyAttr);
+  if (rowHeads !== 0 || array(intermediateHeads).length) {
+    fail("Row headers and intermediate header sections are not supported.");
+  }
+  const rows = [...array(headRows), ...array(bodyRows)].map((value) => {
+    const [rowAttr, cells] = array(value, 2);
+    attr(rowAttr, ["header", "odd", "even"]);
+    if (array(cells).length !== columns.length) {
+      fail("Rows must be rectangular with one cell per column.");
+    }
+    return array(cells).map((value, index) => {
+      const [cellAttr, align, rowSpan, colSpan, content] = array(value, 5);
+      attr(cellAttr);
+      if (rowSpan !== 1 || colSpan !== 1) {
+        fail("Merged cells and row/column spans are not supported.");
+      }
+      return {
+        text: cellText(content),
+        align: alignment(align, columns[index].align),
+      };
+    });
+  });
+  if (!rows.length || rows.length > 2000) fail("Use between 1 and 2000 rows.");
+  return { header: array(headRows).length === 1, columns, rows };
+}
+export function projectTable(
+  node: Node,
+  id: string,
+  y = 166,
+  frame?: Frame,
+): Element {
+  const table = plainTable(node);
+  const fontSize = 18, cellPadX = 16, cellPadY = 11, borderWidth = 1;
+  const width = frame?.w ?? 1120;
+  const height = tableHeight(
+    table,
+    frame ?? { x: 80, y, w: width, h: 720 - y },
+    y,
+  );
+  if (y + height > 720) {
+    throw new Error(
+      "UNSUPPORTED_TABLE_LAYOUT: the complete table exceeds the projected slide area.",
+    );
+  }
+  return {
+    id,
+    type: "table",
+    x: frame?.x ?? 80,
+    y,
+    w: width,
+    h: height,
+    rotation: 0,
+    opacity: 1,
+    header: table.header,
+    columns: table.columns.map((column) => ({ w: column.width })),
+    rows: table.rows.map((row) => ({
+      cells: row.map((cell) => ({
+        html: escapeHtml(cell.text),
+        align: cell.align,
+      })),
+    })),
+    style: {
+      headerBg: "#1E2A3A",
+      headerColor: "#FFFFFF",
+      zebra: "rgba(30,42,58,0.05)",
+      borderColor: "rgba(30,42,58,0.14)",
+      borderWidth,
+      cellPadX,
+      cellPadY,
+      fontSize,
+      color: "#1E2A3A",
+      radius: 10,
+    },
+  };
+}
+
+/** Shared conservative metrics for projection and explicit reusable-layout placement. */
+export function tableHeight(
+  table: PlainTable,
+  frame: Frame,
+  y = frame.y,
+): number {
+  const fontSize = 18, cellPadX = 16, cellPadY = 11, borderWidth = 1;
+  // Match native line-height/padding/border before adding a small rounding margin.
+  // A conservative single-line width gate avoids claiming unmeasured wrapping.
+  const width = frame.w,
+    totalWeight = table.columns.reduce((sum, column) => sum + column.width, 0);
+  for (const [rowIndex, row] of table.rows.entries()) {
+    for (const [columnIndex, cell] of row.entries()) {
+      const usableWidth =
+        width * table.columns[columnIndex].width / totalWeight - cellPadX * 2 -
+        borderWidth * 2;
+      if (
+        usableWidth <= 0 ||
+        Array.from(cell.text).length * fontSize * 2 > usableWidth
+      ) {
+        throw new Error(
+          `UNSUPPORTED_TABLE_LAYOUT: row ${rowIndex + 1}, column ${
+            columnIndex + 1
+          } exceeds the conservative single-line width limit; shorten or split the source table. Wrapped table-cell layout needs separate measured support.`,
+        );
+      }
+    }
+  }
+  const rowHeight = Math.ceil(fontSize * 1.3 + cellPadY * 2 + borderWidth * 2) +
+    8;
+  const height = Math.max(100, table.rows.length * rowHeight);
+  if (
+    !Number.isFinite(width) || width <= 0 || y < 0 ||
+    (y < frame.y || y + height > frame.y + frame.h + .01)
+  ) {
+    throw new Error(
+      "UNSUPPORTED_TABLE_LAYOUT: the complete table does not fit in the remaining slide area; split it into smaller source tables rather than clipping rows.",
+    );
+  }
+  return height;
+}