@osm-editor-kit/street-imagery-react 0.1.0-alpha.3 → 0.1.0-alpha.6

package/dist/chunk-EQ2JKLGT.js

@@ -0,0 +1,311 @@
+import { useViewerActions } from './chunk-25UGGXIE.js';
+import '@panoramax/web-viewer';
+import { getStreetImageryConfig } from '@osm-editor-kit/street-imagery';
+import { useRef, useEffectEvent, useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/panels/panoramaxLimitPanning.ts
+var toRad = (degrees) => degrees * Math.PI / 180;
+var MIN_VISIBLE_SHARE = 0.3;
+var MIN_IMAGE_SHARE_OF_VIEW = 0.8;
+var keepInView = (centre, imageMin, imageMax, halfView) => {
+  const keep = MIN_VISIBLE_SHARE * Math.min(imageMax - imageMin, 2 * halfView);
+  return Math.max(imageMin - halfView + keep, Math.min(imageMax + halfView - keep, centre));
+};
+var limitToImage = (psv, position) => {
+  const crop = psv.state.textureData?.panoData?.baseData;
+  if (!crop || !crop.fullWidth || !crop.fullHeight) {
+    return position;
+  }
+  const halfH = toRad(psv.state.hFov) / 2;
+  const halfV = toRad(psv.state.vFov) / 2;
+  let { yaw, pitch } = position;
+  if (crop.croppedWidth < crop.fullWidth) {
+    const left = crop.croppedX / crop.fullWidth * 2 * Math.PI - Math.PI;
+    const right = (crop.croppedX + crop.croppedWidth) / crop.fullWidth * 2 * Math.PI - Math.PI;
+    const centred = yaw > Math.PI ? yaw - 2 * Math.PI : yaw;
+    yaw = keepInView(centred, left, right, halfH);
+  }
+  if (crop.croppedHeight < crop.fullHeight) {
+    const top = Math.PI / 2 - crop.croppedY / crop.fullHeight * Math.PI;
+    const bottom = Math.PI / 2 - (crop.croppedY + crop.croppedHeight) / crop.fullHeight * Math.PI;
+    pitch = keepInView(pitch, bottom, top, halfV);
+  }
+  return { yaw, pitch };
+};
+var toDeg = (radians) => radians * 180 / Math.PI;
+var widestZoomLevel = (psv) => {
+  const crop = psv.state.textureData?.panoData?.baseData;
+  if (!crop || !crop.fullWidth || !crop.fullHeight) {
+    return null;
+  }
+  const flatWide = crop.croppedWidth < crop.fullWidth;
+  const flatHigh = crop.croppedHeight < crop.fullHeight;
+  if (!flatWide && !flatHigh) {
+    return null;
+  }
+  const imageV = crop.croppedHeight / crop.fullHeight * 180;
+  const imageH = crop.croppedWidth / crop.fullWidth * 360;
+  const aspect = Math.tan(toRad(psv.state.hFov) / 2) / Math.tan(toRad(psv.state.vFov) / 2);
+  const vForImageWidth = toDeg(2 * Math.atan(Math.tan(toRad(Math.min(imageH, 179)) / 2) / aspect));
+  const widestV = Math.min(flatHigh ? imageV : 180, flatWide ? vForImageWidth : 180);
+  return psv.dataHelper.fovToZoomLevel(Math.min(widestV / MIN_IMAGE_SHARE_OF_VIEW, 179));
+};
+var limitPanningToImage = (psv) => {
+  const onMove = (event) => {
+    const move = event;
+    if (move.position) {
+      move.position = limitToImage(psv, move.position);
+    }
+  };
+  const onZoomOrLoad = () => {
+    const widest = widestZoomLevel(psv);
+    if (widest != null && psv.getZoomLevel() < widest - 0.01) {
+      psv.zoom(widest);
+      return;
+    }
+    const current = psv.getPosition();
+    const limited = limitToImage(psv, current);
+    if (Math.abs(limited.yaw - current.yaw) > 1e-4 || Math.abs(limited.pitch - current.pitch) > 1e-4) {
+      psv.rotate(limited);
+    }
+  };
+  psv.addEventListener("before-rotate", onMove);
+  psv.addEventListener("before-animate", onMove);
+  psv.addEventListener("zoom-updated", onZoomOrLoad);
+  psv.addEventListener("panorama-loaded", onZoomOrLoad);
+  return () => {
+    psv.removeEventListener("before-rotate", onMove);
+    psv.removeEventListener("before-animate", onMove);
+    psv.removeEventListener("zoom-updated", onZoomOrLoad);
+    psv.removeEventListener("panorama-loaded", onZoomOrLoad);
+  };
+};
+
+// src/panels/panoramaxPhotoFromMetadata.ts
+var toMs = (iso) => {
+  const ms = iso ? Date.parse(iso) : Number.NaN;
+  return Number.isNaN(ms) ? null : ms;
+};
+var panoramaxPhotoFromMetadata = (metadata) => {
+  const properties = metadata.properties ?? {};
+  const producers = metadata.caption?.producer ?? [];
+  const creatorName = producers.find((entry) => !entry.includes("@")) ?? producers.at(-1);
+  const creatorContact = producers.find((entry) => entry.includes("@"));
+  const camera = properties["pers:interior_orientation"];
+  const cameraName = [camera?.camera_manufacturer, camera?.camera_model].filter(Boolean).join(" ");
+  const crop = metadata.panorama?.cropData;
+  const isFlat = crop?.croppedWidth != null && crop.fullWidth != null && crop.croppedWidth < crop.fullWidth;
+  const uploadedAt = toMs(properties.created);
+  const exifEntries = Object.entries(properties.exif ?? {}).filter(([, value]) => typeof value === "string" || typeof value === "number").map(([key, value]) => [key, String(value)]);
+  const exif = exifEntries.length > 0 ? Object.fromEntries(exifEntries) : null;
+  const details = {
+    ...creatorContact && creatorContact !== creatorName ? { creatorContact } : {},
+    ...properties.license ? { license: properties.license } : {},
+    ...metadata.origLinks?.find((link) => link.rel === "license")?.href ? { licenseUrl: metadata.origLinks.find((link) => link.rel === "license")?.href } : {},
+    ...properties.datetimetz ? { capturedAtLocal: properties.datetimetz } : {},
+    ...uploadedAt != null ? { uploadedAt } : {},
+    ...cameraName ? { camera: cameraName } : {},
+    ...isFlat && metadata.horizontalFov ? { fieldOfViewDeg: metadata.horizontalFov } : {},
+    ...properties["quality:horizontal_accuracy"] != null ? { positionAccuracyMeters: properties["quality:horizontal_accuracy"] } : {},
+    ...metadata.origInstance?.instance_name ? { instance: metadata.origInstance.instance_name } : {},
+    ...camera?.focal_length != null ? { focalLengthMm: camera.focal_length } : {},
+    ...properties["original_file:name"] ? { originalFileName: properties["original_file:name"] } : {},
+    ...properties["original_file:size"] != null ? { originalFileSizeBytes: properties["original_file:size"] } : {},
+    ...properties["geovisio:rank_in_collection"] != null ? { rankInSequence: properties["geovisio:rank_in_collection"] } : {},
+    ...exif ? { exif } : {}
+  };
+  return {
+    providerId: "panoramax",
+    photoId: metadata.id,
+    sequenceId: metadata.sequence?.id ?? null,
+    capturedAt: toMs(properties.datetime),
+    isPano: !isFlat,
+    heading: properties["view:azimuth"] ?? null,
+    lngLat: metadata.gps,
+    ...creatorName ? { creatorName } : {},
+    details
+  };
+};
+var panoramaxApiEndpoint = () => `${getStreetImageryConfig().panoramaxApiBase}/api`;
+var HIDE_LEGEND_CSS = "pnx-photo-viewer pnx-bottom-drawer, pnx-photo-viewer pnx-picture-legend { display: none !important; }";
+var normalizeBearing = (degrees) => (degrees % 360 + 360) % 360;
+var PanoramaxPanel = ({
+  photo,
+  onPhotoSelected,
+  onEaseMapToPoint,
+  onViewerPhoto,
+  hideLegend = false
+}) => {
+  const containerRef = useRef(null);
+  const viewerRef = useRef(null);
+  const lastViewerPhotoIdRef = useRef(null);
+  const readyRef = useRef(false);
+  const pendingSelectRef = useRef(null);
+  const photoRef = useRef(photo);
+  const bearingRafRef = useRef(null);
+  const pendingBearingRef = useRef(null);
+  const pendingHfovRef = useRef(null);
+  const actions = useViewerActions();
+  const emitViewerPhoto = useEffectEvent(
+    (viewerPhoto) => onViewerPhoto?.(viewerPhoto)
+  );
+  useEffect(
+    function syncPhotoRef() {
+      photoRef.current = photo;
+    },
+    [photo]
+  );
+  useEffect(
+    function resetViewerStoreOnProviderChange() {
+      return () => {
+        actions.reset();
+      };
+    },
+    [actions, photo.providerId]
+  );
+  useEffect(
+    function mountPanoramaxViewer() {
+      const viewer = viewerRef.current;
+      const container = containerRef.current;
+      if (!viewer || !container) {
+        return;
+      }
+      lastViewerPhotoIdRef.current = photoRef.current.photoId;
+      const flushBearing = () => {
+        bearingRafRef.current = null;
+        if (pendingBearingRef.current != null) {
+          actions.setPov({ bearing: pendingBearingRef.current });
+          pendingBearingRef.current = null;
+        }
+        if (pendingHfovRef.current != null) {
+          actions.setPov({ hfov: pendingHfovRef.current });
+          pendingHfovRef.current = null;
+        }
+      };
+      const onSelect = (event) => {
+        const { seqId, picId } = event.detail;
+        if (!picId) {
+          return;
+        }
+        lastViewerPhotoIdRef.current = picId;
+        const currentPhoto = photoRef.current;
+        const sequenceId = seqId ?? (picId === currentPhoto.photoId && currentPhoto.sequenceId ? currentPhoto.sequenceId : `photo:${picId}`);
+        onPhotoSelected({
+          provider: "panoramax",
+          sequenceId,
+          photoId: picId
+        });
+      };
+      const onPictureLoaded = (event) => {
+        const detail = event.detail;
+        const metadata = viewer.psv?.getPictureMetadata();
+        if (metadata) {
+          emitViewerPhoto(panoramaxPhotoFromMetadata(metadata));
+        }
+        if (detail.lon == null || detail.lat == null) {
+          return;
+        }
+        actions.setPov({ lngLat: [detail.lon, detail.lat] });
+        if (detail.x != null) {
+          actions.setPov({ bearing: normalizeBearing(detail.x) });
+        }
+        const psv = viewer.psv;
+        if (psv && detail.z != null) {
+          actions.setPov({ hfov: psv.dataHelper.zoomLevelToFov(detail.z) });
+        }
+        onEaseMapToPoint(detail.lon, detail.lat);
+      };
+      const onViewRotated = (event) => {
+        const detail = event.detail;
+        pendingBearingRef.current = normalizeBearing(detail.x);
+        const psv = viewer.psv;
+        if (psv && detail.z != null) {
+          pendingHfovRef.current = psv.dataHelper.zoomLevelToFov(detail.z);
+        }
+        if (bearingRafRef.current == null) {
+          bearingRafRef.current = requestAnimationFrame(flushBearing);
+        }
+      };
+      viewer.addEventListener("select", onSelect);
+      viewer.addEventListener("psv:picture-loaded", onPictureLoaded);
+      viewer.addEventListener("psv:view-rotated", onViewRotated);
+      const resizeObserver = new ResizeObserver(() => {
+        viewer.psv?.resize();
+      });
+      resizeObserver.observe(container);
+      let stopLimit = null;
+      const startLimit = () => {
+        if (!stopLimit && viewer.psv) {
+          stopLimit = limitPanningToImage(viewer.psv);
+        }
+      };
+      startLimit();
+      viewer.addEventListener("psv:picture-loaded", startLimit);
+      readyRef.current = true;
+      const pending = pendingSelectRef.current;
+      if (pending) {
+        pendingSelectRef.current = null;
+        if (typeof viewer.select === "function") {
+          viewer.select(pending.sequenceId ?? null, pending.photoId);
+        }
+      }
+      return () => {
+        readyRef.current = false;
+        if (bearingRafRef.current != null) {
+          cancelAnimationFrame(bearingRafRef.current);
+          bearingRafRef.current = null;
+        }
+        resizeObserver.disconnect();
+        viewer.removeEventListener("select", onSelect);
+        viewer.removeEventListener("psv:picture-loaded", onPictureLoaded);
+        viewer.removeEventListener("psv:view-rotated", onViewRotated);
+        viewer.removeEventListener("psv:picture-loaded", startLimit);
+        stopLimit?.();
+      };
+    },
+    [actions, onEaseMapToPoint, onPhotoSelected]
+  );
+  useEffect(
+    function syncExternalPhotoSelection() {
+      const viewer = viewerRef.current;
+      if (!viewer || photo.photoId === lastViewerPhotoIdRef.current) {
+        return;
+      }
+      actions.reset();
+      lastViewerPhotoIdRef.current = photo.photoId;
+      if (!readyRef.current) {
+        pendingSelectRef.current = { sequenceId: photo.sequenceId, photoId: photo.photoId };
+        return;
+      }
+      if (typeof viewer.select === "function") {
+        viewer.select(photo.sequenceId ?? null, photo.photoId);
+      }
+    },
+    [actions, photo.photoId, photo.sequenceId]
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: "min-h-48 overflow-hidden rounded-lg border border-slate-200 bg-slate-900",
+      style: { aspectRatio: "4 / 3" },
+      children: [
+        hideLegend ? /* @__PURE__ */ jsx("style", { children: HIDE_LEGEND_CSS }) : null,
+        /* @__PURE__ */ jsx(
+          "pnx-photo-viewer",
+          {
+            ref: viewerRef,
+            className: "block h-full w-full",
+            endpoint: panoramaxApiEndpoint(),
+            "url-parameters": "false",
+            picture: photo.photoId,
+            sequence: photo.sequenceId ?? void 0
+          }
+        )
+      ]
+    }
+  );
+};
+
+export { PanoramaxPanel };

