@diagrammo/dgmo 0.65.0 → 0.67.0

package/dist/themes-Dem5xalq.d.ts

@@ -0,0 +1,139 @@
+import { P as PaletteConfig } from './tag-groups-NUA2F1I5.js';
+import { A as AirportData, G as Gazetteer, R as RegionName } from './d3-Bfhj-XBX.js';
+
+/**
+ * All built-in palettes, keyed by camelCase id. Use directly with render():
+ *
+ *   await render(text, { palette: palettes.catppuccin });
+ *
+ * For preference/settings storage, the `.id` field of each entry is the
+ * canonical string (e.g. `'tokyo-night'`, `'nord'`) — that's the wire format
+ * used by share URLs and the CLI `--palette` flag.
+ */
+declare const palettes: {
+    readonly atlas: PaletteConfig;
+    readonly blueprint: PaletteConfig;
+    readonly slate: PaletteConfig;
+    readonly tidewater: PaletteConfig;
+    readonly nord: PaletteConfig;
+    readonly catppuccin: PaletteConfig;
+    readonly tokyoNight: PaletteConfig;
+};
+
+interface MapPlaceCompletion {
+    /** Canonical display name (original casing), e.g. `Portland`. */
+    readonly name: string;
+    /** Text to insert. ISO-qualified (`Portland US-OR`) iff the name is
+     *  ambiguous in the gazetteer; bare otherwise (disambiguate-once, §24B.8). */
+    readonly insert: string;
+    /** Menu label (`Portland — US-OR` when ambiguous, else `Portland`). */
+    readonly label: string;
+    /** Secondary detail, e.g. `US-OR · 652,503`. */
+    readonly detail: string;
+    readonly iso: string;
+    readonly sub?: string;
+    readonly pop: number;
+    /** `'airport'` for IATA-code entries (icon/grouping affordance); absent or
+     *  `'city'` for gazetteer cities. Cities rank above airports for a shared
+     *  prefix so ~1500 codes never bury city names (ADR-5). */
+    readonly kind?: 'city' | 'airport';
+}
+interface MapCompletionOptions {
+    /** Max results (default 12). */
+    readonly limit?: number;
+    /** IATA-coded airports (`airports.json`). When supplied, airport codes
+     *  matching the prefix are offered as a second (post-city) group. Optional —
+     *  absent (old DI bundles / no asset) just yields city-only completions. */
+    readonly airports?: AirportData;
+    /** Resolver-inferred map scope (country `US` or subdivision `US-CA`). Biases
+     *  airport ranking so in-region airports sort above out-of-region same-prefix
+     *  ones (ADR-6). Pure rank, never a filter — cross-region airports still
+     *  appear. App passes the document's inferred scope in (Slice 2). */
+    readonly scopeISO?: string;
+}
+/**
+ * Prefix-match city names + alternate-name aliases against the gazetteer,
+ * rank by population (desc; stable tie-break by gazetteer index), and emit
+ * ISO-qualified insert text only for ambiguous (same-named) places.
+ *
+ * Pure + deterministic. Empty/blank query → `[]` (the caller gates min length).
+ */
+declare function completeMapPlaces(query: string, gazetteer: Gazetteer, opts?: MapCompletionOptions): MapPlaceCompletion[];
+/** A POI search hit — a city or airport the resolver can resolve, with the
+ *  exact `token` to paste into DGMO (a `poi`/route endpoint). Powers the CLI
+ *  `dgmo map search` command and the MCP `lookup_map_location` tool, so authors
+ *  (and AI agents) can DISCOVER valid place tokens instead of guessing — e.g.
+ *  learn that "New York" must be `New York City` and that `JFK` is bundled. */
+interface MapLocationMatch {
+    /** Canonical display name (cities) or full airport name. */
+    readonly name: string;
+    /** Exact text to use in DGMO. Cities: the name, ISO-qualified when ambiguous
+     *  (`Portland US-OR`). Airports: the upper-case IATA code (`JFK`). */
+    readonly token: string;
+    readonly kind: 'city' | 'airport';
+    readonly iso: string;
+    readonly sub?: string;
+    /** City population (0 for airports). */
+    readonly pop: number;
+    /** Human detail, e.g. `US-OR · 652,503` or `Airport · John F Kennedy Intl`. */
+    readonly detail: string;
+}
+/**
+ * Substring-search cities + airports for a discovery surface (CLI / MCP), so an
+ * author can find the exact token the resolver expects. Unlike
+ * {@link completeMapPlaces} (prefix-only, editor type-ahead), this matches
+ * anywhere in a city name OR an airport code/name, so "york" finds
+ * `New York City` and "kennedy" finds `JFK`.
+ *
+ * Ranking: exact-name (or exact-IATA) → prefix → substring; within a tier,
+ * cities by population desc (deterministic index tie-break), cities before
+ * airports. Pure + deterministic. Empty query → `[]`.
+ */
+declare function searchMapLocations(query: string, gazetteer: Gazetteer, opts?: {
+    readonly limit?: number;
+    readonly airports?: AirportData;
+}): MapLocationMatch[];
+interface MapRegionCompletion {
+    /** Display name = insert text (the resolver disambiguates cross-layer
+     *  collisions like Georgia by map scope, §24B.8). */
+    readonly name: string;
+    /** ISO 3166-1/3166-2 id. */
+    readonly iso: string;
+    readonly layer: 'country' | 'us-state';
+    /** Secondary detail, e.g. `US state · US-CA` or `Country · DE`. */
+    readonly detail: string;
+}
+/**
+ * Prefix-match fill-able region names (countries + US states) for region-fill
+ * lines. Matches the folded display name OR the ISO code; deterministic
+ * (alphabetical by name, then layer). Pure. Empty query → `[]`.
+ *
+ * `regions` is injected (the `region-names.json` asset, shipped in dist/map-data
+ * alongside the gazetteer). Cross-layer same-name (Georgia: country GE + state
+ * US-GA) yields both entries, distinguished by `detail`.
+ */
+declare function completeMapRegions(query: string, regions: readonly RegionName[], opts?: MapCompletionOptions): MapRegionCompletion[];
+
+/**
+ * Theme — render mode flag. Selects which palette variant the renderer uses
+ * for background and text:
+ *  - 'light'       → palette.light colors
+ *  - 'dark'        → palette.dark colors
+ *  - 'transparent' → no background fill (for embedding in colored containers)
+ */
+type Theme = 'light' | 'dark' | 'transparent';
+/**
+ * `themes` namespace — use with render() options for a typed handle:
+ *
+ *   await render(text, { theme: themes.dark });
+ *
+ * Passing the raw string `'dark'` also works (the underlying type is the
+ * string-literal union); the namespace is the conventional path.
+ */
+declare const themes: {
+    readonly light: "light";
+    readonly dark: "dark";
+    readonly transparent: "transparent";
+};
+
+export { type MapCompletionOptions as M, type Theme as T, type MapLocationMatch as a, type MapPlaceCompletion as b, type MapRegionCompletion as c, completeMapPlaces as d, completeMapRegions as e, palettes as p, searchMapLocations as s, themes as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "author": "Diagrammo LLC",