diff --git a/client/src/components/Journey/JourneyMap.test.tsx b/client/src/components/Journey/JourneyMap.test.tsx index 3e56ba393..26f645133 100644 --- a/client/src/components/Journey/JourneyMap.test.tsx +++ b/client/src/components/Journey/JourneyMap.test.tsx @@ -1,4 +1,4 @@ -// FE-COMP-JOURNEYMAP-001 to FE-COMP-JOURNEYMAP-055 +// FE-COMP-JOURNEYMAP-001 to FE-COMP-JOURNEYMAP-057 vi.mock('../../api/websocket', () => ({ connect: vi.fn(), @@ -50,7 +50,7 @@ vi.mock('leaflet', () => { map: vi.fn(() => mockMap), tileLayer: vi.fn(() => ({ addTo: vi.fn(), setUrl: vi.fn() })), marker: vi.fn(() => mockMarker), - polyline: vi.fn(() => { const line: any = { addTo: vi.fn(() => line), bindTooltip: vi.fn(() => line) }; return line }), + polyline: vi.fn(() => { const line: any = { addTo: vi.fn(() => line), bindTooltip: vi.fn(() => line), remove: vi.fn() }; return line }), divIcon: vi.fn(() => ({})), latLngBounds: vi.fn(() => ({})), layerGroup: vi.fn(() => ({ addLayer: vi.fn(), addTo: vi.fn(), remove: vi.fn() })), @@ -61,7 +61,7 @@ vi.mock('leaflet', () => { map: vi.fn(() => mockMap), tileLayer: vi.fn(() => ({ addTo: vi.fn(), setUrl: vi.fn() })), marker: vi.fn(() => mockMarker), - polyline: vi.fn(() => { const line: any = { addTo: vi.fn(() => line), bindTooltip: vi.fn(() => line) }; return line }), + polyline: vi.fn(() => { const line: any = { addTo: vi.fn(() => line), bindTooltip: vi.fn(() => line), remove: vi.fn() }; return line }), divIcon: vi.fn(() => ({})), latLngBounds: vi.fn(() => ({})), control: { attribution: vi.fn(() => ({ addTo: vi.fn() })) }, @@ -930,6 +930,49 @@ describe('JourneyMap', () => { map.latLngToContainerPoint.mockImplementation(() => ({ x: 0, y: 0 })); } }); + + describe('the line between the entries on recorded days (#2888)', () => { + const days = [ + { id: 'a', lat: 48.1, lng: 11.5, title: 'A', mood: null, entry_date: '2026-10-29' }, + { id: 'b', lat: 48.2, lng: 11.6, title: 'B', mood: null, entry_date: '2026-10-29' }, + { id: 'c', lat: 48.3, lng: 11.7, title: 'C', mood: null, entry_date: '2026-10-30' }, + ]; + const tracks = [ + { place_id: -1, trip_id: 0, name: '2026-10-29', color: '#7c3aed', points: [[48.1, 11.5], [48.2, 11.6]] as [number, number][], kind: 'dawarich_live' as const, date: '2026-10-29' }, + ]; + const connectionLines = () => { + const polyline = vi.mocked(L.polyline).mock; + return polyline.calls + .map((call, i) => ({ coords: call[0], dashed: (call[1] as { dashArray?: string } | undefined)?.dashArray === '4 6', line: polyline.results[i].value as { addTo: Mock; remove: Mock } })) + .filter(call => call.dashed); + }; + + it('FE-COMP-JOURNEYMAP-056: leaves the recorded day to its track and keeps the jump to the next day', () => { + render(); + + const lines = connectionLines(); + expect(lines.map(l => l.coords)).toEqual([ + [[48.2, 11.6], [48.3, 11.7]], + [[48.1, 11.5], [48.2, 11.6]], + ]); + expect(lines[0].line.addTo).toHaveBeenCalled(); + expect(lines[1].line.addTo).not.toHaveBeenCalled(); + }); + + it('FE-COMP-JOURNEYMAP-057: hiding what was recorded puts the covered stretch back, hiding the entries takes it off again', () => { + mockedMarkerWithRemove(); + const shown = { plan: true, recorded: true, entries: true }; + const { rerender } = render(); + const covered = connectionLines()[1].line; + + rerender(); + expect(covered.addTo).toHaveBeenCalledTimes(1); + + rerender(); + expect(covered.remove).toHaveBeenCalledTimes(1); + expect(L.map).toHaveBeenCalledTimes(1); + }); + }); }); /** The shared marker spy with the `remove` a hidden layer is taken off by. */ diff --git a/client/src/components/Journey/JourneyMap.tsx b/client/src/components/Journey/JourneyMap.tsx index 4d3071e5f..8e18c78df 100644 --- a/client/src/components/Journey/JourneyMap.tsx +++ b/client/src/components/Journey/JourneyMap.tsx @@ -11,7 +11,8 @@ import { escapeHtml, type JourneyTrack } from '@trek/shared' import { ensureJourneyPopupStyle, formatMarkerDate, journeyPopupHtml } from './journeyMapPopup' import { PLANNED_BADGE_SVG, type JourneyMapMark } from './journeyMapMarks' import { isPlannedTrack, type JourneyMapLayerVisibility } from './journeyMapLayers' -import { NOTHING_DRAWN, drawLeafletMarks, leafletWorldPx, switchLeafletLayers, type DrawnLayers, type LeafletLayerKind } from './journeyLeafletLayers' +import { NOTHING_DRAWN, drawLeafletMarks, isLeafletLayerShown, leafletWorldPx, switchLeafletLayers, type DrawnLayers, type LeafletLayerKind } from './journeyLeafletLayers' +import { entryConnections } from './journeyMapConnections' export interface MapMarkerItem { id: string @@ -347,7 +348,7 @@ function JourneyMap( iconPlannedRef.current = plannedRef.current const place = (kind: LeafletLayerKind, layer: T): T => { drawn[kind].push(layer) - if (visibilityRef.current[kind]) layer.addTo(map) + if (isLeafletLayerShown(kind, visibilityRef.current)) layer.addTo(map) return layer } @@ -403,17 +404,18 @@ function JourneyMap( coords.forEach(c => trackCoords.push(c)) } - // route trail: dashed line connecting entries in time order, same as JourneyMapGL - if (items.length > 1) { - const routeCoords = items.map(i => [i.lat, i.lng] as L.LatLngTuple) - place('entries', L.polyline(routeCoords, { - color: dark ? '#71717A' : '#A1A1AA', - weight: 1.5, - opacity: 0.5, - dashArray: '4 6', - lineCap: 'round', lineJoin: 'round', - })) + // The faint line between the entries in their order, same as JourneyMapGL, left + // off the stretches a recorded day already draws as travelled (#2888). + const connections = entryConnections(items.map(i => ({ lat: i.lat, lng: i.lng, date: i.time })), stableTracks) + const connectionStyle: L.PolylineOptions = { + color: dark ? '#71717A' : '#A1A1AA', + weight: 1.5, + opacity: 0.5, + dashArray: '4 6', + lineCap: 'round', lineJoin: 'round', } + for (const line of connections.open) place('entries', L.polyline(line, connectionStyle)) + for (const line of connections.covered) place('coveredConnections', L.polyline(line, connectionStyle)) // place markers items.forEach((item, i) => { diff --git a/client/src/components/Journey/JourneyMapGL.test.tsx b/client/src/components/Journey/JourneyMapGL.test.tsx index cfaf838d6..6bb7d0068 100644 --- a/client/src/components/Journey/JourneyMapGL.test.tsx +++ b/client/src/components/Journey/JourneyMapGL.test.tsx @@ -1,4 +1,4 @@ -// FE-COMP-JMAPGL-001 to FE-COMP-JMAPGL-040, FE-COMP-JMAPGL-2453 +// FE-COMP-JMAPGL-001 to FE-COMP-JMAPGL-042, FE-COMP-JMAPGL-2453 type Spy = ReturnType @@ -255,25 +255,14 @@ describe('JourneyMapGL', () => { render() expect(gl.map.addSource).toHaveBeenCalledWith('journey-route', expect.objectContaining({ type: 'geojson' })) - const source = vi.mocked(gl.map.addSource).mock.calls[0][1] as { data: { geometry: { coordinates: number[][] } } } - expect(source.data.geometry.coordinates).toEqual([[2.3522, 48.8566], [13.405, 52.52]]) + const source = vi.mocked(gl.map.addSource).mock.calls[0][1] as { data: { geometry: { coordinates: number[][][] } } } + expect(source.data.geometry.coordinates).toEqual([[[2.3522, 48.8566], [13.405, 52.52]]]) expect(gl.map.addLayer).toHaveBeenCalledWith(expect.objectContaining({ id: 'journey-route-line', source: 'journey-route', })) }) - it('FE-COMP-JMAPGL-008: an existing route source is updated instead of re-added', () => { - withToken() - const setData = vi.fn() - gl.map.getSource.mockReturnValue({ setData }) - - render() - - expect(gl.map.addSource).not.toHaveBeenCalled() - expect(setData).toHaveBeenCalledWith(expect.objectContaining({ type: 'Feature' })) - }) - it('FE-COMP-JMAPGL-038: a planned GPX track goes on the dashed layer, a recorded route on the solid one (JRN-01)', () => { withToken() render( @@ -764,4 +753,45 @@ describe('JourneyMapGL', () => { expect(gl.markers[0].element.innerHTML).toContain('#16a34a') expect(mapboxgl.Map).toHaveBeenCalledTimes(1) }) + + it('FE-COMP-JMAPGL-041: a recorded day takes the line between its entries off the map, the rest stays (#2888)', () => { + withToken() + const days = [ + { id: 'a', lat: 48.1, lng: 11.5, entry_date: '2026-10-29' }, + { id: 'b', lat: 48.2, lng: 11.6, entry_date: '2026-10-29' }, + { id: 'c', lat: 48.3, lng: 11.7, entry_date: '2026-10-30' }, + { id: 'd', lat: 48.4, lng: 11.8, entry_date: '2026-10-30' }, + ] + render( + , + ) + + const data = (id: string) => (vi.mocked(gl.map.addSource).mock.calls.find(c => c[0] === id)?.[1] as { data: { geometry: { coordinates: number[][][] } } }).data.geometry.coordinates + expect(data('journey-route')).toEqual([[[11.6, 48.2], [11.7, 48.3], [11.8, 48.4]]]) + expect(data('journey-route-covered')).toEqual([[[11.5, 48.1], [11.6, 48.2]]]) + const covered = vi.mocked(gl.map.addLayer).mock.calls.map(c => c[0] as { id: string; layout: Record }).find(l => l.id === 'journey-route-covered-line') + expect(covered?.layout.visibility).toBe('none') + }) + + it('FE-COMP-JMAPGL-042: hiding what was recorded brings the covered stretches back while the entries show', () => { + withToken() + const shown = { plan: true, recorded: true, entries: true } + const days = [ + { id: 'a', lat: 48.1, lng: 11.5, entry_date: '2026-10-29' }, + { id: 'b', lat: 48.2, lng: 11.6, entry_date: '2026-10-29' }, + ] + const tracks = [{ place_id: -1, trip_id: 0, name: 'Day', color: null, points: [[48.1, 11.5], [48.2, 11.6]] as [number, number][], kind: 'day_recording' as const, date: '2026-10-29' }] + const { rerender } = render() + expect(gl.map.addSource).not.toHaveBeenCalledWith('journey-route', expect.anything()) + + rerender() + expect(gl.map.setLayoutProperty).toHaveBeenCalledWith('journey-route-covered-line', 'visibility', 'visible') + + rerender() + expect(gl.map.setLayoutProperty).toHaveBeenLastCalledWith('journey-route-covered-line', 'visibility', 'none') + }) }) diff --git a/client/src/components/Journey/JourneyMapGL.tsx b/client/src/components/Journey/JourneyMapGL.tsx index fc3839fd7..d703ae5ad 100644 --- a/client/src/components/Journey/JourneyMapGL.tsx +++ b/client/src/components/Journey/JourneyMapGL.tsx @@ -9,6 +9,7 @@ import { SHOT_INDEX_ATTR, ensureJourneyPopupStyle, formatMarkerDate, journeyPopu import { clusterPhotos, photoMarkerHtml, type MapPhoto } from './journeyPhotoLayer' import { MARK_CLUSTER_PX, PLANNED_BADGE_SVG, clusterPoints, glWorldPx, markHitSvg, type JourneyMapMark } from './journeyMapMarks' import { isPlannedTrack, type JourneyMapLayerVisibility } from './journeyMapLayers' +import { coveredConnectionsShown, entryConnections } from './journeyMapConnections' export interface JourneyMapGLHandle { highlightMarker: (id: string | null) => void @@ -114,6 +115,33 @@ const LAYER_IDS: Record = { } const EVERY_LAYER: JourneyMapLayerVisibility = { plan: true, recorded: true, entries: true } const NO_PLANNED: ReadonlySet = new Set() +/** The stretches between entries a recorded day already draws; shown only while that recording is hidden. */ +const COVERED_CONNECTION_LAYER = 'journey-route-covered-line' + +/** One of the faint lines between the entries, as a dashed layer over its own source. */ +function addConnectionLayer(map: mapboxgl.Map, id: string, lines: [number, number][][], dark: boolean, visible: boolean) { + if (lines.length === 0) return + map.addSource(id, { + type: 'geojson', + data: { + type: 'Feature', + properties: {}, + geometry: { type: 'MultiLineString', coordinates: lines.map(line => line.map(([lat, lng]) => [lng, lat])) }, + }, + }) + map.addLayer({ + id: `${id}-line`, + type: 'line', + source: id, + paint: { + 'line-color': dark ? '#71717A' : '#A1A1AA', + 'line-width': 1.5, + 'line-opacity': 0.5, + 'line-dasharray': [2, 3], + }, + layout: { 'line-cap': 'round', 'line-join': 'round', visibility: visible ? 'visible' : 'none' }, + }) +} function markerHtml(dayColor: string, dayLabel: number, highlighted: boolean, planned = false): HTMLDivElement { const fill = dayColor @@ -397,31 +425,12 @@ function JourneyMapGL( try { map.setConfigProperty('basemap', 'language', basemapLanguage(mapLangRef.current)) } catch { /* style/SDK may not support it */ } } - // route trail — dashed line connecting entries in time order - if (items.length > 1) { - const coords = items.map(i => [i.lng, i.lat]) - if (map.getSource('journey-route')) (map.getSource('journey-route') as mapboxgl.GeoJSONSource).setData({ - type: 'Feature', properties: {}, geometry: { type: 'LineString', coordinates: coords } as GeoJSON.LineString, - }) - else { - map.addSource('journey-route', { - type: 'geojson', - data: { type: 'Feature', properties: {}, geometry: { type: 'LineString', coordinates: coords } as GeoJSON.LineString }, - }) - map.addLayer({ - id: 'journey-route-line', - type: 'line', - source: 'journey-route', - paint: { - 'line-color': darkRef.current ? '#71717A' : '#A1A1AA', - 'line-width': 1.5, - 'line-opacity': 0.5, - 'line-dasharray': [2, 3], - }, - layout: layout('entries', { 'line-cap': 'round', 'line-join': 'round' }), - }) - } - } + // The faint line between the entries in their order, left off the stretches + // a recorded day already draws as travelled (#2888). Those go on a layer of + // their own that stands in while the reader hides the recording. + const connections = entryConnections(items.map(i => ({ lat: i.lat, lng: i.lng, date: i.time })), stableTracks) + addConnectionLayer(map, 'journey-route', connections.open, !!darkRef.current, visibilityRef.current.entries) + addConnectionLayer(map, 'journey-route-covered', connections.covered, !!darkRef.current, coveredConnectionsShown(visibilityRef.current)) // Tracks, one source for all of them, coloured per feature so a journey // with several routes keeps them apart. Casing underneath, same as the @@ -576,6 +585,10 @@ function JourneyMapGL( markersRef.current.forEach(m => { m.getElement().style.display = layerVisibility.entries ? '' : 'none' }) } } + const coveredShown = coveredConnectionsShown(layerVisibility) + if (coveredConnectionsShown(shownRef.current) !== coveredShown) { + try { map.setLayoutProperty(COVERED_CONNECTION_LAYER, 'visibility', coveredShown ? 'visible' : 'none') } catch { /* not drawn on this map */ } + } shownRef.current = layerVisibility }, [layerVisibility]) diff --git a/client/src/components/Journey/journeyLeafletLayers.ts b/client/src/components/Journey/journeyLeafletLayers.ts index 511b720e2..e6d9754dc 100644 --- a/client/src/components/Journey/journeyLeafletLayers.ts +++ b/client/src/components/Journey/journeyLeafletLayers.ts @@ -1,12 +1,21 @@ import L from 'leaflet'; +import { coveredConnectionsShown } from './journeyMapConnections'; import type { JourneyMapLayerVisibility } from './journeyMapLayers'; import { MARK_CLUSTER_PX, clusterPoints, markHitSvg, type JourneyMapMark, type WorldPx } from './journeyMapMarks'; -/** The layers of the Leaflet journey map a switch takes off and puts back (JRN-04). */ -export type LeafletLayerKind = keyof JourneyMapLayerVisibility; +/** + * The layers of the Leaflet journey map a switch takes off and puts back (JRN-04), + * plus the stretches between entries a recording already shows, which follow two. + */ +export type LeafletLayerKind = keyof JourneyMapLayerVisibility | 'coveredConnections'; export type DrawnLayers = Record; -export const NOTHING_DRAWN = (): DrawnLayers => ({ plan: [], recorded: [], entries: [] }); +export const NOTHING_DRAWN = (): DrawnLayers => ({ plan: [], recorded: [], entries: [], coveredConnections: [] }); + +/** Whether a layer of this kind is on the map with these switches. */ +export function isLeafletLayerShown(kind: LeafletLayerKind, visibility: JourneyMapLayerVisibility): boolean { + return kind === 'coveredConnections' ? coveredConnectionsShown(visibility) : visibility[kind]; +} /** * Puts each layer whose switch changed back on the map or takes it off, @@ -20,9 +29,10 @@ export function switchLeafletLayers( ): JourneyMapLayerVisibility { if (!map) return shown; for (const kind of Object.keys(drawn) as LeafletLayerKind[]) { - if (shown[kind] === next[kind]) continue; + const visible = isLeafletLayerShown(kind, next); + if (isLeafletLayerShown(kind, shown) === visible) continue; for (const layer of drawn[kind]) { - if (next[kind]) layer.addTo(map); + if (visible) layer.addTo(map); else layer.remove(); } } diff --git a/client/src/components/Journey/journeyMapConnections.test.ts b/client/src/components/Journey/journeyMapConnections.test.ts new file mode 100644 index 000000000..cb1f08d68 --- /dev/null +++ b/client/src/components/Journey/journeyMapConnections.test.ts @@ -0,0 +1,116 @@ +import type { JourneyTrack } from '@trek/shared'; +import { describe, expect, it } from 'vitest'; +import { coveredConnectionsShown, entryConnections } from './journeyMapConnections'; + +const stop = (lat: number, date: string) => ({ lat, lng: lat, date }); + +function recorded( + date: string, + kind: JourneyTrack['kind'] = 'day_recording', + points: [number, number][] = [ + [1, 1], + [2, 2], + ] +): JourneyTrack { + return { place_id: -1, trip_id: 0, name: date, color: null, points, kind, date }; +} + +describe('entryConnections (#2888)', () => { + it('JMCONN-001: without a recording the whole line stays open, one polyline through every stop', () => { + const result = entryConnections([stop(1, '2026-10-29'), stop(2, '2026-10-29'), stop(3, '2026-10-30')], []); + expect(result.open).toEqual([ + [ + [1, 1], + [2, 2], + [3, 3], + ], + ]); + expect(result.covered).toEqual([]); + }); + + it('JMCONN-002: a recorded day covers the stretches between its entries, the jump into a day without one stays open', () => { + const result = entryConnections( + [stop(1, '2026-10-29'), stop(2, '2026-10-29'), stop(3, '2026-10-30'), stop(4, '2026-10-30')], + [recorded('2026-10-29', 'dawarich_live')] + ); + expect(result.covered).toEqual([ + [ + [1, 1], + [2, 2], + ], + ]); + expect(result.open).toEqual([ + [ + [2, 2], + [3, 3], + [4, 4], + ], + ]); + }); + + it('JMCONN-003: the night between two recorded days is covered, a day in between without one is not', () => { + const tracks = [recorded('2026-10-29'), recorded('2026-10-30'), recorded('2026-11-01')]; + expect(entryConnections([stop(1, '2026-10-29'), stop(2, '2026-10-30')], tracks).open).toEqual([]); + expect(entryConnections([stop(1, '2026-10-30'), stop(2, '2026-11-01')], tracks).covered).toEqual([]); + }); + + it('JMCONN-004: a trip GPX, a line without a day and a recording without points cover nothing', () => { + const stops = [stop(1, '2026-10-29'), stop(2, '2026-10-29')]; + const gpx: JourneyTrack = { ...recorded('2026-10-29'), kind: 'trip_gpx' }; + const undated: JourneyTrack = { ...recorded('2026-10-29'), date: undefined }; + const empty = recorded('2026-10-29', 'day_recording', [[1, 1]]); + expect(entryConnections(stops, [gpx, undated, empty]).covered).toEqual([]); + }); + + it('JMCONN-005: open and covered stretches alternate in the order of the stops', () => { + const result = entryConnections( + [ + stop(1, '2026-10-28'), + stop(2, '2026-10-29'), + stop(3, '2026-10-29'), + stop(4, '2026-10-31'), + stop(5, '2026-10-31'), + ], + [recorded('2026-10-29'), recorded('2026-10-31')] + ); + expect(result.open).toEqual([ + [ + [1, 1], + [2, 2], + ], + [ + [3, 3], + [4, 4], + ], + ]); + expect(result.covered).toEqual([ + [ + [2, 2], + [3, 3], + ], + [ + [4, 4], + [5, 5], + ], + ]); + }); + + it('JMCONN-006: a timestamp is read by its day, and an unreadable date never counts as recorded', () => { + expect( + entryConnections([stop(1, '2026-10-29T08:00:00Z'), stop(2, '2026-10-29')], [recorded('2026-10-29')]).open + ).toEqual([]); + expect(entryConnections([stop(1, 'someday'), stop(2, '2026-10-29')], [recorded('2026-10-29')]).covered).toEqual([]); + }); + + it('JMCONN-007: fewer than two stops make no line', () => { + expect(entryConnections([stop(1, '2026-10-29')], [])).toEqual({ open: [], covered: [] }); + }); +}); + +describe('coveredConnectionsShown', () => { + it('JMCONN-008: stands in only while the entries show and the recording is hidden', () => { + expect(coveredConnectionsShown({ plan: true, recorded: true, entries: true })).toBe(false); + expect(coveredConnectionsShown({ plan: true, recorded: false, entries: true })).toBe(true); + expect(coveredConnectionsShown({ plan: true, recorded: false, entries: false })).toBe(false); + }); +}); diff --git a/client/src/components/Journey/journeyMapConnections.ts b/client/src/components/Journey/journeyMapConnections.ts new file mode 100644 index 000000000..dd15667b3 --- /dev/null +++ b/client/src/components/Journey/journeyMapConnections.ts @@ -0,0 +1,93 @@ +import type { JourneyTrack } from '@trek/shared'; +import { isPlannedTrack, type JourneyMapLayerVisibility } from './journeyMapLayers'; + +/** A point of the line between entries, `[lat, lng]`. */ +type LatLng = [number, number]; + +/** An entry pin as the connection sees it: where it stands and on which day. */ +export interface ConnectionStop { + lat: number; + lng: number; + /** `YYYY-MM-DD`; a longer ISO string is read by its date. */ + date: string; +} + +/** + * The faint line between the entries, cut where the map already shows how the + * traveller got from one to the next. + * + * `open` is every stretch nothing else on the map accounts for, so the + * straight line is the best guess there is. `covered` is every stretch whose + * days were all recorded: the recorded line is the real way, and a straight + * one across it only gets in its way (#2888). It is still handed back, so a + * reader who hides what was recorded gets the guess back for those stretches. + */ +export interface EntryConnections { + open: LatLng[][]; + covered: LatLng[][]; +} + +const DAY_MS = 86_400_000; + +function dayNumber(date: string): number | null { + const time = Date.parse(`${date.slice(0, 10)}T00:00:00Z`); + return Number.isNaN(time) ? null : Math.round(time / DAY_MS); +} + +/** The days a recorded line with points stands for; a trip's GPX is the plan and stands for none. */ +function recordedDays(tracks: readonly JourneyTrack[]): Set { + const days = new Set(); + for (const track of tracks) { + if (isPlannedTrack(track) || !track.date || track.points.length < 2) continue; + const day = dayNumber(track.date); + if (day !== null) days.add(day); + } + return days; +} + +/** + * Whether the way between two stops is on the map already: every day from the + * first stop's to the second's was recorded, the night between two recorded + * days included. One day in between without a recording leaves it open. + */ +function travelled(from: string, to: string, recorded: ReadonlySet): boolean { + const a = dayNumber(from); + const b = dayNumber(to); + if (a === null || b === null) return false; + const first = Math.min(a, b); + const last = Math.max(a, b); + if (last - first + 1 > recorded.size) return false; + for (let day = first; day <= last; day++) { + if (!recorded.has(day)) return false; + } + return true; +} + +/** + * Splits the line through the stops, taken in the order given (the pins' + * order on the map), into the stretches still open and those a recording + * covers. Neighbouring stretches of the same kind stay one line. + */ +export function entryConnections(stops: readonly ConnectionStop[], tracks: readonly JourneyTrack[]): EntryConnections { + const result: EntryConnections = { open: [], covered: [] }; + const recorded = recordedDays(tracks); + let line: LatLng[] | null = null; + let lineCovered = false; + for (let i = 1; i < stops.length; i++) { + const from = stops[i - 1]; + const to = stops[i]; + const covered = travelled(from.date, to.date, recorded); + if (!line || covered !== lineCovered) { + line = [[from.lat, from.lng]]; + (covered ? result.covered : result.open).push(line); + lineCovered = covered; + } + line.push([to.lat, to.lng]); + } + return result; +} + +/** The covered stretches stand in for the recording only while the pins are shown and the recording is not. */ +export function coveredConnectionsShown(visibility: JourneyMapLayerVisibility): boolean { + return visibility.entries && !visibility.recorded; +} diff --git a/client/src/components/Journey/useJourneyDayImport.test.ts b/client/src/components/Journey/useJourneyDayImport.test.ts index 6cc5e2e96..df637b3e9 100644 --- a/client/src/components/Journey/useJourneyDayImport.test.ts +++ b/client/src/components/Journey/useJourneyDayImport.test.ts @@ -115,6 +115,8 @@ describe('useJourneyDayImport', () => { it('FE-JRN-DAYIMPORT-004: the route goes along only when switched on, kept as previewed', async () => { const { result, onKept, onClose } = setup(); await waitFor(() => expect(result.current.route.offer).toBe('keep')); + expect(result.current.mapTracks.length).toBeGreaterThan(0); + expect(result.current.mapTracks.every((track) => track.date === '2026-05-14')).toBe(true); repo.save.mockResolvedValue({ day: buildRecordedDay(), outcome: 'created' }); act(() => result.current.route.toggle()); diff --git a/client/src/components/Journey/useJourneyDayImport.ts b/client/src/components/Journey/useJourneyDayImport.ts index ed28dbc3b..2a5d37df6 100644 --- a/client/src/components/Journey/useJourneyDayImport.ts +++ b/client/src/components/Journey/useJourneyDayImport.ts @@ -155,8 +155,9 @@ function useDayMap( color: dayColor, points: segment.points, kind: 'day_recording', + date, })), - [route, dayColor, t] + [route, dayColor, date, t] ); return { entries, tracks }; } diff --git a/client/src/components/Journey/useJourneyMapLayers.test.ts b/client/src/components/Journey/useJourneyMapLayers.test.ts index 254a6b8ba..1f6259741 100644 --- a/client/src/components/Journey/useJourneyMapLayers.test.ts +++ b/client/src/components/Journey/useJourneyMapLayers.test.ts @@ -202,6 +202,8 @@ describe('useJourneyMapLayers', () => { expect(result.current.tracks.every((track) => track.kind === 'day_recording' && track.color === '#14b8a6')).toBe( true ); + // The day travels as a date of its own, so the map can tell which stretches it covers (#2888). + expect(result.current.tracks.map((track) => track.date)).toEqual(['2026-05-14', '2026-05-14']); expect(result.current.controls.map((c) => c.layer)).toEqual(['recorded', 'entries', 'photos']); expect(result.current.controls[0]).toEqual({ layer: 'recorded', count: 1, state: 'ready' }); }); diff --git a/client/src/components/Journey/useJourneyMapLayers.ts b/client/src/components/Journey/useJourneyMapLayers.ts index c2dbe51d7..cee7e62ef 100644 --- a/client/src/components/Journey/useJourneyMapLayers.ts +++ b/client/src/components/Journey/useJourneyMapLayers.ts @@ -163,6 +163,7 @@ export function useJourneyMapLayers({ color, points, kind: 'day_recording', + date: day.date, })); }), [sources.recordings, colorOfDay, t, locale] @@ -187,7 +188,7 @@ export function useJourneyMapLayers({ [places, stays, visibility, entryIdsOnMap, stayColor] ); - const recordedDays = useMemo(() => new Set(recorded.map((track) => track.name)).size, [recorded]); + const recordedDays = useMemo(() => new Set(recorded.map((track) => track.date ?? track.name)).size, [recorded]); const controls = useMemo( () => buildControls({ diff --git a/client/src/components/Journey/useJourneyRecordings.test.ts b/client/src/components/Journey/useJourneyRecordings.test.ts index a1c3af93c..73fef1272 100644 --- a/client/src/components/Journey/useJourneyRecordings.test.ts +++ b/client/src/components/Journey/useJourneyRecordings.test.ts @@ -47,6 +47,7 @@ describe('useJourneyRecordings', () => { expect(result.current.byDate.get('2026-05-15')?.id).toBe(4); expect(result.current.tracks).toHaveLength(3); expect(result.current.tracks.every((track) => track.kind === 'day_recording')).toBe(true); + expect(result.current.tracks.map((track) => track.date)).toEqual(['2026-05-14', '2026-05-14', '2026-05-15']); // One line per piece: a gap between two pieces is never drawn over. expect(result.current.tracks.slice(0, 2).map((track) => track.points)).toEqual([ WALK_SEGMENT.points, diff --git a/client/src/components/Journey/useJourneyRecordings.ts b/client/src/components/Journey/useJourneyRecordings.ts index 350192c0f..3dfa72f28 100644 --- a/client/src/components/Journey/useJourneyRecordings.ts +++ b/client/src/components/Journey/useJourneyRecordings.ts @@ -105,6 +105,7 @@ export function useJourneyRecordings( color, points: segment.points, kind: 'day_recording', + date: day.date, })); }), [days, colorOf, t, locale] diff --git a/client/src/hooks/useDawarichJournalTrail.test.ts b/client/src/hooks/useDawarichJournalTrail.test.ts index b76bedc37..1ea89febd 100644 --- a/client/src/hooks/useDawarichJournalTrail.test.ts +++ b/client/src/hooks/useDawarichJournalTrail.test.ts @@ -227,6 +227,7 @@ describe('useDawarichJournalTrail', () => { color: DAWARICH_DAY_COLORS[0], points: [[53.5, 10.0], [53.6, 10.1]], kind: 'dawarich_live', + date: DAY_ONE, }, { place_id: -2, @@ -237,6 +238,7 @@ describe('useDawarichJournalTrail', () => { color: DAWARICH_DAY_COLORS[1], points: [[48.1, 11.5], [48.2, 11.6], [48.3, 11.7]], kind: 'dawarich_live', + date: DAY_TWO, }, ]) // The journey map keys its polylines on place_id. Real places are positive, diff --git a/client/src/hooks/useDawarichJournalTrail.ts b/client/src/hooks/useDawarichJournalTrail.ts index af2c473f1..79beadaa7 100644 --- a/client/src/hooks/useDawarichJournalTrail.ts +++ b/client/src/hooks/useDawarichJournalTrail.ts @@ -72,6 +72,7 @@ export function useDawarichJournalTrail( color: segment.color, points: segment.points, kind: 'dawarich_live', + date: segment.date, })), ) setFetchedAt(track.fetchedAt) diff --git a/client/src/pages/journeyDetail/useJourneyDetailRecordings.test.ts b/client/src/pages/journeyDetail/useJourneyDetailRecordings.test.ts index 9ae960097..74771f9a1 100644 --- a/client/src/pages/journeyDetail/useJourneyDetailRecordings.test.ts +++ b/client/src/pages/journeyDetail/useJourneyDetailRecordings.test.ts @@ -25,8 +25,8 @@ const line = (over: Partial): JourneyTrack => ({ const GPX = [line({})]; const LIVE = [ - line({ place_id: -1, trip_id: 0, name: '2026-05-14', kind: 'dawarich_live' }), - line({ place_id: -2, trip_id: 0, name: '2026-05-15', kind: 'dawarich_live' }), + line({ place_id: -1, trip_id: 0, name: 'Live', kind: 'dawarich_live', date: '2026-05-14' }), + line({ place_id: -2, trip_id: 0, name: 'Live', kind: 'dawarich_live', date: '2026-05-15' }), ]; const ITEMS = [{ entry_date: '2026-05-14', dayColor: '#ff0055' }]; @@ -58,7 +58,7 @@ describe('useJourneyDetailRecordings', () => { const kinds = result.current.mapTracks.map((track) => track.kind ?? 'trip_gpx'); expect(kinds).toEqual(['trip_gpx', 'day_recording', 'dawarich_live']); expect(result.current.mapTracks[1]?.color).toBe('#ff0055'); - expect(result.current.mapTracks[2]?.name).toBe('2026-05-15'); + expect(result.current.mapTracks[2]?.date).toBe('2026-05-15'); }); it('FE-JRN-DETAIL-RECORDINGS-002: with nothing kept and no live trail the GPX tracks pass through as they are', async () => { diff --git a/client/src/pages/journeyDetail/useJourneyDetailRecordings.ts b/client/src/pages/journeyDetail/useJourneyDetailRecordings.ts index c2b19afda..daddedb40 100644 --- a/client/src/pages/journeyDetail/useJourneyDetailRecordings.ts +++ b/client/src/pages/journeyDetail/useJourneyDetailRecordings.ts @@ -42,7 +42,7 @@ export function useJourneyDetailRecordings({ const mapTracks = useMemo(() => { if (recordings.tracks.length === 0 && liveTracks.length === 0) return tripTracks; - const live = liveTracks.filter((track) => !recordings.byDate.has(track.name)); + const live = liveTracks.filter((track) => !track.date || !recordings.byDate.has(track.date)); return [...tripTracks, ...recordings.tracks, ...live]; }, [tripTracks, recordings.tracks, recordings.byDate, liveTracks]); diff --git a/shared/src/journey/journey.schema.spec.ts b/shared/src/journey/journey.schema.spec.ts index cb88c6a03..368a9c104 100644 --- a/shared/src/journey/journey.schema.spec.ts +++ b/shared/src/journey/journey.schema.spec.ts @@ -14,6 +14,7 @@ import { journeyEntryVisibilitySchema, journeyCreateToolSchema, journeyUpdateToolSchema, + journeyTrackSchema, } from './journey.schema'; import { describe, it, expect } from 'vitest'; @@ -143,6 +144,20 @@ describe('the entry enums and the range of a read', () => { }); }); +describe('journeyTrackSchema', () => { + const track = { place_id: -1, trip_id: 0, name: 'Day', color: null, points: [[48.1, 11.5]], kind: 'day_recording' }; + + it('JRNSCH-004: a recorded line may name its calendar day, a GPX track leaves it out', () => { + expect(journeyTrackSchema.parse({ ...track, date: '2026-10-29' }).date).toBe('2026-10-29'); + expect(journeyTrackSchema.parse({ ...track, kind: 'trip_gpx' }).date).toBeUndefined(); + }); + + it('JRNSCH-005: refuses a day that is not a calendar day', () => { + expect(journeyTrackSchema.safeParse({ ...track, date: '29. Oktober' }).success).toBe(false); + expect(journeyTrackSchema.safeParse({ ...track, date: '2026-02-30' }).success).toBe(false); + }); +}); + describe('the journey tool arguments', () => { it('JSCHEMA-TOOL-001: a new journey needs a title and refuses what the tool does not take', () => { expect(journeyCreateToolSchema.parse({ title: 'Japan', trip_ids: [5] })).toEqual({ title: 'Japan', trip_ids: [5] }); diff --git a/shared/src/journey/journey.schema.ts b/shared/src/journey/journey.schema.ts index 72a2f0795..be5a9eaeb 100644 --- a/shared/src/journey/journey.schema.ts +++ b/shared/src/journey/journey.schema.ts @@ -392,6 +392,11 @@ export const journeyTrackSchema = z.object({ * which is all GET `:id/tracks` has ever answered. */ kind: z.enum(['trip_gpx', 'day_recording', 'dawarich_live']).optional(), + /** + * The day a recorded line belongs to, so the map can tell which stretches + * between entries it already shows as travelled. A trip's GPX has none. + */ + date: journeyRecordingDateSchema.optional(), }); export type JourneyTrack = z.infer;