package/dist/chunk-HA4GJWHI.js

@@ -0,0 +1,120 @@
+import { DEFAULT_STREET_IMAGERY_LOCALE, mapillaryValueName } from '@osm-editor-kit/street-imagery';
+import { createContext, use } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/i18n/messages.ts
+var en = {
+  viewer: {
+    regionLabel: "Photo viewer",
+    loading: "Loading viewer\u2026",
+    backInHistory: "Back in history ([)",
+    forwardInHistory: "Forward in history (])",
+    minimize: "Minimize",
+    close: "Close (Esc)",
+    views: "Views",
+    suggestedViews: "Suggested views",
+    suggestedViewsHint: "Suggested views: where the photo is taken from, and which way it looks",
+    noPhoto: (label) => `${label} (no photo)`,
+    noMatchingPhoto: (label) => `${label}: no matching photo`
+  },
+  unknownDate: "Unknown date",
+  viewpointRole: {
+    here: "Here",
+    "line-start": "Start",
+    "line-end": "End",
+    "into-node": "Junction",
+    custom: "View"
+  },
+  viewDirection: (role, kind) => {
+    switch (kind) {
+      case "forward":
+        return `${role}, looking along the street`;
+      case "back":
+        return `${role}, looking back along the street`;
+      case "into":
+        return `${role}, looking into the junction`;
+      default:
+        return `${role}, looking ${kind}`;
+    }
+  },
+  feature: {
+    name: (value) => mapillaryValueName(value, "en"),
+    seen: "Seen",
+    noPhotos: "Mapillary lists no photos for this feature.",
+    daysSummary: (photos, days) => `${photos} photos on ${days} days`,
+    dayPhotos: (photos, canStep) => `${photos} photo${photos === 1 ? "" : "s"}${canStep ? " \u2014 click for the next one" : ""}`
+  }
+};
+var COMPASS_DE = { N: "Norden", E: "Osten", S: "S\xFCden", W: "Westen" };
+var de = {
+  viewer: {
+    regionLabel: "Fotoansicht",
+    loading: "Ansicht wird geladen\u2026",
+    backInHistory: "Zur\xFCck im Verlauf ([)",
+    forwardInHistory: "Vor im Verlauf (])",
+    minimize: "Minimieren",
+    close: "Schlie\xDFen (Esc)",
+    views: "Blicke",
+    suggestedViews: "Vorgeschlagene Blicke",
+    suggestedViewsHint: "Vorgeschlagene Blicke: von wo das Foto aufgenommen ist und wohin es schaut",
+    noPhoto: (label) => `${label} (kein Foto)`,
+    noMatchingPhoto: (label) => `${label}: kein passendes Foto`
+  },
+  unknownDate: "Datum unbekannt",
+  viewpointRole: {
+    here: "Hier",
+    "line-start": "Anfang",
+    "line-end": "Ende",
+    "into-node": "Knoten",
+    custom: "Blick"
+  },
+  viewDirection: (role, kind) => {
+    switch (kind) {
+      case "forward":
+        return `${role}, Blick entlang der Stra\xDFe`;
+      case "back":
+        return `${role}, Blick zur\xFCck entlang der Stra\xDFe`;
+      case "into":
+        return `${role}, Blick in den Knoten`;
+      default:
+        return `${role}, Blick nach ${COMPASS_DE[kind] ?? kind}`;
+    }
+  },
+  feature: {
+    name: (value) => mapillaryValueName(value, "de"),
+    seen: "Gesehen",
+    noPhotos: "Mapillary f\xFChrt keine Fotos zu diesem Objekt.",
+    daysSummary: (photos, days) => `${photos} Fotos an ${days} Tagen`,
+    dayPhotos: (photos, canStep) => `${photos} Foto${photos === 1 ? "" : "s"}${canStep ? " \u2014 klicken f\xFCr das n\xE4chste" : ""}`
+  }
+};
+var STREET_IMAGERY_MESSAGES = {
+  en,
+  de
+};
+var DEFAULT_I18N = {
+  locale: DEFAULT_STREET_IMAGERY_LOCALE,
+  messages: STREET_IMAGERY_MESSAGES[DEFAULT_STREET_IMAGERY_LOCALE]
+};
+var I18nContext = createContext(DEFAULT_I18N);
+var mergeMessages = (base, overrides) => overrides ? {
+  unknownDate: overrides.unknownDate ?? base.unknownDate,
+  viewer: { ...base.viewer, ...overrides.viewer },
+  viewpointRole: { ...base.viewpointRole, ...overrides.viewpointRole },
+  viewDirection: overrides.viewDirection ?? base.viewDirection,
+  feature: { ...base.feature, ...overrides.feature }
+} : base;
+var StreetImageryLocaleProvider = ({
+  locale,
+  messages,
+  children
+}) => /* @__PURE__ */ jsx(
+  I18nContext,
+  {
+    value: { locale, messages: mergeMessages(STREET_IMAGERY_MESSAGES[locale], messages) },
+    children
+  }
+);
+var useStreetImageryI18n = () => use(I18nContext);
+
+export { STREET_IMAGERY_MESSAGES, StreetImageryLocaleProvider, useStreetImageryI18n };

