@elabs-ai/components-maps 4.1.0 → 5.0.0

package/dist/chunk-W76NLFER.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/use-map-breakpoint.ts"],"sourcesContent":["\"use client\";\n\n/**\n * The map's responsive contract: container tiers, `MapResponsive<T>` and the\n * frame context `<MapCanvas>` provides to its furniture (RM-125).\n *\n * A DELIBERATE COPY of `@elabs-ai/components-charts`' `chart-breakpoint.ts`\n * (ADR 0039), with the same thresholds and the same desktop-first\n * `{ base, medium?, narrow? }` shape. `maps` may not import `charts` (both are\n * layer-2 leaves — `pnpm check --rule dep-direction`), so the few lines live\n * here too. Change a threshold in both files or in neither.\n *\n * - Three container tiers, measured on the MAP's own width, never the\n *   viewport: `narrow` (< 480 px), `medium` (< 768 px), `wide`.\n * - `MapResponsive<T>`: one value, or `{ base, medium?, narrow? }` — an\n *   override applies at its tier and every narrower tier that sets nothing.\n *   A plain value structurally matches `charts`' `Responsive<T>`, so one\n *   object can drive a chart and a map.\n */\n\nimport {\n  type CSSProperties,\n  createContext,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useState,\n} from \"react\";\n\n// ── Tiers ────────────────────────────────────────────────────────────────────\n\n/** A map container's width tier — the same three tiers as a chart's. */\nexport type MapBreakpoint = \"narrow\" | \"medium\" | \"wide\";\n\n/** Every tier, narrowest first. */\nexport const MAP_BREAKPOINTS: readonly MapBreakpoint[] = [\"narrow\", \"medium\", \"wide\"];\n\n/**\n * A width (CSS px) below `narrow` is narrow; below `medium` is medium; anything\n * else is wide. A boundary belongs to the wider tier (480 → medium). Same\n * numbers as `CHART_BREAKPOINT_THRESHOLDS`.\n */\nexport const MAP_BREAKPOINT_THRESHOLDS = { narrow: 480, medium: 768 } as const;\n\n/**\n * The tier for a measured container width. `0` or a non-finite width means\n * \"not measured yet\" (server render, first pass, `display: none`) and\n * resolves to `wide`, so a first paint matches the pre-tier layout.\n */\nexport function mapBreakpointForWidth(width: number): MapBreakpoint {\n  if (!Number.isFinite(width) || width <= 0) return \"wide\";\n  if (width < MAP_BREAKPOINT_THRESHOLDS.narrow) return \"narrow\";\n  if (width < MAP_BREAKPOINT_THRESHOLDS.medium) return \"medium\";\n  return \"wide\";\n}\n\n// ── MapResponsive<T> ─────────────────────────────────────────────────────────\n\n/**\n * Per-tier values, desktop-first: `base` is the WIDE value (the opposite of\n * Tailwind's unprefixed, mobile-first class); overrides go down.\n */\nexport interface MapResponsiveByBreakpoint<T> {\n  /** The value at `wide`, and the fallback for every tier that sets nothing. */\n  base: T;\n  /** At `medium` — and at `narrow` too, unless `narrow` is set. */\n  medium?: T;\n  /** At `narrow` only. */\n  narrow?: T;\n}\n\n/**\n * One value for every tier, or per-tier values. `T` must never be an object\n * type with its own `base` key (that key marks the per-tier form). Read it\n * through {@link resolveMapResponsive} / {@link useMapResponsive}.\n */\nexport type MapResponsive<T> = T | MapResponsiveByBreakpoint<T>;\n\n/** True for the per-tier form: a plain object with its own `base` key. */\nexport function isMapResponsiveByBreakpoint<T>(\n  value: MapResponsive<T>,\n): value is MapResponsiveByBreakpoint<T> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    Object.prototype.hasOwnProperty.call(value, \"base\")\n  );\n}\n\n/**\n * The value for `breakpoint`: `wide` → `base`; `medium` → `medium ?? base`;\n * `narrow` → `narrow ?? medium ?? base`. \"Not set\" means `undefined`.\n */\nexport function resolveMapResponsive<T>(value: MapResponsive<T>, breakpoint: MapBreakpoint): T {\n  if (!isMapResponsiveByBreakpoint(value)) return value as T;\n  if (breakpoint === \"wide\") return value.base;\n  if (breakpoint === \"narrow\" && value.narrow !== undefined) return value.narrow;\n  return value.medium !== undefined ? value.medium : value.base;\n}\n\n// ── Height ───────────────────────────────────────────────────────────────────\n\n/** CSS px, or the map's width ÷ height (`{ aspect: 2 }` = twice as wide as tall). */\nexport type MapHeight = number | { aspect: number };\n\n/**\n * The height a `<MapCanvas>` falls back to when its parent gives it none:\n * 1.6 : 1, and square at `narrow` — an aspect-locked map at 380 px would\n * otherwise shrink to a strip nobody can read.\n */\nexport const DEFAULT_MAP_HEIGHT: MapResponsiveByBreakpoint<MapHeight> = {\n  base: { aspect: 1.6 },\n  narrow: { aspect: 1 },\n};\n\nfunction validHeight(value: MapHeight | undefined): MapHeight | undefined {\n  if (typeof value === \"number\") return Number.isFinite(value) && value > 0 ? value : undefined;\n  if (value && Number.isFinite(value.aspect) && value.aspect > 0) return value;\n  return undefined;\n}\n\n/**\n * The map box's geometry is LAYOUT THE ENGINE MEASURES, so it must never\n * interpolate. `transition-property` defaults to `all`, and the house\n * reduced-motion clamp sets `transition-duration: 0.01ms !important` on every\n * element — which turns a height / aspect-ratio change into a (very short)\n * transition that still lands one animation frame later. Under a busy WebGL\n * first paint that frame arrived ~0.7 s late, so MapLibre measured the box\n * mid-transition (348×218 on a box that ends up 348×348) and fitted `bounds`\n * to a rectangle that never existed. `none` beats any stylesheet from the\n * inline style, and the clamp only forces DURATIONS, never the property list.\n */\nconst NO_GEOMETRY_TRANSITION = { transitionProperty: \"none\" } as const;\n\n/**\n * The container style for a `height` at `breakpoint`. An explicit `height`\n * sets the box outright (`height: auto` releases the `h-full` class for an\n * aspect). Without one, only an `aspect-ratio` is set — CSS ignores it while\n * the parent gives the map a definite height, so a map in a sized parent\n * looks exactly as before; a map in an unsized parent stops collapsing to 0.\n * Every branch pins {@link NO_GEOMETRY_TRANSITION} so the box resizes in the\n * same frame the rule changes.\n */\nexport function resolveMapHeightStyle(\n  height: MapResponsive<MapHeight> | undefined,\n  breakpoint: MapBreakpoint,\n): CSSProperties {\n  const own =\n    height === undefined ? undefined : validHeight(resolveMapResponsive(height, breakpoint));\n  if (typeof own === \"number\") return { ...NO_GEOMETRY_TRANSITION, height: own };\n  if (own) return { ...NO_GEOMETRY_TRANSITION, height: \"auto\", aspectRatio: `${own.aspect} / 1` };\n  const fallback = resolveMapResponsive(DEFAULT_MAP_HEIGHT, breakpoint);\n  return typeof fallback === \"number\"\n    ? { ...NO_GEOMETRY_TRANSITION }\n    : { ...NO_GEOMETRY_TRANSITION, aspectRatio: `${fallback.aspect} / 1` };\n}\n\n// ── Measuring ────────────────────────────────────────────────────────────────\n\n/**\n * Measures `node` with a `ResizeObserver` and returns its tier. Re-renders\n * only when the TIER changes.\n */\nexport function useMeasuredMapBreakpoint(node: Element | null): MapBreakpoint {\n  const [breakpoint, setBreakpoint] = useState<MapBreakpoint>(\"wide\");\n  // Layout effect: the first measure lands before paint, so a narrow map never\n  // flashes its wide furniture.\n  useLayoutEffect(() => {\n    if (!node) return undefined;\n    const update = (width: number) => {\n      const next = mapBreakpointForWidth(width);\n      setBreakpoint((prev) => (prev === next ? prev : next));\n    };\n    update(node.getBoundingClientRect().width);\n    if (typeof ResizeObserver === \"undefined\") return undefined;\n    const observer = new ResizeObserver((entries) => {\n      const entry = entries[entries.length - 1];\n      if (entry) update(entry.contentRect.width);\n    });\n    observer.observe(node);\n    return () => observer.disconnect();\n  }, [node]);\n  return breakpoint;\n}\n\n// ── Frame context ────────────────────────────────────────────────────────────\n\n/** Where furniture outside the map box goes: the strip above or below it. */\nexport type MapFrameSide = \"above\" | \"below\";\n\nexport interface MapFrameContextValue {\n  /** The map container's measured tier. */\n  breakpoint: MapBreakpoint;\n  /** `false` when the canvas is static (`<MapCanvas interactive={false}>`). */\n  interactive: boolean;\n  /** The strips around the map box; `null` until something asks for one. */\n  slots: Record<MapFrameSide, HTMLElement | null>;\n  /** Ask the canvas to render a strip; returns the release function. */\n  requestSlot: (side: MapFrameSide) => () => void;\n}\n\nconst noopRelease = () => {};\n\nconst DEFAULT_FRAME: MapFrameContextValue = {\n  breakpoint: \"wide\",\n  interactive: true,\n  slots: { above: null, below: null },\n  requestSlot: () => noopRelease,\n};\n\nexport const MapFrameContext = createContext<MapFrameContextValue>(DEFAULT_FRAME);\n\n/** The frame `<MapCanvas>` provides: tier, static flag, outside strips. */\nexport function useMapFrame(): MapFrameContextValue {\n  return useContext(MapFrameContext);\n}\n\n/** The enclosing map's tier (`wide` outside a `<MapCanvas>`). */\nexport function useMapBreakpoint(): MapBreakpoint {\n  return useContext(MapFrameContext).breakpoint;\n}\n\n/** `value` resolved at the enclosing map's tier. */\nexport function useMapResponsive<T>(value: MapResponsive<T>): T {\n  return resolveMapResponsive(value, useMapBreakpoint());\n}\n\n/**\n * The strip above / below the map box to portal into, or `null` while it is\n * not needed (`side` is `null`) or not mounted yet. Asking renders the strip;\n * the canvas drops it again when nothing asks.\n */\nexport function useMapFrameSlot(side: MapFrameSide | null): HTMLElement | null {\n  const { slots, requestSlot } = useContext(MapFrameContext);\n  useEffect(() => (side ? requestSlot(side) : undefined), [side, requestSlot]);\n  return side ? slots[side] : null;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WNU4IOGL.js

