@theodo-group/epure 0.1.0 → 0.2.0

package/dist-lib/icons.d.ts

@@ -0,0 +1,37 @@
+interface IconMeta {
+    /** Stable id, e.g. "aws/compute/ec2". Stored in the layout JSON. */
+    id: string;
+    /** Humanized display name. */
+    name: string;
+    /** Top-level provider key, e.g. "aws". */
+    provider: string;
+    /** Sub-category, e.g. "compute". */
+    category: string;
+    /** Path under public/icons/, e.g. "aws/compute/ec2.png". */
+    file: string;
+}
+declare const ICON_CATALOG: IconMeta[];
+
+/** Static URL for an icon file path (e.g. "aws/compute/ec2.png"). */
+declare const iconUrl: (file: string) => string;
+declare const iconById: (id: string) => IconMeta | undefined;
+/** Static URL for an icon id, or undefined if the id is unknown. */
+declare const iconUrlById: (id: string) => string | undefined;
+interface ProviderInfo {
+    key: string;
+    label: string;
+    count: number;
+}
+declare const providerLabel: (key: string) => string;
+declare const PROVIDERS: ProviderInfo[];
+interface SearchOptions {
+    provider?: string;
+    limit?: number;
+}
+/**
+ * Filter the catalog by a free-text query (matched against id/name/provider/
+ * category, all terms must hit) and an optional provider, capped to `limit`.
+ */
+declare const searchIcons: (query: string, { provider, limit }?: SearchOptions) => IconMeta[];
+
+export { ICON_CATALOG, type IconMeta, PROVIDERS, type ProviderInfo, type SearchOptions, iconById, iconUrl, iconUrlById, providerLabel, searchIcons };

package/dist-lib/icons.js

@@ -0,0 +1,18 @@
+import {
+  ICON_CATALOG,
+  PROVIDERS,
+  iconById,
+  iconUrl,
+  iconUrlById,
+  providerLabel,
+  searchIcons
+} from "./chunk-KBK6AYWD.js";
+export {
+  ICON_CATALOG,
+  PROVIDERS,
+  iconById,
+  iconUrl,
+  iconUrlById,
+  providerLabel,
+  searchIcons
+};

package/dist-lib/react.d.ts

@@ -0,0 +1,95 @@
+import { FC } from 'react';
+import { S as ShapeName, a as Size, P as PaletteColor, L as LineStyle, F as FillColor, b as Side, E as EdgeRoute, c as EdgeStyle, d as EdgeDirection, A as AreaLayout } from './Canvas-BcrF3N4l.js';
+export { e as EdgeMeta, N as NodeMeta } from './Canvas-BcrF3N4l.js';
+
+interface NodeProps {
+    id: string;
+    shape: ShapeName;
+    label?: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    selected?: boolean;
+    textSize?: Size;
+    textColor?: PaletteColor;
+    borderColor?: PaletteColor;
+    borderStyle?: LineStyle;
+    fillColor?: FillColor;
+    icon?: string;
+    iconPosition?: 'corner' | 'top';
+    onSelect?: (id: string, additive: boolean) => void;
+    onMove?: (id: string, centerX: number, centerY: number, shiftKey: boolean) => void;
+    onResize?: (id: string, side: Side, pxX: number, pxY: number) => void;
+    /** Double-click to edit this node's label inline. */
+    onStartEdit?: (id: string) => void;
+    /** When true this node's label is being edited in the overlay editor, so the
+     *  baked SVG label is suppressed to avoid rendering it twice. */
+    editing?: boolean;
+    gridSize: number;
+    textScale?: number;
+    fontFamily?: string;
+}
+declare const Node: FC<NodeProps>;
+
+interface Crossing {
+    /** Crossing point, in the same px space as `edge.points`. */
+    x: number;
+    y: number;
+    /** Radius (px) of the faded gap to punch into the under-edge here. */
+    r: number;
+}
+
+interface EdgeProps {
+    edge: EdgeRoute;
+    label?: string;
+    style?: EdgeStyle;
+    marker?: EdgeDirection;
+    selected?: boolean;
+    onSelect?: (id: string, additive: boolean) => void;
+    textScale?: number;
+    fontFamily?: string;
+    /** Grid pitch (px); used to convert a label drag into integer grid units. */
+    gridSize?: number;
+    /** Drag the label to a new offset (grid units). Absent → label is static
+     *  (e.g. the headless export). */
+    onMoveLabel?: (id: string, labelDx: number, labelDy: number) => void;
+    /** Points where this edge passes UNDER another edge. A soft transparent gap
+     *  is faded into the stroke at each, so crossings read clearly. Computed once
+     *  per diagram by `computeCrossings` and shared by the canvas and the export
+     *  so the two never diverge. */
+    crossings?: Crossing[];
+}
+declare const EdgeDefs: FC;
+declare const labelPillSize: (label: string, textScale?: number) => {
+    w: number;
+    h: number;
+};
+declare const Edge: FC<EdgeProps>;
+
+interface AreaProps {
+    area: AreaLayout;
+    selected?: boolean;
+    onSelect?: (areaId: string, additive: boolean) => void;
+    onDragStart?: (areaId: string) => void;
+    onDragMove?: (areaId: string, dxPixels: number, dyPixels: number) => void;
+}
+declare const Area: FC<AreaProps>;
+interface AreaLabelProps {
+    area: AreaLayout;
+    textScale?: number;
+    fontFamily?: string;
+}
+declare const AreaLabel: FC<AreaLabelProps>;
+
+interface GridProps {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    gridSize: number;
+    patternId?: string;
+}
+declare const Grid: FC<GridProps>;
+
+export { Area, AreaLabel, Edge, EdgeDefs, Grid, Node, labelPillSize };