package/dist/hooks/useAllProviderMapFeatures.d.ts

@@ -2,7 +2,3 @@ import type { DateRange } from '@osm-editor-kit/street-imagery';
 import type { Bbox, NormalizedMapFeature } from '@osm-editor-kit/street-imagery';
 import { type ProviderId } from '@osm-editor-kit/street-imagery';
 export declare const useAllProviderMapFeatures: (providerIds: ProviderId[], bbox: Bbox | null, zoom: number, date?: DateRange) => NormalizedMapFeature[];
-export declare const useAllProviderMapFeaturesLoading: (providerIds: ProviderId[], bbox: Bbox | null, zoom: number) => {
-    isLoading: boolean;
-    isFetching: boolean;
-};

package/dist/i18n/PhotoDate.d.ts

@@ -0,0 +1,16 @@
+type PhotoDateProps = {
+    /** Capture time (ms); `null` shows "Unknown date". */
+    timestamp: number | null | undefined;
+    className?: string;
+    /**
+     * Capture time with the camera's UTC offset (`2025-03-08T15:40:35+01:00`). The tooltip then
+     * shows date and time as the camera's clock had it, instead of the date alone.
+     */
+    localDateTime?: string;
+};
+/**
+ * A date as month and year ("Aug 2026"). The tooltip has the full date and, on a second line,
+ * how long ago that is.
+ */
+export declare const PhotoDate: ({ timestamp, className, localDateTime }: PhotoDateProps) => import("react").JSX.Element;
+export {};

