@diagrammo/dgmo 0.50.0 → 0.50.1

package/dist/auto.d.ts

@@ -1,54 +0,0 @@
-/**
- * Shared browser-embed helpers for the `@diagrammo/dgmo` client-side
- * drop-ins (`./auto` script-tag renderer and `./element` custom element).
- *
- * These are the SVG sanitizer, theme resolver, the standard-block DOM
- * assembler (canonical chrome from `src/embed` — BL-114), the error card,
- * aria-label derivation, style injection, and share-URL builder — factored
- * out of `auto/index.ts` so the two entries share one implementation rather
- * than diverging copies. The `auto` entry's public `window.dgmo` surface is
- * unaffected; it imports from here.
- */
-declare const VERSION: string;
-
-type ThemePreference = 'auto' | 'light' | 'dark' | 'transparent';
-declare function resolveTheme(theme: ThemePreference | undefined): 'light' | 'dark' | 'transparent';
-
-/**
- * `@diagrammo/dgmo/auto` — IIFE-distributed auto-renderer for static HTML.
- *
- * Drop a `<script src="…/auto.js">` on any page; on `DOMContentLoaded`
- * this module scans for `.dgmo, .language-dgmo`, runs `render()`, and
- * replaces each match with the standard DGMO embed block (BL-114,
- * `figure.dgmo.dgmo-rendered`) — the diagram plus a hover-reveal icon
- * toolbar with view-source, Copy, and "Open in editor" actions.
- *
- * Public API: frozen `window.dgmo` and alias `window.diagrammo` with
- * `{ initialize, run, version }`. Configuration is read from the
- * bundle's own `<script data-config='{…}'>` (JSON with strict
- * allowlist) or via `dgmo.initialize(opts)` for `data-auto="false"`
- * embedders.
- */
-
-interface AutoConfig {
-    theme?: 'auto' | 'light' | 'dark' | 'transparent';
-    palette?: string;
-    showSource?: boolean;
-    showEditorLink?: boolean;
-}
-interface RunOptions {
-    nodes?: Element[] | NodeListOf<Element>;
-}
-
-declare function findScriptTag(): HTMLScriptElement | null;
-declare function parseConfig(raw: string | null | undefined): Partial<AutoConfig>;
-declare function selectTargets(root?: ParentNode): Element[];
-declare function initialize(opts?: AutoConfig): void;
-declare function run(opts?: RunOptions): Promise<void>;
-declare const api: Readonly<{
-    initialize: typeof initialize;
-    run: typeof run;
-    version: string;
-}>;
-
-export { type AutoConfig, type RunOptions, VERSION, api as default, findScriptTag, initialize, parseConfig, resolveTheme, run, selectTargets };

package/dist/block.d.ts