package/dist-lib/react.js

@@ -0,0 +1,50 @@
+import {
+  Area,
+  AreaLabel,
+  Edge,
+  EdgeDefs,
+  Node,
+  labelPillSize
+} from "./chunk-7YSWFGM7.js";
+import "./chunk-KBK6AYWD.js";
+
+// src/renderer/Grid.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Grid = ({
+  x,
+  y,
+  width,
+  height,
+  gridSize,
+  patternId = "epure-grid"
+}) => /* @__PURE__ */ jsxs("g", { "aria-hidden": "true", "data-ep-grid": "", children: [
+  /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx(
+    "pattern",
+    {
+      id: patternId,
+      width: gridSize,
+      height: gridSize,
+      patternUnits: "userSpaceOnUse",
+      children: /* @__PURE__ */ jsx("circle", { cx: 0, cy: 0, r: 1.5, fill: "#cbd5e1" })
+    }
+  ) }),
+  /* @__PURE__ */ jsx(
+    "rect",
+    {
+      x,
+      y,
+      width,
+      height,
+      fill: `url(#${patternId})`
+    }
+  )
+] });
+export {
+  Area,
+  AreaLabel,
+  Edge,
+  EdgeDefs,
+  Grid,
+  Node,
+  labelPillSize
+};

package/dist-lib/render.d.ts