package/dist/i18n/StreetImageryLocaleProvider.d.ts

@@ -0,0 +1,21 @@
+import { type StreetImageryLocale } from '@osm-editor-kit/street-imagery';
+import { type ReactNode } from 'react';
+import { type StreetImageryMessages } from './messages';
+type StreetImageryI18n = {
+    locale: StreetImageryLocale;
+    messages: StreetImageryMessages;
+};
+/** Overrides per group, e.g. `{ feature: { name: germanSignName } }`. */
+export type StreetImageryMessageOverrides = {
+    [Group in keyof StreetImageryMessages]?: StreetImageryMessages[Group] extends object ? StreetImageryMessages[Group] extends (...args: never[]) => unknown ? StreetImageryMessages[Group] : Partial<StreetImageryMessages[Group]> : StreetImageryMessages[Group];
+};
+type StreetImageryLocaleProviderProps = {
+    /** Language of the package's texts and date formats. Without a provider: English. */
+    locale: StreetImageryLocale;
+    messages?: StreetImageryMessageOverrides;
+    children: ReactNode;
+};
+export declare const StreetImageryLocaleProvider: ({ locale, messages, children, }: StreetImageryLocaleProviderProps) => import("react").JSX.Element;
+/** Locale and texts of the nearest `StreetImageryLocaleProvider`. */
+export declare const useStreetImageryI18n: () => StreetImageryI18n;
+export {};

