import React, { useEffect, useMemo, useRef, useState } from 'react' import { Marker, Tooltip, useMap } from 'react-leaflet' import L from 'leaflet' import { useTranslation } from '../../i18n/TranslationContext' import { useStableVias } from './viaMarkerState' import { useLngFrame } from './lngFrameContext' import { frameLng } from '../../utils/lngFrame' import { onRealWorld } from '../../utils/worldCopy' import type { RoadtripVia } from '@trek/shared' /** * The handles that shape a drive. * * A via is deliberately small and unnumbered: it is not a stop, and anything that looks * like one would read as a place on the itinerary. Dragging it redraws the route through * the new spot, which is the whole interaction — the same one a paper map gets when you * put a finger on the road you actually want to take. */ const VIA_ICON = L.divIcon({ className: '', html: ``, iconSize: [12, 12], iconAnchor: [6, 6], }) interface RoadtripViaMarkersProps { viasByDay: Record onMoveVia?: (dayId: number, id: number, lat: number, lng: number) => void onRemoveVia?: (dayId: number, id: number) => void } /** Leaflet's half; the GL renderers draw their own inside `MapViewGL`. */ /** Below this the handles are not drawn. Shared with the GL renderer's own copy. */ const VIA_MIN_ZOOM = 9 export default function RoadtripViaMarkers({ viasByDay, onMoveVia, onRemoveVia, }: RoadtripViaMarkersProps): React.ReactElement | null { const { t } = useTranslation() const vias = useStableVias(viasByDay) // Read through a ref so the handlers below can stay the same objects across renders. // Both callbacks are rebuilt on every render of the planner, and react-leaflet compares // its props by identity: a fresh `eventHandlers` unbinds and rebinds every listener, // and a fresh `position` array calls `setLatLng` on every marker. Doing either while a // drag is in flight is how a freshly placed via lost its first drag. const handlersRef = useRef({ onMoveVia, onRemoveVia }) handlersRef.current = { onMoveVia, onRemoveVia } const draggable = !!onMoveVia /** * Zoomed out, the handles go away. * * A via is a handle for a few hundred metres of road, and at a continental zoom a whole * day's worth collapses into a cluster of dots over one town — not something anybody can * aim at, and a drag there moves the route by kilometres per pixel. Below this the drive * is read, not shaped. */ const map = useMap() const [zoomedIn, setZoomedIn] = useState(() => map.getZoom() >= VIA_MIN_ZOOM) useEffect(() => { const update = () => setZoomedIn(map.getZoom() >= VIA_MIN_ZOOM) update() map.on('zoomend', update) return () => { map.off('zoomend', update) } }, [map]) const frame = useLngFrame() const markers = useMemo(() => vias.map(via => ({ via, position: [via.lat, frameLng(frame, via.lng)] as [number, number], handlers: { dragend: (e: { target: { getLatLng: () => { lat: number; lng: number } } }) => { // Saved on the real world, whichever copy of it the handle was dragged on (#2976). const at = onRealWorld(e.target.getLatLng()) handlersRef.current.onMoveVia?.(via.day_id, via.id, at.lat, at.lng) }, // Right-click rather than a delete handle: a 12px dot has no room for one, // and the same gesture removes things elsewhere on the map. contextmenu: (e: { originalEvent: MouseEvent }) => { e.originalEvent.preventDefault() handlersRef.current.onRemoveVia?.(via.day_id, via.id) }, }, })), [vias, frame]) if (!markers.length || !zoomedIn) return null return ( <> {markers.map(({ via, position, handlers }) => ( {t('roadtrip.via.hint')} ))} ) }