@@ -0,0 +1,100 @@
+import { R as RoutedDiagram, N as NodeMeta, e as EdgeMeta } from './Canvas-BcrF3N4l.js';
+
+declare const setLibavoidWasmPath: (path: string) => void;
+
+interface PngOptions {
+    /** Resolution multiplier (1 = SVG's intrinsic px). */
+    scale?: number;
+    background?: string;
+}
+declare const svgToPng: (svg: string, opts?: PngOptions) => Buffer;
+
+interface RenderModel {
+    routed: RoutedDiagram;
+    /** Topology metadata keyed by node id (shape + label come from the `.d2`). */
+    nodes: Record<string, NodeMeta>;
+    /** Edge metadata keyed by routed edge id (`src->tgt#i`). */
+    edges: Record<string, EdgeMeta>;
+}
+/**
+ * Parse + route a pair into a render model. Returns `{ error }` when the `.d2`
+ * doesn't parse (nothing meaningful to draw). An absent/invalid layout is
+ * tolerated — Phase-0 normalization auto-places any unplaced node.
+ */
+declare const buildRenderModel: (d2: string, layoutText: string | null) => Promise<RenderModel | {
+    error: string;
+}>;
+
+interface SvgOptions {
+    padding?: number;
+    background?: string;
+}
+/** SSR the render model to an SVG string sized exactly to its content. */
+declare const renderSvgString: (model: RenderModel, opts?: SvgOptions) => string;
+/**
+ * Replace `href="/icons/<file>"` (or `xlink:href`) with inlined base64 data
+ * URIs so the rasterizer renders the logos. Unknown/missing files are left
+ * untouched (the rasterizer simply skips a broken href).
+ */
+declare const inlineIcons: (svg: string, iconsDir: string) => string;
+
+/**
+ * Return `png` with an `iTXt` chunk per entry spliced in after IHDR. A
+ * non-PNG (or empty-entries) input is returned untouched — embedding metadata
+ * must never be able to corrupt the image.
+ */
+declare const embedPngText: (png: Buffer, entries: {
+    keyword: string;
+    text: string;
+}[]) => Buffer;
+/** Read every `iTXt`/`tEXt` chunk back into a keyword→text map. Inverse of
+ *  `embedPngText`; used by tests today, and the basis for "recover source from
+ *  an image" later. */
+declare const readPngText: (png: Buffer) => Record<string, string>;
+/** Keywords under which the diagram source is stored in rendered PNGs. */
+declare const PNG_SOURCE_KEYS: {
+    readonly d2: "epure.d2";
+    readonly layout: "epure.layout.json";
+};
+/** Standard PNG text keywords that announce — to any viewer, `exiftool`, or an
+ *  agent like Claude Code that reads the image's metadata — that this is an
+ *  Épure diagram carrying its own editable source. Using the registered
+ *  `Software`/`Description` keywords means generic tools surface them too. */
+declare const PNG_MARKER_KEYS: {
+    readonly software: "Software";
+    readonly description: "Description";
+};
+/** The complete set of text chunks embedded in every rendered PNG: a
+ *  self-describing marker (so the image announces "made with Épure, source
+ *  inside, here's how to edit it") followed by the exact `.epr.d2` /
+ *  `.epr.layout.json` bytes for a lossless round-trip back to the editable pair.
+ *  The browser "Export PNG" path mirrors this in `src/export/pngText.ts`. */
+declare const epureMetaEntries: (d2: string, layoutText: string | null) => {
+    keyword: string;
+    text: string;
+}[];
+
+interface RenderOptions extends SvgOptions, PngOptions {
+    /** Directory holding the icon PNGs (`<iconsDir>/aws/.../x.png`). */
+    iconsDir?: string;
+}
+/** Render a pair to a fit-to-content SVG string, or `{ error }` if the d2 is invalid. */
+declare const renderDiagramSvg: (d2: string, layoutText: string | null, opts?: RenderOptions) => Promise<string | {
+    error: string;
+}>;
+/** Render a pair to fit-to-content PNG bytes, or `{ error }` if the d2 is
+ *  invalid. The diagram's own source (d2 + layout) is embedded as PNG text
+ *  metadata, alongside a self-describing "made with Épure, source inside"
+ *  marker, so the image is a self-contained, round-trippable, agent-readable
+ *  record of the pair. */
+declare const renderDiagramPng: (d2: string, layoutText: string | null, opts?: RenderOptions) => Promise<Buffer | {
+    error: string;
+}>;
+
+/**
+ * Absolute path to the icon images shipped with the package, for use as
+ * `RenderOptions.iconsDir` (icons are then base64-inlined into the SVG).
+ */
+declare const packagedIconsDir: () => string;
+
+export { PNG_MARKER_KEYS, PNG_SOURCE_KEYS, type RenderOptions, buildRenderModel, embedPngText, epureMetaEntries, inlineIcons, packagedIconsDir, readPngText, renderDiagramPng, renderDiagramSvg, renderSvgString, setLibavoidWasmPath, svgToPng };