@draftably/mermaid 0.0.0-stage → 0.1.0

package/dist/types/src/model/appearance.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Diagram appearance: five preset themes, color families with numeric shades, and the overrides a
+ * file can set. `resolveAppearance` turns a saved appearance into the concrete colors, spacing and
+ * type that sizing, the canvas and both SVG exports read, so all of them agree.
+ *
+ * Diagram appearance is separate from the editor's light or dark mode.
+ */
+import type { Footnote } from './footnote';
+import type { Note } from './note';
+import { type FontRole, type TypeProfile } from './fonts';
+import type { FileConfig } from './link';
+export type ThemeId = 'drafting' | 'fieldnotes' | 'signal' | 'ink' | 'blueprint';
+export declare const THEME_IDS: ThemeId[];
+export declare const DEFAULT_THEME: ThemeId;
+/** Shade stops. Lower numbers are lighter and higher numbers darker, in every theme. */
+export declare const SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+export type Shade = (typeof SHADES)[number];
+export declare const isShade: (n: unknown) => n is Shade;
+/** Shade of a node that names a color without a shade. */
+export declare const NODE_SHADE: Shade;
+/**
+ * Shade of a group that names a color without a shade. Groups are quiet surfaces behind nodes, so
+ * this is a pale shade in light themes and a deep one in dark themes; the scale itself never flips.
+ */
+export declare const groupShadeFor: (theme: ThemeId) => Shade;
+/** Built-in color families, available in every theme. `primary` and `secondary` follow the theme. */
+export declare const BUILT_IN_FAMILIES: readonly ["primary", "secondary", "slate", "stone", "blue", "sky", "teal", "mint", "green", "amber", "orange", "red", "rose", "violet"];
+export declare const isBuiltInFamily: (name: string) => boolean;
+export interface Swatch {
+    fill: string;
+    stroke: string;
+    ink: string;
+}
+/** A file's color declaration: one shade of a family. Built-in shades may set some fields only. */
+export interface ColorDefinition {
+    family: string;
+    shade: Shade;
+    fill?: string;
+    stroke?: string;
+    ink?: string;
+}
+export interface AppearanceOverrides {
+    paddingX?: number;
+    paddingY?: number;
+    radius?: number;
+    titleFont?: FontRole;
+    annotationFont?: FontRole;
+    canvas?: string;
+    text?: string;
+    connection?: string;
+}
+export interface DiagramAppearance {
+    theme: ThemeId;
+    overrides: AppearanceOverrides;
+    colors: ColorDefinition[];
+    /** What the colors mean, from `legend` statements, drawn as a key beside the diagram. */
+    legend?: LegendEntry[];
+    /** Title and subtitle drawn above exported images, from `diagram` and `subtitle` statements. */
+    heading?: Heading;
+    /** Sentences drawn on the diagram without moving it, from `note` statements. */
+    notes?: Note[];
+    /** Entries of the block between the drawing and the key, from `footnote` statements. */
+    footnotes?: Footnote[];
+    /** Panel labels from a `compare` statement: draw the old and new versions side by side. */
+    compare?: {
+        /** Set by `draftably compare`: the changes the older panel draws in their new version. */
+        undrawn?: string;
+        before: string;
+        after: string;
+        /** `right` sets the panels side by side, `down` stacks them; chosen by `aspect` when unset. */
+        direction?: 'right' | 'down';
+        /** Width over height the whole image should come closest to; 1.6 when unset. */
+        aspect?: number;
+    };
+    /** File settings from `config` statements. */
+    config?: FileConfig;
+    /** Named emphasis states from `state` statements, in file order. */
+    states?: EmphasisState[];
+}
+/** One way to draw the diagram: these objects and connections in focus, the rest faded or plain. */
+export interface EmphasisState {
+    id: string;
+    label: string;
+    /** Objects (a group brings its members) and connections in focus. */
+    ids: string[];
+    /** How everything else draws: faded like a context line, or as usual. */
+    rest: 'dim' | 'plain';
+}
+export interface Heading {
+    title?: string;
+    subtitle?: string;
+    /** Width of the frame round the drawing, from `diagram width=`; never narrower than its content. */
+    width?: number;
+}
+/** The connection styles a `legend line` row can explain. */
+export declare const LEGEND_LINES: readonly ["dashed", "solid"];
+export type LegendLine = (typeof LEGEND_LINES)[number];
+/** One row of the key: a color swatch (`family`), or a short connection (`line`). */
+export interface LegendEntry {
+    family?: string;
+    line?: LegendLine;
+    /** Shade of the swatch; nodes' default when omitted. */
+    shade?: Shade;
+    label: string;
+}
+export declare const defaultAppearance: () => DiagramAppearance;
+/** Limits for numeric overrides, shared by the file parser and JSON validation. */
+export declare const OVERRIDE_LIMITS: {
+    readonly paddingX: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly paddingY: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly radius: {
+        readonly min: 0;
+        readonly max: 24;
+    };
+};
+export declare const HEX_COLOR: RegExp;
+interface Preset {
+    label: string;
+    description: string;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    titleFont: FontRole;
+    annotationFont: FontRole;
+    titleSize: number;
+    titleLine: number;
+    annotationSize: number;
+    /** Chroma multiplier for the built-in families: how saturated this theme's colors are. */
+    chroma: number;
+    /** Anchor colors for `primary` and `secondary`, at the shade they appear as. */
+    primary: [string, Shade];
+    secondary: [string, Shade];
+    /** Hue and chroma for built-in families this theme draws in its own way. */
+    hues?: Partial<Record<string, [number, number]>>;
+}
+export declare const PRESETS: Record<ThemeId, Preset>;
+export declare function contrast(a: string, b: string): number;
+/** Contrast targets (WCAG ratios) every generated color meets. */
+export declare const CONTRAST: {
+    /** Dark title text on a pale fill. */
+    readonly paleInk: 7;
+    /** White title text on a dark fill. */
+    readonly darkInk: 4.5;
+    /** A shape's outline against the canvas when its fill alone does not separate it. */
+    readonly outline: 3;
+    /** Connection lines and connection label text against the canvas. */
+    readonly connection: 4.5;
+    /** A group's frame against the canvas. */
+    readonly frame: 2;
+};
+/**
+ * Move a color's lightness away from `against` until it reaches `min` contrast with it. Colors
+ * that already meet the target are returned unchanged.
+ */
+export declare function ensureContrast(color: string, against: string, min: number): string;
+/** The built-in families of a preset on a canvas color, generated once. */
+export declare function builtInFamilies(theme: ThemeId, canvas?: string): Map<string, Map<Shade, Swatch>>;
+export interface ResolvedAppearance {
+    theme: ThemeId;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    /** Default node and group colors when nothing names a family. */
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    title: TypeProfile;
+    groupTitle: TypeProfile;
+    annotation: TypeProfile;
+    /** Space above a group's content; the group title sits in it. */
+    groupHeader: number;
+    /** Every family and the shades it defines: built-in ones plus the file's own. */
+    families: Map<string, Map<Shade, Swatch>>;
+    custom: Set<string>;
+    /** Strike a removed object's title through (`config strike-removed=on`). */
+    strikeRemoved: boolean;
+}
+/** Height of a group's title band, derived from the title's line height. */
+export declare const groupHeaderFor: (lineHeight: number) => number;
+/** Preset values, then file overrides. Omitted fields inherit from the preset. */
+export declare function resolveAppearance(appearance?: DiagramAppearance): ResolvedAppearance;
+/**
+ * Colors for an object. `family` is a family name, or `auto` for the theme's default surface; an
+ * omitted shade is 500 for nodes and 100 for groups. Unknown families or shades fall back to the
+ * default surface; the file parser reports them before they get here.
+ */
+export declare function swatchFor(r: ResolvedAppearance, family: string | undefined, shade: Shade | undefined, kind?: 'node' | 'group'): Swatch;
+/** Shades a family defines, in numeric order. */
+export declare const shadesOf: (r: ResolvedAppearance, family: string) => Shade[];
+export {};

