@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-3SMGIJDD.js

@@ -0,0 +1,112 @@
+// src/map/diagnostics.ts
+var MAP_DX = {
+  // Runtime severity: 'error' (matches E_ prefix). ONE code, THREE distinct
+  // emit sites in resolver.ts. The builder switches on params:
+  //   • `iso` present → `No subdivision "<name>" in scope <scope> (it is <iso>).`
+  //     (region names a state but the explicit US-XX scope points elsewhere)
+  //   • `place: true` → `No "<name>" found in scope <scope>.`
+  //     (a scoped POI/place lookup misses)
+  //   • otherwise (and for the `{}` catalog render) → the REPRESENTATIVE
+  //     region-scope-miss wording `No region "<name>" found in scope <scope>.`
+  SCOPE_MISS: {
+    code: "E_MAP_SCOPE_MISS",
+    severity: "error",
+    chartType: "map",
+    title: "No match in the given scope",
+    message: (p) => p.iso !== void 0 ? `No subdivision "${p.name ?? ""}" in scope ${p.scope ?? ""} (it is ${p.iso}).` : p.place ? `No "${p.name ?? ""}" found in scope ${p.scope ?? ""}.` : `No region "${p.name ?? ""}" found in scope ${p.scope ?? ""}.`,
+    hint: "Drop or correct the scope qualifier, or use an ISO code / coordinates.",
+    example: "map\nGeorgia US-CA heat: 2"
+  },
+  UNKNOWN_AIRPORT_CODE: {
+    // Runtime severity: 'error' (matches E_ prefix).
+    code: "E_MAP_UNKNOWN_AIRPORT_CODE",
+    severity: "error",
+    chartType: "map",
+    title: "Unknown airport code",
+    message: (p) => `Unknown airport code "${p.code ?? ""}" \u2014 not in the bundled airport set (large hubs + US commercial). Use coordinates with \`as ${p.code ?? ""}\` if you need it.`,
+    hint: "A 3-letter token that is not a bundled IATA code \u2014 supply coordinates with `poi <lat> <lon> as <CODE>`.",
+    example: "map\npoi ZZZ"
+  },
+  UNKNOWN_PLACE: {
+    // Runtime severity: 'error' (matches E_ prefix). `hint` (a "did you mean?"
+    // suggestion) is interpolated only when a near match exists.
+    code: "E_MAP_UNKNOWN_PLACE",
+    severity: "error",
+    chartType: "map",
+    title: "Unknown place",
+    message: (p) => `Unknown place "${p.name ?? ""}" \u2014 not in the gazetteer.${p.hint ? " " + p.hint : ""} Search the exact token with \`dgmo map-search "${p.name ?? ""}"\` (or the lookup_map_location tool), or use coordinates \`poi <lat> <lon>\`.`,
+    hint: "The POI name is not in the gazetteer \u2014 check spelling or use coordinates.",
+    example: "map\npoi Nowheresville"
+  },
+  UNKNOWN_SUBDIVISION: {
+    // Runtime severity: 'error' (matches E_ prefix). `hint` (a "did you mean?"
+    // suggestion) is interpolated only when a near match exists.
+    code: "E_MAP_UNKNOWN_SUBDIVISION",
+    severity: "error",
+    chartType: "map",
+    title: "Unknown region",
+    message: (p) => `Unknown region "${p.name ?? ""}" \u2014 not a known country or US state.${p.hint ? " " + p.hint : ""} Search the exact token with \`dgmo map-search "${p.name ?? ""}"\` (or the lookup_map_location tool), use an ISO code (e.g. FR, US-CA), or coordinates.`,
+    hint: "The region is neither a known country nor a US state \u2014 check spelling or use an ISO code.",
+    example: "map\nBavaria heat: 1"
+  },
+  AIRPORT_SHADOWED_BY_CITY: {
+    // Runtime severity: 'warning' (matches W_ prefix). Non-blocking, emitted at
+    // most once per shadowed IATA code.
+    code: "W_MAP_AIRPORT_SHADOWED_BY_CITY",
+    severity: "warning",
+    chartType: "map",
+    title: "Airport code shadowed by a city",
+    message: (p) => `"${p.name ?? ""}" resolved to the city; "${p.code ?? ""}" is also an airport code. Use coordinates with \`as ${p.code ?? ""}\` for the airport.`,
+    hint: "A city won a token that is also a bundled airport code \u2014 use coordinates with `as <CODE>` for the airport.",
+    example: "map\npoi Ufa"
+  },
+  AMBIGUOUS_NAME: {
+    // Runtime severity: 'warning' (matches W_ prefix).
+    code: "W_MAP_AMBIGUOUS_NAME",
+    severity: "warning",
+    chartType: "map",
+    title: "Ambiguous place name",
+    message: (p) => `"${p.name ?? ""}" is ambiguous \u2014 resolved to the most-populous match. Set a default with \`locale <ISO>\` (e.g. \`locale US\` / \`locale US-GA\`) to steer it.`,
+    hint: "Multiple places share this name \u2014 add a scope or `locale <ISO>` to steer it.",
+    example: "map\npoi Portland"
+  },
+  DUPLICATE_POI: {
+    // Runtime severity: 'warning' (matches W_ prefix). Only a declared-over-
+    // declared collision warns; an implicit endpoint never triggers it.
+    code: "W_MAP_DUPLICATE_POI",
+    severity: "warning",
+    chartType: "map",
+    title: "Duplicate POI",
+    message: (p) => `Duplicate POI "${p.id ?? ""}" \u2014 last definition wins.`,
+    hint: "Two POIs resolved to the same id \u2014 remove one or give it a distinct alias.",
+    example: "map\npoi Tokyo\npoi Tokyo"
+  },
+  DUPLICATE_REGION: {
+    // Runtime severity: 'warning' (matches W_ prefix).
+    code: "W_MAP_DUPLICATE_REGION",
+    severity: "warning",
+    chartType: "map",
+    title: "Duplicate region",
+    message: (p) => `Duplicate region "${p.name ?? ""}" \u2014 last definition wins.`,
+    hint: "The same region is defined twice \u2014 remove the earlier definition.",
+    example: "map\nCalifornia heat: 1\nCalifornia heat: 9"
+  },
+  REGION_AMBIGUOUS: {
+    // Runtime severity: 'warning' (matches W_ prefix). Suppressed under a US
+    // scope (`locale US`, an explicit ISO scope, or another US-state reference).
+    code: "W_MAP_REGION_AMBIGUOUS",
+    severity: "warning",
+    chartType: "map",
+    title: "Region is both a country and a US state",
+    message: (p) => `"${p.name ?? ""}" is both a country and a US state \u2014 resolved as ${p.layer ?? ""} (${p.chosenId ?? ""}). Pin it with an ISO code (${p.stateId ?? ""} / ${p.countryId ?? ""}) or name + scope ("${p.name ?? ""} US" / "${p.name ?? ""} ${p.countryId ?? ""}").`,
+    hint: "The name collides between a country and a US state \u2014 pin it with an ISO code or a `US` / `US-XX` scope.",
+    example: "map\nGeorgia heat: 2"
+  }
+};
+var MAP_DIAGNOSTICS = Object.values(MAP_DX);
+
+export {
+  MAP_DX,
+  MAP_DIAGNOSTICS
+};
+//# sourceMappingURL=chunk-3SMGIJDD.js.map

