@franken-suite/franken-markdown 0.3.2 → 0.4.4

package/fmd-view.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `<fmd-view>` web component type surface (bead uito).
+ */
+
+export interface FmdRenderedDetail {
+  bytes: number;
+  sourceLength: number;
+  diagnostics: Array<{
+    severity: "warning" | "error";
+    start: number;
+    end: number;
+    message: string;
+  }>;
+}
+
+export interface FmdViewEventMap {
+  "fmd-rendered": CustomEvent<FmdRenderedDetail>;
+  "fmd-error": CustomEvent<{ error: string }>;
+}
+
+export interface FmdView extends HTMLElement {
+  addEventListener<K extends keyof FmdViewEventMap>(
+    type: K,
+    listener: (this: FmdView, ev: FmdViewEventMap[K]) => void,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+}
+
+/**
+ * Register `<fmd-view>` (idempotent). Auto-registered in browser globals on
+ * import; call this explicitly for a non-global registry.
+ */
+export function registerFmdView(
+  registry?: Pick<CustomElementRegistry, "define" | "get">
+): "fmd-view";

package/fmd-view.js

@@ -0,0 +1,137 @@
+// <fmd-view> — drop-in Markdown renderer web component (bead uito).
+//
+// Framework-free custom element over the package's createRenderer surface:
+//
+//   <fmd-view src="./README.md"></fmd-view>
+//   <fmd-view>Six **bytes** of markdown</fmd-view>
+//
+// Attributes:
+//   src       - fetch this URL as the Markdown source (slot content is the
+//               fallback when src is absent/unset)
+//   font      - "sans" | "serif"
+//   dark-mode - "auto" | "disabled"
+//
+// The rendered document lands in a shadow root (style-isolated; the engine's
+// self-contained HTML carries its own CSS). A "fmd-rendered" CustomEvent with
+// { bytes, sourceLength, diagnostics } fires after each successful render;
+// "fmd-error" fires on fetch/render failure. Bytes parity with renderHtml()
+// is exact: the same call is used.
+//
+// Zero dependencies; the shared wasm payload is the package's.
+
+import { createRenderer } from "./franken_markdown.js";
+
+let rendererPromise = null;
+
+function sharedRenderer(wasmInput) {
+  if (!rendererPromise) {
+    rendererPromise = createRenderer(wasmInput);
+  }
+  return rendererPromise;
+}
+
+const SLOT_RENDER = Symbol("slot source");
+
+class FmdView extends HTMLElement {
+  static get observedAttributes() {
+    return ["src", "font", "dark-mode"];
+  }
+
+  #root = null;
+  #lastSrc = undefined;
+
+  constructor() {
+    super();
+    this.#root = this.attachShadow({ mode: "open" });
+    this.#root.innerHTML = "<style>:host{display:block}</style><slot></slot>";
+  }
+
+  connectedCallback() {
+    this.#render();
+  }
+
+  attributeChangedCallback(name, oldV, newV) {
+    if (oldV === newV || !this.#root) {
+      return;
+    }
+    if (name === "src" && newV !== this.#lastSrc) {
+      this.#render();
+      return;
+    }
+    if (name === "font" || name === "dark-mode") {
+      this.#render();
+    }
+  }
+
+  async #source() {
+    const src = this.getAttribute("src");
+    if (src) {
+      const res = await fetch(src);
+      if (!res.ok) {
+        throw new Error(`fmd-view: fetch ${src} -> HTTP ${res.status}`);
+      }
+      return await res.text();
+    }
+    // Slot content as inline Markdown. Preserve text exactly.
+    const slot = this.querySelector("script[type='text/markdown']");
+    if (slot) {
+      return slot.textContent ?? "";
+    }
+    return this.textContent ?? "";
+  }
+
+  async #render() {
+    const srcAttr = this.getAttribute("src");
+    this.#lastSrc = srcAttr;
+    let markdown;
+    try {
+      markdown = await this.#source();
+    } catch (err) {
+      this.dispatchEvent(new CustomEvent("fmd-error", { detail: { error: String(err) } }));
+      return;
+    }
+    let renderer;
+    try {
+      // If the host already initialized the engine with explicit wasm bytes,
+      // a package-level export would be needed; default path resolves the
+      // bundled artifact via the wrapper's own URL resolution.
+      renderer = await sharedRenderer(undefined);
+    } catch (err) {
+      this.dispatchEvent(new CustomEvent("fmd-error", { detail: { error: String(err) } }));
+      return;
+    }
+    const out = await renderer.renderHtml(markdown, {
+      font: this.getAttribute("font") === "serif" ? "serif" : "sans",
+      darkMode: this.getAttribute("dark-mode") === "disabled" ? "disabled" : "auto",
+    });
+    const html = out.text();
+    this.#root.innerHTML = `<style>:host{display:block}</style>${html}`;
+    this.dispatchEvent(
+      new CustomEvent("fmd-rendered", {
+        detail: {
+          bytes: out.bytes.byteLength,
+          sourceLength: out.sourceLength,
+          diagnostics: out.diagnostics,
+        },
+      })
+    );
+  }
+}
+
+const ELEMENT_NAME = "fmd-view";
+
+/**
+ * Register <fmd-view> on a customElements registry (defaults to global).
+ * Idempotent; returns the element name.
+ */
+export function registerFmdView(registry = globalThis.customElements) {
+  if (!registry.get(ELEMENT_NAME)) {
+    registry.define(ELEMENT_NAME, FmdView);
+  }
+  return ELEMENT_NAME;
+}
+
+// Auto-register in browser globals (no-op under Node/bundlers without it).
+if (typeof globalThis.customElements !== "undefined") {
+  registerFmdView();
+}