package/dist/types/src/model/bounds.d.ts

@@ -0,0 +1,19 @@
+import type { VisibleGraph } from './graph';
+import type { Diagram, Point, Rect } from './types';
+/** How far a connection's ink reaches past its points: half the stroke plus the arrowhead's wings. */
+export declare const ROUTE_INK = 4;
+export interface BoundedRoute {
+    id?: string;
+    points: readonly Point[];
+    label: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+}
+/**
+ * Bounds of everything drawn: shapes with their labels, containers, every route point with its
+ * stroke and arrowhead, and every connection label box. `pad` adds a margin on each side.
+ */
+export declare function drawingBounds(doc: Diagram, vg: VisibleGraph, rects: ReadonlyMap<string, Rect>, routes: readonly BoundedRoute[], pad?: number): Rect;

package/dist/types/src/model/document.d.ts

@@ -0,0 +1,24 @@
+import { type DiagramAppearance } from './appearance';
+import type { Diagram, DiagramSettings } from './types';
+export declare const MAX_NODES = 500;
+export declare const MAX_EDGES = 1200;
+export declare function uid(prefix?: string): string;
+export declare const DEFAULT_SETTINGS: DiagramSettings;
+export declare function emptyDiagram(title?: string): Diagram;
+type Raw = any;
+export declare const isLegacyDiagram: (input: Raw) => boolean;
+/**
+ * Validate a diagram from any source and return a complete, canonical copy.
+ * Throws a readable error for anything that cannot be repaired.
+ */
+export declare function normalize(input: unknown): Diagram;
+/** Validate a saved appearance. A missing appearance is the default theme. */
+export declare function normalizeAppearance(input: Raw): DiagramAppearance;
+/** The meaning of a document, ignoring where the camera happens to be. */
+export declare function documentIdentity(doc: Diagram): string;
+/**
+ * Inputs that affect connection routing. The editor store keeps the key order of the document it
+ * replaced, so the worker's freshly projected copy of the same document lists its keys differently.
+ */
+export declare function routingFingerprint(doc: Diagram): string;
+export {};