@@ -0,0 +1,116 @@
+"use client";
+
+// src/lib/plan-regions.ts
+function planRegionCentre(bounds) {
+  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
+}
+function walkCoordinates(input, visit) {
+  if (!Array.isArray(input)) return;
+  if (typeof input[0] === "number" && typeof input[1] === "number") {
+    visit(input[0], input[1]);
+    return;
+  }
+  for (const entry of input) walkCoordinates(entry, visit);
+}
+function planBoundsOfGeometry(geometry) {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  const visit = (x, y) => {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  };
+  if (geometry.type === "GeometryCollection") {
+    for (const member of geometry.geometries) {
+      walkCoordinates(member.coordinates, visit);
+    }
+  } else {
+    walkCoordinates(geometry.coordinates, visit);
+  }
+  if (!Number.isFinite(minX) || !Number.isFinite(minY)) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function read(field, properties, index) {
+  if (field === void 0) return void 0;
+  if (typeof field === "function") return field(properties, index);
+  return properties?.[field];
+}
+function planRegionsFromGeoJSON(data, fields) {
+  const regions = [];
+  data.features.forEach((feature, index) => {
+    const bounds = planBoundsOfGeometry(feature.geometry);
+    if (!bounds) return;
+    const properties = feature.properties;
+    const id = read(fields.id, properties, index) ?? (feature.id != null ? String(feature.id) : null);
+    if (id == null) return;
+    const shortLabel = read(fields.shortLabel, properties, index);
+    const description = read(fields.description, properties, index);
+    const group = read(fields.group, properties, index);
+    const groupLabel = read(fields.groupLabel, properties, index);
+    regions.push({
+      id: String(id),
+      label: String(read(fields.label, properties, index) ?? id),
+      ...shortLabel !== void 0 ? { shortLabel: String(shortLabel) } : {},
+      ...description !== void 0 ? { description: String(description) } : {},
+      ...group !== void 0 ? { group: String(group) } : {},
+      ...groupLabel !== void 0 ? { groupLabel: String(groupLabel) } : {},
+      bounds
+    });
+  });
+  return regions;
+}
+function planGroupId(group) {
+  return `group:${group}`;
+}
+function planBoundsUnion(boxes) {
+  if (boxes.length === 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const box of boxes) {
+    if (box.x < minX) minX = box.x;
+    if (box.y < minY) minY = box.y;
+    if (box.x + box.width > maxX) maxX = box.x + box.width;
+    if (box.y + box.height > maxY) maxY = box.y + box.height;
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function planGroupsFromRegions(regions) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const region of regions) {
+    const key = region.group ?? region.id;
+    const members = byKey.get(key);
+    if (members) members.push(region);
+    else byKey.set(key, [region]);
+  }
+  const groups = [];
+  for (const [key, members] of byKey) {
+    const bounds = planBoundsUnion(members.map((member) => member.bounds));
+    if (!bounds) continue;
+    const first = members[0];
+    groups.push({
+      key,
+      region: {
+        id: planGroupId(key),
+        label: first.groupLabel ?? key,
+        bounds
+      },
+      members
+    });
+  }
+  return groups;
+}
+
+export {
+  planRegionCentre,
+  planBoundsOfGeometry,
+  planRegionsFromGeoJSON,
+  planGroupId,
+  planBoundsUnion,
+  planGroupsFromRegions
+};
+//# sourceMappingURL=chunk-WNU4IOGL.js.map

package/dist/chunk-WNU4IOGL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/plan-regions.ts"],"sourcesContent":["import type { PlanPoint } from \"./plan-crs\";\n\n/** An axis-aligned rectangle in PLAN units. */\nexport interface PlanRegionBounds {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * One interactive area of a plan — a room, a machine cell, a seat. The overlay\n * needs a box and a name, not the geometry: a room's shape is drawn by WebGL,\n * while the keyboard proxy, the label and the readout all work from its box.\n */\nexport interface MapPlanRegion {\n  /** Stable id. Must match the feature id the shape layer promotes. */\n  id: string;\n  /** The visible label, and the start of the button's accessible name. */\n  label: string;\n  /** Shown instead of `label` when the box is too small for the full one. */\n  shortLabel?: string;\n  /** Appended to the accessible name — a status word, a seat count, an owner. */\n  description?: string;\n  /** The region's box, in plan units. */\n  bounds: PlanRegionBounds;\n  /** Group id, for plans with more regions than a keyboard can walk (a carriage, a wing). */\n  group?: string;\n  /** The group's own label, used by group mode. */\n  groupLabel?: string;\n}\n\n/** The centre of a region's box, in plan units. */\nexport function planRegionCentre(bounds: PlanRegionBounds): PlanPoint {\n  return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n}\n\nfunction walkCoordinates(input: unknown, visit: (x: number, y: number) => void): void {\n  if (!Array.isArray(input)) return;\n  if (typeof input[0] === \"number\" && typeof input[1] === \"number\") {\n    visit(input[0], input[1]);\n    return;\n  }\n  for (const entry of input) walkCoordinates(entry, visit);\n}\n\n/** The bounding box of any geometry, in the units its coordinates are written in. */\nexport function planBoundsOfGeometry(geometry: GeoJSON.Geometry): PlanRegionBounds | null {\n  let minX = Number.POSITIVE_INFINITY;\n  let minY = Number.POSITIVE_INFINITY;\n  let maxX = Number.NEGATIVE_INFINITY;\n  let maxY = Number.NEGATIVE_INFINITY;\n\n  const visit = (x: number, y: number) => {\n    if (x < minX) minX = x;\n    if (y < minY) minY = y;\n    if (x > maxX) maxX = x;\n    if (y > maxY) maxY = y;\n  };\n\n  if (geometry.type === \"GeometryCollection\") {\n    for (const member of geometry.geometries) {\n      walkCoordinates((member as { coordinates?: unknown }).coordinates, visit);\n    }\n  } else {\n    walkCoordinates(geometry.coordinates, visit);\n  }\n\n  if (!Number.isFinite(minX) || !Number.isFinite(minY)) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** A field read either from a feature property or computed from the properties. */\nexport type PlanRegionField<P, T> = string | ((properties: P, index: number) => T);\n\nexport interface PlanRegionFields<P extends GeoJSON.GeoJsonProperties> {\n  /** Property name, or a function, giving each region's id. */\n  id: PlanRegionField<P, string>;\n  /** Property name, or a function, giving each region's visible label. */\n  label: PlanRegionField<P, string>;\n  /** Optional short label for a small box. */\n  shortLabel?: PlanRegionField<P, string | undefined>;\n  /** Optional extra words for the accessible name. */\n  description?: PlanRegionField<P, string | undefined>;\n  /** Optional group id. */\n  group?: PlanRegionField<P, string | undefined>;\n  /** Optional group label. */\n  groupLabel?: PlanRegionField<P, string | undefined>;\n}\n\nfunction read<P extends GeoJSON.GeoJsonProperties, T>(\n  field: PlanRegionField<P, T> | undefined,\n  properties: P,\n  index: number,\n): T | undefined {\n  if (field === undefined) return undefined;\n  if (typeof field === \"function\") return field(properties, index);\n  return (properties as Record<string, unknown> | null)?.[field] as T | undefined;\n}\n\n/**\n * Derive the overlay's regions from the same GeoJSON the shape layer draws, so\n * the keyboard proxy can never drift out of step with the picture.\n *\n * ```ts\n * const regions = planRegionsFromGeoJSON(rooms, { id: \"id\", label: \"name\" });\n * ```\n */\nexport function planRegionsFromGeoJSON<P extends GeoJSON.GeoJsonProperties>(\n  data: GeoJSON.FeatureCollection<GeoJSON.Geometry, P>,\n  fields: PlanRegionFields<P>,\n): MapPlanRegion[] {\n  const regions: MapPlanRegion[] = [];\n\n  data.features.forEach((feature, index) => {\n    const bounds = planBoundsOfGeometry(feature.geometry);\n    if (!bounds) return;\n    const properties = feature.properties;\n    const id =\n      read(fields.id, properties, index) ?? (feature.id != null ? String(feature.id) : null);\n    if (id == null) return;\n\n    const shortLabel = read(fields.shortLabel, properties, index);\n    const description = read(fields.description, properties, index);\n    const group = read(fields.group, properties, index);\n    const groupLabel = read(fields.groupLabel, properties, index);\n\n    regions.push({\n      id: String(id),\n      label: String(read(fields.label, properties, index) ?? id),\n      ...(shortLabel !== undefined ? { shortLabel: String(shortLabel) } : {}),\n      ...(description !== undefined ? { description: String(description) } : {}),\n      ...(group !== undefined ? { group: String(group) } : {}),\n      ...(groupLabel !== undefined ? { groupLabel: String(groupLabel) } : {}),\n      bounds,\n    });\n  });\n\n  return regions;\n}\n\n/** The id the overlay gives a group's own button, namespaced away from region ids. */\nexport function planGroupId(group: string): string {\n  return `group:${group}`;\n}\n\n/** One group of regions, with the synthetic region that stands for the whole of it. */\nexport interface MapPlanGroup {\n  /** The group's key, as it appeared on its regions. */\n  key: string;\n  /** A region covering every member's box — what group mode puts a button on. */\n  region: MapPlanRegion;\n  /** The group's regions, in reading order. */\n  members: readonly MapPlanRegion[];\n}\n\n/** The smallest box containing all of them. `null` for an empty list. */\nexport function planBoundsUnion(boxes: readonly PlanRegionBounds[]): PlanRegionBounds | null {\n  if (boxes.length === 0) return null;\n  let minX = Number.POSITIVE_INFINITY;\n  let minY = Number.POSITIVE_INFINITY;\n  let maxX = Number.NEGATIVE_INFINITY;\n  let maxY = Number.NEGATIVE_INFINITY;\n\n  for (const box of boxes) {\n    if (box.x < minX) minX = box.x;\n    if (box.y < minY) minY = box.y;\n    if (box.x + box.width > maxX) maxX = box.x + box.width;\n    if (box.y + box.height > maxY) maxY = box.y + box.height;\n  }\n\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/**\n * Bundle regions by their `group`, in first-seen order.\n *\n * A region with no `group` becomes a group of one, keyed by its own id: group\n * mode then still shows everything, instead of quietly dropping whatever was\n * left ungrouped.\n */\nexport function planGroupsFromRegions(regions: readonly MapPlanRegion[]): MapPlanGroup[] {\n  const byKey = new Map<string, MapPlanRegion[]>();\n\n  for (const region of regions) {\n    const key = region.group ?? region.id;\n    const members = byKey.get(key);\n    if (members) members.push(region);\n    else byKey.set(key, [region]);\n  }\n\n  const groups: MapPlanGroup[] = [];\n  for (const [key, members] of byKey) {\n    const bounds = planBoundsUnion(members.map((member) => member.bounds));\n    if (!bounds) continue;\n    const first = members[0]!;\n    groups.push({\n      key,\n      region: {\n        id: planGroupId(key),\n        label: first.groupLabel ?? key,\n        bounds,\n      },\n      members,\n    });\n  }\n\n  return groups;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WS4Z7ENS.js

@@ -0,0 +1,494 @@
+"use client";
+import {
+  useTokenColor
+} from "./chunk-Y44MEKJV.js";
+import {
+  useMap
+} from "./chunk-JYFERXZT.js";
+import {
+  warnMapOnce
+} from "./chunk-G7JDXDJN.js";
+import {
+  mergeFeatureStatePaint
+} from "./chunk-RNSLG64F.js";
+
+// src/map-geojson/map-geojson.tsx
+import { useEffect, useId, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_HIT_WIDTH = 16;
+var DEFAULT_PLAN_PICK_PADDING = 8;
+function MapGeoJSON({
+  data,
+  id: propId,
+  promoteId,
+  fillPaint,
+  linePaint,
+  fillHoverPaint,
+  fillOpacity,
+  pattern,
+  vignette,
+  lineHoverPaint,
+  fillSelectedPaint,
+  lineSelectedPaint,
+  selectedId,
+  hoveredId,
+  onClick,
+  onHover,
+  interactive: interactiveProp,
+  featureLabel,
+  pickPadding,
+  hitWidth = DEFAULT_HIT_WIDTH,
+  beforeId
+}) {
+  const { map, isLoaded, plan } = useMap();
+  const autoId = useId();
+  const id = propId ?? autoId;
+  const sourceId = `geojson-source-${id}`;
+  const fillLayerId = `geojson-fill-${id}`;
+  const lineLayerId = `geojson-line-${id}`;
+  const patternLayerId = `geojson-pattern-${id}`;
+  const vignetteLayerId = `geojson-vignette-${id}`;
+  const patternImageId = `geojson-pattern-image-${id}`;
+  const hitLayerId = `geojson-hit-${id}`;
+  const interactive = interactiveProp ?? plan != null;
+  const pickPad = pickPadding ?? (plan ? DEFAULT_PLAN_PICK_PADDING : 0);
+  const defaultFill = useTokenColor("--border");
+  const defaultLine = useTokenColor("--background");
+  const defaultInk = useTokenColor("--foreground");
+  const showFill = fillPaint !== false;
+  const showLine = linePaint !== false;
+  const showHit = interactive && !showFill;
+  if (plan && typeof data === "string") {
+    warnMapOnce(
+      "geojson-plan-url",
+      "<MapGeoJSON data={url}> cannot be converted to plan units. Fetch the GeoJSON yourself and pass the object, or pass coordinates already in lng/lat."
+    );
+  }
+  if (interactive && !promoteId) {
+    warnMapOnce(
+      "geojson-promote-id",
+      "<MapGeoJSON interactive> needs `promoteId` to tell features apart: without it hover and selection paint nothing."
+    );
+  }
+  const resolvedData = useMemo(
+    () => plan && typeof data !== "string" ? plan.toGeoJSON(data) : data,
+    [plan, data]
+  );
+  const baseOpacity = fillOpacity ?? (pattern ? 0.25 : void 0);
+  const mergedFillPaint = useMemo(
+    () => mergeFeatureStatePaint(
+      {
+        "fill-color": defaultFill,
+        ...baseOpacity !== void 0 ? { "fill-opacity": baseOpacity } : {},
+        ...fillPaint || {}
+      },
+      { hover: fillHoverPaint, selected: fillSelectedPaint }
+    ),
+    [defaultFill, baseOpacity, fillPaint, fillHoverPaint, fillSelectedPaint]
+  );
+  const configuredFill = fillPaint ? fillPaint["fill-color"] : void 0;
+  const areaColor = configuredFill === void 0 ? defaultFill : typeof configuredFill === "string" ? configuredFill : defaultInk;
+  const stripeWidth = Math.max(1, pattern?.width ?? 2);
+  const stripeGap = Math.max(0, pattern?.gap ?? 4);
+  const vignetteWidth = Math.max(0, vignette?.width ?? 12);
+  const vignetteOpacity = Math.min(1, Math.max(0, vignette?.opacity ?? 0.35));
+  const hasPattern = pattern !== void 0;
+  const hasVignette = vignette !== void 0;
+  const patternDrawnRef = useRef(null);
+  const mergedLinePaint = useMemo(
+    () => mergeFeatureStatePaint(
+      {
+        "line-color": defaultLine,
+        "line-width": 0.5,
+        ...linePaint || {}
+      },
+      { hover: lineHoverPaint, selected: lineSelectedPaint }
+    ),
+    [defaultLine, linePaint, lineHoverPaint, lineSelectedPaint]
+  );
+  const latestRef = useRef({ onClick, onHover, plan });
+  latestRef.current = { onClick, onHover, plan };
+  const setHoverRef = useRef(null);
+  useEffect(() => {
+    if (!isLoaded || !map) return;
+    map.addSource(sourceId, {
+      type: "geojson",
+      data: resolvedData,
+      ...promoteId ? { promoteId } : {}
+    });
+    return () => {
+      try {
+        if (map.getLayer(hitLayerId)) map.removeLayer(hitLayerId);
+        if (map.getLayer(lineLayerId)) map.removeLayer(lineLayerId);
+        if (map.getLayer(patternLayerId)) map.removeLayer(patternLayerId);
+        if (map.getLayer(fillLayerId)) map.removeLayer(fillLayerId);
+        if (map.getLayer(vignetteLayerId)) map.removeLayer(vignetteLayerId);
+        if (map.hasImage(patternImageId)) map.removeImage(patternImageId);
+        if (map.getSource(sourceId)) map.removeSource(sourceId);
+      } catch {
+      }
+    };
+  }, [isLoaded, map]);
+  useEffect(() => {
+    if (!isLoaded || !map) return;
+    const source = map.getSource(sourceId);
+    source?.setData(resolvedData);
+  }, [isLoaded, map, resolvedData, sourceId]);
+  useEffect(() => {
+    if (!isLoaded || !map) return;
+    const source = map.getSource(sourceId);
+    if (!source) return;
+    if (showFill && !map.getLayer(fillLayerId)) {
+      map.addLayer(
+        {
+          id: fillLayerId,
+          type: "fill",
+          source: sourceId,
+          paint: mergedFillPaint
+        },
+        beforeId
+      );
+    } else if (!showFill && map.getLayer(fillLayerId)) {
+      map.removeLayer(fillLayerId);
+    }
+    if (showLine && !map.getLayer(lineLayerId)) {
+      map.addLayer(
+        {
+          id: lineLayerId,
+          type: "line",
+          source: sourceId,
+          paint: mergedLinePaint
+        },
+        beforeId
+      );
+    } else if (!showLine && map.getLayer(lineLayerId)) {
+      map.removeLayer(lineLayerId);
+    }
+    if (showHit && !map.getLayer(hitLayerId)) {
+      map.addLayer(
+        {
+          id: hitLayerId,
+          type: "line",
+          source: sourceId,
+          paint: { "line-color": defaultLine, "line-opacity": 0, "line-width": hitWidth }
+        },
+        beforeId
+      );
+    } else if (!showHit && map.getLayer(hitLayerId)) {
+      map.removeLayer(hitLayerId);
+    }
+    if (showFill && map.getLayer(fillLayerId)) {
+      for (const [key, value] of Object.entries(mergedFillPaint)) {
+        map.setPaintProperty(fillLayerId, key, value);
+      }
+    }
+    if (showLine && map.getLayer(lineLayerId)) {
+      for (const [key, value] of Object.entries(mergedLinePaint)) {
+        map.setPaintProperty(lineLayerId, key, value);
+      }
+    }
+    const vignettePaint = {
+      "line-color": areaColor,
+      "line-width": vignetteWidth * 2,
+      "line-blur": vignetteWidth,
+      "line-opacity": vignetteOpacity
+    };
+    if (hasVignette && !map.getLayer(vignetteLayerId)) {
+      const before = map.getLayer(fillLayerId) ? fillLayerId : map.getLayer(lineLayerId) ? lineLayerId : beforeId;
+      map.addLayer(
+        { id: vignetteLayerId, type: "line", source: sourceId, paint: vignettePaint },
+        before
+      );
+    } else if (hasVignette) {
+      for (const [key, value] of Object.entries(vignettePaint)) {
+        map.setPaintProperty(vignetteLayerId, key, value);
+      }
+    } else if (map.getLayer(vignetteLayerId)) {
+      map.removeLayer(vignetteLayerId);
+    }
+    if (hasPattern) {
+      const drawKey = `${areaColor}|${stripeWidth}|${stripeGap}`;
+      if (patternDrawnRef.current !== drawKey || !map.hasImage(patternImageId)) {
+        const image = stripeImage(areaColor, stripeWidth, stripeGap);
+        if (image) {
+          if (map.hasImage(patternImageId)) map.removeImage(patternImageId);
+          map.addImage(patternImageId, image.data, { pixelRatio: image.pixelRatio });
+          patternDrawnRef.current = drawKey;
+        }
+      }
+      if (map.hasImage(patternImageId)) {
+        if (!map.getLayer(patternLayerId)) {
+          map.addLayer(
+            {
+              id: patternLayerId,
+              type: "fill",
+              source: sourceId,
+              paint: { "fill-pattern": patternImageId }
+            },
+            map.getLayer(lineLayerId) ? lineLayerId : beforeId
+          );
+        }
+      }
+    } else {
+      if (map.getLayer(patternLayerId)) map.removeLayer(patternLayerId);
+      if (map.hasImage(patternImageId)) map.removeImage(patternImageId);
+      patternDrawnRef.current = null;
+    }
+    if (showHit && map.getLayer(hitLayerId)) {
+      map.setPaintProperty(hitLayerId, "line-width", hitWidth);
+    }
+  }, [
+    areaColor,
+    hasPattern,
+    stripeWidth,
+    stripeGap,
+    hasVignette,
+    vignetteWidth,
+    vignetteOpacity,
+    patternLayerId,
+    vignetteLayerId,
+    patternImageId,
+    isLoaded,
+    map,
+    sourceId,
+    fillLayerId,
+    lineLayerId,
+    hitLayerId,
+    showFill,
+    showLine,
+    showHit,
+    hitWidth,
+    defaultLine,
+    mergedFillPaint,
+    mergedLinePaint,
+    beforeId
+  ]);
+  const selectedKey = useMemo(() => {
+    if (selectedId == null) return "";
+    return (Array.isArray(selectedId) ? selectedId : [selectedId]).join("\0");
+  }, [selectedId]);
+  const appliedSelectionRef = useRef([]);
+  useEffect(() => {
+    if (!isLoaded || !map || !map.getSource(sourceId)) return;
+    const next = selectedId == null ? [] : Array.isArray(selectedId) ? [...selectedId] : [selectedId];
+    for (const previous of appliedSelectionRef.current) {
+      if (!next.includes(previous)) {
+        map.setFeatureState({ source: sourceId, id: previous }, { selected: false });
+      }
+    }
+    for (const current of next) {
+      map.setFeatureState({ source: sourceId, id: current }, { selected: true });
+    }
+    appliedSelectionRef.current = next;
+  }, [isLoaded, map, sourceId, selectedKey]);
+  const hoverIsControlled = hoveredId !== void 0;
+  const appliedHoverRef = useRef(null);
+  useEffect(() => {
+    if (!hoverIsControlled || !isLoaded || !map || !map.getSource(sourceId)) return;
+    const previous = appliedHoverRef.current;
+    if (previous != null && previous !== hoveredId) {
+      map.setFeatureState({ source: sourceId, id: previous }, { hover: false });
+    }
+    if (hoveredId != null) {
+      map.setFeatureState({ source: sourceId, id: hoveredId }, { hover: true });
+    }
+    appliedHoverRef.current = hoveredId ?? null;
+  }, [hoverIsControlled, hoveredId, isLoaded, map, sourceId]);
+  const pickLayerId = showFill ? fillLayerId : hitLayerId;
+  useEffect(() => {
+    if (!isLoaded || !map || !interactive) return;
+    if (!showFill && !showHit) return;
+    let pointerHoverId = null;
+    const setHover = (next) => {
+      if (hoverIsControlled) return;
+      if (next === pointerHoverId) return;
+      const sourceExists = !!map.getSource(sourceId);
+      if (pointerHoverId != null && sourceExists) {
+        map.setFeatureState({ source: sourceId, id: pointerHoverId }, { hover: false });
+      }
+      pointerHoverId = next;
+      if (next != null && sourceExists) {
+        map.setFeatureState({ source: sourceId, id: next }, { hover: true });
+      }
+    };
+    const payload = (feature, e) => {
+      const planCrs = latestRef.current.plan;
+      return {
+        feature,
+        longitude: e.lngLat.lng,
+        latitude: e.lngLat.lat,
+        plan: planCrs ? planCrs.toPlan([e.lngLat.lng, e.lngLat.lat]) : null,
+        originalEvent: e
+      };
+    };
+    const handleMouseMove = (e) => {
+      const feature = e.features?.[0];
+      if (!feature) return;
+      map.getCanvas().style.cursor = "pointer";
+      const featureId = feature.id;
+      if (featureId === pointerHoverId) return;
+      setHover(featureId ?? null);
+      latestRef.current.onHover?.(payload(feature, e));
+    };
+    const handleMouseLeave = () => {
+      setHover(null);
+      map.getCanvas().style.cursor = "";
+      latestRef.current.onHover?.(null);
+    };
+    const pickPadded = (e) => {
+      const exact = map.queryRenderedFeatures(e.point, { layers: [pickLayerId] });
+      if (exact.length > 0) return exact[0];
+      const { x, y } = e.point;
+      const box = [
+        [x - pickPad, y - pickPad],
+        [x + pickPad, y + pickPad]
+      ];
+      return map.queryRenderedFeatures(box, { layers: [pickLayerId] })[0];
+    };
+    setHoverRef.current = setHover;
+    const handleClick = (e) => {
+      const feature = pickPad > 0 ? pickPadded(e) : e.features?.[0];
+      if (!feature) return;
+      latestRef.current.onClick?.(payload(feature, e));
+    };
+    map.on("mousemove", pickLayerId, handleMouseMove);
+    map.on("mouseleave", pickLayerId, handleMouseLeave);
+    if (pickPad > 0) {
+      map.on("click", handleClick);
+    } else {
+      map.on("click", pickLayerId, handleClick);
+    }
+    return () => {
+      map.off("mousemove", pickLayerId, handleMouseMove);
+      map.off("mouseleave", pickLayerId, handleMouseLeave);
+      if (pickPad > 0) {
+        map.off("click", handleClick);
+      } else {
+        map.off("click", pickLayerId, handleClick);
+      }
+      setHover(null);
+      setHoverRef.current = null;
+      map.getCanvas().style.cursor = "";
+    };
+  }, [
+    isLoaded,
+    map,
+    pickLayerId,
+    sourceId,
+    interactive,
+    showFill,
+    showHit,
+    pickPad,
+    hoverIsControlled
+  ]);
+  const keyboardFeatures = useMemo(
+    () => interactive && showFill ? listKeyboardFeatures(data, promoteId) : [],
+    [interactive, showFill, data, promoteId]
+  );
+  const reach = (entry) => {
+    setHoverRef.current?.(entry.id ?? null);
+    latestRef.current.onHover?.({
+      feature: entry.feature,
+      longitude: entry.longitude,
+      latitude: entry.latitude,
+      // A plan map's keyboard path is `MapPlanOverlay`'s job, so this list
+      // never has plan units to hand back.
+      plan: null,
+      originalEvent: null
+    });
+  };
+  if (keyboardFeatures.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx("div", { className: "sr-only", "data-slot": "map-geojson-keyboard-list", children: /* @__PURE__ */ jsx("ul", { children: keyboardFeatures.map((entry, index) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(
+    "button",
+    {
+      onBlur: () => {
+        setHoverRef.current?.(null);
+        latestRef.current.onHover?.(null);
+      },
+      onClick: () => latestRef.current.onClick?.({
+        feature: entry.feature,
+        longitude: entry.longitude,
+        latitude: entry.latitude,
+        plan: null,
+        originalEvent: null
+      }),
+      onFocus: () => reach(entry),
+      type: "button",
+      children: featureLabel?.(entry.feature, index) ?? entry.fallbackLabel
+    }
+  ) }, entry.key)) }) });
+}
+function geometryPositions(geometry) {
+  if (geometry.type === "GeometryCollection") {
+    return geometry.geometries.flatMap(geometryPositions);
+  }
+  if (geometry.type === "Point") {
+    return [geometry.coordinates];
+  }
+  const flatten = (value) => Array.isArray(value) && typeof value[0] === "number" ? [value] : Array.isArray(value) ? value.flatMap(flatten) : [];
+  return flatten(geometry.coordinates);
+}
+function geometryCentre(geometry) {
+  const positions = geometryPositions(geometry);
+  if (positions.length === 0) return [0, 0];
+  let west = Number.POSITIVE_INFINITY;
+  let east = Number.NEGATIVE_INFINITY;
+  let south = Number.POSITIVE_INFINITY;
+  let north = Number.NEGATIVE_INFINITY;
+  for (const [lng, lat] of positions) {
+    west = Math.min(west, lng ?? 0);
+    east = Math.max(east, lng ?? 0);
+    south = Math.min(south, lat ?? 0);
+    north = Math.max(north, lat ?? 0);
+  }
+  return [(west + east) / 2, (south + north) / 2];
+}
+function listKeyboardFeatures(data, promoteId) {
+  if (typeof data === "string") return [];
+  const features = data.type === "FeatureCollection" ? data.features : data.type === "Feature" ? [data] : [];
+  return features.map((feature, index) => {
+    const promoted = promoteId ? feature.properties?.[promoteId] : void 0;
+    const id = typeof promoted === "string" || typeof promoted === "number" ? promoted : typeof feature.id === "string" || typeof feature.id === "number" ? feature.id : void 0;
+    const [longitude, latitude] = geometryCentre(feature.geometry);
+    return {
+      key: `${id ?? index}`,
+      id,
+      feature,
+      longitude,
+      latitude,
+      fallbackLabel: `${id ?? index + 1}`
+    };
+  });
+}
+function stripeImage(color, width, gap) {
+  if (typeof document === "undefined") return null;
+  const pixelRatio = Math.max(1, Math.round(globalThis.devicePixelRatio || 1));
+  const size = Math.max(2, Math.round((width + gap) * Math.SQRT2 * pixelRatio));
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  let context = null;
+  try {
+    context = canvas.getContext("2d");
+  } catch {
+    context = null;
+  }
+  if (!context) return null;
+  context.strokeStyle = color;
+  context.lineWidth = width * pixelRatio;
+  context.lineCap = "square";
+  context.beginPath();
+  for (const k of [0, 1, 2]) {
+    context.moveTo(k * size - size, size);
+    context.lineTo(k * size, 0);
+  }
+  context.stroke();
+  return { data: context.getImageData(0, 0, size, size), pixelRatio };
+}
+
+export {
+  MapGeoJSON
+};
+//# sourceMappingURL=chunk-WS4Z7ENS.js.map