@diagrammo/dgmo 0.47.0 → 0.48.1

package/src/map/legend-band.ts

@@ -1,127 +0,0 @@
-// Vertical band reserved at the top of a map canvas for the choropleth / tag
-// legend, so the projected land starts BELOW the legend instead of being covered
-// by it. The legend (§24B.11) is drawn as a top-center foreground overlay; on a
-// world map that placement sits over land (e.g. Europe), hiding it. Reserving a
-// band in the fit box pushes the map down so the legend clears the land.
-//
-// Shared by `layoutMap` (grows `topPad`) and `mapExportDimensions` is intentionally
-// NOT a consumer — the canvas height is independent; the band only repositions the
-// map WITHIN the canvas. The group builder + config are reused by the renderer so
-// the measured band matches exactly what gets drawn.
-import { computeLegendLayout } from '../utils/legend-layout';
-import { TITLE_FONT_SIZE, TITLE_Y } from '../utils/title-constants';
-import type {
-  LegendConfig,
-  LegendGroupData,
-  LegendMode,
-  LegendState,
-} from '../utils/legend-types';
-import type { MapLayoutLegend } from './types';
-
-// Gap between the title/subtitle banner and the legend top — mirrors the `+ 8`
-// in renderer.ts `legendY`.
-const LEGEND_TOP_GAP = 8;
-// Gap between the legend bottom and the start of the map content.
-const LEGEND_BOTTOM_GAP = 10;
-
-/** The legend's colouring groups (score ramp first, then non-empty tag groups) —
- *  the SAME array the renderer draws, so a measured layout matches the rendered
- *  one. Empty when the legend has neither a ramp nor any populated tag group. */
-export function mapLegendGroups(legend: MapLayoutLegend): LegendGroupData[] {
-  const ramp = legend.ramp;
-  // Reserved name "Value" when no region-heat label is set — must match
-  // VALUE_NAME in layout.ts so the resolved activeGroup selects it.
-  const scoreGroup: LegendGroupData | null = ramp
-    ? {
-        name: ramp.metric?.trim() || 'Value',
-        entries: [],
-        gradient: {
-          min: ramp.min,
-          max: ramp.max,
-          low: ramp.low,
-          high: ramp.high,
-        },
-      }
-    : null;
-  const tagGroups: LegendGroupData[] = legend.tagGroups
-    .filter((g) => g.entries.length > 0)
-    .map((g) => ({ name: g.name, entries: [...g.entries] }));
-  return [...(scoreGroup ? [scoreGroup] : []), ...tagGroups];
-}
-
-/** The shared map-legend config (top-center, below the title, inactive pills kept
- *  so the preview can flip the active colouring dimension). `mode` gates the
- *  export-only filtering (active group only). */
-export function mapLegendConfig(
-  groups: readonly LegendGroupData[],
-  mode: LegendMode
-): LegendConfig {
-  return {
-    groups,
-    position: { placement: 'top-center', titleRelation: 'below-title' },
-    mode,
-    showEmptyGroups: false,
-    showInactivePills: true,
-  };
-}
-
-/** Y of the legend's top edge — mirrors `legendY` in renderer.ts. */
-export function mapLegendTop(hasTitle: boolean, hasSubtitle: boolean): number {
-  return (
-    (hasTitle ? TITLE_Y + TITLE_FONT_SIZE : 0) +
-    (hasSubtitle ? TITLE_FONT_SIZE : 0) +
-    LEGEND_TOP_GAP
-  );
-}
-
-/** Total vertical band (px from the canvas top) the legend occupies = its top Y +
- *  measured height + a bottom gap. Returns 0 when no legend is drawn, so callers
- *  can `Math.max` it into their existing top reserve without special-casing. */
-export function mapLegendBand(
-  legend: MapLayoutLegend | null,
-  opts: {
-    width: number;
-    mode: LegendMode;
-    hasTitle: boolean;
-    hasSubtitle: boolean;
-  }
-): number {
-  if (!legend) return 0;
-  const groups = mapLegendGroups(legend);
-  if (groups.length === 0) return 0;
-  const config = mapLegendConfig(groups, opts.mode);
-  const state: LegendState = { activeGroup: legend.activeGroup };
-  const { height } = computeLegendLayout(config, state, opts.width);
-  if (height <= 0) return 0;
-  return (
-    mapLegendTop(opts.hasTitle, opts.hasSubtitle) + height + LEGEND_BOTTOM_GAP
-  );
-}
-
-/** The legend's actual centred bounding box (top-centre overlay), or null when no
- *  legend is drawn. Used to feed the legend into the on-map label collision set so
- *  a region / context name never lands under it. Mirrors `mapLegendBand` but keeps
- *  the width + x rather than collapsing to a band height. */
-export function mapLegendBox(
-  legend: MapLayoutLegend | null,
-  opts: {
-    width: number;
-    mode: LegendMode;
-    hasTitle: boolean;
-    hasSubtitle: boolean;
-  }
-): { x: number; y: number; width: number; height: number } | null {
-  if (!legend) return null;
-  const groups = mapLegendGroups(legend);
-  if (groups.length === 0) return null;
-  const config = mapLegendConfig(groups, opts.mode);
-  const state: LegendState = { activeGroup: legend.activeGroup };
-  const { width, height } = computeLegendLayout(config, state, opts.width);
-  if (height <= 0 || width <= 0) return null;
-  return {
-    x: (opts.width - width) / 2,
-    y: mapLegendTop(opts.hasTitle, opts.hasSubtitle),
-    width,
-    height,
-  };
-}