package/dist/types/src/model/font-faces.d.ts

@@ -0,0 +1,24 @@
+/** SHA-256 prefix of the metric table and its four WOFF2 files, in declared face order. */
+export declare const fontMetricsVersion = "269b2d3580f4";
+export declare const FACES: {
+    'sans-500': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'sans-600': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'serif-600': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'mono-500': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+};

package/dist/types/src/model/fonts.d.ts

@@ -0,0 +1,47 @@
+export type FontRole = 'sans' | 'serif' | 'mono';
+export declare const FONT_ROLES: FontRole[];
+export interface FontFace {
+    /** Registered family name; unique so an installed copy of the font is never used instead. */
+    family: string;
+    weight: number;
+    file: string;
+}
+export { FACES } from './font-faces';
+import { FACES } from './font-faces';
+export type FaceId = keyof typeof FACES;
+/** Face used for each role: titles are a little heavier than annotations in sans-serif. */
+export declare const faceFor: (role: FontRole, title: boolean) => FaceId;
+export declare const fontStack: (role: FontRole) => string;
+/** A text style: which face, at what size and line height. */
+export interface TypeProfile {
+    role: FontRole;
+    face: FaceId;
+    family: string;
+    weight: number;
+    size: number;
+    lineHeight: number;
+}
+export declare function typeProfile(role: FontRole, title: boolean, size: number, lineHeight: number): TypeProfile;
+/**
+ * Width of `text` in `profile`, from the stored advance widths. Kerning is ignored, which only
+ * ever overstates a width slightly, so measured text fits where this says it fits.
+ */
+export declare function measureText(text: string, profile: Pick<TypeProfile, 'face' | 'size'>): number;
+/**
+ * The pieces an identifier reads in, so a long one can break where a reader would: after a
+ * separator (`/`, `.`, `_`, `-`, `:`) or between a lower-case letter or digit and a capital
+ * (camelCase). `annotationCommands` → `annotation`, `Commands`; `src/viz/Treemap.tsx` → `src/`,
+ * `viz/`, `Treemap.tsx`. A word with none of these is one piece.
+ */
+export declare function wordPieces(word: string): string[];
+/** Width of the widest piece of any word in `text`: the narrowest line it wraps into whole. */
+export declare function widestPiece(text: string, profile: Pick<TypeProfile, 'face' | 'size'>): number;
+/**
+ * Break text into lines no wider than `width`, starting a new line at each `\n`. A word longer
+ * than a line breaks between its pieces (`wordPieces`), and only a piece that is itself too long
+ * breaks by character. With `balance`, a paragraph that wraps keeps its line count but its lines
+ * run near equal (`even`), so no word sits alone on the last line when a better break exists.
+ */
+export declare function wrapLines(text: string, width: number, profile: TypeProfile, balance?: boolean): string[];
+/** Shorten text with an ellipsis so it fits in `width`. */
+export declare function truncateText(text: string, width: number, profile: TypeProfile): string;

