@illusions-lab/mdi 2.0.7 → 2.0.9

package/README.md

@@ -62,15 +62,74 @@ unsupported version.
 
 ## Rendering
 
-Rendering starts from the same Rust IR. Canonical MDI, plain text, HTML, EPUB,
-and DOCX renderers execute in Rust and are exposed through this package. PDF
-uses Rust HTML as its input to a host layout adapter such as
+Rendering starts from the same Rust IR. Canonical MDI, plain text, HTML, and
+the one-argument baseline EPUB/DOCX renderers execute in Rust and are exposed
+through this package. PDF uses Rust HTML as its input to a host layout adapter such as
 `@illusions-lab/mdi-to-pdf`; the adapter may control Chromium, but it never
 parses MDI or produces semantic HTML.
 
 Browser WebAssembly cannot start Chromium. Browser code sends Rust-rendered
 HTML to a server or desktop host when it needs PDF output.
 
+### HTML, diagnostics, and host workflows
+
+`renderHtml(source)` returns a standalone HTML document with the stable MDI
+classes emitted by Rust. Pass `{ bodyOnly: true }` to embed its semantic body
+in an application shell; this changes only the outer document wrapper, never
+the MDI-to-HTML semantics.
+
+```ts
+import { renderHtmlWithDiagnostics } from "@illusions-lab/mdi";
+
+const result = renderHtmlWithDiagnostics(source, { bodyOnly: true });
+preview.replaceChildren(htmlToDom(result.output));
+showDiagnostics(result.diagnostics); // stable codes and UTF-8 source spans
+buildOutline(result.headings);       // source-backed heading nodes, not HTML scraping
+```
+
+For a parse-first flow, call `prepareRender(source)` (or `parse(source)`) and
+display `diagnostics` before choosing an exporter. The public Rust ABI accepts
+source text for renderer calls today, so renderers re-enter the same
+Rust-authoritative parser rather than accepting mutable JavaScript IR. This
+keeps the source spans and error codes predictable and prevents JavaScript from
+becoming a second syntax implementation.
+
+Configuration ownership is deliberately split: Rust owns MDI parsing and
+semantic HTML; publication profiles own EPUB/DOCX metadata and typesetting;
+the host owns Chromium/Electron, paper-printer integration, and application UI
+preferences. This keeps platform-specific pagination controls out of the
+parser and lets Electron supply its own PDF adapter.
+
+### Configured EPUB and DOCX
+
+For publication output, pass an export profile to the overloads (or use the
+explicit `WithProfile` functions). These Node.js-only async paths map the
+Rust-owned IR through the publication adapters and retain configuration for
+metadata, chapter splitting, vertical writing, font selection, paper size,
+margins, and page numbers. EPUB also accepts in-memory PNG or JPEG cover art.
+
+```ts
+import { renderDocxWithProfile, renderEpubWithProfile } from "@illusions-lab/mdi";
+
+const epub = await renderEpubWithProfile(source, {
+  profile: {
+    metadata: { title: "Book", author: "Author" },
+    typesetting: { writingMode: "vertical", fontFamily: "Noto Serif JP" },
+    epub: { chapterSplitLevel: "h1" },
+  },
+  cover: { data: coverBytes, mediaType: "image/png" },
+});
+
+const docx = await renderDocxWithProfile(source, {
+  pagination: { pageSize: "A5", margins: { top: 12, bottom: 12, left: 14, right: 14 } },
+});
+```
+
+`renderEpub(source)` and `renderDocx(source)` remain synchronous,
+backward-compatible Rust baseline exports. `renderEpub(source, options)` and
+`renderDocx(source, profile)` are equivalent async overloads for configured
+publication output.
+
 ## Remark compatibility
 
 Remark support is an optional adapter between Rust IR and mdast. It exists for

package/dist/chunk-FA5R33XH.js