package/dist/chunk-44CM72SQ.js

@@ -0,0 +1,409 @@
+import {
+  tryStripDescriptionKeyword
+} from "./chunk-IYULMRBE.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames
+} from "./chunk-QLCCJEJI.js";
+import {
+  JOURNEY_MAP_REGISTRY,
+  OPTION_NOCOLON_RE,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  peelTrailingColorName,
+  splitNameAndMeta,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/journey-map/parser.ts
+var PHASE_RE = /^\[(.+?)\]$/;
+var ANNOTATION_RE = /^(pain|opportunity|thought)\s*:\s*(.+)$/i;
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["active-tag"]);
+var KNOWN_BOOLEANS = /* @__PURE__ */ new Set(["solid-fill", "no-title"]);
+var REMOVED_BOOLEANS = {
+  "no-legend": '"no-legend" has been removed \u2014 remove tag groups to hide the legend.'
+};
+function parseJourneyMap(content, palette) {
+  const options = {};
+  const result = {
+    type: "journey-map",
+    phases: [],
+    steps: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let currentTagGroup = null;
+  let inPersona = false;
+  let currentPhase = null;
+  let currentStep = null;
+  let currentPersona = null;
+  let stepBaseIndent = 0;
+  let phaseCounter = 0;
+  let stepCounter = 0;
+  let hasPhases = false;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const tagValueSets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (currentTagGroup) currentTagGroup = null;
+      if (inPersona) inPersona = false;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    const indent = measureIndent(line);
+    if (!contentStarted && !currentTagGroup && !inPersona) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine) {
+        if (firstLine.chartType !== "journey-map") {
+          const allTypes = ["journey-map", "kanban", "sequence", "flowchart"];
+          let msg = `Expected chart type "journey-map", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, allTypes);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        if (firstLine.title) {
+          result.title = firstLine.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+    }
+    if (!contentStarted && !currentTagGroup && indent === 0) {
+      const personaMatch = trimmed.match(/^persona\s+(.+)$/i);
+      if (personaMatch) {
+        const afterKeyword = personaMatch[1].trim();
+        let personaName;
+        let personaColor;
+        const colorMatch = afterKeyword.match(/^(.+?)\s+color:\s*(\S+)$/i);
+        if (colorMatch) {
+          personaName = colorMatch[1].trim();
+          personaColor = resolveColorWithDiagnostic(
+            colorMatch[2],
+            lineNumber,
+            result.diagnostics,
+            palette
+          ) ?? void 0;
+        } else {
+          const { label, colorName } = peelTrailingColorName(afterKeyword);
+          if (colorName) {
+            personaName = label;
+            personaColor = resolveColorWithDiagnostic(
+              colorName,
+              lineNumber,
+              result.diagnostics,
+              palette
+            ) ?? void 0;
+          } else {
+            personaName = afterKeyword;
+          }
+        }
+        if (!personaName) {
+          return fail(lineNumber, "persona requires a name");
+        }
+        currentPersona = {
+          name: personaName,
+          ...personaColor !== void 0 && { color: personaColor },
+          lineNumber
+        };
+        result.persona = currentPersona;
+        inPersona = true;
+        continue;
+      }
+      if (/^persona\s*$/i.test(trimmed)) {
+        return fail(lineNumber, "persona requires a name");
+      }
+    }
+    if (inPersona && indent > 0) {
+      if (currentPersona) {
+        currentPersona.description = currentPersona.description ? currentPersona.description + "\n" + trimmed : trimmed;
+      }
+      continue;
+    }
+    if (inPersona && indent === 0) {
+      inPersona = false;
+    }
+    if (!contentStarted) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          aliasMap.set(
+            tagBlockMatch.alias.toLowerCase(),
+            tagAttrKey(tagBlockMatch.name)
+          );
+        }
+        aliasMap.set(
+          tagAttrKey(tagBlockMatch.name),
+          tagAttrKey(tagBlockMatch.name)
+        );
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+    if (currentTagGroup && !contentStarted) {
+      if (indent > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    if (!contentStarted && !currentTagGroup && indent === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch && !PHASE_RE.test(trimmed)) {
+        const key = optMatch[1].trim().toLowerCase();
+        if (KNOWN_OPTIONS.has(key)) {
+          options[key] = optMatch[2].trim();
+          continue;
+        }
+      }
+      const removedMsg = REMOVED_BOOLEANS[trimmed.toLowerCase()];
+      if (removedMsg && !PHASE_RE.test(trimmed)) {
+        warn(lineNumber, removedMsg);
+        continue;
+      }
+      if (KNOWN_BOOLEANS.has(trimmed.toLowerCase()) && !PHASE_RE.test(trimmed)) {
+        options[trimmed.toLowerCase()] = "on";
+        continue;
+      }
+    }
+    const phaseMatch = indent === 0 ? trimmed.match(PHASE_RE) : null;
+    if (phaseMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      inPersona = false;
+      hasPhases = true;
+      if (currentStep) {
+        currentStep.endLineNumber = lineNumber - 1;
+      }
+      currentStep = null;
+      phaseCounter++;
+      currentPhase = {
+        id: `phase-${phaseCounter}`,
+        // Capture group 1 present by regex shape.
+        name: phaseMatch[1].trim(),
+        steps: [],
+        lineNumber
+      };
+      result.phases.push(currentPhase);
+      continue;
+    }
+    if (indent === 0 && !contentStarted) {
+      if (trimmed.includes("|") || !KNOWN_OPTIONS.has(trimmed.toLowerCase()) && !KNOWN_BOOLEANS.has(trimmed.toLowerCase())) {
+        contentStarted = true;
+      }
+    }
+    if (!contentStarted) continue;
+    if (indent === 0 && hasPhases && !phaseMatch) {
+      if (trimmed.includes("|") || !PHASE_RE.test(trimmed)) {
+        warn(
+          lineNumber,
+          `Step "${trimmed}" sits outside any phase and is ignored \u2014 indent it under a '[Phase]' header (per \xA722).`
+        );
+        continue;
+      }
+    }
+    if (currentStep && indent > stepBaseIndent) {
+      const annoMatch = trimmed.match(ANNOTATION_RE);
+      if (annoMatch) {
+        currentStep.annotations.push({
+          type: annoMatch[1].toLowerCase(),
+          text: annoMatch[2].trim()
+        });
+        currentStep.endLineNumber = lineNumber;
+        continue;
+      }
+      const descResult = tryStripDescriptionKeyword(trimmed);
+      if (descResult.isKeyword) {
+        currentStep.description = descResult.text;
+        currentStep.endLineNumber = lineNumber;
+        continue;
+      }
+      currentStep.endLineNumber = lineNumber;
+      continue;
+    }
+    if (currentPhase && indent > 0 || !hasPhases && indent === 0) {
+      if (currentStep) {
+        currentStep.endLineNumber = lineNumber - 1;
+      }
+      stepCounter++;
+      const step = parseStepLine(
+        trimmed,
+        lineNumber,
+        stepCounter,
+        aliasMap,
+        warn,
+        result.diagnostics
+      );
+      stepBaseIndent = indent;
+      currentStep = step;
+      if (currentPhase) {
+        currentPhase.steps.push(step);
+      } else {
+        result.steps.push(step);
+      }
+      continue;
+    }
+    if (indent > 0 && !currentPhase && hasPhases) {
+      warn(
+        lineNumber,
+        `Indented line outside any phase \u2014 add a '[Phase]' header above it, or unindent it to a top-level step. (\xA722)`
+      );
+    }
+  }
+  if (currentStep) {
+    currentStep.endLineNumber = lines.length;
+  }
+  for (const group of result.tagGroups) {
+    const values = new Set(group.entries.map((e) => e.value.toLowerCase()));
+    tagValueSets.set(tagAttrKey(group.name), values);
+  }
+  const allSteps = hasPhases ? result.phases.flatMap((p) => p.steps) : result.steps;
+  for (const step of allSteps) {
+    for (const [tagKey, tagValue] of Object.entries(step.tags)) {
+      const groupKey = aliasMap.get(tagKey.toLowerCase()) ?? tagKey.toLowerCase();
+      const validValues = tagValueSets.get(groupKey);
+      if (validValues && !validValues.has(tagValue.toLowerCase())) {
+        const entries = result.tagGroups.find((g) => g.name.toLowerCase() === groupKey)?.entries.map((e) => e.value);
+        let msg = `Unknown tag value "${tagValue}" for group "${groupKey}"`;
+        if (entries) {
+          const hint = suggest(tagValue, entries);
+          if (hint) msg += `. ${hint}`;
+        }
+        warn(step.lineNumber, msg);
+      }
+    }
+    if (step.score === void 0) {
+      warn(
+        step.lineNumber,
+        `Step "${step.title}" has no score \u2014 it will not appear on the emotion curve`
+      );
+    }
+  }
+  if (result.phases.length === 0 && result.steps.length === 0 && !result.error) {
+    return fail(1, "No phases or steps found");
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  validateTagGroupNames(result.tagGroups, warn, (line, msg) => {
+    const diag = makeDgmoError(line, msg);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  });
+  return result;
+}
+function parseStepLine(trimmed, lineNumber, counter, aliasMap, warn, diagnostics) {
+  let score;
+  let emotionLabel;
+  const tags = {};
+  const registry = withTagAliases(
+    JOURNEY_MAP_REGISTRY,
+    new Set(aliasMap.keys())
+  );
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    aliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => warn(lineNumber, msg),
+    split.name
+  );
+  const title = split.name;
+  const splitMeta = { ...split.meta };
+  if ("score" in splitMeta) {
+    const scoreVal = splitMeta["score"];
+    delete splitMeta["score"];
+    const parsed = parseInt(scoreVal, 10);
+    if (!isNaN(parsed) && scoreVal === String(parsed) && parsed >= 1 && parsed <= 5) {
+      score = parsed;
+    } else if (!isNaN(parsed) && (parsed < 1 || parsed > 5)) {
+      warn(lineNumber, `Score out of range: ${parsed} (must be 1-5)`);
+    } else {
+      warn(lineNumber, `Score must be an integer 1-5, got ${scoreVal}`);
+    }
+  }
+  if ("emotion" in splitMeta) {
+    const emotionVal = splitMeta["emotion"];
+    delete splitMeta["emotion"];
+    if (emotionVal.includes(" ")) {
+      warn(
+        lineNumber,
+        `Emotion label must be a single word \u2014 got "${emotionVal}"`
+      );
+    } else {
+      emotionLabel = emotionVal;
+    }
+  }
+  Object.assign(tags, splitMeta);
+  return {
+    id: `step-${counter}`,
+    title,
+    ...score !== void 0 && { score },
+    ...emotionLabel !== void 0 && { emotionLabel },
+    tags,
+    annotations: [],
+    lineNumber,
+    endLineNumber: lineNumber
+  };
+}
+
+export {
+  parseJourneyMap
+};
+//# sourceMappingURL=chunk-44CM72SQ.js.map