@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-BUPDIHML.js

@@ -0,0 +1,613 @@
+import {
+  MAP_DIRECTIVE_KEY_SET
+} from "./chunk-DKEPS5LH.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  parseInArrowLabel
+} from "./chunk-FFUN5D66.js";
+import {
+  MAP_REGISTRY,
+  extractColor,
+  measureIndent,
+  peelRampColors,
+  splitNameAndMeta,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  formatDgmoError,
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/map/parser.ts
+var COORD_RE = /^[+-]?\d+(?:\.\d+)?\s+[+-]?\d+(?:\.\d+)?$/;
+var NUMERIC_LEAD_RE = /^[+-]?\d/;
+var SCOPE_RE = /^[A-Z]{2}(?:-[A-Z0-9]{1,3})?$/;
+var ARROW_TOKENS = "-[^>]*?->|->|~[^>]*?~>|~>|-[^>]*?-|~[^>]*?~";
+var ARROW_SPLIT = new RegExp(`\\s+(${ARROW_TOKENS})\\s+`);
+var HUB_RE = new RegExp(`^(${ARROW_TOKENS})\\s+(.+)$`);
+var LEG_ARROW_RE = new RegExp(`^(${ARROW_TOKENS})\\s+(.+)$`);
+var AT_RE = /(^|[\s,])at\s*:/i;
+var CHANNEL_FOREIGN = {
+  heat: ["size", "width"],
+  size: ["heat", "width"],
+  width: ["heat", "size"]
+};
+var CHANNEL_HINT = {
+  heat: "regions take `heat:`",
+  size: "points take `size:`",
+  width: "edges take `width:`"
+};
+var MAP_DIRECTIVE_SET = MAP_DIRECTIVE_KEY_SET;
+var DIRECTIVE_SET = MAP_DIRECTIVE_SET;
+function looksLikeMap(content) {
+  for (const raw of content.split("\n")) {
+    const t = stripInlineComment(raw).trim();
+    if (!t || t.startsWith("//")) continue;
+    return /^map(\s|$)/.test(t);
+  }
+  return false;
+}
+function stripInlineComment(line) {
+  return line.replace(/(^|\s)\/\/.*$/, (_m, p1) => p1).replace(/\s+$/, "");
+}
+function parseMap(content, palette) {
+  const result = {
+    title: null,
+    titleLineNumber: null,
+    directives: {},
+    tagGroups: [],
+    regions: [],
+    pois: [],
+    routes: [],
+    edges: [],
+    options: {},
+    diagnostics: [],
+    error: null
+  };
+  const diagnostics = result.diagnostics;
+  const pushError = (line, message, code) => {
+    diagnostics.push(makeDgmoError(line, message, "error", code));
+    result.error ??= formatDgmoError(diagnostics[diagnostics.length - 1]);
+  };
+  const fail = (line, message) => {
+    pushError(line, message);
+    return result;
+  };
+  const pushWarning = (line, message) => {
+    diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const lines = content.split("\n");
+  let firstIdx = 0;
+  while (firstIdx < lines.length) {
+    const t = stripInlineComment(lines[firstIdx]).trim();
+    if (t && !t.startsWith("//")) break;
+    firstIdx++;
+  }
+  const firstLine = stripInlineComment(lines[firstIdx] ?? "").trim();
+  const firstTok = firstLine.split(/\s+/)[0] ?? "";
+  if (firstTok !== "map") {
+    return fail(
+      firstIdx + 1,
+      `Expected chart type "map" on the first line, got "${firstTok || "(empty)"}"`
+    );
+  }
+  const titleText = firstLine.slice(3).trim();
+  if (titleText) {
+    result.title = titleText;
+    result.titleLineNumber = firstIdx + 1;
+  }
+  const tagGroups = result.tagGroups;
+  const regions = result.regions;
+  const pois = result.pois;
+  const routes = result.routes;
+  const edges = result.edges;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const open = { tag: null, route: null, poi: null };
+  const registry = () => withTagAliases(MAP_REGISTRY, new Set(aliasMap.keys()));
+  const tagGroupNames = () => new Set(tagGroups.map((g) => tagAttrKey(g.name)));
+  const closeBlocks = () => {
+    open.tag = null;
+    open.route = null;
+    open.poi = null;
+  };
+  for (let i = firstIdx + 1; i < lines.length; i++) {
+    const raw = lines[i];
+    const lineNumber = i + 1;
+    const cleaned = stripInlineComment(raw);
+    const trimmed = cleaned.trim();
+    const indent = measureIndent(raw);
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (open.tag && indent > 0) {
+      addTagEntry(open.tag, trimmed, lineNumber);
+      continue;
+    }
+    if (open.route && indent > open.route.indent) {
+      const leg = parseLeg(trimmed, lineNumber);
+      if (leg) open.route.route.legs.push(leg);
+      continue;
+    }
+    if (open.poi && indent > open.poi.indent) {
+      const hub = trimmed.match(HUB_RE);
+      if (hub) {
+        const src = open.poi.poi.alias ?? poiName(open.poi.poi.pos);
+        if (src) {
+          const arr = classifyArrow(hub[1], lineNumber);
+          const hubSplit = splitNameAndMeta(hub[2], registry(), aliasMap);
+          const { tags, meta } = partitionMeta(hubSplit.meta, tagGroupNames());
+          edges.push({
+            from: src,
+            to: hubSplit.name.trim(),
+            ...arr.label !== void 0 && { label: arr.label },
+            directed: arr.directed,
+            style: arr.style,
+            meta,
+            tags,
+            lineNumber
+          });
+        }
+        continue;
+      }
+      const split = splitNameAndMeta(trimmed, registry(), aliasMap);
+      if (Object.keys(split.meta).length && !split.name) {
+        Object.assign(open.poi.poi.meta, split.meta);
+        continue;
+      }
+      if (split.name) {
+        const src = open.poi.poi.alias ?? poiName(open.poi.poi.pos) ?? "the poi";
+        pushError(
+          lineNumber,
+          `Malformed hub edge: "${trimmed}" \u2014 an indented line under a poi is an edge from "${src}" and needs an arrow glyph (\`-> dest\`, \`~> dest\`, or labeled \`-label-> dest\`). For a standalone place, declare it at the top level. (\xA724B.5)`
+        );
+        continue;
+      }
+    }
+    closeBlocks();
+    const firstWord = trimmed.split(/\s+/)[0];
+    if (firstWord === "tag") {
+      handleTag(trimmed, lineNumber);
+      continue;
+    }
+    if (DIRECTIVE_SET.has(firstWord) && !trimmed.slice(firstWord.length).trimStart().startsWith(":")) {
+      handleDirective(
+        firstWord,
+        trimmed.slice(firstWord.length).trim(),
+        lineNumber
+      );
+      continue;
+    }
+    if (firstWord === "poi") {
+      handlePoi(trimmed.slice(3).trim(), lineNumber, indent);
+      continue;
+    }
+    if (firstWord === "route") {
+      handleRoute(trimmed.slice(5).trim(), lineNumber, indent);
+      continue;
+    }
+    if (ARROW_SPLIT.test(" " + trimmed + " ") || ARROW_SPLIT.test(trimmed)) {
+      handleEdges(trimmed, lineNumber);
+      continue;
+    }
+    handleRegion(trimmed, lineNumber);
+  }
+  finalizeAutoTagColors(tagGroups, palette);
+  validateTagGroupNames(
+    tagGroups,
+    pushWarning,
+    (line, m) => pushError(line, m)
+  );
+  const at = result.directives.activeTag;
+  if (at && at.toLowerCase() !== "none") {
+    const names = tagGroupNames();
+    if (!names.has(at.toLowerCase())) {
+      const hint = tagGroups.length ? ` Declared groups: ${tagGroups.map((g) => g.name).join(", ")}.` : " No tag groups are declared.";
+      pushWarning(
+        0,
+        `active-tag "${at}" does not match a declared tag group.${hint}`
+      );
+    }
+  }
+  return result;
+  function rejectForeignChannels(meta, own, line) {
+    for (const k of CHANNEL_FOREIGN[own]) {
+      if (meta[k] !== void 0) {
+        pushError(
+          line,
+          `\`${k}:\` is not a valid channel here \u2014 ${CHANNEL_HINT[own]} (\xA724B).`
+        );
+        delete meta[k];
+      }
+    }
+  }
+  function handleDirective(key, value, line) {
+    const d = result.directives;
+    const dup = (have) => {
+      if (have !== void 0)
+        pushWarning(line, `Duplicate directive "${key}" \u2014 last value wins.`);
+    };
+    switch (key) {
+      case "region-heat": {
+        dup(d.regionMetric);
+        const {
+          label: rmLabel,
+          low: rmLow,
+          high: rmHigh
+        } = peelRampColors(value);
+        d.regionMetric = rmLabel;
+        if (rmHigh) d.regionMetricColor = rmHigh;
+        if (rmLow) d.regionMetricLowColor = rmLow;
+        break;
+      }
+      case "poi-size":
+        dup(d.poiMetric);
+        d.poiMetric = value;
+        break;
+      case "flow-width":
+        dup(d.flowMetric);
+        d.flowMetric = value;
+        break;
+      case "locale":
+        dup(d.locale);
+        d.locale = value;
+        break;
+      case "active-tag":
+        dup(d.activeTag);
+        d.activeTag = value;
+        break;
+      case "caption":
+        dup(d.caption);
+        d.caption = value;
+        break;
+      // ── Cosmetic `no-*` opt-outs: bare flags, idempotent (mirror `no-legend`,
+      //    no dup warning); each defaults the feature ON when absent. ──
+      case "no-title":
+        d.noTitle = true;
+        break;
+      case "no-legend":
+        d.noLegend = true;
+        break;
+      case "no-coastline":
+        d.noCoastline = true;
+        break;
+      case "no-relief":
+        d.noRelief = true;
+        break;
+      case "no-context-labels":
+        d.noContextLabels = true;
+        break;
+      case "no-region-labels":
+        d.noRegionLabels = true;
+        break;
+      case "no-region-heat-value":
+        d.noRegionValue = true;
+        break;
+      case "no-poi-labels":
+        d.noPoiLabels = true;
+        break;
+      case "no-colorize":
+        d.noColorize = true;
+        break;
+      case "no-cities":
+        d.noCities = true;
+        break;
+      case "no-cluster-pois":
+        d.noClusterPois = true;
+        break;
+    }
+  }
+  function handleTag(trimmed, line) {
+    const m = matchTagBlockHeading(trimmed);
+    if (!m) {
+      pushError(
+        line,
+        `Malformed tag declaration: "${trimmed}" \u2014 write 'tag <Group>' (optionally 'tag <Group> as <alias>'), e.g. 'tag Market as m', with indented 'Value color' entries below.`
+      );
+      return;
+    }
+    const group = {
+      name: m.name,
+      ...m.alias !== void 0 && { alias: m.alias },
+      entries: [],
+      lineNumber: line
+    };
+    if (m.alias) aliasMap.set(m.alias.toLowerCase(), tagAttrKey(m.name));
+    tagGroups.push(group);
+    open.tag = group;
+    if (m.inlineValues?.length) {
+      for (const seg of m.inlineValues) addTagEntry(group, seg.trim(), line);
+      open.tag = null;
+    }
+  }
+  function addTagEntry(group, text, line) {
+    const { text: clean, isDefault } = stripDefaultModifier(text);
+    const { label, color } = extractColor(clean, palette, diagnostics, line);
+    const entries = group.entries;
+    if (isDefault || entries.length === 0) group.defaultValue = label;
+    entries.push({
+      value: label,
+      color: color ?? AUTO_TAG_COLOR_SENTINEL,
+      lineNumber: line
+    });
+  }
+  function handleRegion(trimmed, line) {
+    if (AT_RE.test(trimmed))
+      pushError(
+        line,
+        "Coordinates are positional, not `at:` \u2014 write region names bare and POIs as `poi <lat> <lon>`."
+      );
+    const split = splitNameAndMeta(
+      trimmed,
+      registry(),
+      aliasMap,
+      void 0,
+      diagnostics,
+      line
+    );
+    const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
+    rejectForeignChannels(meta, "heat", line);
+    let valueNum;
+    const value = meta["heat"];
+    if (value !== void 0) {
+      delete meta["heat"];
+      valueNum = Number(value);
+      if (!Number.isFinite(valueNum)) {
+        pushError(line, `heat must be a number (got "${value}").`);
+        valueNum = void 0;
+      }
+    }
+    let regionName = split.name;
+    let regionScope;
+    const rToks = regionName.split(/\s+/);
+    const rLast = rToks[rToks.length - 1];
+    if (rToks.length > 1 && SCOPE_RE.test(rLast)) {
+      regionName = rToks.slice(0, -1).join(" ");
+      regionScope = rLast;
+    }
+    const region = {
+      name: regionName,
+      tags,
+      meta,
+      lineNumber: line
+    };
+    if (regionScope !== void 0) region.scope = regionScope;
+    if (valueNum !== void 0) region.value = valueNum;
+    if (split.color) region.color = split.color;
+    regions.push(region);
+  }
+  function handlePoi(rest, line, indent) {
+    if (AT_RE.test(rest))
+      pushError(
+        line,
+        "Coordinates are positional, not `at:` \u2014 write `poi <lat> <lon>`."
+      );
+    const split = splitNameAndMeta(
+      rest,
+      registry(),
+      aliasMap,
+      void 0,
+      diagnostics,
+      line
+    );
+    const pos = parsePos(split.name, line);
+    if (!pos) return;
+    const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
+    rejectForeignChannels(meta, "size", line);
+    const label = meta["label"];
+    if (label !== void 0) delete meta["label"];
+    const poi = { pos, tags, meta, lineNumber: line };
+    if (split.alias) poi.alias = split.alias;
+    if (label !== void 0) poi.label = label;
+    if (split.color) poi.color = split.color;
+    pois.push(poi);
+    open.poi = { poi, indent };
+  }
+  function handleRoute(rest, line, indent) {
+    const split = rest ? splitNameAndMeta(
+      rest,
+      registry(),
+      aliasMap,
+      void 0,
+      diagnostics,
+      line
+    ) : { name: "", meta: {}, alias: void 0 };
+    const pos = parsePos(split.name, line);
+    if (!pos || pos.kind === "name" && !pos.name) {
+      pushError(
+        line,
+        "route needs an origin place \u2014 `route <origin>` then indented legs (`-> dest`); origin may be a city name, IATA code, or `<lat> <lon>`. (\xA724B)"
+      );
+      return;
+    }
+    const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
+    rejectForeignChannels(meta, "size", line);
+    const originLabel = meta["label"];
+    const originValue = meta["size"];
+    if (meta["style"] !== void 0) {
+      pushError(
+        line,
+        "route header no longer takes `style:` \u2014 set leg shape with the arrow glyph instead (`~\u2026~>` for an arc leg, `-\u2026->` for a straight one). (\xA724B.6)"
+      );
+    }
+    const route = {
+      origin: pos,
+      ...split.alias !== void 0 && { originAlias: split.alias },
+      ...originLabel !== void 0 && { originLabel },
+      ...originValue !== void 0 && { originValue },
+      originTags: tags,
+      legs: [],
+      lineNumber: line
+    };
+    routes.push(route);
+    open.route = { route, indent };
+  }
+  function parseLeg(trimmed, line) {
+    const m = trimmed.match(LEG_ARROW_RE);
+    if (!m) {
+      pushError(
+        line,
+        `Malformed route leg: "${trimmed}" \u2014 a leg needs an arrow glyph (\`-> dest\`, \`~> dest\`, or labeled \`-label-> dest\` / \`~label~> dest\`). (\xA724B.6)`
+      );
+      return null;
+    }
+    const arr = classifyArrow(m[1], line);
+    if (!arr.directed) {
+      pushError(
+        line,
+        `A route leg is directional \u2014 "${trimmed}" uses an undirected glyph; use \`-> \` (straight) or \`~> \` (arc). (\xA724B.6)`
+      );
+      return null;
+    }
+    const arrowStyle = arr.style;
+    const label = arr.label;
+    const rest = m[2];
+    const split = splitNameAndMeta(
+      rest,
+      registry(),
+      aliasMap,
+      void 0,
+      diagnostics,
+      line
+    );
+    const pos = parsePos(split.name, line) ?? {
+      kind: "name",
+      name: split.name
+    };
+    const { tags, meta } = partitionMeta(split.meta, tagGroupNames());
+    rejectForeignChannels(meta, "width", line);
+    const value = meta["width"];
+    const destLabel = meta["label"];
+    return {
+      ...label !== void 0 && { label },
+      style: arrowStyle,
+      ...value !== void 0 && { value },
+      dest: pos,
+      ...split.alias !== void 0 && { destAlias: split.alias },
+      ...destLabel !== void 0 && { destLabel },
+      tags,
+      // colour the LINE (§24B.6); stop tags go on the poi line
+      lineNumber: line
+    };
+  }
+  function handleEdges(trimmed, line) {
+    const parts = trimmed.split(ARROW_SPLIT);
+    if (parts.length < 3) {
+      pushError(
+        line,
+        `Malformed edge: "${trimmed}" \u2014 an edge is 'A -> B' (or 'A -label-> B', '~>' for arc, '--' undirected), both endpoints non-empty. (\xA724B)`
+      );
+      return;
+    }
+    const endpoints = [];
+    const links = [];
+    for (let k = 0; k < parts.length; k++) {
+      if (k % 2 === 0) endpoints.push(parts[k].trim());
+      else links.push(classifyArrow(parts[k], line));
+    }
+    const lastSplit = splitNameAndMeta(
+      endpoints[endpoints.length - 1],
+      registry(),
+      aliasMap
+    );
+    endpoints[endpoints.length - 1] = lastSplit.name;
+    const { tags: lastTags, meta: lastMeta } = partitionMeta(
+      lastSplit.meta,
+      tagGroupNames()
+    );
+    rejectForeignChannels(lastMeta, "width", line);
+    for (let k = 0; k < links.length; k++) {
+      const from = endpoints[k];
+      const to = endpoints[k + 1];
+      if (!from || !to) {
+        pushError(
+          line,
+          `Edge has an empty endpoint: "${trimmed}" \u2014 both sides of the arrow need a place, e.g. 'Paris -> Berlin'. (\xA724B)`
+        );
+        continue;
+      }
+      const isLast = k === links.length - 1;
+      const meta = isLast ? lastMeta : {};
+      const tags = isLast ? lastTags : {};
+      const style = links[k].style === "arc" ? "arc" : "straight";
+      edges.push({
+        from,
+        to,
+        ...links[k].label !== void 0 && { label: links[k].label },
+        directed: links[k].directed,
+        style,
+        meta,
+        tags,
+        lineNumber: line
+      });
+    }
+  }
+  function classifyArrow(tok, line) {
+    if (tok === "--") return { directed: false, style: "straight" };
+    if (tok === "~~") return { directed: false, style: "arc" };
+    if (tok === "->") return { directed: true, style: "straight" };
+    if (tok === "~>") return { directed: true, style: "arc" };
+    const directed = tok.endsWith(">");
+    const style = tok.startsWith("~") ? "arc" : "straight";
+    const inner = directed ? tok.slice(1, -2) : tok.slice(1, -1);
+    const lbl = parseInArrowLabel(inner, line);
+    lbl.diagnostics.forEach((d) => diagnostics.push(d));
+    return {
+      ...lbl.label !== void 0 && { label: lbl.label },
+      directed,
+      style
+    };
+  }
+  function parsePos(nameRegion, line) {
+    const n = nameRegion.trim();
+    if (COORD_RE.test(n)) {
+      const [latS, lonS] = n.split(/\s+/);
+      const lat = Number(latS);
+      const lon = Number(lonS);
+      if (lat < -90 || lat > 90 || lon < -180 || lon > 180) {
+        pushError(
+          line,
+          `Coordinates out of range: lat ${lat}, lon ${lon} (lat \u2208 [-90,90], lon \u2208 [-180,180]).`
+        );
+        return null;
+      }
+      return { kind: "coords", lat, lon };
+    }
+    if (NUMERIC_LEAD_RE.test(n)) {
+      pushError(
+        line,
+        `Malformed coordinates "${n}" \u2014 expected "<lat> <lon>" (two signed numbers).`
+      );
+      return null;
+    }
+    const toks = n.split(/\s+/);
+    const last = toks[toks.length - 1];
+    if (toks.length > 1 && SCOPE_RE.test(last)) {
+      return { kind: "name", name: toks.slice(0, -1).join(" "), scope: last };
+    }
+    return { kind: "name", name: n };
+  }
+}
+function partitionMeta(meta, tagGroupNames) {
+  const tags = {};
+  const inert = {};
+  for (const [k, v] of Object.entries(meta)) {
+    if (tagGroupNames.has(k)) tags[k] = v;
+    else inert[k] = v;
+  }
+  return { tags, meta: inert };
+}
+function poiName(pos) {
+  return pos.kind === "name" ? pos.name : void 0;
+}
+
+export {
+  MAP_DIRECTIVE_SET,
+  looksLikeMap,
+  parseMap
+};
+//# sourceMappingURL=chunk-BUPDIHML.js.map