@diagrammo/dgmo 0.19.0 → 0.20.1

package/src/map/load-data.ts

@@ -10,16 +10,41 @@
 // build must inject `MapData` (or supply a fetch/bundle loader) — `resolveMap`
 // takes `MapData` by DI precisely so the browser path can differ. Do NOT assume
 // a green Node smoke test proves the browser load.
-import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
+//
+// Node builtins (`fs/promises`, `url`, `path`) are imported LAZILY inside
+// `loadMapData` — never at module top level — so this file can be pulled into a
+// browser bundle (Obsidian's esbuild `platform: browser`, the app's Vite/Rollup
+// web build) without the bundler trying to resolve `node:*`. Mirrors the
+// `await import('jsdom')` seam in render.ts. The web build injects `MapData` via
+// DI and never calls `loadMapData`, so the dynamic import only runs in Node.
 import type { MapData } from './resolved-types';
 import type { BoundaryTopology, Gazetteer } from './data/types';
 
+type NodeBuiltins = {
+  readFile: typeof import('node:fs/promises').readFile;
+  fileURLToPath: typeof import('node:url').fileURLToPath;
+  dirname: typeof import('node:path').dirname;
+  resolve: typeof import('node:path').resolve;
+};
+
+async function loadNodeBuiltins(): Promise<NodeBuiltins> {
+  const [{ readFile }, { fileURLToPath }, { dirname, resolve }] =
+    await Promise.all([
+      import('node:fs/promises'),
+      import('node:url'),
+      import('node:path'),
+    ]);
+  return { readFile, fileURLToPath, dirname, resolve };
+}
+
 const FILES = {
   worldCoarse: 'world-coarse.json',
   worldDetail: 'world-detail.json',
   usStates: 'us-states.json',
+  lakes: 'lakes.json',
+  rivers: 'rivers.json',
+  naLand: 'na-land.json',
+  naLakes: 'na-lakes.json',
   gazetteer: 'gazetteer.json',
 } as const;
 
