@ferax564/noma-cli 0.11.0

package/src/fmt.ts

@@ -0,0 +1,126 @@
+/**
+ * Source formatter — currently scoped to GitHub-style pipe tables.
+ *
+ * The parser already accepts misaligned tables; this rewriter exists so the
+ * *source* stays readable even when cell widths drift (mixed `✓`/long-prose
+ * columns are the friction point). It only touches recognised pipe-table
+ * blocks; unrelated lines are byte-identical to the input.
+ */
+import { splitPipeRow } from "./inline.js";
+
+const TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+const TABLE_SEPARATOR_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+const FENCE_RE = /^```(\w*)\s*$/;
+
+interface Alignment {
+  left: boolean;
+  right: boolean;
+}
+
+function visibleWidth(s: string): number {
+  // js String.length — good enough for ASCII; not perfect for full-width
+  // CJK or emoji clusters, but predictable and dependency-free.
+  return Array.from(s).length;
+}
+
+const splitRow = splitPipeRow;
+
+function parseSeparator(line: string): Alignment[] | null {
+  if (!TABLE_SEPARATOR_RE.test(line)) return null;
+  return splitRow(line).map((c) => ({
+    left: c.startsWith(":"),
+    right: c.endsWith(":"),
+  }));
+}
+
+function buildSeparator(widths: number[], aligns: Alignment[]): string {
+  const cells = widths.map((w, i) => {
+    const a = aligns[i] ?? { left: false, right: false };
+    const target = Math.max(3, w);
+    if (a.left && a.right) return `:${"-".repeat(target - 2)}:`;
+    if (a.right) return `${"-".repeat(target - 1)}:`;
+    if (a.left) return `:${"-".repeat(target - 1)}`;
+    return "-".repeat(target);
+  });
+  return `| ${cells.join(" | ")} |`;
+}
+
+function pad(cell: string, width: number, align: Alignment): string {
+  const w = visibleWidth(cell);
+  const slack = Math.max(0, width - w);
+  if (align.left && align.right) {
+    const left = Math.floor(slack / 2);
+    const right = slack - left;
+    return " ".repeat(left) + cell + " ".repeat(right);
+  }
+  if (align.right) return " ".repeat(slack) + cell;
+  return cell + " ".repeat(slack);
+}
+
+function buildRow(
+  cells: string[],
+  widths: number[],
+  aligns: Alignment[],
+): string {
+  const padded = cells.map((c, i) =>
+    pad(c, widths[i] ?? visibleWidth(c), aligns[i] ?? { left: false, right: false }),
+  );
+  return `| ${padded.join(" | ")} |`;
+}
+
+export function formatSource(source: string): string {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const out: string[] = [];
+  let i = 0;
+  let inFence = false;
+
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (FENCE_RE.test(line)) {
+      inFence = !inFence;
+      out.push(line);
+      i++;
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      i++;
+      continue;
+    }
+    if (
+      TABLE_ROW_RE.test(line) &&
+      i + 1 < lines.length &&
+      TABLE_SEPARATOR_RE.test(lines[i + 1] ?? "")
+    ) {
+      const header = splitRow(line);
+      const sepAligns = parseSeparator(lines[i + 1] ?? "") ?? [];
+      const rows: string[][] = [];
+      let j = i + 2;
+      while (j < lines.length && TABLE_ROW_RE.test(lines[j] ?? "")) {
+        const cells = splitRow(lines[j] ?? "");
+        while (cells.length < header.length) cells.push("");
+        if (cells.length > header.length) cells.length = header.length;
+        rows.push(cells);
+        j++;
+      }
+      const widths = header.map((h, idx) =>
+        Math.max(
+          visibleWidth(h),
+          ...rows.map((r) => visibleWidth(r[idx] ?? "")),
+          3,
+        ),
+      );
+      const aligns: Alignment[] = header.map(
+        (_, idx) => sepAligns[idx] ?? { left: false, right: false },
+      );
+      out.push(buildRow(header, widths, aligns));
+      out.push(buildSeparator(widths, aligns));
+      for (const r of rows) out.push(buildRow(r, widths, aligns));
+      i = j;
+      continue;
+    }
+    out.push(line);
+    i++;
+  }
+  return out.join("\n");
+}

package/src/ids.ts

@@ -0,0 +1,42 @@
+import type { DocumentNode, Node } from "./ast.js";
+import { walk } from "./ast.js";
+
+export interface IdRecord {
+  id: string;
+  type: Node["type"];
+  name?: string;
+  title?: string;
+  aliases?: string[];
+  line?: number;
+}
+
+export interface IdRegistry {
+  ids: string[];
+  aliases: Record<string, string>;
+  records: IdRecord[];
+}
+
+export function collectIdRegistry(doc: DocumentNode): IdRegistry {
+  const ids: string[] = [];
+  const aliases: Record<string, string> = {};
+  const records: IdRecord[] = [];
+
+  for (const node of walk(doc)) {
+    if (!node.id) continue;
+    ids.push(node.id);
+    const record: IdRecord = {
+      id: node.id,
+      type: node.type,
+      ...(node.aliases && node.aliases.length > 0 ? { aliases: node.aliases } : {}),
+      ...(node.pos?.line ? { line: node.pos.line } : {}),
+    };
+    if (node.type === "directive") record.name = node.name;
+    if (node.type === "section") record.title = node.title;
+    records.push(record);
+    for (const alias of node.aliases ?? []) {
+      aliases[alias] = node.id;
+    }
+  }
+
+  return { ids, aliases, records };
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+export * from "./ast.js";
+export { parse, slugify } from "./parser.js";
+export type { ParseOptions } from "./parser.js";
+export { renderHtml } from "./renderer-html.js";
+export type { HtmlRenderOptions } from "./renderer-html.js";
+export { renderLlm } from "./renderer-llm.js";
+export { renderJson } from "./renderer-json.js";
+export type { JsonRenderOptions } from "./renderer-json.js";
+export { renderNoma } from "./renderer-noma.js";
+export type { NomaRenderOptions } from "./renderer-noma.js";
+export { patch, patchAll, patchSource, findById, PatchError } from "./patch.js";
+export type { PatchOp } from "./patch.js";
+export { loadBook, isBookManifestPath, listChapters } from "./book.js";
+export type { BookManifest } from "./book.js";
+export { validate, formatDiagnostics } from "./validator.js";
+export type { ValidateOptions } from "./validator.js";
+export { diffDocs } from "./diff.js";
+export type { DiffOptions } from "./diff.js";
+export { collectIdRegistry } from "./ids.js";
+export type { IdRecord, IdRegistry } from "./ids.js";

package/src/inline.ts

@@ -0,0 +1,92 @@
+/**
+ * Tiny inline markup parser. Operates on plain text and emits HTML.
+ * Order matters: handle code spans first so emphasis inside `code` stays raw.
+ */
+export function inlineToHtml(src: string): string {
+  let text = escapeHtml(src);
+
+  // Code spans go first AND get placeholdered so subsequent inline rules
+  // (emphasis, links, wikilinks) don't reach into their content. Without the
+  // placeholder, a sequence like `x_y` ... `a_b` lets the underscore regex
+  // greedily span across the rendered <code> tags.
+  const codeSpans: string[] = [];
+  const PH_OPEN = String.fromCharCode(2);
+  const PH_CLOSE = String.fromCharCode(3);
+  text = text.replace(/`([^`]+)`/g, (_m, body) => {
+    const i = codeSpans.push("<code>" + body + "</code>") - 1;
+    return PH_OPEN + i + PH_CLOSE;
+  });
+  text = text.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  text = text.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  text = text.replace(/\b_([^_]+)_\b/g, "<em>$1</em>");
+  text = text.replace(
+    /\[([^\]]+)\]\(([^)\s]+)\)/g,
+    (_m, label, href) => `<a href="${escapeAttr(href)}">${label}</a>`,
+  );
+  text = text.replace(/\[\[([a-zA-Z_][\w\-./:]*)\]\]/g, (_m, id) =>
+    `<a class="noma-ref" href="#${escapeAttr(id)}">${id}</a>`,
+  );
+  // CommonMark: a single newline inside a paragraph is a soft line break
+  // (renders as a space); two trailing spaces or a trailing backslash before
+  // the newline make it a hard break (`<br/>`).
+  text = text.replace(/(?:  +|\\)\n/g, "<br />");
+  text = text.replace(/\n/g, " ");
+  // Restore code-span placeholders.
+  const restoreRe = new RegExp(PH_OPEN + "(\\d+)" + PH_CLOSE, "g");
+  text = text.replace(restoreRe, (_m, i) => codeSpans[Number(i)] ?? "");
+  return text;
+}
+
+export function inlineToPlain(src: string): string {
+  return src
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/\*\*([^*]+)\*\*/g, "$1")
+    .replace(/\*([^*]+)\*/g, "$1")
+    .replace(/\b_([^_]+)_\b/g, "$1")
+    .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, "$1 ($2)")
+    .replace(/\[\[([a-zA-Z_][\w\-./:]*)\]\]/g, "$1");
+}
+
+export function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+export function escapeAttr(s: string): string {
+  return escapeHtml(s).replace(/"/g, "&quot;");
+}
+
+/**
+ * Split a pipe-table row respecting `code spans` and `\|` escapes — pipes
+ * inside backticks or escaped with a backslash are kept verbatim inside the
+ * cell. Used by the parser and by `noma fmt` so both agree on cell counts.
+ */
+export function splitPipeRow(line: string): string[] {
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  const cells: string[] = [];
+  let buf = "";
+  let inBacktick = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i]!;
+    if (ch === "\\" && trimmed[i + 1] === "|") {
+      buf += "\\|";
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = !inBacktick;
+      buf += ch;
+      continue;
+    }
+    if (ch === "|" && !inBacktick) {
+      cells.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  cells.push(buf.trim());
+  return cells;
+}

package/src/loader.ts

@@ -0,0 +1,55 @@
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import type { DocumentNode } from "./ast.js";
+import { walk } from "./ast.js";
+
+/**
+ * In-place: for every `::dataset{src="..."}` block without an inline body,
+ * read the referenced file and stuff its contents into `body`. Sets the
+ * `format` attribute (csv/tsv/json/yaml) when not already provided.
+ *
+ * Path resolution: absolute paths used as-is, relative paths resolved
+ * against `baseDir` (or the document's own filename's directory).
+ *
+ * Renderers stay pure — they read `body` and `format`, never the filesystem.
+ */
+export function inlineDatasetSources(
+  doc: DocumentNode,
+  baseDir?: string,
+): DocumentNode {
+  const dir =
+    baseDir ??
+    (typeof doc.meta.filename === "string"
+      ? dirname(doc.meta.filename)
+      : process.cwd());
+  for (const node of walk(doc)) {
+    if (node.type !== "directive" || node.name !== "dataset") continue;
+    const src = node.attrs.src;
+    if (typeof src !== "string" || !src.trim()) continue;
+    if (node.body && node.body.trim()) continue;
+    const path = isAbsolute(src) ? src : resolve(dir, src);
+    try {
+      const content = readFileSync(path, "utf8");
+      node.body = content;
+      if (!node.attrs.format) {
+        node.attrs.format = inferFormat(src, content);
+      }
+    } catch (e) {
+      node.body = `# error loading ${src}: ${(e as Error).message}`;
+      node.attrs.format = "error";
+    }
+  }
+  return doc;
+}
+
+function inferFormat(src: string, content: string): string {
+  const ext = src.split(".").pop()?.toLowerCase();
+  if (ext === "csv") return "csv";
+  if (ext === "tsv") return "tsv";
+  if (ext === "json") return "json";
+  if (ext === "yaml" || ext === "yml") return "yaml";
+  const head = content.trimStart()[0];
+  if (head === "{" || head === "[") return "json";
+  if (/^[^\n]*,[^\n]*\n/.test(content)) return "csv";
+  return "yaml";
+}