package/dist/i18n/messages.d.ts

@@ -0,0 +1,35 @@
+import { type StreetImageryLocale, type ViewDirection, type ViewpointRole } from '@osm-editor-kit/street-imagery';
+/**
+ * Every text the package's components show. Texts with values are plain functions, so a host app
+ * can override single entries from a constant or from its own i18n library.
+ */
+export type StreetImageryMessages = {
+    viewer: {
+        regionLabel: string;
+        loading: string;
+        backInHistory: string;
+        forwardInHistory: string;
+        minimize: string;
+        close: string;
+        views: string;
+        suggestedViews: string;
+        suggestedViewsHint: string;
+        noPhoto: (label: string) => string;
+        noMatchingPhoto: (label: string) => string;
+    };
+    viewpointRole: Record<ViewpointRole, string>;
+    unknownDate: string;
+    /** e.g. "Start, looking along the street"; `role` is the viewpoint's label. */
+    viewDirection: (role: string, kind: ViewDirection['kind']) => string;
+    feature: {
+        /** Name of a Mapillary value like `regulatory--turn-right-ahead--g1`. */
+        name: (value: string) => string;
+        /** Line below the name; `first` and `last` are the rendered dates. */
+        seen: string;
+        noPhotos: string;
+        daysSummary: (photos: number, days: number) => string;
+        /** Third tooltip line of a day button, below date and age. */
+        dayPhotos: (photos: number, canStep: boolean) => string;
+    };
+};
+export declare const STREET_IMAGERY_MESSAGES: Record<StreetImageryLocale, StreetImageryMessages>;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { StreetLevelImagerySelectionOverlay, resolveSelectedSequence, } from './StreetLevelImagerySelectionOverlay';
+export { BASE_COLOR, SELECTION_COLOR, StreetLevelImagerySelectionOverlay, resolveSelectedSequence, } from './StreetLevelImagerySelectionOverlay';
 export { StreetLevelImagerySourcesAndLayers, type PhotoFilter, } from './StreetLevelImagerySourcesAndLayers';