@@ -0,0 +1,383 @@
+// src/index.ts
+import {
+  parseMdiSyntaxJson,
+  renderHtml as renderHtmlFromRust,
+  renderEpub as renderEpubFromRust,
+  renderDocx as renderDocxFromRust,
+  renderText as renderTextFromRust,
+  renderTextFormat as renderTextFormatFromRust,
+  serializeMdi as serializeMdiFromRust
+} from "@illusions-lab/mdi-core";
+import {
+  requireLayoutSystem
+} from "@illusions-lab/mdi-export-profile";
+import { parse as parseYaml } from "yaml";
+var MDI_SPEC_VERSION = "2.0";
+var MDI_IR_VERSION = "1.0";
+function parse(source) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+  const result = JSON.parse(parseMdiSyntaxJson(source));
+  if (result.irVersion !== MDI_IR_VERSION) {
+    throw new Error(`Unsupported MDI IR version: ${String(result.irVersion)}`);
+  }
+  return result;
+}
+function renderHtml(source, options) {
+  assertSource(source);
+  assertHtmlOptions(options);
+  const html = renderHtmlFromRust(source);
+  return options?.bodyOnly ? htmlBody(html) : html;
+}
+function renderHtmlWithDiagnostics(source, options) {
+  assertSource(source);
+  assertHtmlOptions(options);
+  return renderWithDiagnostics(source, () => renderHtml(source, options));
+}
+function prepareRender(source) {
+  return parse(source);
+}
+function renderEpub(source, options) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+  if (options !== void 0) {
+    assertEpubOptions(options);
+    return renderEpubWithProfile(source, options);
+  }
+  return renderEpubFromRust(source);
+}
+function renderEpubWithDiagnostics(source, options) {
+  return options === void 0 ? renderWithDiagnostics(source, () => renderEpub(source)) : renderWithDiagnosticsAsync(source, () => renderEpub(source, options));
+}
+function renderDocx(source, profile) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+  if (profile !== void 0) {
+    assertPlainObject(profile, "profile");
+    return renderDocxWithProfile(source, profile);
+  }
+  return renderDocxFromRust(source);
+}
+function renderDocxWithDiagnostics(source, profile) {
+  return profile === void 0 ? renderWithDiagnostics(source, () => renderDocx(source)) : renderWithDiagnosticsAsync(source, () => renderDocx(source, profile));
+}
+async function renderEpubWithProfile(source, options = {}) {
+  assertSource(source);
+  assertEpubOptions(options);
+  const { mdiToEpub } = await import("@illusions-lab/mdi-to-epub");
+  const normalized = normalizeEpubOptions(options);
+  requireLayoutSystem(normalized.profile);
+  return mdiToEpub(toPublicationMdast(parse(source).document), normalized);
+}
+async function renderDocxWithProfile(source, profile = {}) {
+  assertSource(source);
+  assertPlainObject(profile, "profile");
+  prepareNodeDocxImport();
+  const { mdiToDocx } = await import("@illusions-lab/mdi-to-docx");
+  const normalized = normalizeDocxProfile(profile);
+  requireLayoutSystem(normalized);
+  return mdiToDocx(toPublicationMdast(parse(source).document), normalized);
+}
+function prepareNodeDocxImport() {
+  const nodeProcess = globalThis.process;
+  if (nodeProcess?.release?.name === "node" && !nodeProcess.execArgv?.some((argument) => argument.startsWith("--localstorage-file="))) {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+    if (descriptor?.configurable && descriptor.get)
+      Object.defineProperty(globalThis, "localStorage", {
+        value: void 0,
+        configurable: true
+      });
+  }
+}
+function toPublicationMdast(document) {
+  const children = document.children.map(toPublicationMdastNode);
+  const tree = { type: "root", children };
+  if (document.frontmatter) {
+    children.unshift({ type: "yaml", value: document.frontmatter.raw });
+    const frontmatter = publicationFrontmatter(document.frontmatter.raw);
+    tree.data ??= {};
+    tree.data.frontmatter = frontmatter;
+  }
+  return tree;
+}
+function toPublicationMdastNode(node) {
+  const { span: _span, children, ...rest } = node;
+  const mapped = { ...rest };
+  if (children) mapped.children = children.map(toPublicationMdastNode);
+  switch (node.type) {
+    case "ruby": {
+      const ruby = node.ruby;
+      return { ...mapped, type: "mdiRuby", ruby: ruby.value };
+    }
+    case "tcy":
+      return { ...mapped, type: "mdiTcy" };
+    case "break":
+      return { ...mapped, type: "mdiBreak" };
+    case "em":
+      return { ...mapped, type: "mdiEm" };
+    case "noBreak":
+      return { ...mapped, type: "mdiNoBreak" };
+    case "warichu":
+      return { ...mapped, type: "mdiWarichu" };
+    case "kern":
+      return { ...mapped, type: "mdiKern" };
+    case "blank":
+      return { ...mapped, type: "mdiBlank" };
+    case "pagebreak": {
+      if (mapped.variant === null) delete mapped.variant;
+      return { ...mapped, type: "mdiPagebreak" };
+    }
+    case "paragraph": {
+      const data = {};
+      if (typeof mapped.indent === "number") data.mdiIndent = mapped.indent;
+      if (typeof mapped.bottom === "number") data.mdiBottom = mapped.bottom;
+      delete mapped.indent;
+      delete mapped.bottom;
+      if (Object.keys(data).length) mapped.data = data;
+      return mapped;
+    }
+    default:
+      return mapped;
+  }
+}
+function publicationFrontmatter(raw) {
+  let value;
+  try {
+    value = parseYaml(raw);
+  } catch {
+    value = void 0;
+  }
+  const source = isRecord(value) ? value : {};
+  const writingMode = source["writing-mode"] === "vertical" ? "vertical" : "horizontal";
+  return {
+    mdi: stringValue(source.mdi) ?? "2.0",
+    title: stringValue(source.title),
+    author: stringValue(source.author),
+    lang: stringValue(source.lang) ?? "ja",
+    date: stringValue(source.date),
+    writingMode,
+    pageProgression: source["page-progression"] === "ltr" || source["page-progression"] === "rtl" ? source["page-progression"] : writingMode === "vertical" ? "rtl" : "ltr"
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function renderWithDiagnostics(source, render) {
+  const parsed = parse(source);
+  return {
+    output: render(),
+    document: parsed.document,
+    diagnostics: parsed.diagnostics,
+    headings: headingsFromDocument(parsed.document)
+  };
+}
+async function renderWithDiagnosticsAsync(source, render) {
+  const parsed = parse(source);
+  return {
+    output: await render(),
+    document: parsed.document,
+    diagnostics: parsed.diagnostics,
+    headings: headingsFromDocument(parsed.document)
+  };
+}
+function assertSource(source) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+}
+function assertHtmlOptions(options) {
+  if (options === void 0) return;
+  assertPlainObject(options, "options");
+  if (options.bodyOnly !== void 0 && typeof options.bodyOnly !== "boolean") {
+    throw new TypeError("options.bodyOnly must be a boolean");
+  }
+}
+function htmlBody(html) {
+  const match = /<body(?:\s[^>]*)?>([\s\S]*)<\/body>/i.exec(html);
+  if (!match) throw new Error("Rust HTML renderer returned a document without a body");
+  return match[1];
+}
+function headingsFromDocument(document) {
+  const headings = [];
+  visitNodes(document.children, (node) => {
+    if (node.type !== "heading" || !isHeadingDepth(node.depth)) return;
+    headings.push({
+      depth: node.depth,
+      text: plainNodeText(node),
+      span: node.span,
+      node
+    });
+  });
+  return headings;
+}
+function visitNodes(nodes, visit) {
+  for (const node of nodes) {
+    visit(node);
+    if (node.children) visitNodes(node.children, visit);
+  }
+}
+function isHeadingDepth(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 6;
+}
+function plainNodeText(node) {
+  if (node.type === "ruby" && typeof node.base === "string") return node.base;
+  const value = node.value;
+  const ownText = typeof value === "string" ? value : "";
+  return ownText + (node.children?.map(plainNodeText).join("") ?? "");
+}
+function assertPlainObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+}
+function assertEpubOptions(options) {
+  assertPlainObject(options, "options");
+  if (options.cover !== void 0) {
+    assertPlainObject(options.cover, "options.cover");
+    if (!(options.cover.data instanceof Uint8Array)) {
+      throw new TypeError("options.cover.data must be a Uint8Array");
+    }
+    if (options.cover.mediaType !== "image/jpeg" && options.cover.mediaType !== "image/png") {
+      throw new TypeError("options.cover.mediaType must be image/jpeg or image/png");
+    }
+  }
+  if (options.coverImage !== void 0 && !(options.coverImage instanceof Uint8Array)) {
+    throw new TypeError("options.coverImage must be a Uint8Array");
+  }
+  if (options.coverMediaType !== void 0 && options.coverMediaType !== "image/jpeg" && options.coverMediaType !== "image/png") {
+    throw new TypeError("options.coverMediaType must be image/jpeg or image/png");
+  }
+}
+function normalizeEpubOptions(options) {
+  const {
+    title,
+    author,
+    publisher,
+    identifier,
+    language,
+    date,
+    verticalWriting,
+    fontFamily,
+    fontSize,
+    lineSpacing,
+    textIndent,
+    fullwidthSpaceIndent,
+    gridMode,
+    chapterSplitLevel,
+    coverImage,
+    coverMediaType,
+    cover,
+    profile
+  } = options;
+  const metadata = { ...profile?.metadata, ...defined({ title, author, publisher, identifier, language, date }) };
+  const writingMode = verticalWriting === void 0 ? void 0 : verticalWriting ? "vertical" : "horizontal";
+  const typesetting = {
+    ...profile?.typesetting,
+    ...defined({
+      writingMode,
+      fontFamily,
+      fontSize,
+      lineSpacing,
+      textIndentEm: textIndent,
+      fullwidthSpaceIndent
+    })
+  };
+  const epub = { ...profile?.epub, ...defined({ chapterSplitLevel }) };
+  return {
+    profile: {
+      ...profile,
+      metadata,
+      typesetting,
+      epub,
+      pagination: { ...profile?.pagination, ...defined({ gridMode }) }
+    },
+    cover: cover ?? (coverImage ? { data: coverImage, mediaType: coverMediaType ?? "image/png" } : void 0)
+  };
+}
+function normalizeDocxProfile(profile) {
+  const {
+    title,
+    author,
+    publisher,
+    identifier,
+    language,
+    date,
+    verticalWriting,
+    fontFamily,
+    fontSize,
+    lineSpacing,
+    textIndent,
+    pageSize,
+    landscape,
+    gridMode,
+    charactersPerLine,
+    linesPerPage,
+    margins,
+    fullwidthSpaceIndent,
+    showPageNumbers,
+    pageNumberPosition,
+    pageNumberFormat,
+    ...nested
+  } = profile;
+  const writingMode = verticalWriting === void 0 ? void 0 : verticalWriting ? "vertical" : "horizontal";
+  return {
+    ...nested,
+    metadata: { ...nested.metadata, ...defined({ title, author, publisher, identifier, language, date }) },
+    typesetting: {
+      ...nested.typesetting,
+      ...defined({ writingMode, fontFamily, fontSize, lineSpacing, textIndentEm: textIndent, fullwidthSpaceIndent })
+    },
+    pagination: {
+      ...nested.pagination,
+      ...defined({ pageSize, landscape, gridMode, charactersPerLine, linesPerPage, margins }),
+      pageNumbers: {
+        ...nested.pagination?.pageNumbers,
+        ...defined({ enabled: showPageNumbers, position: pageNumberPosition, format: pageNumberFormat })
+      }
+    }
+  };
+}
+function defined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function serializeMdi(source) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+  return serializeMdiFromRust(source);
+}
+function renderText(source) {
+  if (typeof source !== "string") throw new TypeError("source must be a string");
+  return renderTextFromRust(source);
+}
+function renderTextWithDiagnostics(source) {
+  return renderWithDiagnostics(source, () => renderText(source));
+}
+function renderTextFormat(source, format, indentPrefix = "") {
+  if (typeof source !== "string" || typeof indentPrefix !== "string") {
+    throw new TypeError("source and indentPrefix must be strings");
+  }
+  return renderTextFormatFromRust(source, format, indentPrefix);
+}
+function renderTextFormatWithDiagnostics(source, format, indentPrefix = "") {
+  return renderWithDiagnostics(source, () => renderTextFormat(source, format, indentPrefix));
+}
+var parseMdiSyntax = parse;
+
+export {
+  MDI_SPEC_VERSION,
+  MDI_IR_VERSION,
+  parse,
+  renderHtml,
+  renderHtmlWithDiagnostics,
+  prepareRender,
+  renderEpub,
+  renderEpubWithDiagnostics,
+  renderDocx,
+  renderDocxWithDiagnostics,
+  renderEpubWithProfile,
+  renderDocxWithProfile,
+  toPublicationMdast,
+  serializeMdi,
+  renderText,
+  renderTextWithDiagnostics,
+  renderTextFormat,
+  renderTextFormatWithDiagnostics,
+  parseMdiSyntax
+};