@@ -33,15 +58,22 @@ const CANDIDATE_DIRS = [
 
 let cache: Promise<MapData> | undefined;
 
-async function readJson<T>(dir: string, name: string): Promise<T> {
-  return JSON.parse(await readFile(resolve(dir, name), 'utf8')) as T;
+async function readJson<T>(
+  nb: NodeBuiltins,
+  dir: string,
+  name: string
+): Promise<T> {
+  return JSON.parse(await nb.readFile(nb.resolve(dir, name), 'utf8')) as T;
 }
 
-async function firstExistingDir(baseDir: string): Promise<string> {
+async function firstExistingDir(
+  nb: NodeBuiltins,
+  baseDir: string
+): Promise<string> {
   for (const rel of CANDIDATE_DIRS) {
-    const dir = resolve(baseDir, rel);
+    const dir = nb.resolve(baseDir, rel);
     try {
-      await readFile(resolve(dir, FILES.gazetteer), 'utf8');
+      await nb.readFile(nb.resolve(dir, FILES.gazetteer), 'utf8');
       return dir;
     } catch {
       /* try next candidate */
@@ -74,10 +106,10 @@ function validate(data: MapData): MapData {
  *  (dist/cli.cjs, where `import.meta.url` is `undefined` → `fileURLToPath`
  *  throws). The `typeof __dirname` guard is safe in ESM (evaluates to
  *  'undefined' without a ReferenceError). */
-function moduleBaseDir(): string {
+function moduleBaseDir(nb: NodeBuiltins): string {
   try {
     const url = import.meta.url;
-    if (url) return dirname(fileURLToPath(url));
+    if (url) return nb.dirname(nb.fileURLToPath(url));
   } catch {
     /* CJS: import.meta unavailable — fall through */
   }
@@ -91,14 +123,38 @@ function moduleBaseDir(): string {
  *  call can retry rather than inheriting a poisoned promise. */
 export function loadMapData(): Promise<MapData> {
   cache ??= (async (): Promise<MapData> => {
-    const dir = await firstExistingDir(moduleBaseDir());
-    const [worldCoarse, worldDetail, usStates, gazetteer] = await Promise.all([
-      readJson<BoundaryTopology>(dir, FILES.worldCoarse),
-      readJson<BoundaryTopology>(dir, FILES.worldDetail),
-      readJson<BoundaryTopology>(dir, FILES.usStates),
-      readJson<Gazetteer>(dir, FILES.gazetteer),
+    const nb = await loadNodeBuiltins();
+    const dir = await firstExistingDir(nb, moduleBaseDir(nb));
+    const [
+      worldCoarse,
+      worldDetail,
+      usStates,
+      lakes,
+      rivers,
+      naLand,
+      naLakes,
+      gazetteer,
+    ] = await Promise.all([
+      readJson<BoundaryTopology>(nb, dir, FILES.worldCoarse),
+      readJson<BoundaryTopology>(nb, dir, FILES.worldDetail),
+      readJson<BoundaryTopology>(nb, dir, FILES.usStates),
+      // Lakes/rivers/NA assets are optional — older bundles may predate them.
+      readJson<BoundaryTopology>(nb, dir, FILES.lakes).catch(() => undefined),
+      readJson<BoundaryTopology>(nb, dir, FILES.rivers).catch(() => undefined),
+      readJson<BoundaryTopology>(nb, dir, FILES.naLand).catch(() => undefined),
+      readJson<BoundaryTopology>(nb, dir, FILES.naLakes).catch(() => undefined),
+      readJson<Gazetteer>(nb, dir, FILES.gazetteer),
     ]);
-    return validate({ worldCoarse, worldDetail, usStates, gazetteer });
+    return validate({
+      worldCoarse,
+      worldDetail,
+      usStates,
+      gazetteer,
+      ...(lakes && { lakes }),
+      ...(rivers && { rivers }),
+      ...(naLand && { naLand }),
+      ...(naLakes && { naLakes }),
+    });
   })().catch((e: unknown) => {
     cache = undefined; // don't poison future calls with a rejected promise
     throw e;

package/src/map/parser.ts

@@ -105,11 +105,6 @@ export function parseMap(content: string): ParsedMap {
   const pushWarning = (line: number, message: string): void => {
     diagnostics.push(makeDgmoError(line, message, 'warning'));
   };
-  // §24B calls the score+tag-coexistence note "info", but DgmoSeverity is only
-  // error|warning — emit at warning (lowest available informational severity).
-  const pushInfo = (line: number, message: string): void => {
-    diagnostics.push(makeDgmoError(line, message, 'warning'));
-  };
 
   const lines = content.split('\n');
 
@@ -289,11 +284,16 @@ export function parseMap(content: string): ParsedMap {
         dup(d.projection);
         if (
           value &&
-          !['natural-earth', 'albers-usa', 'mercator'].includes(value)
+          ![
+            'equirectangular',
+            'natural-earth',
+            'albers-usa',
+            'mercator',
+          ].includes(value)
         )
           pushWarning(
             line,
-            `Unknown projection "${value}" (expected natural-earth | albers-usa | mercator).`
+            `Unknown projection "${value}" (expected equirectangular | natural-earth | albers-usa | mercator).`
           );
         d.projection = value;
         break;
@@ -441,17 +441,26 @@ export function parseMap(content: string): ParsedMap {
         scoreNum = undefined;
       }
     }
-    if (scoreNum !== undefined && Object.keys(tags).length)
-      pushInfo(
-        line,
-        'A region has both `score:` and a tag value — v1 renders only the score (bivariate is a future seam).'
-      );
+    // A region may carry BOTH a `score:` and a tag value — they are two
+    // selectable colouring dimensions (the legend flips between the score ramp
+    // and the tag group), so this is no longer warned (bivariate is handled).
+    // Peel a trailing ISO scope token (§24B.8) — same qualifier POIs accept,
+    // so `Georgia US-GA` / `Georgia US` can force the country-vs-state pick.
+    let regionName = split.name;
+    let regionScope: string | undefined;
+    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: Writable<MapRegion> = {
-      name: split.name,
+      name: regionName,
       tags,
       meta,
       lineNumber: line,
     };
+    if (regionScope !== undefined) region.scope = regionScope;
     if (scoreNum !== undefined) region.score = scoreNum;
     regions.push(region);
   }