@brianmsm/quarto-bento 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,290 @@
+import { originalAttributeTokens } from "./attributes.ts";
+/** Independent proof for the supported literal original-QMD pipe-table subset. */
+import { escapeHtml } from "../render/html.ts";
+import type { PlainTable, TableAlign } from "../render/table.ts";
+import type { Element, Json } from "../render/types.ts";
+import {
+  hashSource,
+  scanSource,
+  type SourceBlock,
+  type SourceDocument,
+} from "./mod.ts";
+function fail(message: string): never {
+  throw new Error(`UNMAPPED_TABLE_SOURCE: ${message}`);
+}
+function bodyBlocks(doc: SourceDocument, block: SourceBlock) {
+  return doc.blocks.filter((b) =>
+    b !== block && b.span.start >= block.contentSpan.start &&
+    b.span.end <= block.contentSpan.end
+  );
+}
+/** Pipes must have explicit outside delimiters; escaped punctuation remains literal. */
+function cells(line: string): string[] {
+  let trailingSlashes = 0;
+  for (let i = line.length - 2; i >= 0 && line[i] === "\\"; i--) {
+    trailingSlashes++;
+  }
+  if (!line.startsWith("|") || !line.endsWith("|") || trailingSlashes % 2) {
+    fail("Use explicit outer pipes for every row.");
+  }
+  const result: string[] = [];
+  let cell = "";
+  for (let i = 1; i < line.length - 1; i++) {
+    const char = line[i];
+    if (
+      char === "\\" &&
+      /[!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~]/.test(line[i + 1] ?? "")
+    ) {
+      cell += char + line[++i];
+    } else if (char === "|") {
+      result.push(cell.trim());
+      cell = "";
+    } else cell += char;
+  }
+  result.push(cell.trim());
+  return result;
+}
+export function parsePipeTable(content: string): PlainTable {
+  const lines = content.replace(/\r\n|\r/g, "\n").replace(/^\n+|\n+$/g, "")
+    .split("\n");
+  if (
+    lines.length < 2 || lines.some((line) => !line.trim() || /^\s/.test(line))
+  ) fail("Use one contiguous, unindented pipe table.");
+  const header = cells(lines[0]), separator = cells(lines[1]);
+  if (
+    header.length !== separator.length ||
+    !separator.every((cell) => /^:?-{3,}:?$/.test(cell))
+  ) {
+    fail(
+      "The second row must declare one Markdown column separator per header.",
+    );
+  }
+  const columns = separator.map((
+    cell,
+  ): { width: number; align: TableAlign } => ({
+    width: 1,
+    align: cell.endsWith(":")
+      ? cell.startsWith(":") ? "center" : "right"
+      : "left",
+  }));
+  const rows = [header, ...lines.slice(2).map(cells)].map((row) => {
+    if (row.length !== columns.length) fail("Source table is not rectangular.");
+    return row.map((cell, index) => ({
+      text: cell.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~])/g, "$1"),
+      align: columns[index].align,
+    }));
+  });
+  return { header: true, columns, rows };
+}
+export function authoredTableBlock(
+  doc: SourceDocument,
+  wrapperId: string,
+): SourceBlock {
+  if (doc.diagnostics.length) {
+    fail("Resolve source mapping diagnostics before rendering tables.");
+  }
+  const wrappers = doc.blocks.filter((b) =>
+    b.id === wrapperId && b.kind === "div" && b.stable && b.explicitId
+  );
+  if (wrappers.length !== 1) {
+    fail("An authored table needs a unique identified fenced-div wrapper.");
+  }
+  const wrapper = wrappers[0], blocks = bodyBlocks(doc, wrapper);
+  if (
+    blocks.length !== 1 || blocks[0].kind !== "unsupported" ||
+    blocks[0].parentId !== wrapper.id || blocks[0].origin !== "authored"
+  ) {
+    fail(
+      "The identified wrapper must contain exactly one literal pipe table and no computed or other content.",
+    );
+  }
+  parsePipeTable(blocks[0].content);
+  return blocks[0];
+}
+/** A native identity binding must be explicit in the original table wrapper. */
+export function tableNativeIdentity(
+  doc: SourceDocument,
+  wrapperId: string,
+): string | undefined {
+  const original = scanSource(doc.text);
+  authoredTableBlock(original, wrapperId);
+  const wrapper = original.blocks.find((block) => block.id === wrapperId)!;
+  const content = /^ {0,3}:{3,}\s*\{([^{}]*)\}\s*$/.exec(
+    wrapper.raw.split(/\r?\n/)[0],
+  )?.[1];
+  if (content === undefined) {
+    fail("Table wrapper requires original literal attributes.");
+  }
+  const attributes = originalAttributeTokens(content).filter((token) =>
+    token.key === "bento-element-id"
+  );
+  if (attributes.length > 1) {
+    fail("Table wrapper has ambiguous native identities.");
+  }
+  return attributes[0]?.value;
+}
+/** Exact semantic fields, independent of native geometry and table styling. */
+export function literalTableContent(content: string): Record<string, Json> {
+  const table = parsePipeTable(content);
+  return {
+    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,
+      })),
+    })),
+  };
+}
+export function tableContent(element: Element): Record<string, Json> {
+  return {
+    header: element.header,
+    columns: element.columns,
+    rows: element.rows,
+  };
+}
+/** Only the original source bytes may establish a literal table fragment. */
+export function literalTableBlock(
+  doc: SourceDocument,
+  blockId: string,
+): SourceBlock {
+  if (doc.hash !== hashSource(doc.text)) {
+    fail("Original table source snapshot is stale.");
+  }
+  const original = scanSource(doc.text),
+    candidates = original.blocks.filter((b) => b.id === blockId);
+  if (
+    original.diagnostics.length || candidates.length !== 1 ||
+    candidates[0].kind !== "unsupported" || candidates[0].origin !== "authored"
+  ) {
+    fail("Table has no unique literal original source fragment.");
+  }
+  const block = candidates[0].parentId
+    ? authoredTableBlock(original, candidates[0].parentId)
+    : candidates[0];
+  if (block.id !== blockId) {
+    fail("Original table fragment does not match its container.");
+  }
+  parsePipeTable(block.content);
+  return block;
+}
+export function validateAuthoredTable(
+  doc: SourceDocument,
+  blockId: string,
+  element: Element,
+): SourceBlock {
+  const block = literalTableBlock(doc, blockId);
+  if (
+    element.type !== "table" ||
+    JSON.stringify(tableContent(element)) !==
+      JSON.stringify(literalTableContent(block.content))
+  ) {
+    fail(
+      "Executed table cells, header or alignment differ from the exact literal source proof.",
+    );
+  }
+  return block;
+}
+/** Recognize only complete literal top-level tables, never arbitrary unsupported blocks. */
+export function bareTableBlocks(doc: SourceDocument): SourceBlock[] {
+  if (doc.hash !== hashSource(doc.text)) {
+    fail("Original table source snapshot is stale.");
+  }
+  const original = scanSource(doc.text);
+  if (original.diagnostics.length) {
+    fail("Resolve source mapping diagnostics before binding a bare table.");
+  }
+  return original.blocks.filter((block) => {
+    if (
+      block.kind !== "unsupported" || block.parentId ||
+      block.origin !== "authored"
+    ) return false;
+    try {
+      parsePipeTable(block.content);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+/** Coverage also applies after an approved wrapper makes a formerly bare table stable. */
+export function literalTableBlocks(doc: SourceDocument): SourceBlock[] {
+  if (doc.hash !== hashSource(doc.text)) {
+    fail("Original table source snapshot is stale.");
+  }
+  const original = scanSource(doc.text);
+  if (original.diagnostics.length) {
+    fail("Resolve source mapping diagnostics before table coverage checks.");
+  }
+  return original.blocks.filter((block) => {
+    if (block.kind !== "unsupported" || block.origin !== "authored") {
+      return false;
+    }
+    try {
+      literalTableBlock(original, block.id);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+/** Bare tables without IDs require a unique exact whole-table source match. */
+export function matchBareTable(
+  doc: SourceDocument,
+  element: Element,
+): SourceBlock {
+  if (doc.hash !== hashSource(doc.text)) {
+    fail("Original table source snapshot is stale.");
+  }
+  const original = scanSource(doc.text);
+  if (original.diagnostics.length) {
+    fail("Resolve source mapping diagnostics before binding a bare table.");
+  }
+  const matches = bareTableBlocks(original).filter((block) => {
+    try {
+      return JSON.stringify(literalTableContent(block.content)) ===
+        JSON.stringify(tableContent(element));
+    } catch {
+      return false;
+    }
+  });
+  if (matches.length !== 1) {
+    fail(
+      "A bare table needs one exact original literal table; duplicate or transformed tables require explicit source wrappers.",
+    );
+  }
+  return matches[0];
+}
+export function tableProducer(
+  doc: SourceDocument,
+  contextId: string,
+  verifiedProducerId?: string,
+): SourceBlock {
+  if (doc.hash !== hashSource(doc.text)) fail("Original source hash changed.");
+  const original = scanSource(doc.text);
+  if (original.diagnostics.length) {
+    fail("Resolve source mapping diagnostics before binding a computed table.");
+  }
+  const contexts = original.blocks.filter((b) => b.id === contextId);
+  if (contexts.length !== 1) {
+    fail(
+      "Computed table does not identify one original producer or container.",
+    );
+  }
+  const context = contexts[0];
+  if (
+    context.kind === "chunk" &&
+    (context.stable || verifiedProducerId === context.id)
+  ) return context;
+  if (context.kind === "div" && context.stable) {
+    const children = bodyBlocks(original, context);
+    if (
+      children.length === 1 && children[0].kind === "chunk" &&
+      children[0].stable
+    ) return children[0];
+  }
+  return fail(
+    "Wrap a single explicitly labelled producer chunk in an identified div; a table cannot guess which original computation produced it.",
+  );
+}

package/distribution/runtime/src/source/text-conversion.ts

@@ -0,0 +1,146 @@
+/** Explicit paragraph/list conversion over one independently bound source unit. */
+import {
+  scanSource,
+  sliceBytes,
+  type SourceDocument,
+  SourceError,
+  type Span,
+} from "./mod.ts";
+import { pureWrapper } from "./deletion.ts";
+import {
+  originalAttributeTokens,
+  originalPandocAttributes,
+} from "./attributes.ts";
+import { isNativeIdentity } from "./identity-id.ts";
+export interface TextConversion {
+  type: "convert-text";
+  blockId: string;
+  expected: string;
+  markdown: string;
+  from: "paragraph" | "list";
+  to: "paragraph" | "list";
+  nativeId: string;
+}
+const fail = (message: string): never => {
+  throw new SourceError("unsafe-text-conversion", message);
+};
+function binding(doc: SourceDocument, op: TextConversion) {
+  const blocks = doc.blocks.filter((b) => b.id === op.blockId),
+    block = blocks[0];
+  if (
+    doc.diagnostics.length || blocks.length !== 1 || !block.editable ||
+    block.origin !== "authored" || block.kind !== op.from ||
+    block.content !== op.expected || !block.slideId ||
+    !isNativeIdentity(op.nativeId) ||
+    !["paragraph", "list"].includes(op.from) ||
+    !["paragraph", "list"].includes(op.to) || op.from === op.to
+  ) {
+    fail(
+      "Conversion needs an exact independent authored paragraph/list baseline.",
+    );
+  }
+  const parent = block.parentId
+    ? doc.blocks.find((b) => b.id === block.parentId)
+    : undefined;
+  if (parent) {
+    if (!parent.stable || parent.parentId) {
+      fail("Nested or weak containers need explicit source authoring.");
+    }
+    pureWrapper(doc, parent, block);
+    if (block.explicitId && block.id !== op.nativeId) {
+      fail(
+        "The technical marker must retain its native identity during conversion.",
+      );
+    }
+  } else if (!block.stable || block.id !== op.nativeId) {
+    fail(
+      "Acquire an explicit source/native identity before converting this text.",
+    );
+  }
+  const parsed = scanSource(op.markdown), replacement = parsed.blocks[0];
+  if (
+    parsed.diagnostics.length || parsed.blocks.length !== 1 ||
+    replacement.kind !== op.to || !replacement.editable ||
+    replacement.origin !== "authored" || replacement.explicitId ||
+    replacement.parentId || replacement.content !== op.markdown ||
+    /<!--|-->|\{\{[<%]/.test(op.markdown)
+  ) {
+    fail(
+      "Replacement must be exactly one non-executable authored paragraph or list.",
+    );
+  }
+  return { block, parent };
+}
+export function convertedBlockId(
+  doc: SourceDocument,
+  op: TextConversion,
+): string {
+  const { block } = binding(doc, op);
+  return block.explicitId ??
+    (block.parentId ? `${block.parentId}/${op.to}:1` : block.id);
+}
+export function conversionEdits(
+  doc: SourceDocument,
+  op: TextConversion,
+): { span: Span; expected: string; replacement: string }[] {
+  const { block, parent } = binding(doc, op);
+  const edits = [{
+    span: block.contentSpan,
+    expected: block.content,
+    replacement: op.markdown.replace(/\r\n|\r|\n/g, doc.newline),
+  }];
+  if (parent && !block.explicitId) {
+    const opener = parent.raw.split(/\r?\n/)[0];
+    const attributeText = /\{([^{}]+)\}/.exec(opener)![1];
+    const attributes = originalPandocAttributes(
+      attributeText,
+      originalAttributeTokens(attributeText),
+    );
+    const existing = attributes[2].find(([key]) => key === "bento-element-id");
+    if (existing && existing[1] !== op.nativeId) {
+      fail(
+        "Container's explicit native identity differs from the edited object.",
+      );
+    }
+    if (!existing) {
+      const end = opener.lastIndexOf("}");
+      if (end < 0) fail("Missing verified wrapper attributes.");
+      const span = {
+        start: parent.span.start,
+        end: parent.span.start + new TextEncoder().encode(opener).length,
+      };
+      edits.push({
+        span,
+        expected: sliceBytes(doc.text, span),
+        replacement: opener.slice(0, end) +
+          ` bento-element-id="${op.nativeId}"` + opener.slice(end),
+      });
+    }
+  }
+  return edits;
+}
+export function verifyConversion(
+  before: SourceDocument,
+  after: SourceDocument,
+  op: TextConversion,
+): void {
+  const { block, parent } = binding(before, op),
+    id = convertedBlockId(before, op),
+    next = after.blocks.find((b) => b.id === id);
+  if (
+    !next || next.kind !== op.to || next.origin !== "authored" ||
+    !next.editable || next.slideId !== block.slideId ||
+    next.content.replace(/\r\n/g, "\n") !==
+      op.markdown.replace(/\r\n/g, "\n") ||
+    after.blocks.length !== before.blocks.length
+  ) fail("Conversion changed an unrelated source boundary.");
+  const prior = before.blocks.filter((b) => b !== block && b !== parent).map(
+    (b) => [b.id, b.kind, b.raw, b.origin],
+  );
+  const remaining = after.blocks.filter((b) =>
+    b.id !== id && b.id !== parent?.id
+  ).map((b) => [b.id, b.kind, b.raw, b.origin]);
+  if (JSON.stringify(prior) !== JSON.stringify(remaining)) {
+    fail("Conversion changed unrelated source bytes or identities.");
+  }
+}