package/src/map/load-data.ts

@@ -1,186 +0,0 @@
-// Lazy loader for the map data assets (the one async seam — DI keeps resolveMap
-// pure). Node/CLI implementation reads the committed JSON from disk.
-//
-// PATH RECONCILIATION (R4): the assets live at `src/map/data/*.json` (dev) and
-// are copied to `dist/map-data/*.json` by the step-1 tsup `onSuccess` hook
-// (built). This module resolves relative to `import.meta.url` and tries the
-// known candidate dirs in order, so it works in BOTH contexts.
-//
-// BROWSER/WEB GAP (step-5 contract): this fs-based loader is Node-only. The web
-// 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.
-//
-// 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,
-  WaterBodies,
-  AirportData,
-} 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',
-  mountainRanges: 'mountain-ranges.json',
-  naLand: 'na-land.json',
-  naLakes: 'na-lakes.json',
-  waterBodies: 'water-bodies.json',
-  airports: 'airports.json',
-  gazetteer: 'gazetteer.json',
-} as const;
-
-// Candidate dirs relative to this module, covering dev (src) + built (dist).
-const CANDIDATE_DIRS = [
-  './data',
-  './map-data',
-  '../map-data',
-  '../src/map/data',
-];
-
-let cache: Promise<MapData> | undefined;
-
-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(
-  nb: NodeBuiltins,
-  baseDir: string
-): Promise<string> {
-  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 {
-      /* try next candidate */
-    }
-  }
-  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: MapData): MapData {
-  const topoOk = (t: BoundaryTopology | undefined): boolean =>
-    !!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;
-}
-
-/** This module's directory, resolved for BOTH build formats: `import.meta.url`
- *  in ESM (dist/index.js, vitest/src) and `__dirname` in the CJS CLI bundle
- *  (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(nb: NodeBuiltins): string {
-  try {
-    const url = import.meta.url;
-    if (url) return nb.dirname(nb.fileURLToPath(url));
-  } catch {
-    /* CJS: import.meta unavailable — fall through */
-  }
-  if (typeof __dirname !== 'undefined') return __dirname;
-  return process.cwd();
-}
-
-/** Load + memoize the four map assets (Node). Throws if none of the candidate
- *  locations contain them, or if a loaded asset fails shape validation. A
- *  rejected load is NOT cached (#7): the memo is cleared on failure so a later
- *  call can retry rather than inheriting a poisoned promise. */
-export function loadMapData(): Promise<MapData> {
-  cache ??= (async (): Promise<MapData> => {
-    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<BoundaryTopology>(nb, dir, FILES.worldCoarse),
-      readJson<BoundaryTopology>(nb, dir, FILES.worldDetail),
-      readJson<BoundaryTopology>(nb, dir, FILES.usStates),
-      // Lakes/rivers/mountain/NA/water 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.mountainRanges).catch(
-        () => undefined
-      ),
-      readJson<BoundaryTopology>(nb, dir, FILES.naLand).catch(() => undefined),
-      readJson<BoundaryTopology>(nb, dir, FILES.naLakes).catch(() => undefined),
-      readJson<WaterBodies>(nb, dir, FILES.waterBodies).catch(() => undefined),
-      readJson<AirportData>(nb, dir, FILES.airports).catch(() => undefined),
-      readJson<Gazetteer>(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: unknown) => {
-    cache = undefined; // don't poison future calls with a rejected promise
-    throw e;
-  });
-  return cache;
-}