package/dist/types/src/model/footnote.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Footnotes: a block of short entries between the drawing and the key, from `footnote`
+ * statements, in file order, at body text size and wrapped to the frame. An entry may carry a
+ * marker (`1`, `a`, `*`) that a label can point at, and links in `[label](href)` form. The viewer,
+ * `inspect --svg`, PDF and the editor's exports all lay it out here.
+ */
+import { type ResolvedAppearance } from './appearance';
+import { type Run } from './rich-text';
+export interface Footnote {
+    text: string;
+    /** A short marker drawn before the entry, which labels can point at as `[1]`. */
+    mark?: string;
+}
+/** The block's entries, wrapped to `width`, with their offsets from its top-left corner. */
+export declare function footnoteSize(look: ResolvedAppearance, notes: readonly Footnote[], width: number): {
+    type: import("./fonts").TypeProfile;
+    gutter: number;
+    items: {
+        note: Footnote;
+        lines: Run[][];
+        y: number;
+    }[];
+    h: number;
+};
+export type FootnoteLayout = ReturnType<typeof footnoteSize>;
+/** Where each line of every entry is drawn, from the block's top-left corner at (x, y). */
+export declare function footnoteLines(layout: FootnoteLayout, x: number, y: number): {
+    entry: number;
+    runs: Run[];
+    x: number;
+    y: number;
+}[];
+/** SVG markup for the block: a short rule, then each entry's marker and wrapped text. */
+export declare function footnoteMarkup(look: ResolvedAppearance, layout: FootnoteLayout, x: number, y: number, write?: (href: string) => string | null): string;

package/dist/types/src/model/geometry.d.ts

@@ -0,0 +1,29 @@
+import type { Point, Rect } from './types';
+export declare const clamp: (n: number, min: number, max: number) => number;
+export declare const finite: (n: unknown) => n is number;
+/** Document coordinates are stored with one decimal place. */
+export declare const rounded: (n: number) => number;
+export declare const center: (r: Rect) => Point;
+export declare const manhattan: (a: Point, b: Point) => number;
+export declare const inside: (p: Point, r: Rect, pad?: number) => boolean;
+export declare const contains: (outer: Rect, inner: Rect) => boolean;
+export declare const overlaps: (a: Rect, b: Rect, pad?: number) => boolean;
+/** Bounding box of the given rectangles, or a placeholder area when there are none. */
+export declare function rectUnion(rects: readonly Rect[], pad?: number): Rect;
+/** Rectangle spanned by two corner points. */
+export declare const rectFromPoints: (a: Point, b: Point) => Rect;
+export type Segment = [Point, Point];
+export declare const segments: (points: readonly Point[]) => Segment[];
+export declare const shrink: (r: Rect, d: number) => Rect;
+/** Overlap of two rectangles larger than half a pixel on both axes. */
+export declare const covers: (a: Rect, b: Rect) => boolean;
+/** Length of a segment inside a rectangle (Liang–Barsky clipping). */
+export declare function segmentInside([a, b]: Segment, r: Rect): number;
+/** SVG path for an orthogonal polyline with rounded corners. */
+export declare function roundedPath(points: readonly Point[], radius: number): string;
+export declare const clone: <T>(value: T) => T;
+/**
+ * A rectangle whose left and right sides are zigzags, for a field of variable length: the reader
+ * sees it continue past what is drawn.
+ */
+export declare function brokenRectPath(r: Rect, step?: number, depth?: number): string;

package/dist/types/src/model/graph.d.ts

