@canopy-iiif/app 1.3.5 → 1.4.0

package/ui/dist/index.mjs

@@ -2692,6 +2692,656 @@ function TimelinePoint() {
   return null;
 }
 TimelinePoint.displayName = "TimelinePoint";
+
+// ui/src/content/map/Map.jsx
+import React34 from "react";
+var DEFAULT_TILE_LAYERS = [
+  {
+    name: "OpenStreetMap",
+    url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+    attribution: "© OpenStreetMap contributors",
+    maxZoom: 19
+  }
+];
+function resolveGlobalLeaflet() {
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.L) return globalThis.L;
+  } catch (_) {
+  }
+  try {
+    if (typeof window !== "undefined" && window.L) return window.L;
+  } catch (_) {
+  }
+  return null;
+}
+function waitForLeaflet(timeoutMs = 5e3) {
+  const existing = resolveGlobalLeaflet();
+  if (existing) return Promise.resolve(existing);
+  let timer = null;
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    const onReady = () => {
+      const resolved = resolveGlobalLeaflet();
+      if (resolved) {
+        cleanup();
+        resolve(resolved);
+      }
+    };
+    const poll = () => {
+      const resolved = resolveGlobalLeaflet();
+      if (resolved) {
+        cleanup();
+        resolve(resolved);
+        return;
+      }
+      if (Date.now() > deadline) {
+        cleanup();
+        reject(new Error("Leaflet runtime not available"));
+        return;
+      }
+      timer = setTimeout(poll, 50);
+    };
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (typeof document !== "undefined") {
+        document.removeEventListener("canopy:leaflet-ready", onReady);
+      }
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("canopy:leaflet-ready", onReady);
+    }
+    poll();
+  });
+}
+function readBasePath2() {
+  const normalize = (val) => {
+    if (!val) return "";
+    const raw = String(val).trim();
+    if (!raw) return "";
+    const withLead = raw.startsWith("/") ? raw : `/${raw}`;
+    return withLead.replace(/\/+$/, "");
+  };
+  try {
+    if (typeof window !== "undefined" && window.CANOPY_BASE_PATH != null) {
+      const fromWindow = normalize(window.CANOPY_BASE_PATH);
+      if (fromWindow) return fromWindow;
+    }
+  } catch (_) {
+  }
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.CANOPY_BASE_PATH != null) {
+      const fromGlobal = normalize(globalThis.CANOPY_BASE_PATH);
+      if (fromGlobal) return fromGlobal;
+    }
+  } catch (_) {
+  }
+  try {
+    if (typeof process !== "undefined" && process.env && process.env.CANOPY_BASE_PATH) {
+      const fromEnv = normalize(process.env.CANOPY_BASE_PATH);
+      if (fromEnv) return fromEnv;
+    }
+  } catch (_) {
+  }
+  return "";
+}
+function withBasePath(href) {
+  try {
+    const raw = typeof href === "string" ? href.trim() : "";
+    if (!raw) return raw;
+    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(raw)) return raw;
+    if (!raw.startsWith("/")) return raw;
+    const base = readBasePath2();
+    if (!base || base === "/") return raw;
+    if (raw === base || raw.startsWith(`${base}/`)) return raw;
+    return `${base}${raw}`;
+  } catch (_) {
+    return href;
+  }
+}
+function normalizeKey(value) {
+  if (!value && value !== 0) return "";
+  try {
+    const str = String(value).trim();
+    if (!str) return "";
+    return str.replace(/\.html?$/i, "").replace(/\/+$/, "").toLowerCase();
+  } catch (_) {
+    return "";
+  }
+}
+function createMarkerMap() {
+  try {
+    if (typeof globalThis !== "undefined" && typeof globalThis.Map === "function") {
+      return new globalThis.Map();
+    }
+  } catch (_) {
+  }
+  try {
+    if (typeof window !== "undefined" && typeof window.Map === "function") {
+      return new window.Map();
+    }
+  } catch (_) {
+  }
+  const store = /* @__PURE__ */ Object.create(null);
+  return {
+    has(key) {
+      return Object.prototype.hasOwnProperty.call(store, key);
+    },
+    get(key) {
+      return store[key];
+    },
+    set(key, value) {
+      store[key] = value;
+      return this;
+    }
+  };
+}
+function readIiifType(resource) {
+  if (!resource) return "";
+  const raw = resource.type || resource["@type"];
+  const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  const normalized = list.map((entry) => {
+    try {
+      return String(entry).toLowerCase();
+    } catch (_) {
+      return "";
+    }
+  }).filter(Boolean);
+  if (normalized.some((value) => value.includes("manifest"))) return "manifest";
+  if (normalized.some((value) => value.includes("collection"))) return "collection";
+  return "";
+}
+function extractCollectionEntries(resource) {
+  if (!resource || typeof resource !== "object") return [];
+  const chunks = [];
+  if (Array.isArray(resource.items)) chunks.push(resource.items);
+  if (Array.isArray(resource.manifests)) chunks.push(resource.manifests);
+  if (Array.isArray(resource.members)) chunks.push(resource.members);
+  return chunks.flat();
+}
+function extractManifestKeysFromIiif(resource, fallback) {
+  const fallbackKey = normalizeKey(fallback);
+  if (!resource) return fallbackKey ? [fallbackKey] : [];
+  const type = readIiifType(resource);
+  if (type === "manifest") {
+    const id = resource.id || resource["@id"] || fallback;
+    const key = normalizeKey(id);
+    return key ? [key] : fallbackKey ? [fallbackKey] : [];
+  }
+  if (type === "collection") {
+    const seen = /* @__PURE__ */ new Set();
+    const keys = [];
+    const queue = extractCollectionEntries(resource).slice();
+    while (queue.length) {
+      const entry = queue.shift();
+      if (!entry || typeof entry !== "object") continue;
+      const entryType = readIiifType(entry);
+      if (entryType === "manifest") {
+        const manifestId = entry.id || entry["@id"];
+        const key = normalizeKey(manifestId);
+        if (key && !seen.has(key)) {
+          seen.add(key);
+          keys.push(key);
+        }
+      } else if (entryType === "collection") {
+        queue.push(...extractCollectionEntries(entry));
+      }
+    }
+    if (keys.length) return keys;
+  }
+  return fallbackKey ? [fallbackKey] : [];
+}
+function buildTileLayers(inputLayers, leaflet) {
+  if (!leaflet) return [];
+  const layers = Array.isArray(inputLayers) && inputLayers.length ? inputLayers : DEFAULT_TILE_LAYERS;
+  return layers.map((entry) => {
+    if (!entry || !entry.url) return null;
+    const options = {};
+    if (entry.attribution) options.attribution = entry.attribution;
+    if (typeof entry.maxZoom === "number") options.maxZoom = entry.maxZoom;
+    if (typeof entry.minZoom === "number") options.minZoom = entry.minZoom;
+    if (entry.subdomains) options.subdomains = entry.subdomains;
+    return {
+      name: entry.name || entry.title || "Layer",
+      layer: leaflet.tileLayer(entry.url, options)
+    };
+  }).filter(Boolean);
+}
+function buildMarkerIcon(marker, leaflet) {
+  if (!leaflet) return null;
+  const hasThumbnail = Boolean(marker && marker.thumbnail);
+  const size = 56;
+  const anchor = size / 2;
+  const html = hasThumbnail ? `<div class="canopy-map__marker-thumb"><img src="${escapeHtml(
+    marker.thumbnail
+  )}" alt="" loading="lazy" /></div>` : '<span class="canopy-map__marker-solid"></span>';
+  try {
+    return leaflet.divIcon({
+      className: "canopy-map__marker",
+      iconSize: [size, size],
+      iconAnchor: [anchor, anchor],
+      popupAnchor: [0, -anchor + 10],
+      html
+    });
+  } catch (_) {
+    return null;
+  }
+}
+function buildClusterOptions(leaflet) {
+  if (!leaflet) return null;
+  const size = 56;
+  const anchor = size / 2;
+  return {
+    chunkedLoading: true,
+    iconCreateFunction: (cluster) => {
+      const count = cluster && typeof cluster.getChildCount === "function" ? cluster.getChildCount() : 0;
+      return leaflet.divIcon({
+        html: `<div class="canopy-map__cluster">${count}</div>`,
+        className: "canopy-map__cluster-wrapper",
+        iconSize: [size, size],
+        iconAnchor: [anchor, anchor]
+      });
+    }
+  };
+}
+function escapeHtml(value) {
+  if (value == null) return "";
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderPopup(marker) {
+  if (!marker) return "";
+  const title = marker.title || marker.manifestTitle || "";
+  const summary = marker.summary || marker.manifestSummary || "";
+  const href = marker.href ? withBasePath(marker.href) : "";
+  const thumbnail = marker.thumbnail || "";
+  const thumbWidth = marker.thumbnailWidth;
+  const thumbHeight = marker.thumbnailHeight;
+  const chunks = ['<div class="canopy-map__popup">'];
+  if (thumbnail) {
+    const sizeAttrs = [];
+    if (typeof thumbWidth === "number" && thumbWidth > 0) sizeAttrs.push(`width="${thumbWidth}"`);
+    if (typeof thumbHeight === "number" && thumbHeight > 0) sizeAttrs.push(`height="${thumbHeight}"`);
+    chunks.push(
+      `<div class="canopy-map__popup-media"><img src="${escapeHtml(thumbnail)}" alt="" loading="lazy" ${sizeAttrs.join(" ")} /></div>`
+    );
+  }
+  chunks.push('<div class="canopy-map__popup-body">');
+  if (title) {
+    const heading = href ? `<a href="${escapeHtml(href)}" class="canopy-map__popup-title">${escapeHtml(title)}</a>` : `<span class="canopy-map__popup-title">${escapeHtml(title)}</span>`;
+    chunks.push(heading);
+  }
+  if (summary) chunks.push(`<p class="canopy-map__popup-summary">${escapeHtml(summary)}</p>`);
+  if (marker.detailsHtml) chunks.push(`<div class="canopy-map__popup-details">${marker.detailsHtml}</div>`);
+  if (!summary && !marker.detailsHtml && href && !title) {
+    chunks.push(`<a href="${escapeHtml(href)}" class="canopy-map__popup-link">View item</a>`);
+  }
+  chunks.push("</div></div>");
+  return chunks.join("");
+}
+function normalizeCustomMarkers(points) {
+  if (!Array.isArray(points)) return [];
+  return points.map((point) => {
+    if (!point) return null;
+    const lat = Number(point.lat);
+    const lng = Number(point.lng);
+    if (!Number.isFinite(lat) || !Number.isFinite(lng)) return null;
+    return {
+      id: point.id || `${lat}-${lng}`,
+      lat,
+      lng,
+      title: point.title || point.label || "",
+      summary: point.summary || "",
+      detailsHtml: point.detailsHtml || "",
+      href: point.href || "",
+      thumbnail: point.thumbnail || "",
+      thumbnailWidth: point.thumbnailWidth,
+      thumbnailHeight: point.thumbnailHeight,
+      type: "custom"
+    };
+  }).filter(Boolean);
+}
+function extractNavMarkers(data, allowedKeys) {
+  if (!data || !Array.isArray(data.manifests)) return [];
+  const keys = allowedKeys instanceof Set ? allowedKeys : /* @__PURE__ */ new Set();
+  if (!keys.size) return [];
+  const markers = [];
+  data.manifests.forEach((entry) => {
+    if (!entry || !Array.isArray(entry.features)) return;
+    const manifestKeys = new Set([
+      normalizeKey(entry.id),
+      normalizeKey(entry.href),
+      normalizeKey(entry.slug)
+    ].filter(Boolean));
+    const hasMatch = Array.from(manifestKeys).some((key) => keys.has(key));
+    if (!hasMatch) return;
+    const matchKeys = Array.from(manifestKeys);
+    entry.features.forEach((feature, index) => {
+      if (!feature) return;
+      const lat = Number(feature.lat);
+      const lng = Number(feature.lng);
+      if (!Number.isFinite(lat) || !Number.isFinite(lng)) return;
+      const id = feature.id || `${entry.id || entry.slug || "feature"}-${index}`;
+      markers.push({
+        id,
+        lat,
+        lng,
+        title: feature.label || entry.title || "",
+        summary: feature.summary || entry.summary || "",
+        href: entry.href || "",
+        thumbnail: entry.thumbnail || "",
+        thumbnailWidth: entry.thumbnailWidth,
+        thumbnailHeight: entry.thumbnailHeight,
+        manifestTitle: entry.title || "",
+        manifestSummary: entry.summary || "",
+        type: "navPlace",
+        matchKeys
+      });
+    });
+  });
+  return markers;
+}
+function normalizeCenterInput(value) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!value) return null;
+  if (typeof value === "string") {
+    const parts = value.split(/[,\s]+/).filter(Boolean);
+    if (parts.length >= 2) {
+      const lat = Number(parts[0]);
+      const lng = Number(parts[1]);
+      if (Number.isFinite(lat) && Number.isFinite(lng)) return { lat, lng };
+    }
+    return null;
+  }
+  if (typeof value === "object") {
+    const lat = Number((_b = (_a = value.lat) != null ? _a : value.latitude) != null ? _b : value.y);
+    const lng = Number((_f = (_e = (_d = (_c = value.lng) != null ? _c : value.lon) != null ? _d : value.long) != null ? _e : value.longitude) != null ? _f : value.x);
+    if (Number.isFinite(lat) && Number.isFinite(lng)) return { lat, lng };
+  }
+  return null;
+}
+function Map2({
+  className = "",
+  id = null,
+  style = null,
+  height = "600px",
+  tileLayers = [],
+  scrollWheelZoom = false,
+  cluster = true,
+  customPoints = [],
+  navDataset = null,
+  iiifContent = null,
+  defaultCenter = null,
+  defaultZoom = null
+} = {}) {
+  const containerRef = React34.useRef(null);
+  const mapRef = React34.useRef(null);
+  const layerRef = React34.useRef(null);
+  const [leafletLib, setLeafletLib] = React34.useState(() => resolveGlobalLeaflet());
+  const [leafletError, setLeafletError] = React34.useState(null);
+  const datasetInfo = navDataset && typeof navDataset === "object" ? navDataset : null;
+  const datasetHref = datasetInfo && datasetInfo.href || "/api/navplace.json";
+  const datasetVersion = datasetInfo && datasetInfo.version;
+  const datasetHasFeatures = !!(datasetInfo && datasetInfo.hasFeatures);
+  const [navState, setNavState] = React34.useState(() => ({
+    loading: false,
+    error: null,
+    markers: []
+  }));
+  const [iiifTargets, setIiifTargets] = React34.useState(() => ({
+    loading: false,
+    error: null,
+    keys: []
+  }));
+  React34.useEffect(() => {
+    if (!iiifContent) {
+      setIiifTargets({ loading: false, error: null, keys: [] });
+      return;
+    }
+    if (typeof iiifContent === "object") {
+      const keys = extractManifestKeysFromIiif(iiifContent, "");
+      setIiifTargets({
+        loading: false,
+        error: keys.length ? null : "No IIIF manifests were found for this resource.",
+        keys
+      });
+      return;
+    }
+    const target = String(iiifContent || "").trim();
+    if (!target) {
+      setIiifTargets({ loading: false, error: null, keys: [] });
+      return;
+    }
+    let cancelled = false;
+    setIiifTargets({ loading: true, error: null, keys: [] });
+    const iiifUrl = withBasePath(target);
+    fetch(iiifUrl).then((res) => {
+      if (!res.ok) throw new Error(`Failed to load IIIF content (${res.status})`);
+      return res.json();
+    }).then((json) => {
+      if (cancelled) return;
+      const keys = extractManifestKeysFromIiif(json, target);
+      setIiifTargets({
+        loading: false,
+        error: keys.length ? null : "No IIIF manifests were found for this resource.",
+        keys
+      });
+    }).catch((error) => {
+      if (cancelled) return;
+      setIiifTargets({
+        loading: false,
+        error: error && error.message ? error.message : "Failed to load IIIF content",
+        keys: []
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [iiifContent]);
+  const navTargets = iiifTargets.keys || [];
+  const navTargetsKey = navTargets.join("|");
+  const shouldFetchNav = datasetHasFeatures && navTargets.length > 0;
+  React34.useEffect(() => {
+    if (!shouldFetchNav) {
+      setNavState({ loading: false, error: null, markers: [] });
+      return void 0;
+    }
+    let cancelled = false;
+    setNavState({ loading: true, error: null, markers: [] });
+    const url = (() => {
+      const base = withBasePath(datasetHref);
+      if (!datasetVersion) return base;
+      const joiner = base.includes("?") ? "&" : "?";
+      return `${base}${joiner}v=${encodeURIComponent(datasetVersion)}`;
+    })();
+    fetch(url).then((res) => {
+      if (!res.ok) throw new Error(`Failed to load map data (${res.status})`);
+      return res.json();
+    }).then((json) => {
+      if (cancelled) return;
+      const markers = extractNavMarkers(json, new Set(navTargets));
+      setNavState({ loading: false, error: null, markers });
+    }).catch((error) => {
+      if (cancelled) return;
+      setNavState({
+        loading: false,
+        error: error && error.message ? error.message : "Failed to load map data",
+        markers: []
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [datasetHref, datasetVersion, navTargetsKey, shouldFetchNav]);
+  React34.useEffect(() => {
+    if (leafletLib) return;
+    let cancelled = false;
+    waitForLeaflet().then((lib) => {
+      if (!cancelled) setLeafletLib(lib);
+    }).catch((error) => {
+      if (!cancelled) setLeafletError(error);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [leafletLib]);
+  const navMatchMap = React34.useMemo(() => {
+    const matchMap = createMarkerMap();
+    (navState.markers || []).forEach((marker) => {
+      if (!marker || !Array.isArray(marker.matchKeys)) return;
+      marker.matchKeys.forEach((key) => {
+        if (!key || matchMap.has(key)) return;
+        matchMap.set(key, marker);
+      });
+    });
+    return matchMap;
+  }, [navState.markers]);
+  const normalizedCustom = React34.useMemo(() => {
+    return normalizeCustomMarkers(customPoints).map((point) => {
+      if (!point || point.thumbnail || !point.href) return point;
+      const match = navMatchMap.get(normalizeKey(point.href));
+      if (!match || !match.thumbnail) return point;
+      return {
+        ...point,
+        thumbnail: match.thumbnail,
+        thumbnailWidth: match.thumbnailWidth || point.thumbnailWidth,
+        thumbnailHeight: match.thumbnailHeight || point.thumbnailHeight,
+        manifestTitle: match.manifestTitle || point.manifestTitle,
+        manifestSummary: match.manifestSummary || point.manifestSummary
+      };
+    });
+  }, [customPoints, navMatchMap]);
+  const allMarkers = React34.useMemo(() => {
+    return [...navState.markers || [], ...normalizedCustom];
+  }, [navState.markers, normalizedCustom]);
+  const clusterOptions = React34.useMemo(() => buildClusterOptions(leafletLib), [leafletLib]);
+  React34.useEffect(() => {
+    if (!containerRef.current || mapRef.current || !leafletLib) return void 0;
+    const map = leafletLib.map(containerRef.current, {
+      zoomControl: true,
+      scrollWheelZoom: scrollWheelZoom === true
+    });
+    mapRef.current = map;
+    const layers = buildTileLayers(tileLayers, leafletLib);
+    const layerControlEntries = {};
+    layers.forEach((entry, index) => {
+      try {
+        if (index === 0) entry.layer.addTo(map);
+        layerControlEntries[entry.name || `Layer ${index + 1}`] = entry.layer;
+      } catch (_) {
+      }
+    });
+    if (Object.keys(layerControlEntries).length > 1) {
+      leafletLib.control.layers(layerControlEntries, {}).addTo(map);
+    }
+    const supportsClusters = typeof leafletLib.markerClusterGroup === "function";
+    const layerGroup = cluster !== false && supportsClusters ? leafletLib.markerClusterGroup(clusterOptions || { chunkedLoading: true }) : leafletLib.layerGroup();
+    layerGroup.addTo(map);
+    layerRef.current = layerGroup;
+    setTimeout(() => {
+      try {
+        map.invalidateSize();
+      } catch (_) {
+      }
+    }, 0);
+    return () => {
+      try {
+        map.remove();
+      } catch (_) {
+      }
+      mapRef.current = null;
+      layerRef.current = null;
+    };
+  }, [tileLayers, scrollWheelZoom, cluster, clusterOptions, leafletLib]);
+  React34.useEffect(() => {
+    const map = mapRef.current;
+    const layer = layerRef.current;
+    if (!map || !layer || !leafletLib) return;
+    try {
+      layer.clearLayers();
+    } catch (_) {
+    }
+    const bounds = [];
+    allMarkers.forEach((marker) => {
+      if (!marker || !Number.isFinite(marker.lat) || !Number.isFinite(marker.lng)) return;
+      const latlng = leafletLib.latLng(marker.lat, marker.lng);
+      bounds.push(latlng);
+      const icon = buildMarkerIcon(marker, leafletLib);
+      const leafletMarker = leafletLib.marker(latlng, icon ? { icon } : void 0);
+      const popup = renderPopup(marker);
+      if (popup) {
+        try {
+          leafletMarker.bindPopup(popup);
+        } catch (_) {
+        }
+      }
+      try {
+        layer.addLayer(leafletMarker);
+      } catch (_) {
+      }
+    });
+    const centerOverride = normalizeCenterInput(defaultCenter);
+    const hasDefaultZoom = Number.isFinite(defaultZoom);
+    if (hasDefaultZoom) {
+      let targetCenter = centerOverride;
+      if (!targetCenter && bounds.length) {
+        try {
+          const mapBounds = leafletLib.latLngBounds(bounds);
+          const center = mapBounds.getCenter();
+          targetCenter = { lat: center.lat, lng: center.lng };
+        } catch (_) {
+        }
+      }
+      try {
+        if (targetCenter) {
+          map.setView([targetCenter.lat, targetCenter.lng], defaultZoom);
+        } else {
+          map.setZoom(defaultZoom);
+        }
+      } catch (_) {
+      }
+      return;
+    }
+    if (bounds.length) {
+      try {
+        const mapBounds = leafletLib.latLngBounds(bounds);
+        map.fitBounds(mapBounds, { padding: [32, 32] });
+      } catch (_) {
+      }
+      return;
+    }
+    if (centerOverride) {
+      try {
+        map.setView([centerOverride.lat, centerOverride.lng], 2);
+      } catch (_) {
+      }
+    }
+  }, [allMarkers, defaultCenter, defaultZoom, leafletLib]);
+  const isLoadingMarkers = iiifTargets.loading || navState.loading;
+  const hasMarkers = allMarkers.length > 0;
+  const hasCustomPoints = normalizedCustom.length > 0;
+  const datasetUnavailable = navTargets.length > 0 && !datasetHasFeatures;
+  const rootClass = [
+    "canopy-map",
+    className,
+    isLoadingMarkers ? "canopy-map--loading" : null,
+    iiifTargets.error || navState.error || datasetUnavailable ? "canopy-map--error" : null
+  ].filter(Boolean).join(" ");
+  const statusLabel = leafletError ? leafletError.message || "Failed to load map library" : !leafletLib ? "Loading map\u2026" : iiifTargets.error ? iiifTargets.error : datasetUnavailable ? "Map data is unavailable for this site." : navState.error ? navState.error : isLoadingMarkers ? "Loading map data\u2026" : !iiifContent && !hasCustomPoints ? "Add iiifContent or MapPoint markers to populate this map." : !hasMarkers ? "No map locations available." : "";
+  const showStatus = Boolean(statusLabel);
+  return /* @__PURE__ */ React34.createElement("div", { className: rootClass, id: id || void 0, style: style || void 0 }, /* @__PURE__ */ React34.createElement(
+    "div",
+    {
+      ref: containerRef,
+      className: "canopy-map__canvas",
+      style: { height: height || "600px" }
+    }
+  ), showStatus ? /* @__PURE__ */ React34.createElement("div", { className: "canopy-map__status", "aria-live": "polite" }, statusLabel) : null);
+}
+
+// ui/src/content/map/MapPoint.jsx
+function MapPoint() {
+  return null;
+}
+MapPoint.displayName = "MapPoint";
 export {
   ArticleCard,
   Button,
@@ -2709,6 +3359,8 @@ export {
   GridItem,
   HelloWorld,
   Image,
+  Map2 as Map,
+  MapPoint,
   MdxRelatedItems as RelatedItems,
   Scroll,
   MdxSearch as Search,