-export { StreetLevelImageryViewCone } from './StreetLevelImageryViewCone';
+export { StreetLevelImageryViewCone, VIEW_SHAPE_FILL_OPACITY } from './StreetLevelImageryViewCone';
 export { StreetLevelImageryViewer } from './StreetLevelImageryViewer';
 export type { StreetImageryPhotoSelection } from './types';
 export { queryStreetImageryFeatures, streetImageryInteractiveLayerIds, type StreetImageryClickFeature, } from './streetImageryClick';
@@ -12,3 +12,16 @@ export * from './hooks/usePhotoThumbnails';
 export { MapillaryPanel } from './panels/MapillaryPanel';
 export { PanoramaxPanel } from './panels/PanoramaxPanel';
 export * from './useViewerStore';
+export { FloatingPhotoViewer, FloatingViewerInfoButton, type FloatingPhotoViewerProps, } from './viewpoints/FloatingPhotoViewer';
+export { VIEWPOINT_DEFAULT_COLOR, VIEWPOINT_DIRECTION_LAYER_ID, ViewpointLayer, viewDirectionKeyFromFeatures, type ViewpointLayerProps, } from './viewpoints/ViewpointLayer';
+export { viewSuggestionLabel } from './viewpoints/viewDirectionLabels';
+export * from './viewpoints/useViewpointSessionStore';
+export * from './viewpoints/useViewSuggestions';
+export { mapillaryViewFor, setMapillaryViewerOutlines, turnMapillaryViewerTo, type MapillaryLookAt, type MapillaryViewerOutline, } from './panels/mapillaryLookAt';
+export * from './mapillary/useMapillaryFeatures';
+export { LocationPickOnMap, type LocationPickOnMapProps } from './openers/LocationPickOnMap';
+export * from './openers/useLocationPickStore';
+export { MapillaryFeatureBar, type MapillaryFeatureBarProps } from './mapillary/MapillaryFeatureBar';
+export { STREET_IMAGERY_MESSAGES, type StreetImageryMessages } from './i18n/messages';
+export { StreetImageryLocaleProvider, useStreetImageryI18n, type StreetImageryMessageOverrides, } from './i18n/StreetImageryLocaleProvider';
+export { PhotoDate } from './i18n/PhotoDate';