@@ -0,0 +1,53 @@
+import type { Diagram, DiagramEdge, DiagramGroup, DiagramNode, Direction, Entity, NodeLayout, NodeStyle, Rect } from './types';
+export declare const findNode: (doc: Diagram, id: string | null | undefined) => DiagramNode | undefined;
+export declare const findGroup: (doc: Diagram, id: string | null | undefined) => DiagramGroup | undefined;
+export declare const findEdge: (doc: Diagram, id: string | null | undefined) => DiagramEdge | undefined;
+export declare const findObject: (doc: Diagram, id: string | null | undefined) => DiagramNode | DiagramGroup | undefined;
+export declare const findEntity: (doc: Diagram, id: string | null | undefined) => Entity | undefined;
+export declare const isNode: (doc: Diagram, id: string) => boolean;
+export declare const isGroup: (doc: Diagram, id: string) => boolean;
+export declare const isEdge: (doc: Diagram, id: string) => boolean;
+export declare const styleOf: (doc: Diagram, id: string) => NodeStyle;
+/** Direct children (shapes and containers) of a container, or of the diagram root. */
+/** The title band of a `cells` group; undefined for any other group. */
+export declare const cellsBandOf: (doc: Diagram, id: string | null | undefined) => number | undefined;
+/** Whether a cell is a field of variable length in a byte or bit layout. */
+export declare const isOpenCell: (doc: Diagram, id: string) => boolean;
+/** Whether a node is a cell of a `cells` group, which holds it in place edge to edge. */
+export declare const isCell: (doc: Diagram, id: string) => boolean;
+export declare function childrenOf(doc: Diagram, parentId: string | null | undefined): (DiagramNode | DiagramGroup)[];
+export declare function descendants(doc: Diagram, id: string): string[];
+/** Containers enclosing an object, nearest first. */
+export declare function ancestors(doc: Diagram, id: string): string[];
+export declare const isCollapsed: (doc: Diagram, id: string) => boolean;
+export declare const isHiddenByCollapse: (doc: Diagram, id: string) => boolean;
+/** The visible object that stands in for `id`: its outermost collapsed container, if any. */
+export declare function visibleProxy(doc: Diagram, id: string): string;
+export interface VisibleEdge extends DiagramEdge {
+    /** Visible source, which may be a collapsed container. */
+    a: string;
+    /** Visible target, which may be a collapsed container. */
+    b: string;
+}
+export interface VisibleGraph {
+    nodes: DiagramNode[];
+    groups: DiagramGroup[];
+    edges: VisibleEdge[];
+}
+/** Objects and connections that are not hidden inside a collapsed container. */
+export declare function visibleGraph(doc: Diagram): VisibleGraph;
+/** Selected shapes and containers whose own container is not also selected. */
+export declare function selectionRoots(doc: Diagram, selected: Iterable<string>): string[];
+/** Layout direction for the contents of an object's container. */
+export declare function inheritedDirection(doc: Diagram, id: string): Direction;
+export declare const COLLAPSED_HEIGHT = 58;
+export declare const CONTAINER_HEADER = 28;
+/** Read geometry for an object, preferring a temporary override (preview, animation, brush). */
+export type GeometryLookup = (id: string) => NodeLayout;
+export declare function makeGeometry(doc: Diagram, override?: Record<string, NodeLayout> | null): (id: string) => NodeLayout;
+/**
+ * Container frame as drawn: collapsed containers shrink to their title band plus a line for the
+ * shape count, so the title stays where it was in the open frame.
+ */
+export declare function frameRect(doc: Diagram, geometry: GeometryLookup, id: string): NodeLayout;
+export declare const objectRect: (doc: Diagram, geometry: GeometryLookup, id: string) => Rect;