@@ -1,123 +0,0 @@
-/**
- * Canonical stylesheet for the standard DGMO embed block (BL-114).
- *
- * Shipped two ways: `dist/block.css` (extracted at build time by
- * tsup.config.ts, same regex mechanism as auto.css) for `<link>`/import
- * consumers, and the `BLOCK_CSS` string export for embedders that inject a
- * `<style>` tag.
- *
- * Dark mode keys off `[data-theme="dark"]`. Hosts with a different signal
- * (`html.dark`, `body.theme-dark`) rewrite the selector at their build step —
- * fumadocs-dgmo/nextra-dgmo's build-css.mjs is the reference adapter.
- *
- * The `.dgmo-tok-*` role colors mirror LIGHT_ROLE_STYLES (light) and
- * NORD_ROLE_STYLES (dark) from editor/highlight-api.ts. A parity test
- * (tests/block.test.ts) guards against drift — update both when either
- * changes.
- *
- * IMPORTANT: keep this a single pure template literal — the build extracts it
- * with a regex, so no interpolation or computed values.
- */
-declare const BLOCK_CSS: string;
-
-/**
- * Standard DGMO embed block (BL-114) — the ONE canonical
- * "diagram + source chrome" HTML builder shared by every embed surface:
- * remark-dgmo (and through it the astro/docusaurus/fumadocs/nextra/vitepress
- * wrappers), the `/auto` script-tag drop-in, `<dgmo-diagram>`, dgmo-mcp HTML
- * reports, the marketing site, and the Obsidian plugin.
- *
- * Chrome contract (user-approved 2026-07-05): the diagram is the star. A slim
- * icon toolbar sits in a reserved row below the SVG, invisible until the
- * block is hovered/focused or the source is open. Four wordless icon
- * buttons — `</>` toggles the hidden source panel, expand (full-screen),
- * copy, open-in-editor. No disclosure triangle, no text labels. The toolbar
- * IS the <summary> of a native <details>, so show/hide works with zero
- * JavaScript; copy and expand need a small delegated click handler
- * (remark-dgmo's `bindDgmo` is the reference — expand's lightbox helper is
- * mirrored across every client surface, same as copy).
- *
- * Markup vocabulary: `figure.dgmo` (`--diagram`/`--showcase`/`--error`),
- * `.dgmo-light`/`.dgmo-dark` (dual color-mode) or `.dgmo-svg` (single),
- * `details.dgmo-source-wrap > summary.dgmo-toolbar`, `.dgmo-source-inner`,
- * `pre.dgmo-pre > span.dgmo-code` with `.dgmo-tok-<role>` token spans. While
- * the source is open the wrapper gets one shared frame (`:has()` rule) so
- * diagram + code read as a single unit. No visible caption — `title` becomes
- * the wrapper's aria-label. Styles ship as `BLOCK_CSS` / `dist/block.css`.
- */
-
-/** Default hosted editor used by "Open in editor" links. */
-declare const EDITOR_BASE_URL = "https://online.diagrammo.app";
-type BlockMode = 'diagram' | 'showcase';
-/**
- * Color-mode strategy for the emitted SVG(s).
- * - `auto` — render twice (light + dark) and let CSS flip visibility.
- * - `light` / `dark` / `transparent` — single render with that theme.
- */
-type BlockColorMode = 'auto' | 'light' | 'dark' | 'transparent';
-interface DgmoBlockOptions {
-    /** `diagram` (default): SVG only. `showcase`: SVG + source chrome. */
-    mode?: BlockMode;
-    /** Palette name. Default `slate`; unknown names warn + fall back. */
-    palette?: string;
-    /** Default `auto` (dual light/dark render). */
-    colorMode?: BlockColorMode;
-    /** Default: true in showcase mode, false in diagram mode. */
-    showSource?: boolean;
-    /** Default: true in showcase mode, false in diagram mode. */
-    showCopy?: boolean;
-    /**
-     * Show the expand (full-screen) toolbar button. Default: true in showcase
-     * mode, false in diagram mode. Needs the client lightbox handler to do
-     * anything (mirrored across surfaces); markup-only surfaces can omit it.
-     */
-    showExpand?: boolean;
-    /** Default: true in showcase mode, false in diagram mode. */
-    showOpenInEditor?: boolean;
-    /** Base URL for the open-in-editor link. Default: online.diagrammo.app. */
-    editorBaseUrl?: string;
-    /** Outer wrapper element. Default `figure`. */
-    wrapper?: 'figure' | 'div';
-    /** Base class for the wrapper (styling hook). Default `dgmo`. */
-    className?: string;
-    /** Extra classes appended to every emitted wrapper (compat shims). */
-    legacyClassNames?: string[];
-    /**
-     * Accessible name for the block (`aria-label` on the wrapper). NOT rendered
-     * visually — the chart's visible title belongs in the DGMO source itself.
-     */
-    title?: string;
-    /** Receives palette-fallback warnings. Default: console.warn. */
-    onWarn?: (message: string) => void;
-}
-interface DgmoBlockResult {
-    html: string;
-    diagnostics: Array<{
-        message: string;
-        line?: number;
-        severity?: string;
-    }>;
-}
-/**
- * Render one ```dgmo source block to the standard embed HTML. Async because
- * it runs the full dgmo render pipeline (once per color mode).
- *
- * Render errors are NOT caught here — callers decide between throwing,
- * `errorBlockHtml()`, or their own fallback.
- */
-declare function renderDgmoBlock(source: string, options?: DgmoBlockOptions): Promise<DgmoBlockResult>;
-/**
- * Assemble the standard block around already-rendered SVG markup. Exposed for
- * surfaces that render through their own pipeline (e.g. dgmo-mcp's
- * renderPipeline) but must emit the canonical chrome. `svgsHtml` must be the
- * `.dgmo-light`+`.dgmo-dark` (or `.dgmo-svg`) wrapper divs.
- */
-declare function buildDgmoBlockHtml(source: string, svgsHtml: string, options?: DgmoBlockOptions): string;
-/**
- * Standard error card for a block that failed to parse/render. Same shape on
- * every surface: `.dgmo--error` with `role="alert"`, message + offending
- * source.
- */
-declare function errorBlockHtml(err: unknown, source: string, options?: Pick<DgmoBlockOptions, 'className' | 'legacyClassNames'>): string;
-
-export { BLOCK_CSS, type BlockColorMode, type BlockMode, type DgmoBlockOptions, type DgmoBlockResult, EDITOR_BASE_URL, buildDgmoBlockHtml, errorBlockHtml, renderDgmoBlock };