package/franken_markdown.d.ts

@@ -1,4 +1,12 @@
-export type FmdOutputFormat = "html" | "pdf";
+export type FmdOutputFormat =
+  | "html"
+  | "pdf"
+  | "svg"
+  | "epub"
+  | "interactive-html"
+  | "diff-html"
+  | "book-site"
+  | "book-pdf";
 export type FmdFont = "sans" | "serif";
 export type FmdDarkMode = "auto" | "disabled";
 
@@ -12,7 +20,7 @@ export interface FmdDiagnostic {
 export interface FmdPdfImageAsset {
   /** Markdown image destination, for example `images/chart.png` from `![Chart](images/chart.png)`. */
   destination: string;
-  /** Browser-supplied image bytes. PNG and SVG assets are supported in PDF output. */
+  /** Browser-supplied image bytes. PNG and SVG are supported in HTML and PDF output. */
   bytes: Uint8Array | ArrayBuffer | ArrayBufferView;
 }
 
@@ -28,6 +36,12 @@ export interface FmdFontAsset {
   slot: FmdFontAssetSlot;
   /** Browser-supplied TrueType font bytes. */
   bytes: Uint8Array | ArrayBuffer | ArrayBufferView;
+  /**
+   * Optional CSS `font-weight` pin (integer 1..=1000) for variable `wght` faces.
+   * Static faces ignore the pin. When `body-bold` is omitted and `body-regular`
+   * is a variable face, bold instances from that same file at 700 (or this pin).
+   */
+  weight?: number;
 }
 
 export interface FmdRenderOptions {
@@ -40,7 +54,33 @@ export interface FmdRenderOptions {
   /** Finite non-negative integer seconds, <= Number.MAX_SAFE_INTEGER. */
   metadataEpochSeconds?: number;
   codeLineNumbers?: boolean;
-  /** Host-supplied PDF image bytes; any number of assets may be supplied per render call. */
+  /** Render running page numbers in the bottom margin of PDF pages. */
+  pageNumbers?: boolean;
+  /** Base body size override in points (clamped by the core to [6, 24]). */
+  baseFontSize?: number;
+  /** Uniform typographic scale factor (e.g. 1.125 = 112.5% / Large) or preset name ('xs' | 'sm' | 'compact' | 'md' | 'lg' | 'xl' | '2xl' | 'huge'). Scales both HTML and PDF uniformly. */
+  fontScale?: number | string;
+  /** Alias for fontScale. */
+  typeSize?: number | string;
+  /** Per-step heading ratio, e.g. 1.25 (Major Third); clamped to [1.05, 2]. */
+  headingScale?: number;
+  /** Nominal table cell size override in points; clamped to [5, base]. */
+  tableFontSize?: number;
+  /** BCP-47 language tag used for HTML metadata and language-aware hyphenation. */
+  lang?: "en" | "de" | "fr" | "es" | "nl" | string;
+  /** Generate a document table of contents. */
+  toc?: boolean;
+  /** Maximum generated TOC heading depth (1...6). */
+  tocDepth?: number;
+  /** Adaptive PDF page-count target. */
+  fitToPages?: number;
+  /** Enable optical-margin punctuation protrusion for justified PDF text. */
+  microtype?: "disabled" | "protrusion";
+  /** Boolean alias for microtype: "protrusion". */
+  microtypeProtrusion?: boolean;
+  /** Standalone SVG poster width in points. */
+  maxWidthPt?: number;
+  /** Host-supplied image bytes (HTML data URIs and PDF embedding); any number per render. */
   pdfImages?: FmdPdfImageAsset[];
   /** Host-supplied TrueType font bytes by renderer slot. */
   fontAssets?: FmdFontAsset[];
@@ -66,13 +106,16 @@ export interface FmdCapabilities {
     mime_type: "text/html; charset=utf-8";
     self_contained: boolean;
     custom_css_utf8: boolean;
+    image_assets: "png_svg_v0_host_supplied_bytes";
     font_assets: "ttf_v0_host_supplied_bytes";
+    font_slot_weight: "css_1_to_1000_variable_wght";
   };
   pdf: {
     mime_type: "application/pdf";
     deterministic_metadata_epoch: boolean;
     image_assets: "png_svg_v0_host_supplied_bytes";
     font_assets: "ttf_v0_host_supplied_bytes";
+    font_slot_weight: "css_1_to_1000_variable_wght";
   };
   diagnostics: {
     source_spans: "byte_offsets";
@@ -89,14 +132,80 @@ export interface FmdCapabilities {
 
 export interface FmdRenderer {
   capabilities(): Promise<FmdCapabilities>;
+  accessibilityAudit(markdown: string): Promise<FmdAccessibilityReport>;
+  documentStats(markdown: string): Promise<FmdDocumentStats>;
+  renderBookPdf(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderBookSite(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderEpub(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
   renderHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderInteractiveHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
   renderPdf(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  renderSemanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdRenderOutput>;
+  renderSvg(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+  searchIndex(markdown: string): Promise<FmdSearchIndex>;
+  semanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdSemanticDiff>;
+}
+
+export interface FmdBookFile { path: string; source: string; }
+export interface FmdDiffOptions { oldName?: string; newName?: string; }
+export interface FmdFinding { severity?: string; code: string; message?: string; detail?: string; }
+export interface FmdDocumentStats {
+  schema: "fmd-document-stats-v1";
+  bytes: number;
+  lines: number;
+  words: number;
+  characters: number;
+  sentences: number;
+  syllables: number;
+  reading_time_secs: number;
+  speaking_time_secs: number;
+  flesch_reading_ease: number;
+  flesch_kincaid_grade: number;
+  reading_ease_label: string;
+  structure: Record<string, unknown>;
+  outline: Array<{ level: number; text: string; slug: string }>;
+  findings: FmdFinding[];
+}
+export interface FmdAccessibilityReport {
+  schema_version: "1";
+  target: "pdf";
+  findings: FmdFinding[];
+  [key: string]: unknown;
+}
+export interface FmdSearchIndex {
+  schema: "fmd-search-index-v1";
+  entries: Array<{ kind: "heading" | "paragraph"; level?: number; anchor: string; text: string }>;
+}
+export interface FmdSemanticDiff {
+  schema: "fmd-diff-v1";
+  old_name: string;
+  new_name: string;
+  stats: {
+    unchanged_blocks: number;
+    inserted_blocks: number;
+    deleted_blocks: number;
+    modified_blocks: number;
+    words_inserted: number;
+    words_deleted: number;
+    similarity_ratio: number;
+  };
+  [key: string]: unknown;
 }
 
 export function init(input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module): Promise<void>;
 export function capabilities(): Promise<FmdCapabilities>;
+export function accessibilityAudit(markdown: string): Promise<FmdAccessibilityReport>;
+export function documentStats(markdown: string): Promise<FmdDocumentStats>;
+export function renderBookPdf(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderBookSite(files: FmdBookFile[], options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderEpub(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
 export function renderHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderInteractiveHtml(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
 export function renderPdf(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function renderSemanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdRenderOutput>;
+export function renderSvg(markdown: string, options?: FmdRenderOptions): Promise<FmdRenderOutput>;
+export function searchIndex(markdown: string): Promise<FmdSearchIndex>;
+export function semanticDiff(oldMarkdown: string, newMarkdown: string, options?: FmdDiffOptions): Promise<FmdSemanticDiff>;
 export function createRenderer(
   input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module
 ): Promise<FmdRenderer>;