package/dist/types/src/model/heading.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The title and subtitle drawn above an exported diagram, shared by `inspect --svg` and the
+ * editor's export, so a copied image still says what it shows.
+ */
+import type { Heading, ResolvedAppearance } from './appearance';
+/** Title type: the theme's title face, larger; subtitle type: its annotation face. */
+declare function types(look: ResolvedAppearance): {
+    title: import("./fonts").TypeProfile;
+    subtitle: import("./fonts").TypeProfile;
+};
+/**
+ * Width the subtitle wraps to over a drawing `room` wide: the drawing's width, held between 360px
+ * and about 70 characters, so a long subtitle wraps instead of widening the frame.
+ */
+export declare function subtitleMeasure(look: ResolvedAppearance, room: number): number;
+/** Size of the heading block, including the gap under it. Zero when there is nothing to draw. */
+export declare function headingSize(look: ResolvedAppearance, heading: Heading | undefined, wrap: number): {
+    w: number;
+    h: number;
+};
+/**
+ * Each line of the heading with its own type and box, top-left corner at (x, y). The title is one
+ * line; the subtitle wraps to `wrap` (`subtitleMeasure`).
+ */
+export declare function headingLines(look: ResolvedAppearance, heading: Heading | undefined, x: number, y: number, wrap: number): {
+    key: "title" | "subtitle";
+    text: string;
+    type: Type;
+    fill: string;
+    x: number;
+    y: number;
+}[];
+type Type = ReturnType<typeof types>['title'];
+/** SVG markup for the heading with its top-left corner at (x, y). */
+export declare function headingMarkup(look: ResolvedAppearance, heading: Heading | undefined, x: number, y: number, wrap: number): string;
+/** Title and subtitle type, for drawing and editing them in the viewer. */
+export declare const headingTypes: typeof types;
+export {};

package/dist/types/src/model/icons.d.ts

@@ -0,0 +1,2 @@
+/** SVG path data for interface and shape icons, drawn on a 24×24 grid. */
+export declare const ICONS: Record<string, string>;

package/dist/types/src/model/labels.d.ts