package/dist/element.d.ts

@@ -1,62 +0,0 @@
-/**
- * `@diagrammo/dgmo/element` — the universal `<dgmo-diagram>` custom element.
- *
- * A mermaid-style, framework-agnostic client-side web component. Drop the
- * IIFE script (`dist/element.js`) on ANY page — Hugo, Jekyll, MkDocs,
- * VitePress, plain HTML — and author diagrams as:
- *
- * ```html
- * <script src="https://unpkg.com/@diagrammo/dgmo/dist/element.js"></script>
- * <dgmo-diagram palette="nord">
- *   flowchart
- *   [Start] -> [Done]
- * </dgmo-diagram>
- * ```
- *
- * The element reads its DGMO source (a nested `<script type="text/dgmo">`,
- * a `<pre>`, or its own text content — de-indented), calls the isomorphic
- * `render()`, sanitizes the SVG, and injects it. Attributes: `palette`,
- * `theme`/`color-mode`, `mode` (diagram|showcase), `editor-base`,
- * `map-data-base`.
- *
- * DOM strategy — **light DOM** (not shadow DOM). Rationale: the rendered
- * SVG, source panel, and syntax-highlight token classes are all styled by
- * the shared `auto.css` (injected once via `ensureStyles()`). Cloning that
- * whole stylesheet into every shadow root would be heavy and would break
- * the `.dgmo-tok-*` highlight hooks; the CSS is already namespaced under
- * `.dgmo-*` so collision risk is low. See the CLAUDE.md embed notes.
- *
- * Map-data seam — the base bundle never statically imports the ~380 KB geo
- * JSON. Only when a diagram's first token is `map` does the element
- * lazy-`fetch()` the map assets from `map-data-base` (default: the pinned
- * unpkg `dist/map-data/` path) and inject them as `render({ mapData })`.
- * Fetched data is cached across every element on the page. Non-map diagrams
- * trigger ZERO extra network requests.
- */
-
-declare class DgmoDiagram extends HTMLElement {
-    static get observedAttributes(): readonly string[];
-    /** DGMO source, captured from the original children ONCE before the first
-     *  render replaces them. */
-    private source;
-    /** Monotonic render token — a late-resolving render/fetch whose token is
-     *  stale (superseded by a newer attribute-driven render) is discarded. */
-    private renderToken;
-    private container;
-    connectedCallback(): void;
-    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
-    private readSource;
-    private themePreference;
-    private palette;
-    private editorBase;
-    private mapDataBase;
-    private isShowcase;
-    private mount;
-    private showError;
-    private rerender;
-}
-/** Idempotently define `<dgmo-diagram>`. Safe to call multiple times and in
- *  SSR/no-DOM contexts (no-ops when `customElements` is unavailable). */
-declare function defineDgmoDiagram(): void;
-
-export { DgmoDiagram, DgmoDiagram as default, defineDgmoDiagram };

