mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-21 03:26:07 +00:00
fix(pdf): route every leg of the trip map and mark what is left unrouted
The PDF export routed the whole trip under an 8 s deadline while the router is asked one leg at a time, a second apart. A cold month-long trip got about seven legs routed per export; the rest printed as straight lines at "0 m" under a total that looked final, and every further export routed a few more days from the device cache. The export now waits for every leg, bounded by the request pacing, the rate-limit retries and a per-leg timeout. The export dialog and the phone sheet count the legs while they route and offer to print without the rest. Any leg left without a road is marked in the document: the day reads "not routed" or "at least ...", the total says it is a floor, and a note names how many legs are missing. The planner overview shares the same wording. The PDF also routes what the planner map routes now: the road trip's vias, the multi-day tour stages and the reader's distance unit. Closes #2876
This commit is contained in:
@@ -100,6 +100,9 @@ describe('TripRouteOverviewPanel', () => {
|
||||
|
||||
expect(screen.getByTestId('trip-overview-unrouted')).toHaveTextContent('map.overview.unrouted')
|
||||
expect(screen.getAllByRole('img', { name: 'map.overview.dayUnrouted' })).toHaveLength(1)
|
||||
// The short figures read as floors, the trip's and the day's, not as measurements (#2876).
|
||||
expect(screen.getAllByText('map.overview.distanceAtLeast')).toHaveLength(2)
|
||||
expect(screen.getByText('140.5 km')).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('FE-MAP-TROU-010: does not call a leg unrouted while the round is still running', () => {
|
||||
|
||||
@@ -2,7 +2,7 @@ import { AlertTriangle, Route } from 'lucide-react'
|
||||
import { useTranslation } from '../../i18n'
|
||||
import { MapTogglePill } from './MapTogglePill'
|
||||
import { routeModeIcon } from '../Planner/routeModes'
|
||||
import { formatDistance } from '../../utils/units'
|
||||
import { routeDistanceLabel } from './tripRouteLabels'
|
||||
import type { TripRouteOverview as Overview } from './useTripRouteOverview'
|
||||
import type { DistanceUnit } from '../../types'
|
||||
|
||||
@@ -65,7 +65,7 @@ export function TripRouteOverviewPanel({ overview, unit, selectedDayId, onSelect
|
||||
{/* Same tier as the label beside it: the two read as one line rather than as a
|
||||
heading with a number stuck under it. */}
|
||||
<span className="text-content" style={{ fontSize: 'calc(11px * var(--fs-scale-caption, 1))', fontWeight: 600 }}>
|
||||
{formatDistance(overview.totalDistance / 1000, unit)}
|
||||
{routeDistanceLabel(overview.totalDistance, unrouted, unit, t)}
|
||||
{/* Still routing: the number is a partial sum, and saying so beats a total
|
||||
that silently grows while you read it. */}
|
||||
{overview.loading && <span className="text-content-muted" style={{ fontWeight: 400 }}>{' '}…</span>}
|
||||
@@ -112,7 +112,7 @@ export function TripRouteOverviewPanel({ overview, unit, selectedDayId, onSelect
|
||||
/>
|
||||
)}
|
||||
<span className="text-content-muted" style={{ flexShrink: 0, fontVariantNumeric: 'tabular-nums' }}>
|
||||
{formatDistance(day.distance / 1000, unit)}
|
||||
{routeDistanceLabel(day.distance, dayUnrouted, unit, t)}
|
||||
</span>
|
||||
</>
|
||||
)
|
||||
|
||||
@@ -78,31 +78,61 @@ describe('tripRouteGeometry', () => {
|
||||
expect(calculateRouteWithLegs).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('FE-MAP-TRG-005: the deadline gives back what answered and leaves the rest as straight lines', async () => {
|
||||
neverAnswers()
|
||||
// The PDF used to route under an 8 s deadline: with a second between two requests that
|
||||
// is about seven legs, so a month-long trip printed most of its days as straight lines
|
||||
// and a total that looked final, and every export routed a few more days (#2876).
|
||||
it('FE-MAP-TRG-005: a long trip is routed to its last leg, and says how far it has got', async () => {
|
||||
const days = Array.from({ length: 12 }, (_, i) => buildDay({ id: i + 1, day_number: i + 1 }))
|
||||
const assignments: AssignmentsMap = Object.fromEntries(days.map(day => [
|
||||
String(day.id),
|
||||
[at(48 + day.id / 10, 2.35, 0, day.id), at(48 + day.id / 10, 2.45, 1, day.id)],
|
||||
]))
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const pending = routeTrip(input, { profile: 'driving', tripId: 7, timeoutMs: 8000 })
|
||||
await vi.advanceTimersByTimeAsync(8100)
|
||||
vi.mocked(calculateRouteWithLegs).mockImplementation(() => new Promise(resolve => {
|
||||
setTimeout(() => resolve({ coordinates: [[48.86, 2.35], [48.90, 2.42]], distance: 10000, duration: 600, legs: [leg(10000)] }), 100)
|
||||
}))
|
||||
const onProgress = vi.fn<(done: number, total: number) => void>()
|
||||
const pending = routeTrip({ ...input, days, assignments }, { profile: 'driving', tripId: 7, onProgress })
|
||||
await vi.advanceTimersByTimeAsync(12 * 1200)
|
||||
const summary = await pending
|
||||
|
||||
// The shape of the trip survives...
|
||||
expect(summary.lines).toHaveLength(2)
|
||||
expect(summary.lines[0]).toEqual([[48.86, 2.35], [48.90, 2.42]])
|
||||
// ...and nothing that never answered is counted.
|
||||
expect(summary.totalDistance).toBe(0)
|
||||
expect(calculateRouteWithLegs).toHaveBeenCalledTimes(12)
|
||||
expect(summary.unroutedLegs).toBe(0)
|
||||
expect(summary.totalDistance).toBe(120000)
|
||||
expect(onProgress.mock.calls[0]).toEqual([0, 12])
|
||||
expect(onProgress.mock.calls.map(([done]) => done)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
|
||||
expect(onProgress.mock.calls.every(([, total]) => total === 12)).toBe(true)
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
})
|
||||
|
||||
it('FE-MAP-TRG-006: a caller\'s own abort cuts the routing short too', async () => {
|
||||
it('FE-MAP-TRG-006: a caller's own abort cuts the routing short, and what never answered is counted', async () => {
|
||||
neverAnswers()
|
||||
const controller = new AbortController()
|
||||
const pending = routeTrip(input, { profile: 'driving', tripId: 7, timeoutMs: 60_000, signal: controller.signal })
|
||||
const pending = routeTrip(input, { profile: 'driving', tripId: 7, signal: controller.signal })
|
||||
controller.abort()
|
||||
|
||||
await expect(pending).resolves.toMatchObject({ totalDistance: 0 })
|
||||
await expect(pending).resolves.toMatchObject({ totalDistance: 0, unroutedLegs: 2 })
|
||||
})
|
||||
|
||||
it('FE-MAP-TRG-014: a host that never answers costs one leg its road, not the whole round', async () => {
|
||||
neverAnswers()
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const pending = routeTrip(input, { profile: 'driving', tripId: 7 })
|
||||
await vi.advanceTimersByTimeAsync(30_000)
|
||||
expect(calculateRouteWithLegs).toHaveBeenCalledTimes(1)
|
||||
await vi.advanceTimersByTimeAsync(1100 + 30_000)
|
||||
const summary = await pending
|
||||
|
||||
expect(calculateRouteWithLegs).toHaveBeenCalledTimes(2)
|
||||
expect(summary.lines).toHaveLength(2)
|
||||
expect(summary.unroutedLegs).toBe(2)
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
})
|
||||
|
||||
// The public OSRM hosts allow about one request a second. Every leg of every day at
|
||||
|
||||
@@ -29,7 +29,7 @@ export interface TripOverviewDay {
|
||||
modes: string[]
|
||||
/**
|
||||
* Legs drawn as a straight line because the router gave no road for them: not asked
|
||||
* yet while the round is running, refused or cut off by the deadline once it is over.
|
||||
* yet while the round is running, refused, timed out or skipped by the caller once it is over.
|
||||
* Those legs add nothing to `distance`, so a day with any of them reads too short.
|
||||
*/
|
||||
unroutedLegs?: number
|
||||
@@ -56,7 +56,7 @@ export interface TripRouteSummary {
|
||||
interface Chunk { points: DayRoutePoint[]; mode: string; waypoints: { lat: number; lng: number }[]; stopAt: number[] }
|
||||
|
||||
/** The day inputs plus the road trip's vias, which bend a day the way it was picked there (#2580). */
|
||||
interface TripRouteInputs extends DayRouteInputs {
|
||||
export interface TripRouteInputs extends DayRouteInputs {
|
||||
/** The stored day lists the vias are anchored in, hidden rows included. Absent: `assignments`. */
|
||||
storedAssignments?: AssignmentsMap
|
||||
viasByDay?: Record<number, readonly RoadtripVia[]>
|
||||
@@ -187,6 +187,15 @@ export function summariseTripRoute(days: TripOverviewDay[]): TripRouteSummary {
|
||||
const REQUEST_SPACING_MS = 1100
|
||||
/** Anything answered faster than this came out of RouteCalculator's cache, not the network. */
|
||||
const CACHE_HIT_MS = 60
|
||||
/**
|
||||
* The longest one leg may take, its rate-limit retries included. The OSRM request has no
|
||||
* deadline of its own, and a round that waits for every leg must not hang on a host that
|
||||
* accepted the connection and never answered.
|
||||
*/
|
||||
const LEG_TIMEOUT_MS = 30_000
|
||||
|
||||
/** How far a routing round has got: legs answered or given up on, out of all it asks. */
|
||||
export type TripRouteProgress = (done: number, total: number) => void
|
||||
|
||||
/**
|
||||
* Ask the router for every leg of every day, one at a time.
|
||||
@@ -206,13 +215,15 @@ const CACHE_HIT_MS = 60
|
||||
*/
|
||||
export async function routeTripLegs(
|
||||
plan: TripRoutePlanDay[],
|
||||
{ tripId, signal, onAnswer, unit }: {
|
||||
{ tripId, signal, onAnswer, onProgress, unit }: {
|
||||
tripId: number | null
|
||||
signal?: AbortSignal
|
||||
/** The unit a leg bent through vias has its text written again in. */
|
||||
unit?: DistanceUnit
|
||||
/** Called after each answer, for a caller that wants to draw as they arrive. */
|
||||
onAnswer?: (routed: Answer[][][]) => void
|
||||
/** Called once before the first leg and again after every leg, answered or not. */
|
||||
onProgress?: TripRouteProgress
|
||||
},
|
||||
): Promise<Answer[][][]> {
|
||||
const routed = emptyAnswers(plan)
|
||||
@@ -222,25 +233,34 @@ export async function routeTripLegs(
|
||||
chunks.forEach((chunk, c) => {
|
||||
tasks.push(async () => {
|
||||
if (signal?.aborted) return
|
||||
const leg = new AbortController()
|
||||
const abortLeg = () => leg.abort()
|
||||
const timer = setTimeout(abortLeg, LEG_TIMEOUT_MS)
|
||||
signal?.addEventListener('abort', abortLeg, { once: true })
|
||||
try {
|
||||
const answer = await calculateRouteWithRetries(
|
||||
chunk.waypoints,
|
||||
{ signal, profile: chunk.mode, tripId, dayId: day.id },
|
||||
{ signal: leg.signal, profile: chunk.mode, tripId, dayId: day.id },
|
||||
)
|
||||
routed[d][r][c] = { coordinates: answer.coordinates, legs: foldViaLegs(answer.legs, chunk.stopAt, unit) }
|
||||
onAnswer?.(routed)
|
||||
} catch {
|
||||
// Refused for good, or aborted: the leg keeps its straight line.
|
||||
// Refused for good, timed out or aborted: the leg keeps its straight line.
|
||||
} finally {
|
||||
clearTimeout(timer)
|
||||
signal?.removeEventListener('abort', abortLeg)
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
onProgress?.(0, tasks.length)
|
||||
for (let i = 0; i < tasks.length; i++) {
|
||||
if (signal?.aborted) break
|
||||
const startedAt = performance.now()
|
||||
await tasks[i]()
|
||||
onProgress?.(i + 1, tasks.length)
|
||||
const wasNetwork = performance.now() - startedAt > CACHE_HIT_MS
|
||||
if (wasNetwork && i < tasks.length - 1) await sleep(REQUEST_SPACING_MS, signal)
|
||||
}
|
||||
@@ -250,30 +270,25 @@ export async function routeTripLegs(
|
||||
/**
|
||||
* The whole thing end to end, for a caller with no need to draw the intermediate state.
|
||||
*
|
||||
* `timeoutMs` stops waiting rather than stopping the work: legs that answered are kept
|
||||
* and the rest stay straight lines, which is what makes this usable from an export
|
||||
* somebody is standing in front of. A month-long trip with a cold cache is a few hundred
|
||||
* requests against a shared router, and no document is worth that wait.
|
||||
* Waits for every leg: a cold month-long trip is a few minutes against a shared router,
|
||||
* which is why `onProgress` exists, and the pacing, the retry limit and the per-leg
|
||||
* timeout keep that wait finite. A document printed after a deadline looked finished
|
||||
* while most of its days were straight lines (#2876). The caller's `signal` is the only
|
||||
* way to stop early; the legs that answered by then are kept, the rest stay straight
|
||||
* lines and are counted in `unroutedLegs`.
|
||||
*/
|
||||
export async function routeTrip(
|
||||
input: TripRouteInputs,
|
||||
{ profile, tripId, signal, timeoutMs, unit }: {
|
||||
{ profile, tripId, signal, unit, onProgress }: {
|
||||
profile: RouteProfileKey
|
||||
tripId: number | null
|
||||
signal?: AbortSignal
|
||||
timeoutMs?: number
|
||||
unit?: DistanceUnit
|
||||
onProgress?: TripRouteProgress
|
||||
},
|
||||
): Promise<TripRouteSummary> {
|
||||
const plan = planTripRoute(input, profile)
|
||||
if (!plan.length) return summariseTripRoute([])
|
||||
const deadline = timeoutMs ? new AbortController() : null
|
||||
const timer = deadline ? setTimeout(() => deadline.abort(), timeoutMs) : null
|
||||
if (deadline && signal) signal.addEventListener('abort', () => deadline.abort(), { once: true })
|
||||
try {
|
||||
const routed = await routeTripLegs(plan, { tripId, signal: deadline?.signal ?? signal, unit })
|
||||
return summariseTripRoute(assembleTripRoute(plan, routed))
|
||||
} finally {
|
||||
if (timer) clearTimeout(timer)
|
||||
}
|
||||
const routed = await routeTripLegs(plan, { tripId, signal, unit, onProgress })
|
||||
return summariseTripRoute(assembleTripRoute(plan, routed))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
import type { DistanceUnit } from '../../types';
|
||||
import { formatDistance } from '../../utils/units';
|
||||
|
||||
type Translate = (key: string, params?: Record<string, string | number>) => string;
|
||||
|
||||
/**
|
||||
* A day's or the trip's distance as the overview panel and the PDF print it.
|
||||
*
|
||||
* A leg the router gave no road for is drawn straight and adds nothing to the sum, so a
|
||||
* figure with such legs in it is a floor, and a figure made of nothing but such legs is
|
||||
* no figure at all. "0 m" for a day of driving read as a measurement (#2876). One wording
|
||||
* for the screen and the document, so the two cannot drift apart again.
|
||||
*/
|
||||
export function routeDistanceLabel(meters: number, unroutedLegs: number, unit: DistanceUnit, t: Translate): string {
|
||||
const distance = formatDistance(meters / 1000, unit);
|
||||
if (unroutedLegs <= 0) return distance;
|
||||
return meters > 0 ? t('map.overview.distanceAtLeast', { distance }) : t('map.overview.notRouted');
|
||||
}
|
||||
Reference in New Issue
Block a user