@@ -0,0 +1,88 @@
+import { type ResolvedAppearance } from './appearance';
+import { type TypeProfile } from './fonts';
+import type { Diagram, LabelMode, Rect, ShapeKind } from './types';
+/**
+ * Room for a shape's title. Every size, wrap and overflow decision goes through these functions,
+ * in the compiler, the canvas and the CLI alike.
+ */
+export interface TitleArea {
+    /** Line width available to the title. */
+    width: number;
+    /** Tallest text block that fits inside the shape at its current height. */
+    maxHeight: number;
+}
+export declare function titleArea(shape: ShapeKind, w: number, h: number, r: ResolvedAppearance, icon?: boolean): TitleArea;
+/** Height a shape needs for `lines` title lines; never less than `base`. */
+export declare function titleHeight(shape: ShapeKind, lines: number, base: number, r: ResolvedAppearance): number;
+/** A shape's title in balanced lines no wider than `width` (see `wrapLines`). */
+export declare const wrapTitle: (text: string, width: number, r: ResolvedAppearance) => string[];
+/**
+ * Line width for a diamond's title, `s` its side. A text block W wide and H tall fits inside a
+ * square diamond when W + H <= s, so this takes the widest measure whose wrapped lines still fit:
+ * the title reads in as few lines as the shape allows. Undefined when no measure fits.
+ */
+export declare function diamondMeasure(title: string, s: number, r: ResolvedAppearance): number | undefined;
+/** Most lines a group title wraps to; past that the frame widens instead. */
+export declare const GROUP_TITLE_LINES = 3;
+/** A group's header height when its title takes `lines` lines. */
+export declare const groupHeaderFor: (r: ResolvedAppearance, lines?: number) => number;
+/**
+ * A group title as drawn in a frame `w` wide: wrapped to at most `lines` lines (the compiler
+ * reserves that many), the last shortened with an ellipsis if the text runs on.
+ */
+export declare function groupTitleLines(title: string, w: number, r: ResolvedAppearance, lines?: number): string[];
+export interface NodeLabel {
+    /** Center of the label, relative to the shape's top-left corner. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    lines: string[];
+    mode: LabelMode;
+    lineHeight: number;
+    leader: boolean;
+}
+/** Where a shape's title is drawn, relative to the shape. */
+export declare function nodeLabel(doc: Diagram, id: string, title: string, r: Rect): NodeLabel;
+/** Bounds of a shape together with its label. */
+export declare function visualBounds(doc: Diagram, id: string, title: string, r: Rect): Rect;
+/** Text width a sequence message's label wraps to; the gap between participants follows it. */
+export declare const MESSAGE_WRAP = 168;
+/**
+ * The type a connection label is set in: the annotation type, or a step larger for a sequence
+ * message (`message`), whose label is the main thing to read.
+ */
+export declare const edgeLabelType: (r: ResolvedAppearance, message?: boolean) => TypeProfile;
+/**
+ * Text width a flow line's label wraps to: about 24 characters of the annotation type, so a short
+ * phrase stays on one line and a sentence stacks instead of widening its gap.
+ */
+export declare const LABEL_WRAP = 140;
+/**
+ * A connection label's lines: split at each `\n` and wrapped to `LABEL_WRAP`, or a sequence
+ * message's to `MESSAGE_WRAP`.
+ */
+export declare const edgeLabelLines: (label: string, r: ResolvedAppearance, message?: boolean) => string[];
+/**
+ * A self-message's loop: its run out to the right of the lifeline and its drop. Its label sits
+ * `label` past the loop, centred on the drop.
+ */
+export declare const SELF_LOOP: {
+    out: number;
+    down: number;
+    label: number;
+};
+/** Box for a connection label in the diagram's annotation type. */
+export declare function edgeLabelSize(label: string, r?: ResolvedAppearance, message?: boolean): {
+    w: number;
+    h: number;
+};
+/**
+ * What a self-message draws, measured from where its row meets the lifeline: how far right, how
+ * far above the row and how far below it.
+ */
+export declare function selfMessageInk(label: string | undefined, r: ResolvedAppearance): {
+    right: number;
+    above: number;
+    below: number;
+};

package/dist/types/src/model/link.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Links on objects (`href=`): what a link points at, and where its mark sits on a shape.
+ *
+ * A link is kept as the author wrote it. A URL (`https://…`, `mailto:`) opens as written; a
+ * `.draft` opens in the viewer; anything else is a file path that opens in the editor. A file
+ * path may end in `:line` or `:line:col`, and a relative one starts at the link base: the git
+ * root of the diagram, unless the file sets `config link-base=`.
+ */
+import { type TypeProfile } from './fonts';
+export type LinkKind = 'url' | 'draft' | 'file';
+export interface LinkTarget {
+    kind: LinkKind;
+    /** The URL, or the file path without its line and column. */
+    path: string;
+    line?: number;
+    col?: number;
+}
+export declare function linkTarget(href: string): LinkTarget;
+/**
+ * A relative `href` against a URL `link-base` (`https://host/org/repo/blob/<sha>/`), as the URL
+ * it opens; null when the base is a folder or unset, or `href` is already a URL.
+ */
+export declare function baseUrl(href: string, base: string | undefined): string | null;
+/** Join and normalize forward-slash paths; an absolute `path` ignores `base`. */
+export declare function joinPath(base: string, path: string): string;
+/** The path from folder `from` to `to`, both absolute with forward slashes. */
+export declare function relativePath(from: string, to: string): string;
+/**
+ * A link as a static SVG carries it. A URL stays as written; a file or `.draft` becomes a path
+ * from the diagram's folder (a first guess at where the SVG is saved), without its line.
+ */
+export declare function staticHref(href: string, base: string, folder: string): string;
+/** Editors that open `<scheme>://file/<path>:<line>:<col>`. */
+export declare const EDITORS: readonly ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"];
+export type Editor = (typeof EDITORS)[number];
+/** File settings from `config` statements. */
+export interface FileConfig {
+    /**
+     * Where relative links start: a folder relative to the diagram's (its git root when unset), or
+     * a URL that relative links are joined to.
+     */
+    linkBase?: string;
+    /** The editor file links open in; VS Code when unset. */
+    editor?: Editor;
+    /** Strike removed titles through in a diff; off when unset. */
+    strikeRemoved?: boolean;
+}
+export declare const editorUrl: (editor: Editor, file: string, line?: number, col?: number) => string;
+/** The link mark: a small arrow out of a shape's top-right corner, inside the shape when it can be. */
+export interface LinkMark {
+    x: number;
+    y: number;
+    size: number;
+    /** Inside the shape's fill (draw in its ink), or on the canvas beside it. */
+    inside: boolean;
+}
+export declare const LINK_MARK_SIZE = 10;
+/** `badge` is the width of a `count` badge on the corner, which the mark steps left of. */
+export declare function linkMark(shape: string, w: number, h: number, badge?: number): LinkMark;
+/** The mark next to a container's title. */
+export declare const groupLinkMark: (title: string, font: TypeProfile, band: number) => LinkMark;
+/** The arrow, in a 10×10 box. */
+export declare const LINK_MARK_PATH = "M2 8L8 2M3.5 2H8V6.5";