package/dist/index.d.ts

@@ -1,166 +0,0 @@
-import { ab as DiagnosticSpec, a as PaletteConfig, J as Theme, C as CompactViewState, D as DgmoError } from './themes-1-CuKpeH.js';
-export { f as ChartTypeMeta, h as DgmoSeverity, ac as DiagnosticParams, ad as EmitOptions, j as Gazetteer, k as GazetteerEntry, l as MapCompletionOptions, M as MapData, o as MapLocationMatch, p as MapPlaceCompletion, s as MapRegionCompletion, P as PaletteColors, w as RegionName, x as RegionNames, N as chartTypes, O as completeMapPlaces, Q as completeMapRegions, ae as emit, X as formatDgmoError, _ as getPalette, a4 as palettes, af as resolvePaletteOrFallback, a8 as searchMapLocations, aa as themes, a5 as validate } from './themes-1-CuKpeH.js';
-
-declare function getMinDimensions(content: string): {
-    width: number;
-    height: number;
-};
-
-/**
- * Make an SVG produced by `@diagrammo/dgmo`'s static `render()` suitable for
- * responsive inline embedding in any host (Obsidian, remark/markdown, web
- * pages):
- *
- * - dgmo renders diagrams inside a fixed export canvas (e.g.
- *   `viewBox="0 0 1200 800"`), with content often occupying only a fraction
- *   of it. We compute a tight content bounding box from element coordinates
- *   and set the root `viewBox` to bbox+padding, so the diagram's intrinsic
- *   aspect ratio matches its CONTENT — no dead space above/below or beside it.
- * - Ensure the root `<svg>` has a `viewBox` so it scales responsively.
- * - Strip fixed `width="N"` / `height="N"` so CSS (e.g. `width:100%;
- *   height:auto`, or an aspect-ratio derived from the tight viewBox) controls
- *   sizing.
- * - The root inline `background:` (the theme's opaque `palette.bg`) is
- *   PRESERVED: every chart type now carries its own opaque background so
- *   diagrams render consistently across hosts and color modes rather than
- *   inheriting an arbitrary host page background.
- *
- * This is intentionally a string transform, not a DOM `getBBox()` step: dgmo
- * can dual-render light/dark SVGs where one is hidden by color-mode CSS, and
- * `getBBox()` returns 0 for the hidden copy. Parsing coordinates from the
- * markup measures both copies reliably and works server-side (Node).
- */
-declare function normalizeSvgForEmbed(input: string): string;
-/**
- * Parse the content bounding box of a normalized embed SVG, if one can be
- * derived. Returns `null` when no usable coordinates are found (e.g. an empty
- * diagram). Useful for hosts that want to set an explicit `aspect-ratio` from
- * the tight viewBox.
- */
-declare function getEmbedSvgViewBox(svg: string): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-} | null;
-
-interface MountD3Opts {
-    theme?: 'light' | 'dark' | 'transparent';
-    palette?: string;
-    /** Forwarded to the interaction adapter: source-line navigation on click. */
-    onNavigate?: (line: number) => void;
-    mutedColor?: string;
-    surface?: string;
-    text?: string;
-}
-interface MountedD3Chart {
-    /** Re-render with new content and/or theme/palette; re-attaches interactions. */
-    update: (content: string, opts?: Partial<MountD3Opts>) => Promise<void>;
-    /** Emphasize the chart element on the given source line (editor cursor sync);
-     *  pass null to clear. */
-    highlight: (line: number | null) => void;
-    /** Tear down listeners + overlays and clear the container. */
-    destroy: () => void;
-}
-declare function mountD3DataChart(container: HTMLElement, content: string, opts?: MountD3Opts): MountedD3Chart;
-
-interface DataChartInteractionOpts {
-    onNavigate?: (line: number) => void;
-    mutedColor?: string;
-    surface?: string;
-    text?: string;
-}
-interface DataChartController {
-    /** Remove all listeners + overlays. */
-    destroy: () => void;
-    /** Emphasize the chart element(s) on the given source line (editor cursor
-     *  sync); pass null to clear. No-op while the pointer is actively hovering. */
-    highlight: (line: number | null) => void;
-}
-declare function attachDataChartInteractions(svg: SVGSVGElement, opts?: DataChartInteractionOpts): DataChartController;
-
-/** All data-chart types the hand-built renderers currently cover. */
-declare const D3_DATA_CHART_TYPES: Set<string>;
-declare function supportsD3DataChart(type: string): boolean;
-
-/**
- * The full diagnostic catalog, sorted by code. Every coded diagnostic
- * dgmo can emit — its severity, owning chart type, canonical message,
- * fix hint, and a triggering example. This is the enumerable source of
- * truth for the CLI `diagnostics` subcommand, the console error-review
- * surface, MCP, and the language-spec catalog.
- */
-declare function listDiagnosticCodes(): DiagnosticSpec[];
-/** Look up a single spec by its code, or `undefined` if not cataloged. */
-declare function getDiagnosticSpec(code: string): DiagnosticSpec | undefined;
-
-interface RenderOptions {
-    theme?: Theme;
-    /**
-     * A `PaletteConfig` (e.g. `palettes.catppuccin`) or a palette id string
-     * (e.g. `'catppuccin'`). Unknown ids fall back to the default palette.
-     */
-    palette?: PaletteConfig | string;
-    /**
-     * How to handle parse errors:
-     *   'svg'    — render an inline error SVG (default)
-     *   'silent' — return empty svg + diagnostics; caller handles UI
-     *   'throw'  — throw an Error with the diagnostics
-     */
-    onError?: 'svg' | 'silent' | 'throw';
-    /**
-     * Pre-applied interactive view state — collapsed sections/columns,
-     * active swimlane tag-group, etc. Used to render a specific view
-     * non-interactively (server-side render, share-link decode).
-     */
-    viewState?: CompactViewState;
-}
-interface RenderResult {
-    svg: string;
-    diagnostics: DgmoError[];
-}
-/**
- * Render DGMO source to an SVG string.
- *
- * @example
- * ```ts
- * import { render, palettes, themes } from '@diagrammo/dgmo';
- *
- * const { svg } = await render(text, {
- *   palette: palettes.catppuccin,
- *   theme: themes.dark,
- * });
- * document.getElementById('chart').innerHTML = svg;
- * ```
- */
-declare function render(text: string, options?: RenderOptions): Promise<RenderResult>;
-
-interface EncodeDiagramUrlOptions {
-    baseUrl?: string;
-    palette?: PaletteConfig;
-    theme?: Theme;
-    filename?: string;
-    /**
-     * Initial view state to embed in the URL — re-applied when the link is
-     * decoded so recipients open the diagram in the same configuration.
-     */
-    viewState?: CompactViewState;
-}
-/**
- * Encode DGMO text into a shareable URL. Returns null if the compressed
- * payload exceeds the 8 KB URL limit.
- */
-declare function encodeDiagramUrl(text: string, options?: EncodeDiagramUrlOptions): string | null;
-interface DecodedDiagramUrl {
-    text: string;
-    palette?: PaletteConfig;
-    theme?: Theme;
-    filename?: string;
-}
-/**
- * Decode a share URL back into DGMO text plus optional palette/theme/filename.
- * Returns null if the URL contains no valid DGMO payload.
- */
-declare function decodeDiagramUrl(url: string): DecodedDiagramUrl | null;
-
-export { CompactViewState, D3_DATA_CHART_TYPES, type DataChartInteractionOpts, type DecodedDiagramUrl, DgmoError, DiagnosticSpec, type EncodeDiagramUrlOptions, type MountD3Opts, type MountedD3Chart, PaletteConfig, type RenderOptions, type RenderResult, Theme, attachDataChartInteractions, decodeDiagramUrl, encodeDiagramUrl, getDiagnosticSpec, getEmbedSvgViewBox, getMinDimensions, listDiagnosticCodes, mountD3DataChart, normalizeSvgForEmbed, render, supportsD3DataChart };