@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-6HO5ZTXK.js

@@ -0,0 +1,277 @@
+import {
+  CYCLE_REGISTRY,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys
+} from "./chunk-Y3J7VR52.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/cycle/parser.ts
+var BARE_EDGE_RE = /^->\s*(.*)?$/;
+var LABELED_EDGE_RE = /^-(.+?)->\s*(.*)?$/;
+function parseCycle(content) {
+  const options = {};
+  const result = {
+    type: "cycle",
+    title: "",
+    titleLineNumber: 0,
+    nodes: [],
+    edges: [],
+    direction: "clockwise",
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let state = "top";
+  let currentNode = null;
+  let currentEdge = null;
+  const fail = makeFail(result);
+  const warn = (line, message, severity = "warning") => {
+    result.diagnostics.push(makeDgmoError(line, message, severity));
+  };
+  const info = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  function flushEdge() {
+    if (currentEdge) {
+      result.edges.push(currentEdge);
+      currentEdge = null;
+    }
+  }
+  function flushNode() {
+    flushEdge();
+    if (currentNode) {
+      result.nodes.push(currentNode);
+      currentNode = null;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(raw);
+    if (!headerParsed) {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult?.chartType === "cycle") {
+        result.title = firstLineResult.title ?? "";
+        result.titleLineNumber = lineNum;
+        headerParsed = true;
+        continue;
+      }
+      return fail(lineNum, 'Expected "cycle [Title]" as the first line.');
+    }
+    if (indent === 0 && trimmed === "direction-counterclockwise") {
+      result.direction = "counterclockwise";
+      continue;
+    }
+    if (indent === 0 && trimmed.toLowerCase() === "no-descriptions") {
+      warn(
+        lineNum,
+        '"no-descriptions" has been removed \u2014 delete description lines from your source instead.'
+      );
+      continue;
+    }
+    if (indent === 0 && trimmed.toLowerCase() === "circle-nodes") {
+      options["circle-nodes"] = "true";
+      continue;
+    }
+    if (indent === 0 && tryParseSharedOption(trimmed, options)) {
+      continue;
+    }
+    if (indent === 0) {
+      flushNode();
+      if (trimmed.includes("->") || trimmed.includes("<-")) {
+        warn(
+          lineNum,
+          'Node labels cannot contain "->". Use indented lines for edges.',
+          "error"
+        );
+        continue;
+      }
+      const split = splitNameAndMeta(
+        trimmed,
+        CYCLE_REGISTRY,
+        /* @__PURE__ */ new Map(),
+        void 0,
+        result.diagnostics,
+        lineNum
+      );
+      warnUnknownMetaKeys(
+        split.meta,
+        CYCLE_REGISTRY,
+        (msg) => warn(lineNum, msg),
+        split.name
+      );
+      const label = split.name;
+      const metadata = { ...split.meta };
+      if (split.color !== void 0) metadata["color"] = split.color;
+      if (!label) {
+        warn(lineNum, "Empty node label.");
+        continue;
+      }
+      const color = metadata["color"];
+      const spanStr = metadata["span"];
+      let span = 1;
+      if (spanStr !== void 0) {
+        const spanVal = parseFloat(spanStr);
+        if (isNaN(spanVal) || spanVal <= 0) {
+          warn(
+            lineNum,
+            `span must be a positive number, got "${spanStr}".`,
+            "error"
+          );
+          continue;
+        }
+        span = spanVal;
+      }
+      const descFromPipe = metadata["description"];
+      const description = descFromPipe ? [descFromPipe] : [];
+      const restMeta = { ...metadata };
+      delete restMeta["color"];
+      delete restMeta["span"];
+      delete restMeta["description"];
+      currentNode = {
+        label,
+        lineNumber: lineNum,
+        ...color !== void 0 && { color },
+        span,
+        description,
+        metadata: restMeta
+      };
+      state = "node";
+      continue;
+    }
+    if (indent > 0) {
+      const bareMatch = trimmed.match(BARE_EDGE_RE);
+      const labeledMatch = !bareMatch ? trimmed.match(LABELED_EDGE_RE) : null;
+      const edgeMatch = bareMatch ?? labeledMatch;
+      if (edgeMatch) {
+        flushEdge();
+        if (!currentNode) {
+          warn(lineNum, "Edge line found outside of a node context.");
+          continue;
+        }
+        const edgeLabel = bareMatch ? void 0 : labeledMatch[1]?.trim() || void 0;
+        const rest = (bareMatch ? bareMatch[1] ?? "" : labeledMatch[2] ?? "").trim();
+        const edgeSplit = splitNameAndMeta(
+          rest,
+          CYCLE_REGISTRY,
+          /* @__PURE__ */ new Map(),
+          void 0,
+          result.diagnostics,
+          lineNum
+        );
+        warnUnknownMetaKeys(
+          edgeSplit.meta,
+          CYCLE_REGISTRY,
+          (msg) => warn(lineNum, msg),
+          edgeSplit.name
+        );
+        const explicitTarget = edgeSplit.name || void 0;
+        if (explicitTarget?.endsWith(":")) {
+          warn(
+            lineNum,
+            `Trailing colon is not valid \u2014 write '${explicitTarget.replace(/:$/, "")}' instead`,
+            "error"
+          );
+          continue;
+        }
+        const edgeMeta = { ...edgeSplit.meta };
+        if (edgeSplit.color !== void 0) edgeMeta["color"] = edgeSplit.color;
+        const edgeColor = edgeMeta["color"];
+        const widthStr = edgeMeta["width"];
+        const edgeWidth = widthStr ? parseFloat(widthStr) : void 0;
+        const edgeDescFromPipe = edgeMeta["description"];
+        const edgeRestMeta = { ...edgeMeta };
+        delete edgeRestMeta["color"];
+        delete edgeRestMeta["width"];
+        delete edgeRestMeta["description"];
+        const sourceIndex = result.nodes.length;
+        const targetIndex = sourceIndex + 1;
+        currentEdge = {
+          sourceIndex,
+          targetIndex,
+          ...edgeLabel !== void 0 && { label: edgeLabel },
+          ...edgeColor !== void 0 && { color: edgeColor },
+          ...edgeWidth !== void 0 && { width: edgeWidth },
+          description: edgeDescFromPipe ? [edgeDescFromPipe] : [],
+          lineNumber: lineNum,
+          metadata: edgeRestMeta
+        };
+        if (explicitTarget) {
+          currentEdge._explicitTarget = explicitTarget;
+        }
+        state = "edge";
+        continue;
+      }
+      if (state === "edge" && currentEdge) {
+        const descLine = trimmed.startsWith("- ") ? `\u2022 ${trimmed.substring(2)}` : trimmed;
+        currentEdge.description.push(descLine);
+        continue;
+      }
+      if (state === "node" && currentNode) {
+        const descLine = trimmed.startsWith("- ") ? `\u2022 ${trimmed.substring(2)}` : trimmed;
+        currentNode.description.push(descLine);
+        continue;
+      }
+      warn(
+        lineNum,
+        `Indented line "${trimmed}" has no step above it \u2014 add a step on a non-indented line first, then indent its details. (\xA721)`
+      );
+      continue;
+    }
+  }
+  flushNode();
+  if (result.nodes.length < 2) {
+    return fail(
+      result.titleLineNumber || 1,
+      "cycle requires at least 2 nodes."
+    );
+  }
+  const nodeCount = result.nodes.length;
+  const edgeBySource = /* @__PURE__ */ new Map();
+  for (const edge of result.edges) {
+    edge.targetIndex = (edge.sourceIndex + 1) % nodeCount;
+    edgeBySource.set(edge.sourceIndex, edge);
+    const typed = edge;
+    if (typed._explicitTarget) {
+      const actualTarget = result.nodes[edge.targetIndex].label;
+      if (typed._explicitTarget !== actualTarget) {
+        info(
+          edge.lineNumber,
+          `In cycle diagrams, edges always connect to the next node ('${actualTarget}'). Explicit target '${typed._explicitTarget}' is ignored.`
+        );
+      }
+      delete typed._explicitTarget;
+    }
+  }
+  const allEdges = [];
+  for (let i = 0; i < nodeCount; i++) {
+    const existing = edgeBySource.get(i);
+    if (existing) {
+      allEdges.push(existing);
+    } else {
+      allEdges.push({
+        sourceIndex: i,
+        targetIndex: (i + 1) % nodeCount,
+        description: [],
+        metadata: {}
+      });
+    }
+  }
+  result.edges = allEdges;
+  return result;
+}
+
+export {
+  parseCycle
+};
+//# sourceMappingURL=chunk-6HO5ZTXK.js.map

package/dist/chunk-6KFWC4CO.js

@@ -0,0 +1,7 @@
+// src/fonts.ts
+var FONT_FAMILY = "Inter, system-ui, Avenir, Helvetica, Arial, sans-serif";
+
+export {
+  FONT_FAMILY
+};
+//# sourceMappingURL=chunk-6KFWC4CO.js.map

package/dist/chunk-6MTWIQVO.js

@@ -0,0 +1,121 @@
+// src/map/load-data.ts
+async function loadNodeBuiltins() {
+  const [{ readFile }, { fileURLToPath }, { dirname, resolve }] = await Promise.all([
+    import("fs/promises"),
+    import("url"),
+    import("path")
+  ]);
+  return { readFile, fileURLToPath, dirname, resolve };
+}
+var FILES = {
+  worldCoarse: "world-coarse.json",
+  worldDetail: "world-detail.json",
+  usStates: "us-states.json",
+  lakes: "lakes.json",
+  rivers: "rivers.json",
+  mountainRanges: "mountain-ranges.json",
+  naLand: "na-land.json",
+  naLakes: "na-lakes.json",
+  waterBodies: "water-bodies.json",
+  airports: "airports.json",
+  gazetteer: "gazetteer.json"
+};
+var CANDIDATE_DIRS = [
+  "./data",
+  "./map-data",
+  "../map-data",
+  "../src/map/data"
+];
+var cache;
+async function readJson(nb, dir, name) {
+  return JSON.parse(await nb.readFile(nb.resolve(dir, name), "utf8"));
+}
+async function firstExistingDir(nb, baseDir) {
+  for (const rel of CANDIDATE_DIRS) {
+    const dir = nb.resolve(baseDir, rel);
+    try {
+      await nb.readFile(nb.resolve(dir, FILES.gazetteer), "utf8");
+      return dir;
+    } catch {
+    }
+  }
+  throw new Error(
+    `map data assets not found near ${baseDir} (looked in ${CANDIDATE_DIRS.join(", ")}). Run \`pnpm build:map-data\` and \`pnpm build\`.`
+  );
+}
+function validate(data) {
+  const topoOk = (t) => !!t && t.type === "Topology" && !!t.objects;
+  if (!topoOk(data.worldCoarse) || !topoOk(data.worldDetail) || !topoOk(data.usStates) || !data.gazetteer || !Array.isArray(data.gazetteer.cities) || !data.gazetteer.byName) {
+    throw new Error("map data assets are malformed (failed shape validation)");
+  }
+  return data;
+}
+function moduleBaseDir(nb) {
+  try {
+    const url = import.meta.url;
+    if (url) return nb.dirname(nb.fileURLToPath(url));
+  } catch {
+  }
+  if (typeof __dirname !== "undefined") return __dirname;
+  return process.cwd();
+}
+function loadMapData() {
+  cache ??= (async () => {
+    const nb = await loadNodeBuiltins();
+    const dir = await firstExistingDir(nb, moduleBaseDir(nb));
+    const [
+      worldCoarse,
+      worldDetail,
+      usStates,
+      lakes,
+      rivers,
+      mountainRanges,
+      naLand,
+      naLakes,
+      waterBodies,
+      airports,
+      gazetteer
+    ] = await Promise.all([
+      // worldCoarse (110m) is LOAD-BEARING but NOT a render source: the world
+      // basemap renders from worldDetail (50m) at all scales (resolver pins
+      // basemaps.world = 'detail'). Coarse stays as the authoritative region
+      // name index + dominant-landmass bbox source in resolver.ts. Do not drop it.
+      readJson(nb, dir, FILES.worldCoarse),
+      readJson(nb, dir, FILES.worldDetail),
+      readJson(nb, dir, FILES.usStates),
+      // Lakes/rivers/mountain/NA/water assets are optional — older bundles may predate them.
+      readJson(nb, dir, FILES.lakes).catch(() => void 0),
+      readJson(nb, dir, FILES.rivers).catch(() => void 0),
+      readJson(nb, dir, FILES.mountainRanges).catch(
+        () => void 0
+      ),
+      readJson(nb, dir, FILES.naLand).catch(() => void 0),
+      readJson(nb, dir, FILES.naLakes).catch(() => void 0),
+      readJson(nb, dir, FILES.waterBodies).catch(() => void 0),
+      readJson(nb, dir, FILES.airports).catch(() => void 0),
+      readJson(nb, dir, FILES.gazetteer)
+    ]);
+    return validate({
+      worldCoarse,
+      worldDetail,
+      usStates,
+      gazetteer,
+      ...lakes && { lakes },
+      ...rivers && { rivers },
+      ...mountainRanges && { mountainRanges },
+      ...naLand && { naLand },
+      ...naLakes && { naLakes },
+      ...waterBodies && { waterBodies },
+      ...airports && { airports }
+    });
+  })().catch((e) => {
+    cache = void 0;
+    throw e;
+  });
+  return cache;
+}
+
+export {
+  loadMapData
+};
+//# sourceMappingURL=chunk-6MTWIQVO.js.map