)}
- {/* Instance configuration, not a taste, which is why it sits here rather
- than in a user's own Map settings. The origin has to appear in the CSP
- `connect-src` the server emits at boot, and that list is built from
- this default — a value on a personal settings row is read by the route
- calculator and then refused by the browser, so the whole app stops
- routing with no error it could report. The write route refuses one
- from a non-admin for the same reason. */}
{!managed && (
-
- )}
- {/* The second engine, next to the first because it is the same kind of decision
- and carries the same restart caveat. Only ever asked to leave a road class
- out of one leg, which is the one question the OSRM above refuses. */}
- {!managed && (
-
+
+ {/* First, because it decides what everything under it means: with no
+ vehicle named, a petrol station and a charger both fill the tank, which
+ is arithmetic that is wrong for everybody who drives just one of them.
+
+ Radios in a segmented shell rather than a dropdown: three options that
+ change the meaning of everything below them should be readable without
+ being opened, and the arrow keys, the names and the roles then come
+ from the browser instead of from a rebuilt listbox. */}
+
+
+
+
+ {/* Read-only once the parts add up, because then it IS the parts. Leaving
+ it editable would offer a second answer to a question that already has
+ one, and the traveller would have no way of telling which the warnings
+ were using. Clearing a field above hands the row straight back. */}
+ setPreview({ key: 'range', value: v })}
+ onChange={setRange}
+ />
+ {/* Under the range, because it is a fraction OF it. Nobody charges to
+ 100 % on the road: the last fifth takes as long as the first four, so a
+ stop counted as a full tank overstates everything after it by that
+ fifth. */}
+ setPreview({ key: 'fill', value: v > 100 ? 100 : v })}
+ onChange={v => onSave?.('roadtrip_fill_percent', v > 100 ? 100 : v)}
+ />
+
+ {/* The car's own figures, folded away. Nothing here is required — somebody
+ who knows their range types it above and never opens this — but it
+ starts open the moment any of them is stored, because otherwise the
+ range row is read-only with its cause out of sight. */}
+ {vehicleKind ? (
+ <>
+
+ {/* `hidden` rather than unmounting: it really leaves the tab order,
+ and a field that kept a draft while folded away would be a draft
+ nobody can see. */}
+ {/* The display class only while it is open. `[hidden]` sets
+ `display: none` in the preflight, but a `flex` class beats it on
+ specificity — so the attribute flipped, the semantics were right,
+ and the panel stayed on screen. */}
+
+
+ ) : null}
+
+
+
{/* The road between one day's last stop and the next day's first is real
driving that the rail has never drawn: days are routed one at a time,
so that gap was never asked for. Off by default because it costs a
routing request per join and changes every day's kilometres. */}
-
+
+ {t('roadtrip.line.connect')}
+
+
+ ) : onSave?.('roadtrip_connect_days', !settings.roadtrip_connect_days)}
- />
+ />}
{/* Which matters most once the line IS continuous: end to end it is one
stroke, and a colour per day is what puts the days back into it. */}
-
-
- {/* First, because it decides what everything under it means: with no
- vehicle named, a petrol station and a charger both fill the tank, which
- is arithmetic that is wrong for everybody who drives just one of them.
-
- Radios in a segmented shell rather than a dropdown: three options that
- change the meaning of everything below them should be readable without
- being opened, and the arrow keys, the names and the roles then come
- from the browser instead of from a rebuilt listbox. */}
-
-
-
-
- {/* Read-only once the parts add up, because then it IS the parts. Leaving
- it editable would offer a second answer to a question that already has
- one, and the traveller would have no way of telling which the warnings
- were using. Clearing a field above hands the row straight back. */}
- setPreview({ key: 'range', value: v })}
- onChange={setRange}
- />
- {/* Under the range, because it is a fraction OF it. Nobody charges to
- 100 % on the road: the last fifth takes as long as the first four, so a
- stop counted as a full tank overstates everything after it by that
- fifth. */}
- setPreview({ key: 'fill', value: v > 100 ? 100 : v })}
- onChange={v => onSave?.('roadtrip_fill_percent', v > 100 ? 100 : v)}
- />
-
- {/* The car's own figures, folded away. Nothing here is required — somebody
- who knows their range types it above and never opens this — but it
- starts open the moment any of them is stored, because otherwise the
- range row is read-only with its cause out of sight. */}
- {vehicleKind ? (
- <>
-
- {/* `hidden` rather than unmounting: it really leaves the tab order,
- and a field that kept a draft while folded away would be a draft
- nobody can see. */}
- {/* The display class only while it is open. `[hidden]` sets
- `display: none` in the preflight, but a `flex` class beats it on
- specificity — so the attribute flipped, the semantics were right,
- and the panel stayed on screen. */}
-
diff --git a/client/src/components/Roadtrip/RoadtripSidebar.tsx b/client/src/components/Roadtrip/RoadtripSidebar.tsx
index 22e9d271d..2e089b53c 100644
--- a/client/src/components/Roadtrip/RoadtripSidebar.tsx
+++ b/client/src/components/Roadtrip/RoadtripSidebar.tsx
@@ -27,8 +27,10 @@ import type { RouteVia } from '../../types'
import { FS } from './typeScale'
import type { RouteSegment } from '../../types'
import EmptyState from '../shared/EmptyState'
+import AutomaticDayStop from './AutomaticDayStop'
interface RoadtripSidebarProps {
+ onFocusPoint?: (lat: number, lng: number) => void
/** Legs and totals for the whole trip, computed once in the planner hook. */
routes: RoadtripRoutes
selectedAssignmentId?: number | null
@@ -1203,13 +1205,7 @@ function SpillBlock({ spill, children }: {
boxShadow: `inset 0 1px 0 color-mix(in srgb, var(--info) 20%, transparent)`,
}}
>
- {/* Moonlight from the left, falling on the mascot. A radial wash rather than a
- second background colour: it has no edge of its own, so the head reads as lit
- rather than as another box stacked on the first. */}
-
+
+
@@ -1294,7 +1290,8 @@ function SpillBlock({ spill, children }: {
* move, a stay edit or a refuel offer still names the day the server knows it by. See
* `nightSpill.ts`.
*/
-function DaySection({ day, selectedAssignmentId, onSelectStop, onReorderStop, onMoveStopToDay, drag, onAskAlternatives, openAlternatives, onEditStay, onSetStopKind, onSetStopFill, onFollowTrack, viaCount, trackName, refuel, onAskRefuel, onAcceptRefuel, loading, collapsed, onToggle }: {
+function DaySection({ day, selectedAssignmentId, onSelectStop, onReorderStop, onMoveStopToDay, drag, onAskAlternatives, openAlternatives, onEditStay, onSetStopKind, onSetStopFill, onFollowTrack, viaCount, trackName, refuel, onAskRefuel, onAcceptRefuel, loading, collapsed, onToggle, onFocusPoint }: {
+ onFocusPoint?: RoadtripSidebarProps['onFocusPoint']
day: RoadtripDay
/** Folded down to the header, and off the map with it. */
collapsed?: boolean
@@ -1355,6 +1352,20 @@ function DaySection({ day, selectedAssignmentId, onSelectStop, onReorderStop, on
* still stored on the day it set off from (`nightSpill.ts`).
*/
const renderStop = (stop: RoadtripStop, i: number): React.ReactElement => {
+ if (stop.automaticNight) return (
+
+ )
const service = isServiceStopType(stop.stopType)
if (!service) counted += 1
// Every finding at this index is read on its own. Taking the first match let an
@@ -1424,10 +1435,10 @@ function DaySection({ day, selectedAssignmentId, onSelectStop, onReorderStop, on
onPickFill={onSetStopFill ? anchor => setFilling({ anchor, stop }) : undefined}
/>
)}
- {i < last ? (
+ {i < last && (!day.stops[i + 1].automaticNight || day.legs[i]?.distance !== 0) ? (
onAskAlternatives(day.dayId, i) : undefined}
+ onAskAlternatives={onAskAlternatives && !day.stops[i + 1].automaticNight ? () => onAskAlternatives(day.dayId, i) : undefined}
alternativesOpen={openAlternatives?.dayId === day.dayId && openAlternatives.index === i}
/>
) : null}
@@ -1556,7 +1567,7 @@ function DaySection({ day, selectedAssignmentId, onSelectStop, onReorderStop, on
) : null}
- {t('roadtrip.day.stopCount', { count: day.stops.filter(s => !isServiceStopType(s.stopType)).length })}
+ {t('roadtrip.day.stopCount', { count: day.stops.filter(s => !s.automaticNight && !isServiceStopType(s.stopType)).length })}
{/* The other half of "where possible". The setting is a weighting, so a day
with no untolled crossing comes back on the toll road — and the only thing
@@ -1714,7 +1725,7 @@ function QuietDaySection({ day, onMoveStopToDay, drag }: {
export default function RoadtripSidebar({
routes, selectedAssignmentId, onSelectStop, onReorderStop, onMoveStopToDay, onAskAlternatives, openAlternatives, onEditStay,
onSetStopKind, onSetStopFill, onFollowTrack, viaCounts, trackNames, refuel, onAskRefuel, onAcceptRefuel,
- collapsedDayIds, onToggleDay,
+ collapsedDayIds, onToggleDay, onFocusPoint,
}: RoadtripSidebarProps): React.ReactElement {
const { t } = useTranslation()
// One drag state for the whole rail rather than one per day: a stop that cannot leave
@@ -1751,12 +1762,18 @@ export default function RoadtripSidebar({
e.stopPropagation()}>
undefined),
removeAssignment: vi.fn(async () => undefined),
reorderAssignments: vi.fn(async () => undefined),
+ setAssignmentEndDay: vi.fn(async () => undefined),
reorderDays: vi.fn(async () => undefined),
insertDay: vi.fn(async () => undefined),
updateDayTitle: vi.fn(async () => undefined),
@@ -187,6 +188,23 @@ function wrapper({ children }: { children: React.ReactNode }) {
/** Mount with the addon on and the mode on, and wait until both have landed. */
async function renderRoadtrip() {
+ if (!rt.routes.days.length && rt.corridor.day) {
+ const dayId = Number(rt.corridor.day.dayId)
+ const assigned = useTripStore.getState().assignments[String(dayId)] ?? []
+ const stops = assigned.length
+ ? assigned.filter(a => typeof a.place.lat === 'number' && typeof a.place.lng === 'number').map(a => ({
+ assignmentId: a.id, placeId: a.place_id, lat: a.place.lat, lng: a.place.lng,
+ }))
+ : [0, 1, 2].map(i => ({ assignmentId: i + 1, placeId: i + 1, lat: 53 - i, lng: 10 + i }))
+ rt.routes.days = [{ ...rt.corridor.day, stops }]
+ }
+ rt.routes.days = rt.routes.days.map(day => ({
+ ...day,
+ stops: (day.stops as Array>).map((stop, i) => ({
+ ownerDayId: day.dayId, ownerIndex: i, ...stop,
+ })),
+ }))
+ if (rt.corridor.day) rt.corridor.day = rt.routes.days.find(d => d.dayId === rt.corridor.day?.dayId) ?? rt.corridor.day
const rendered = renderHook(() => useTripPlanner(), { wrapper })
await act(async () => { await Promise.resolve() })
await waitFor(() => expect(rendered.result.current.roadtripActive).toBe(true))
@@ -311,6 +329,51 @@ afterEach(() => {
vi.restoreAllMocks()
})
+describe('visit day-end controls', () => {
+ const setup = async () => {
+ const place = buildPlace({ id: 101 })
+ seedTrip({ places: [place], days: [buildDay({ id: 5 })] })
+ rt.routes.days = [{ dayId: 5, stops: [{ assignmentId: 11, placeId: 101, endDay: true }] }]
+ useSettingsStore.setState(s => ({ settings: { ...s.settings, roadtrip_day_start: '08:00', roadtrip_day_end: '18:00' } }))
+ const rendered = await renderRoadtrip()
+ act(() => rendered.result.current.selectAssignment(11, 101))
+ return rendered
+ }
+
+ it('offers the selected visit and saves to its stored day', async () => {
+ const { result } = await setup()
+ expect(result.current.roadtripEndDay?.active).toBe(true)
+ await act(async () => result.current.roadtripEndDay?.onToggle())
+ expect(actions.setAssignmentEndDay).toHaveBeenCalledWith(42, 5, 11, false)
+ })
+
+ it('hides the control when daily times are off and restores the stored choice when enabled', async () => {
+ const { result } = await setup()
+ act(() => useSettingsStore.setState(s => ({ settings: { ...s.settings, roadtrip_day_end: '' } })))
+ expect(result.current.roadtripEndDay).toBeUndefined()
+ act(() => useSettingsStore.setState(s => ({ settings: { ...s.settings, roadtrip_day_end: '18:00' } })))
+ expect(result.current.roadtripEndDay?.active).toBe(true)
+ })
+
+ it('hides the control in Days mode and from a reader', async () => {
+ const { result } = await setup()
+ act(() => result.current.toggleRoadtripMode())
+ expect(result.current.roadtripEndDay).toBeUndefined()
+ act(() => {
+ result.current.toggleRoadtripMode()
+ asReader('day_edit')
+ })
+ expect(result.current.roadtripEndDay).toBeUndefined()
+ })
+
+ it('reports a rejected change', async () => {
+ const { result } = await setup()
+ actions.setAssignmentEndDay.mockRejectedValueOnce(new Error('Save failed'))
+ await act(async () => result.current.roadtripEndDay?.onToggle())
+ expect(toasts.some(t => t.type === 'error')).toBe(true)
+ })
+})
+
describe('useTripPlanner road trip: a hit on the drive', () => {
it('FE-TP-ROAD-001: a corridor hit opens the popup on the day being searched, at its place in the chain', async () => {
seedTrip({ days: [buildDay({ id: 5, day_number: 1 })] })
diff --git a/client/src/pages/tripPlanner/useTripPlanner.ts b/client/src/pages/tripPlanner/useTripPlanner.ts
index 9aa3dcfbb..43f737bd3 100644
--- a/client/src/pages/tripPlanner/useTripPlanner.ts
+++ b/client/src/pages/tripPlanner/useTripPlanner.ts
@@ -22,7 +22,11 @@ import { useAuthStore } from '../../store/authStore'
import { useResizablePanels } from '../../hooks/useResizablePanels'
import { useTripWebSocket } from '../../hooks/useTripWebSocket'
import { useRouteCalculation } from '../../hooks/useRouteCalculation'
-import { useRoadtripRoutes } from '../../components/Roadtrip/useRoadtripRoutes'
+import { useRoadtripRoutes, type RoadtripStop } from '../../components/Roadtrip/useRoadtripRoutes'
+import { useAutomaticDayPoints } from '../../components/Roadtrip/useAutomaticDayPoints'
+import { useDayBoundaries } from '../../components/Roadtrip/useDayBoundaries'
+import type { DayBoundaryControls } from '../../components/Map/dayBoundaryDrag'
+import { dayWindow, roadtripInsertion } from '../../components/Roadtrip/dayWindow'
import { useRoadtripCorridor } from '../../components/Roadtrip/useRoadtripCorridor'
import { useRoadtripVias } from '../../components/Roadtrip/useRoadtripVias'
import { useRefuelSearch } from '../../components/Roadtrip/useRefuelSearch'
@@ -540,6 +544,14 @@ export function useTripPlanner() {
// Road trip mode reads the whole trip, not the selected day, so it owns its own legs.
// Passing no days while the mode is off keeps it inert — no routing requests, no state.
const roadtripActive = !!enabledAddons.roadtrip && roadtripMode
+ const dailyTimesActive = !!dayWindow(settings.roadtrip_day_start, settings.roadtrip_day_end)
+ const dayBoundaries = useDayBoundaries(tripId, roadtripActive && dailyTimesActive, assignments)
+ useEffect(() => { if (dayBoundaries.stale) toast.error(t('trip.toast.loadError')) }, [dayBoundaries.stale, toast, t])
+ const resetDayBoundaries = dayBoundaries.editable && dayBoundaries.boundaries.length && can('day_edit', trip) ? async () => {
+ try {
+ for (const boundary of dayBoundaries.boundaries) await dayBoundaries.save(boundary.day_number, null)
+ } catch (err: unknown) { toast.error(err instanceof Error ? err.message : t('common.unknownError')) }
+ } : undefined
const roadtripVias = useRoadtripVias(tripId, roadtripActive)
const refuel = useRefuelSearch()
const roadtripRoutes = useRoadtripRoutes(
@@ -548,6 +560,7 @@ export function useTripPlanner() {
assignments,
routeProfile,
roadtripVias.byDay,
+ dayBoundaries.boundaries,
)
// Lives here rather than in the panel because the map draws what it finds.
const roadtripCorridor = useRoadtripCorridor(roadtripRoutes)
@@ -707,20 +720,24 @@ export function useTripPlanner() {
// the chain in driving order instead of being dragged there afterwards.
const hit = roadtripActive && 'alongKm' in poi ? (poi as unknown as CorridorPoi) : null
if (hit && roadtripDayId != null) {
+ const displayed = roadtripRoutes.days.find(d => d.dayId === roadtripDayId)
+ const insert = displayed && roadtripInsertion(displayed, roadtripInsertIndexFor(hit))
+ if (!insert) return
setStopDraft({
poi: hit,
- dayId: roadtripDayId,
- position: roadtripInsertIndexFor(hit),
+ ...insert,
dayNumber: roadtripDayNumber,
// Only for a hit somebody could sleep at, and it is what gives the popup its
// second mode. The check-out options are the days from this one on in travel
// order; the default is the next one, which is what a night usually means.
- ...(isOvernightCategory(hit.category) ? { overnight: overnightOptions(roadtripDayId) } : {}),
+ ...(isOvernightCategory(hit.category) ? { overnight: overnightOptions(insert.dayId) } : {}),
})
return
}
- openAddPlaceFromPoi(poi, roadtripActive ? roadtripDayId : undefined)
- }, [openAddPlaceFromPoi, roadtripActive, roadtripDayId, roadtripDayNumber, roadtripInsertIndexFor, overnightOptions, can, trip])
+ const selected = roadtripRoutes.days.find(d => d.dayId === roadtripDayId)
+ const target = selected && roadtripInsertion(selected, selected.stops.length)
+ openAddPlaceFromPoi(poi, roadtripActive ? target?.dayId ?? roadtripDayId : undefined)
+ }, [openAddPlaceFromPoi, roadtripActive, roadtripDayId, roadtripDayNumber, roadtripInsertIndexFor, roadtripRoutes.days, overnightOptions, can, trip])
/**
* The stops of a day as the road trip counts them, in the order it drives them.
@@ -830,11 +847,11 @@ export function useTripPlanner() {
const hidden = new Set()
for (const day of roadtripRoutes.days) {
if (!collapsedRoadtripDays.has(day.dayId)) continue
- for (const stop of day.stops) hidden.add(stop.placeId)
+ for (const stop of day.stops) if (!stop.automaticNight) hidden.add(stop.placeId)
}
for (const day of roadtripRoutes.days) {
if (collapsedRoadtripDays.has(day.dayId)) continue
- for (const stop of day.stops) hidden.delete(stop.placeId)
+ for (const stop of day.stops) if (!stop.automaticNight) hidden.delete(stop.placeId)
}
return mapPlaces.filter(p => !hidden.has(p.id))
}, [mapPlaces, roadtripRoutes.days, collapsedRoadtripDays])
@@ -1044,6 +1061,20 @@ export function useTripPlanner() {
*/
const [stayDraft, setStayDraft] = useState<{ placeId: number; name: string; minutes: number | null; arrival: string | null } | null>(null)
+ const setRoadtripEndDay = useCallback(async (stop: RoadtripStop) => {
+ if (!dailyTimesActive || !can('day_edit', trip)) return
+ try {
+ const manual = dayBoundaries.boundaries.find(b => b.to_assignment_id === null && b.from_assignment_id === stop.assignmentId)
+ if (manual) {
+ await dayBoundaries.save(manual.day_number, null)
+ if (!stop.endDay) return
+ }
+ await tripActions.setAssignmentEndDay(tripId, stop.ownerDayId, stop.assignmentId, !stop.endDay)
+ } catch (err: unknown) {
+ toast.error(err instanceof Error ? err.message : t('common.unknownError'))
+ }
+ }, [dailyTimesActive, can, trip, tripActions, tripId, toast, t, dayBoundaries.boundaries, dayBoundaries.save])
+
/**
* How long the traveller stays at one stop.
*
@@ -1177,11 +1208,33 @@ export function useTripPlanner() {
* They are the newer, smaller and more specific answer, so they take the view from the
* alternatives rather than being averaged with them into a frame that shows neither.
*/
+ const automaticPoints = useAutomaticDayPoints(roadtripRoutes, collapsedRoadtripDays)
+ const focusRoadtripPoint = useCallback((lat: number, lng: number) => {
+ refuel.close()
+ routeAlternatives.close()
+ automaticPoints.focusPoint(lat, lng)
+ }, [refuel, routeAlternatives, automaticPoints])
+ const roadtripMapVias = automaticPoints.markers
+ const dayBoundaryControls = useMemo(() => {
+ if (!dayBoundaries.editable || !can('day_edit', trip) || !roadtripRoutes.boundaryPath?.length) return undefined
+ return {
+ path: roadtripRoutes.boundaryPath,
+ hint: t('roadtrip.window.dragHint'),
+ move: async (day, boundary) => {
+ const next = dayBoundaries.boundaries.filter(b => b.day_number !== day)
+ if (boundary) next.push(boundary)
+ const issue = roadtripRoutes.validateBoundaries?.(next)
+ if (boundary && issue) { toast.error(t(`roadtrip.window.${issue}`)); return false }
+ try { return await dayBoundaries.save(day, boundary) }
+ catch (err: unknown) { toast.error(err instanceof Error ? err.message : t('common.unknownError')); return false }
+ },
+ }
+ }, [dayBoundaries.editable, dayBoundaries.boundaries, dayBoundaries.save, can, trip, roadtripRoutes, t, toast])
const mapFocusPoints = useMemo<[number, number][]>(
() => (refuel.offered.length
? refuel.offered.map(p => [p.lat, p.lng] as [number, number])
- : alternativeFocusPoints),
- [refuel.offered, alternativeFocusPoints],
+ : alternativeFocusPoints.length ? alternativeFocusPoints : automaticPoints.focusPoints ?? alternativeFocusPoints),
+ [refuel.offered, alternativeFocusPoints, automaticPoints.focusPoints],
)
/** Asks the router for other ways of driving one leg of one day. */
@@ -1196,8 +1249,8 @@ export function useTripPlanner() {
}
// The vias on THIS leg, so the road currently driven is offered alongside the
// router's own suggestions rather than being missing from its own picker.
- const dayIndex = day.stops.indexOf(from)
- const legVias = (roadtripVias.byDay[dayId] ?? [])
+ const dayIndex = from.ownerIndex
+ const legVias = (roadtripVias.byDay[from.ownerDayId] ?? [])
.filter(v => v.after_order_index === dayIndex)
.sort((a, b) => a.sequence - b.sequence)
routeAlternatives.ask(dayId, legIndex, from, to, routeProfile, legVias)
@@ -1221,7 +1274,7 @@ export function useTripPlanner() {
if (alt.direct || !alt.divergence) {
const day = roadtripRoutes.days.find(d => d.dayId === open.dayId)
const stop = day?.stops[open.index]
- const dayIndex = stop && day ? day.stops.indexOf(stop) : -1
+ const dayIndex = stop?.ownerIndex ?? -1
// Clearing the leg in one write. One delete per via meant a full trip re-route
// between each of them, so undoing a detour with three vias drew three routes.
//
@@ -1231,7 +1284,7 @@ export function useTripPlanner() {
// request failed, not even the reload ran to contradict them.
if (dayIndex >= 0) {
try {
- await roadtripVias.addMany(open.dayId, [], [dayIndex])
+ await roadtripVias.addMany(stop!.ownerDayId, [], [dayIndex])
} catch (err: unknown) {
toast.error(err instanceof Error ? err.message : t('common.unknownError'))
return
@@ -1402,7 +1455,7 @@ export function useTripPlanner() {
const anchor = day.stops[at]
if (!anchor) return
refuel.close()
- setStopDraft({ poi, dayId: anchor.ownerDayId, position: anchor.ownerIndex, dayNumber: day.dayNumber })
+ setStopDraft({ poi, ...roadtripInsertion(day, at)!, dayNumber: day.dayNumber })
}, [roadtripRoutes.days, refuel, can, trip])
/** Removing a via lets the drive take the direct road again. */
@@ -1435,10 +1488,11 @@ export function useTripPlanner() {
if (!hit || !day) return
const at = projectOntoRoute({ lat, lng }, roadtripCorridor.search.spine)
if (!at || at.offRouteKm > roadtripCorridor.widthKm) return
+ const insert = roadtripInsertion(day, insertIndexForAlong(roadtripCorridor.stopsAlongKm, at.alongKm))
+ if (!insert) return
setStopDraft({
poi: hit,
- dayId: day.dayId,
- position: insertIndexForAlong(roadtripCorridor.stopsAlongKm, at.alongKm),
+ ...insert,
dayNumber: day.dayNumber,
})
}, [roadtripCorridor, can, trip])
@@ -1968,6 +2022,16 @@ export function useTripPlanner() {
}
const selectedPlace = selectedPlaceId ? places.find(p => p.id === selectedPlaceId) : null
+ const selectedRoadtripStops = roadtripRoutes.days.flatMap(day => day.stops).filter(stop =>
+ !stop.automaticNight && (selectedAssignmentId ? stop.assignmentId === selectedAssignmentId : stop.placeId === selectedPlaceId),
+ )
+ const endDayStop = selectedRoadtripStops.length === 1 ? selectedRoadtripStops[0] : undefined
+ const roadtripEndDay = roadtripActive && dailyTimesActive && can('day_edit', trip) && endDayStop && endDayStop.assignmentId > 0
+ ? { active: !!endDayStop.endDay || dayBoundaries.boundaries.some(b => b.to_assignment_id === null && b.from_assignment_id === endDayStop.assignmentId), onToggle: () => setRoadtripEndDay(endDayStop) }
+ : undefined
+ const roadtripStay = roadtripActive && selectedPlace
+ ? { minutes: selectedPlace.duration_minutes ?? null, onEdit: can('place_edit', trip) ? () => setStayDraft({ placeId: selectedPlace.id, name: selectedPlace.name, minutes: selectedPlace.duration_minutes ?? null, arrival: null }) : undefined }
+ : undefined
// Build placeId → order-number map from the selected day's assignments
const dayOrderMap = useMemo(() => {
@@ -2025,10 +2089,10 @@ export function useTripPlanner() {
setRoadtripStopKind,
setRoadtripStopFill,
saveRoadtripLimit,
- roadtripVias, addRoadtripVia, moveRoadtripVia, removeRoadtripVia,
+ roadtripVias, addRoadtripVia, moveRoadtripVia, removeRoadtripVia, dayBoundaryControls, resetDayBoundaries,
refuel, askRefuel, acceptRefuel,
- routeAlternatives, askRouteAlternatives, chooseRouteAlternative, alternativeOverlays, alternativeFocusPoints, mapFocusPoints,
- stayDraft, setStayDraft, setRoadtripStay,
+ routeAlternatives, askRouteAlternatives, chooseRouteAlternative, alternativeOverlays, alternativeFocusPoints, mapFocusPoints, roadtripMapVias, focusRoadtripPoint,
+ stayDraft, setStayDraft, setRoadtripStay, roadtripEndDay, roadtripStay,
highlightedAlternative, setHighlightedAlternative,
moveRoadtripStopToDay,
dropPoiOnRoute,
diff --git a/client/src/repo/assignmentRepo.test.ts b/client/src/repo/assignmentRepo.test.ts
new file mode 100644
index 000000000..3187c8f65
--- /dev/null
+++ b/client/src/repo/assignmentRepo.test.ts
@@ -0,0 +1,52 @@
+import 'fake-indexeddb/auto'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { assignmentRepo } from './assignmentRepo'
+import { offlineDb, clearAll } from '../db/offlineDb'
+import { saveAssignmentEndDay } from '../api/assignmentEndDay'
+import { isEffectivelyOffline } from '../sync/networkMode'
+import { mutationQueue } from '../sync/mutationQueue'
+import { apiClient } from '../api/client'
+import type { Assignment, Day } from '../types'
+
+vi.mock('../api/assignmentEndDay', () => ({ saveAssignmentEndDay: vi.fn() }))
+vi.mock('../sync/networkMode', () => ({ isEffectivelyOffline: vi.fn(() => true) }))
+vi.mock('../sync/authGate', () => ({ isAuthed: () => true }))
+vi.mock('../api/client', () => ({ apiClient: { request: vi.fn() } }))
+const assignment = { id: 7, day_id: 1, place_id: 2, order_index: 0, assignment_time: '07:00', place: { id: 2, name: 'Berlin' } } as Assignment
+
+beforeEach(async () => {
+ await clearAll()
+ vi.clearAllMocks()
+ vi.mocked(isEffectivelyOffline).mockReturnValue(true)
+ await offlineDb.days.put({ id: 1, trip_id: 9, day_number: 1, assignments: [assignment] } as Day)
+})
+
+describe('assignment day-end persistence', () => {
+ it('stores the offline flag with a replayable write and preserves manual time', async () => {
+ await assignmentRepo.setEndDay(9, assignment, true)
+ expect((await offlineDb.days.get(1))?.assignments?.[0]).toMatchObject({ end_day: true, assignment_time: '07:00' })
+ expect(await offlineDb.mutationQueue.toArray()).toEqual([expect.objectContaining({
+ url: '/trips/9/assignments/7/end-day', method: 'PUT', body: { end_day: true }, resource: 'assignments',
+ })])
+ vi.mocked(isEffectivelyOffline).mockReturnValue(false)
+ vi.mocked(apiClient.request).mockResolvedValue({ data: { assignment: { ...assignment, end_day: true } } })
+ await mutationQueue.flush()
+ expect(await offlineDb.mutationQueue.count()).toBe(0)
+ expect((await offlineDb.days.get(1))?.assignments?.[0].end_day).toBe(true)
+ })
+
+ it('saves and clears through the online API', async () => {
+ vi.mocked(isEffectivelyOffline).mockReturnValue(false)
+ vi.mocked(saveAssignmentEndDay).mockResolvedValue({ ...assignment, end_day: false })
+ await assignmentRepo.setEndDay(9, assignment, false)
+ expect(saveAssignmentEndDay).toHaveBeenCalledWith(9, 7, { end_day: false })
+ expect((await offlineDb.days.get(1))?.assignments?.[0].end_day).toBe(false)
+ })
+
+ it('keeps the cached visit unchanged after a rejected save', async () => {
+ vi.mocked(isEffectivelyOffline).mockReturnValue(false)
+ vi.mocked(saveAssignmentEndDay).mockRejectedValue(new Error('Denied'))
+ await expect(assignmentRepo.setEndDay(9, assignment, true)).rejects.toThrow('Denied')
+ expect((await offlineDb.days.get(1))?.assignments?.[0].end_day).toBeUndefined()
+ })
+})
diff --git a/client/src/repo/assignmentRepo.ts b/client/src/repo/assignmentRepo.ts
new file mode 100644
index 000000000..95b3e0645
--- /dev/null
+++ b/client/src/repo/assignmentRepo.ts
@@ -0,0 +1,26 @@
+import { saveAssignmentEndDay } from '../api/assignmentEndDay'
+import { offlineDb } from '../db/offlineDb'
+import { cacheAssignment } from '../db/cacheAssignment'
+import { generateUUID, mutationQueue } from '../sync/mutationQueue'
+import { isEffectivelyOffline } from '../sync/networkMode'
+import type { Assignment } from '../types'
+
+export const assignmentRepo = {
+ async setEndDay(tripId: number | string, assignment: Assignment, endDay: boolean): Promise {
+ if (!isEffectivelyOffline()) {
+ const saved = await saveAssignmentEndDay(tripId, assignment.id, { end_day: endDay })
+ await cacheAssignment(saved)
+ return saved
+ }
+ const updated = { ...assignment, end_day: endDay }
+ await offlineDb.transaction('rw', offlineDb.days, offlineDb.mutationQueue, async () => {
+ await mutationQueue.enqueue({
+ id: generateUUID(), tripId: Number(tripId), method: 'PUT',
+ url: `/trips/${tripId}/assignments/${assignment.id}/end-day`,
+ body: { end_day: endDay }, resource: 'assignments', entityId: assignment.id,
+ })
+ await cacheAssignment(updated)
+ })
+ return updated
+ },
+}
diff --git a/client/src/store/slices/assignmentsSlice.ts b/client/src/store/slices/assignmentsSlice.ts
index 45a2c786b..0b367ffd8 100644
--- a/client/src/store/slices/assignmentsSlice.ts
+++ b/client/src/store/slices/assignmentsSlice.ts
@@ -3,11 +3,13 @@ import type { StoreApi } from 'zustand'
import type { TripStoreState } from '../tripStore'
import type { Assignment, AssignmentsMap } from '../../types'
import { getApiErrorMessage } from '../../types'
+import { assignmentRepo } from '../../repo/assignmentRepo'
type SetState = StoreApi['setState']
type GetState = StoreApi['getState']
export interface AssignmentsSlice {
+ setAssignmentEndDay: (tripId: number | string, dayId: number, assignmentId: number, endDay: boolean) => Promise
assignPlaceToDay: (tripId: number | string, dayId: number | string, placeId: number | string, position?: number | null) => Promise
removeAssignment: (tripId: number | string, dayId: number | string, assignmentId: number) => Promise
reorderAssignments: (tripId: number | string, dayId: number | string, orderedIds: number[]) => Promise
@@ -16,6 +18,23 @@ export interface AssignmentsSlice {
}
export const createAssignmentsSlice = (set: SetState, get: GetState): AssignmentsSlice => ({
+ setAssignmentEndDay: async (tripId, dayId, assignmentId, endDay) => {
+ const assignment = get().assignments[String(dayId)]?.find(a => a.id === assignmentId)
+ if (!assignment || assignmentId < 0) return
+ const apply = (value: boolean) => set(state => ({
+ assignments: Object.fromEntries(Object.entries(state.assignments).map(([key, items]) => [
+ key, items.map(a => a.id === assignmentId ? { ...a, end_day: value } : a),
+ ])),
+ }))
+ apply(endDay)
+ try {
+ const saved = await assignmentRepo.setEndDay(tripId, assignment, endDay)
+ apply(saved.end_day === true)
+ } catch (err: unknown) {
+ apply(assignment.end_day === true)
+ throw err
+ }
+ },
assignPlaceToDay: async (tripId, dayId, placeId, position) => {
const state = get()
const place = state.places.find(p => p.id === Number.parseInt(String(placeId)))
diff --git a/client/src/sync/mutationQueue.ts b/client/src/sync/mutationQueue.ts
index 0eff392d1..946e1b0a2 100644
--- a/client/src/sync/mutationQueue.ts
+++ b/client/src/sync/mutationQueue.ts
@@ -13,6 +13,8 @@ import { getOfflinePrefs } from './offlinePrefs'
import { randomId } from '../utils/randomId'
import type { QueuedMutation } from '../db/offlineDb'
import type { Table } from 'dexie'
+import { assignmentSchema } from '@trek/shared'
+import { cacheAssignment } from '../db/cacheAssignment'
// Map Dexie table names used in `resource` field → actual Dexie tables.
function getTable(resource: string): Table | undefined {
@@ -194,6 +196,9 @@ export const mutationQueue = {
})
// Apply canonical server response to Dexie
+ if (mutation.resource === 'assignments') {
+ await cacheAssignment(assignmentSchema.parse(response.data.assignment))
+ }
if (mutation.method !== 'DELETE' && mutation.resource) {
const table = getTable(mutation.resource)
if (table && response.data && typeof response.data === 'object') {
diff --git a/client/src/types.ts b/client/src/types.ts
index 39ae6ca02..d082992c7 100644
--- a/client/src/types.ts
+++ b/client/src/types.ts
@@ -148,6 +148,9 @@ export interface Settings {
*/
roadtrip_leg_minutes?: number
roadtrip_day_minutes?: number
+ roadtrip_day_start?: string
+ roadtrip_day_end?: string
+ roadtrip_day_end_mode?: 'route' | 'stop'
roadtrip_range_km?: number
/**
* Road classes the drive should leave out where it can, as a comma list
@@ -256,6 +259,8 @@ export interface RouteSegment {
/** An intermediate stop a plugin route places on the drawn line (charging stop, rest area). */
export interface RouteVia {
+ hoverCard?: boolean
+ nightPause?: { day: number; atPlace: boolean; position?: number; manual?: boolean; minPosition?: number; maxPosition?: number }
lat: number
lng: number
label?: string
diff --git a/client/tests/unit/mobile/admin/MAdminDefaultUserSettings.test.tsx b/client/tests/unit/mobile/admin/MAdminDefaultUserSettings.test.tsx
index 419ab5561..773fd7fb4 100644
--- a/client/tests/unit/mobile/admin/MAdminDefaultUserSettings.test.tsx
+++ b/client/tests/unit/mobile/admin/MAdminDefaultUserSettings.test.tsx
@@ -408,6 +408,39 @@ describe('MAdminDefaultUserSettings', () => {
await screen.findByText('Default User Settings');
expect(screen.queryByText('Shared CARTO key')).not.toBeInTheDocument();
+ expect(screen.queryByPlaceholderText('https://osrm.example.org')).not.toBeInTheDocument();
+ expect(screen.queryByPlaceholderText('https://valhalla.example.org')).not.toBeInTheDocument();
+ });
+
+ it.each([
+ ['routing_base_url', 'https://osrm.example.org'],
+ ['valhalla_base_url', 'https://valhalla.example.org'],
+ ])('loads, saves and resets the mobile %s field', async (key, placeholder) => {
+ const { puts } = stubDefaults({ [key]: 'https://router.example.org' });
+ render();
+ const input = await screen.findByPlaceholderText(placeholder);
+ expect(input).toHaveValue('https://router.example.org');
+ fireEvent.change(input, { target: { value: ' https://new.example.org ' } });
+ expect(puts).toEqual([]);
+ fireEvent.blur(input);
+ await waitFor(() => expect(puts).toEqual([{ [key]: 'https://new.example.org' }]));
+ await waitFor(() => expect(input).toHaveValue('https://new.example.org'));
+ await waitFor(() => expect(input).toBeEnabled());
+ fireEvent.click(within(input.parentElement!).getByRole('button', { name: 'reset' }));
+ await waitFor(() => expect(input).toHaveValue(''));
+ expect(puts[1]).toEqual({ [key]: null });
+ });
+
+ it('restores the saved routing URL and shows the error when saving fails', async () => {
+ stubDefaults({ routing_base_url: 'https://router.example.org' });
+ server.use(http.put('/api/admin/default-user-settings', () => HttpResponse.json({ error: 'Routing URL rejected' }, { status: 400 })));
+ withToast();
+ const input = await screen.findByPlaceholderText('https://osrm.example.org');
+ fireEvent.change(input, { target: { value: 'https://new.example.org' } });
+ fireEvent.blur(input);
+ expect(await screen.findByText('Routing URL rejected')).toBeInTheDocument();
+ await waitFor(() => expect(input).toHaveValue('https://router.example.org'));
+ expect(input).toBeEnabled();
});
it('FE-MOB-MDUS-027: a managed instance hides the shared Mapbox token as well', async () => {
diff --git a/server/src/db/migrations.ts b/server/src/db/migrations.ts
index d9746f80a..71bfe1960 100644
--- a/server/src/db/migrations.ts
+++ b/server/src/db/migrations.ts
@@ -4534,6 +4534,22 @@ function runMigrations(db: Database.Database): void {
db.exec('ALTER TABLE places ADD COLUMN fill_percent INTEGER');
}
},
+ () => {
+ const cols = db.prepare("SELECT name FROM pragma_table_info('day_assignments')").all() as Array<{ name: string }>;
+ if (!cols.some(c => c.name === 'end_day')) {
+ db.exec('ALTER TABLE day_assignments ADD COLUMN end_day INTEGER NOT NULL DEFAULT 0');
+ }
+ },
+ () => {
+ db.exec(`CREATE TABLE IF NOT EXISTS roadtrip_day_boundaries (
+ trip_id INTEGER NOT NULL REFERENCES trips(id) ON DELETE CASCADE,
+ day_number INTEGER NOT NULL CHECK (day_number BETWEEN 1 AND 366),
+ from_assignment_id INTEGER NOT NULL REFERENCES day_assignments(id) ON DELETE CASCADE,
+ to_assignment_id INTEGER REFERENCES day_assignments(id) ON DELETE CASCADE,
+ fraction REAL NOT NULL CHECK (fraction BETWEEN 0 AND 1),
+ PRIMARY KEY (trip_id, day_number)
+ )`);
+ },
];
if (currentVersion < migrations.length) {
diff --git a/server/src/nest/assignments/assignments.controller.ts b/server/src/nest/assignments/assignments.controller.ts
index f36718c59..3d5908cb9 100644
--- a/server/src/nest/assignments/assignments.controller.ts
+++ b/server/src/nest/assignments/assignments.controller.ts
@@ -17,6 +17,7 @@ import {
AssignmentReorderDto,
AssignmentMoveDto,
AssignmentTimeDto,
+ AssignmentEndDayDto,
AssignmentNotesDto,
AssignmentTransportDto,
AssignmentParticipantsDto,
@@ -172,6 +173,22 @@ export class AssignmentOpsController {
return { assignment };
}
+ @RequirePermission('day_edit')
+ @Put(':id/end-day')
+ endDay(
+ @Param('tripId') tripId: string,
+ @Param('id') id: string,
+ @Body() body: AssignmentEndDayDto,
+ @Headers('x-socket-id') socketId?: string,
+ ) {
+ if (!this.assignments.getAssignmentForTrip(id, tripId)) {
+ throw new HttpException({ error: 'Assignment not found' }, 404);
+ }
+ const assignment = this.assignments.setEndDay(id, body.end_day);
+ this.assignments.broadcast(tripId, 'assignment:updated', { assignment }, socketId);
+ return { assignment };
+ }
+
// #2163: the per-assignment note was write-once (create bodies, MCP, plugin
// RPC) with no edit path anywhere. Same guard shape and 404 body as its
// neighbours; no reconcile — the note doesn't touch the journey skeleton.
diff --git a/server/src/nest/assignments/assignments.dto.ts b/server/src/nest/assignments/assignments.dto.ts
index 5bb19adf1..b7ffa0a72 100644
--- a/server/src/nest/assignments/assignments.dto.ts
+++ b/server/src/nest/assignments/assignments.dto.ts
@@ -4,6 +4,7 @@ import {
assignmentReorderRequestSchema,
assignmentMoveRequestSchema,
assignmentTimeRequestSchema,
+ assignmentEndDayRequestSchema,
assignmentNotesRequestSchema,
assignmentTransportRequestSchema,
assignmentParticipantsRequestSchema,
@@ -20,6 +21,7 @@ export class AssignmentCreateDto extends createZodDto(assignmentCreateRequestSch
export class AssignmentReorderDto extends createZodDto(assignmentReorderRequestSchema) {}
export class AssignmentMoveDto extends createZodDto(assignmentMoveRequestSchema) {}
export class AssignmentTimeDto extends createZodDto(assignmentTimeRequestSchema) {}
+export class AssignmentEndDayDto extends createZodDto(assignmentEndDayRequestSchema) {}
export class AssignmentNotesDto extends createZodDto(assignmentNotesRequestSchema) {}
export class AssignmentTransportDto extends createZodDto(assignmentTransportRequestSchema) {}
export class AssignmentParticipantsDto extends createZodDto(assignmentParticipantsRequestSchema) {}
diff --git a/server/src/nest/assignments/assignments.mcp.ts b/server/src/nest/assignments/assignments.mcp.ts
index 5d6c98492..76b5c0c45 100644
--- a/server/src/nest/assignments/assignments.mcp.ts
+++ b/server/src/nest/assignments/assignments.mcp.ts
@@ -6,6 +6,7 @@ import {
} from '../../nest-mcp';
import { McpToolGuardsService } from '../mcp-shared/mcp-tool-guards.service';
import { z } from 'zod';
+import { assignmentEndDayRequestSchema, type AssignmentEndDayRequest } from '@trek/shared';
import { AuthService } from '../auth/auth.service';
import { noAccess, permissionDenied } from '../../mcp/tools/_shared';
import { AssignmentsService } from './assignments.service';
@@ -56,6 +57,30 @@ export class AssignmentsMcp {
return ok({ assignment });
}
+ @Tool({
+ name: 'set_assignment_end_day',
+ description: 'End the travel day after this visit and its stay. Applies only with daily travel times enabled. Pass false to follow the default again.',
+ inputSchema: {
+ tripId: z.number().int().positive(),
+ assignmentId: z.number().int().positive(),
+ ...assignmentEndDayRequestSchema.shape,
+ },
+ annotations: TOOL_ANNOTATIONS_WRITE,
+ access: { group: 'places', mode: 'write' },
+ })
+ async setAssignmentEndDay(
+ { tripId, assignmentId, end_day }: AssignmentEndDayRequest & { tripId: number; assignmentId: number },
+ ctx: McpContext,
+ ) {
+ if (this.auth.isDemoUser(ctx.userId)) return demoDenied();
+ if (!this.assignments.verifyTripAccess(tripId, ctx.userId)) return noAccess();
+ if (!this.guards.hasTripPermission('day_edit', tripId, ctx.userId)) return permissionDenied();
+ if (!this.assignments.getAssignmentForTrip(assignmentId, tripId)) return errorResult('Assignment not found.');
+ const assignment = this.assignments.setEndDay(assignmentId, end_day);
+ this.guards.safeBroadcast(tripId, 'assignment:updated', { assignment });
+ return ok({ assignment });
+ }
+
@Tool({
name: 'unassign_place',
description: 'Remove a place assignment from a day.',
diff --git a/server/src/nest/assignments/assignments.service.ts b/server/src/nest/assignments/assignments.service.ts
index e745aed32..56af252fe 100644
--- a/server/src/nest/assignments/assignments.service.ts
+++ b/server/src/nest/assignments/assignments.service.ts
@@ -225,6 +225,11 @@ export class AssignmentsService {
return this.getAssignmentWithPlace(Number(id));
}
+ setEndDay(id: string | number, endDay: boolean) {
+ this.dbs.run('UPDATE day_assignments SET end_day = ? WHERE id = ?', endDay ? 1 : 0, id);
+ return this.getAssignmentWithPlace(Number(id));
+ }
+
/**
* Edit the per-assignment note after creation (#2163) — until now the note
* was write-once via the create paths (REST body, MCP tools, plugin RPC) and
diff --git a/server/src/nest/common/rowShape.ts b/server/src/nest/common/rowShape.ts
index 2c964e8ec..d4a5f2062 100644
--- a/server/src/nest/common/rowShape.ts
+++ b/server/src/nest/common/rowShape.ts
@@ -18,6 +18,7 @@ export function formatAssignmentWithPlace(a: AssignmentRow, tags: Partial[]
notes: a.notes,
assignment_time: a.assignment_time ?? null,
assignment_end_time: a.assignment_end_time ?? null,
+ end_day: a.end_day === 1,
leg_transport_mode: a.leg_transport_mode ?? null,
incoming_leg_transport_mode: a.incoming_leg_transport_mode ?? null,
participants: participants || [],
diff --git a/server/src/nest/days/days.service.ts b/server/src/nest/days/days.service.ts
index 8a471ab4a..c73fc28b8 100644
--- a/server/src/nest/days/days.service.ts
+++ b/server/src/nest/days/days.service.ts
@@ -112,6 +112,7 @@ export class DaysService {
id: a.id,
day_id: a.day_id,
order_index: a.order_index,
+ end_day: a.end_day === 1,
notes: a.notes,
created_at: a.created_at,
place: {
diff --git a/server/src/nest/roadtrip/day-boundaries.controller.ts b/server/src/nest/roadtrip/day-boundaries.controller.ts
new file mode 100644
index 000000000..aca3d9ca7
--- /dev/null
+++ b/server/src/nest/roadtrip/day-boundaries.controller.ts
@@ -0,0 +1,40 @@
+import { Body, Controller, Delete, Get, Headers, Param, ParseIntPipe, Put, UseGuards } from '@nestjs/common';
+import { createZodDto } from 'nestjs-zod';
+import { roadtripDayBoundarySchema } from '@trek/shared';
+import { ADDON_IDS } from '../../addons';
+import { RequireAddon } from '../addons/require-addon.decorator';
+import { AddonGuard } from '../addons/addon.guard';
+import { JwtAuthGuard } from '../auth/jwt-auth.guard';
+import { RequirePermission, TripAccessGuard } from '../permissions/trip-access.guard';
+import { RealtimeService } from '../realtime/realtime.service';
+import { DayBoundariesService } from './day-boundaries.service';
+
+class DayBoundaryDto extends createZodDto(roadtripDayBoundarySchema) {}
+
+@Controller('api/trips/:tripId/roadtrip/day-boundaries')
+@UseGuards(AddonGuard, JwtAuthGuard, TripAccessGuard)
+@RequireAddon(ADDON_IDS.ROADTRIP, 'Road trip')
+export class DayBoundariesController {
+ constructor(private readonly boundaries: DayBoundariesService, private readonly realtime: RealtimeService) {}
+
+ @Get()
+ list(@Param('tripId') tripId: string) {
+ return { boundaries: this.boundaries.list(tripId) };
+ }
+
+ @Put()
+ @RequirePermission('day_edit')
+ save(@Param('tripId') tripId: string, @Body() body: DayBoundaryDto, @Headers('x-socket-id') socketId?: string) {
+ const boundaries = this.boundaries.save(tripId, body);
+ this.realtime.broadcast(tripId, 'roadtripBoundary:changed', { boundaries }, socketId);
+ return { boundaries };
+ }
+
+ @Delete(':dayNumber')
+ @RequirePermission('day_edit')
+ remove(@Param('tripId') tripId: string, @Param('dayNumber', ParseIntPipe) dayNumber: number, @Headers('x-socket-id') socketId?: string) {
+ const boundaries = this.boundaries.remove(tripId, dayNumber);
+ this.realtime.broadcast(tripId, 'roadtripBoundary:changed', { boundaries }, socketId);
+ return { boundaries };
+ }
+}
diff --git a/server/src/nest/roadtrip/day-boundaries.mcp.ts b/server/src/nest/roadtrip/day-boundaries.mcp.ts
new file mode 100644
index 000000000..0a35a457f
--- /dev/null
+++ b/server/src/nest/roadtrip/day-boundaries.mcp.ts
@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { roadtripDayBoundarySchema, type RoadtripDayBoundary } from '@trek/shared';
+import { McpController, Tool, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE, ok, type McpContext } from '../../nest-mcp';
+import { demoDenied, noAccess, permissionDenied } from '../../mcp/tools/_shared';
+import { DatabaseService } from '../database/database.service';
+import { AuthService } from '../auth/auth.service';
+import { McpToolGuardsService } from '../mcp-shared/mcp-tool-guards.service';
+import { RealtimeService } from '../realtime/realtime.service';
+import { AddonsService } from '../addons/addons.service';
+import { addonGate } from '../addons/addon-gate';
+import { ADDON_IDS } from '../../addons';
+import { DayBoundariesService } from './day-boundaries.service';
+
+const when = addonGate(ADDON_IDS.ROADTRIP);
+
+@McpController()
+export class DayBoundariesMcp {
+ constructor(
+ private readonly boundaries: DayBoundariesService,
+ private readonly db: DatabaseService,
+ private readonly auth: AuthService,
+ private readonly guards: McpToolGuardsService,
+ private readonly realtime: RealtimeService,
+ readonly addons: AddonsService,
+ ) {}
+
+ @Tool({
+ name: 'list_day_boundaries', description: 'List manual road trip day endings. They apply only with daily travel times enabled.',
+ inputSchema: { tripId: z.number().int().positive() },
+ annotations: TOOL_ANNOTATIONS_READONLY, access: { group: 'trips', mode: 'read' }, when,
+ })
+ async list({ tripId }: { tripId: number }, ctx: McpContext) {
+ if (!this.db.canAccessTrip(tripId, ctx.userId)) return noAccess();
+ return ok({ boundaries: this.boundaries.list(tripId) });
+ }
+
+ @Tool({
+ name: 'set_day_boundary',
+ description: 'Override a road trip day ending at a visit or a fraction along the driving leg between consecutive visits. Daily travel times must be enabled in the planner. Fixed visit times stay protected and conflicts are shown. Pass null to restore the automatic day ending.',
+ inputSchema: { tripId: z.number().int().positive(), dayNumber: z.number().int().min(1).max(366), boundary: roadtripDayBoundarySchema.nullable() },
+ annotations: TOOL_ANNOTATIONS_WRITE, access: { group: 'trips', mode: 'write' }, when,
+ })
+ async save({ tripId, dayNumber, boundary }: { tripId: number; dayNumber: number; boundary: RoadtripDayBoundary | null }, ctx: McpContext) {
+ if (this.auth.isDemoUser(ctx.userId)) return demoDenied();
+ if (!this.db.canAccessTrip(tripId, ctx.userId)) return noAccess();
+ if (!this.guards.hasTripPermission('day_edit', tripId, ctx.userId)) return permissionDenied();
+ const boundaries = boundary
+ ? this.boundaries.save(tripId, { ...boundary, day_number: dayNumber })
+ : this.boundaries.remove(tripId, dayNumber);
+ this.realtime.broadcast(String(tripId), 'roadtripBoundary:changed', { boundaries });
+ return ok({ boundaries });
+ }
+}
diff --git a/server/src/nest/roadtrip/day-boundaries.service.ts b/server/src/nest/roadtrip/day-boundaries.service.ts
new file mode 100644
index 000000000..bcc74fc15
--- /dev/null
+++ b/server/src/nest/roadtrip/day-boundaries.service.ts
@@ -0,0 +1,33 @@
+import { HttpException, Injectable } from '@nestjs/common';
+import type { RoadtripDayBoundary } from '@trek/shared';
+import { DatabaseService } from '../database/database.service';
+
+@Injectable()
+export class DayBoundariesService {
+ constructor(private readonly db: DatabaseService) {}
+
+ list(tripId: string | number): RoadtripDayBoundary[] {
+ return this.db.all(
+ 'SELECT day_number, from_assignment_id, to_assignment_id, fraction FROM roadtrip_day_boundaries WHERE trip_id = ? ORDER BY day_number', tripId,
+ );
+ }
+
+ save(tripId: string | number, boundary: RoadtripDayBoundary): RoadtripDayBoundary[] {
+ const belongs = (id: number) => this.db.get(
+ 'SELECT a.id FROM day_assignments a JOIN days d ON d.id = a.day_id WHERE a.id = ? AND d.trip_id = ?', id, tripId,
+ );
+ if (!belongs(boundary.from_assignment_id) || boundary.to_assignment_id !== null && !belongs(boundary.to_assignment_id)) {
+ throw new HttpException({ error: 'Stop not found' }, 404);
+ }
+ this.db.run(`INSERT INTO roadtrip_day_boundaries (trip_id, day_number, from_assignment_id, to_assignment_id, fraction)
+ VALUES (?, ?, ?, ?, ?) ON CONFLICT (trip_id, day_number) DO UPDATE SET
+ from_assignment_id = excluded.from_assignment_id, to_assignment_id = excluded.to_assignment_id, fraction = excluded.fraction`,
+ tripId, boundary.day_number, boundary.from_assignment_id, boundary.to_assignment_id, boundary.to_assignment_id === null ? 1 : boundary.fraction);
+ return this.list(tripId);
+ }
+
+ remove(tripId: string | number, dayNumber: number): RoadtripDayBoundary[] {
+ this.db.run('DELETE FROM roadtrip_day_boundaries WHERE trip_id = ? AND day_number = ?', tripId, dayNumber);
+ return this.list(tripId);
+ }
+}
diff --git a/server/src/nest/roadtrip/roadtrip.module.ts b/server/src/nest/roadtrip/roadtrip.module.ts
index 5cdfeecbd..9e224c026 100644
--- a/server/src/nest/roadtrip/roadtrip.module.ts
+++ b/server/src/nest/roadtrip/roadtrip.module.ts
@@ -7,14 +7,17 @@ import { PermissionsModule } from '../permissions/permissions.module';
import { AuthModule } from '../auth/auth.module';
import { RealtimeModule } from '../realtime/realtime.module';
import { AddonsModule } from '../addons/addons.module';
+import { DayBoundariesController } from './day-boundaries.controller';
+import { DayBoundariesService } from './day-boundaries.service';
+import { DayBoundariesMcp } from './day-boundaries.mcp';
/** Road trip domain (#1797): the points a drive is routed through. Registered in AppModule. */
@Module({
// McpShared brings the tool guards, Auth the demo check, Permissions the trip guard,
// Addons the enabled-check the MCP tools gate on (the controller has @RequireAddon).
imports: [McpSharedModule, PermissionsModule, AuthModule, AddonsModule, RealtimeModule],
- controllers: [RoadtripController],
- providers: [RoadtripService, RoadtripMcp],
+ controllers: [RoadtripController, DayBoundariesController],
+ providers: [RoadtripService, RoadtripMcp, DayBoundariesService, DayBoundariesMcp],
exports: [RoadtripService],
})
export class RoadtripModule {}
diff --git a/server/src/nest/trips/trips.service.ts b/server/src/nest/trips/trips.service.ts
index 9d1b49158..e3d122ebd 100644
--- a/server/src/nest/trips/trips.service.ts
+++ b/server/src/nest/trips/trips.service.ts
@@ -610,8 +610,8 @@ export class TripsService {
`).all(sourceTripId) as any[];
const assignmentMap = new Map();
const insertAssignment = this.db.prepare(`
- INSERT INTO day_assignments (day_id, place_id, order_index, notes, reservation_status, reservation_notes, reservation_datetime, assignment_time, assignment_end_time)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+ INSERT INTO day_assignments (day_id, place_id, order_index, notes, reservation_status, reservation_notes, reservation_datetime, assignment_time, assignment_end_time, end_day)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`);
for (const a of oldAssignments) {
const newDayId = dayMap.get(a.day_id);
@@ -619,11 +619,21 @@ export class TripsService {
if (newDayId && newPlaceId) {
const r = insertAssignment.run(newDayId, newPlaceId, a.order_index, a.notes,
a.reservation_status, a.reservation_notes, a.reservation_datetime,
- a.assignment_time, a.assignment_end_time);
+ a.assignment_time, a.assignment_end_time, a.end_day ?? 0);
assignmentMap.set(a.id, r.lastInsertRowid);
}
}
+ const oldBoundaries = this.db.prepare('SELECT * FROM roadtrip_day_boundaries WHERE trip_id = ?').all(sourceTripId) as {
+ day_number: number; from_assignment_id: number; to_assignment_id: number | null; fraction: number;
+ }[];
+ const insertBoundary = this.db.prepare('INSERT INTO roadtrip_day_boundaries (trip_id, day_number, from_assignment_id, to_assignment_id, fraction) VALUES (?, ?, ?, ?, ?)');
+ for (const boundary of oldBoundaries) {
+ const from = assignmentMap.get(boundary.from_assignment_id);
+ const to = boundary.to_assignment_id === null ? null : assignmentMap.get(boundary.to_assignment_id);
+ if (from && to !== undefined) insertBoundary.run(newTripId, boundary.day_number, from, to, boundary.fraction);
+ }
+
const oldParticipants = this.db.prepare(`
SELECT ap.* FROM assignment_participants ap
JOIN day_assignments da ON da.id = ap.assignment_id
diff --git a/server/src/types.ts b/server/src/types.ts
index 9ed944821..c5d54dd32 100644
--- a/server/src/types.ts
+++ b/server/src/types.ts
@@ -114,6 +114,7 @@ export interface DayAssignment {
reservation_datetime?: string | null;
assignment_time?: string | null;
assignment_end_time?: string | null;
+ end_day?: number;
leg_transport_mode?: string | null;
incoming_leg_transport_mode?: string | null;
created_at?: string;
diff --git a/server/tests/integration/assignments.test.ts b/server/tests/integration/assignments.test.ts
index 53122b8eb..a8396ffb7 100644
--- a/server/tests/integration/assignments.test.ts
+++ b/server/tests/integration/assignments.test.ts
@@ -83,6 +83,31 @@ function setupAssignmentFixtures(userId: number) {
// ─────────────────────────────────────────────────────────────────────────────
describe('Create assignment', () => {
+ it('sets a day end for one visit, preserves its times, and clears it again', async () => {
+ const { user } = createUser(testDb);
+ const { trip, day, place } = setupAssignmentFixtures(user.id);
+ const created = await request(app).post(`/api/trips/${trip.id}/days/${day.id}/assignments`)
+ .set('Cookie', authCookie(user.id)).send({ place_id: place.id });
+ const id = created.body.assignment.id;
+ const url = `/api/trips/${trip.id}/assignments/${id}/end-day`;
+ testDb.prepare('UPDATE day_assignments SET assignment_time = ? WHERE id = ?').run('07:00', id);
+ const changed = await request(app).put(url).set('Cookie', authCookie(user.id)).send({ end_day: true }).expect(200);
+ expect(changed.body.assignment).toMatchObject({ end_day: true, assignment_time: '07:00' });
+ const listed = await request(app).get(`/api/trips/${trip.id}/days`).set('Cookie', authCookie(user.id)).expect(200);
+ expect(listed.body.days[0].assignments[0].end_day).toBe(true);
+ const repeatedDay = createDay(testDb, trip.id, { day_number: 2 });
+ const repeated = await request(app).post(`/api/trips/${trip.id}/days/${repeatedDay.id}/assignments`)
+ .set('Cookie', authCookie(user.id)).send({ place_id: place.id }).expect(201);
+ expect(repeated.body.assignment.end_day).toBe(false);
+ await request(app).put(url).set('Cookie', authCookie(user.id)).send({ end_day: 'true' }).expect(400);
+ const foreign = createTrip(testDb, user.id);
+ await request(app).put(`/api/trips/${foreign.id}/assignments/${id}/end-day`).set('Cookie', authCookie(user.id))
+ .send({ end_day: true }).expect(404);
+ const cleared = await request(app).put(url).set('Cookie', authCookie(user.id)).send({ end_day: false }).expect(200);
+ expect(cleared.body.assignment).toMatchObject({ end_day: false, assignment_time: '07:00' });
+ await request(app).put(url).send({ end_day: true }).expect(401);
+ });
+
it('ASSIGN-001 — POST creates assignment linking place to day', async () => {
const { user } = createUser(testDb);
const { trip, day, place } = setupAssignmentFixtures(user.id);
diff --git a/server/tests/unit/mcp/tools-assignments.test.ts b/server/tests/unit/mcp/tools-assignments.test.ts
index ad5a02664..887b224bd 100644
--- a/server/tests/unit/mcp/tools-assignments.test.ts
+++ b/server/tests/unit/mcp/tools-assignments.test.ts
@@ -72,6 +72,23 @@ async function withHarness(userId: number, fn: (h: McpHarness) => Promise)
// ---------------------------------------------------------------------------
describe('Tool: assign_place_to_day', () => {
+ it('sets and clears a visit day end through the shared service', async () => {
+ const { user } = createUser(testDb);
+ const trip = createTrip(testDb, user.id);
+ const day = createDay(testDb, trip.id);
+ const place = createPlace(testDb, trip.id);
+ const visit = createDayAssignment(testDb, day.id, place.id);
+ await withHarness(user.id, async h => {
+ for (const end_day of [true, false]) {
+ const changed = await h.client.callTool({ name: 'set_assignment_end_day', arguments: { tripId: trip.id, assignmentId: visit.id, end_day } });
+ expect(parseToolResult(changed)).toMatchObject({ assignment: { end_day } });
+ }
+ const other = createTrip(testDb, user.id);
+ const refused = await h.client.callTool({ name: 'set_assignment_end_day', arguments: { tripId: other.id, assignmentId: visit.id, end_day: true } });
+ expect(refused.isError).toBe(true);
+ });
+ });
+
it('assigns a place to a day', async () => {
const { user } = createUser(testDb);
const trip = createTrip(testDb, user.id);
diff --git a/server/tests/unit/nest/assignments.controller.test.ts b/server/tests/unit/nest/assignments.controller.test.ts
index 0d3e95674..14c4bae28 100644
--- a/server/tests/unit/nest/assignments.controller.test.ts
+++ b/server/tests/unit/nest/assignments.controller.test.ts
@@ -67,6 +67,18 @@ describe('DayAssignmentsController (parity with the legacy day-assignments route
});
describe('AssignmentOpsController (parity with the per-assignment op routes)', () => {
+ it('scopes explicit day ends to the trip and broadcasts the saved visit', () => {
+ const setEndDay = vi.fn().mockReturnValue({ id: 9, end_day: true });
+ const s = svc({ getAssignmentForTrip: vi.fn().mockReturnValue({ id: 9 }), setEndDay });
+ const controller = new AssignmentOpsController(s);
+ expect(controller.endDay('5', '9', { end_day: true }, 'sock')).toEqual({ assignment: { id: 9, end_day: true } });
+ expect(s.getAssignmentForTrip).toHaveBeenCalledWith('9', '5');
+ expect(setEndDay).toHaveBeenCalledWith('9', true);
+ expect(s.broadcast).toHaveBeenCalledWith('5', 'assignment:updated', { assignment: { id: 9, end_day: true } }, 'sock');
+ vi.mocked(s.getAssignmentForTrip).mockReturnValue(undefined);
+ expect(thrown(() => controller.endDay('5', '9', { end_day: false }))).toEqual({ status: 404, body: { error: 'Assignment not found' } });
+ });
+
it('PUT /:id/move 404 assignment, 404 target day, else moves', () => {
expect(thrown(() => new AssignmentOpsController(svc({ getAssignmentForTrip: vi.fn().mockReturnValue(undefined) } as Partial)).move(user, '5', '9', { new_day_id: 4 }))).toEqual({ status: 404, body: { error: 'Assignment not found' } });
expect(thrown(() => new AssignmentOpsController(svc({ getAssignmentForTrip: vi.fn().mockReturnValue({ day_id: 3 }), dayExists: vi.fn().mockReturnValue(false) } as Partial)).move(user, '5', '9', { new_day_id: 4 }))).toEqual({ status: 404, body: { error: 'Target day not found' } });
diff --git a/server/tests/unit/nest/day-boundaries.test.ts b/server/tests/unit/nest/day-boundaries.test.ts
new file mode 100644
index 000000000..e65553066
--- /dev/null
+++ b/server/tests/unit/nest/day-boundaries.test.ts
@@ -0,0 +1,82 @@
+import Database from 'better-sqlite3';
+import { afterEach, expect, it, vi } from 'vitest';
+import { HttpException } from '@nestjs/common';
+import { DayBoundariesService } from '../../../src/nest/roadtrip/day-boundaries.service';
+import { DayBoundariesController } from '../../../src/nest/roadtrip/day-boundaries.controller';
+import { DayBoundariesMcp } from '../../../src/nest/roadtrip/day-boundaries.mcp';
+import type { DatabaseService } from '../../../src/nest/database/database.service';
+import type { McpContext } from '../../../src/nest-mcp';
+
+const open: Database.Database[] = [];
+afterEach(() => open.splice(0).forEach(db => db.close()));
+function setup() {
+ const raw = new Database(':memory:');
+ open.push(raw);
+ raw.pragma('foreign_keys = ON');
+ raw.exec(`CREATE TABLE days (id INTEGER PRIMARY KEY, trip_id INTEGER);
+ CREATE TABLE day_assignments (id INTEGER PRIMARY KEY, day_id INTEGER REFERENCES days(id) ON DELETE CASCADE);
+ CREATE TABLE roadtrip_day_boundaries (trip_id INTEGER, day_number INTEGER, from_assignment_id INTEGER REFERENCES day_assignments(id) ON DELETE CASCADE,
+ to_assignment_id INTEGER REFERENCES day_assignments(id) ON DELETE CASCADE, fraction REAL, PRIMARY KEY(trip_id, day_number));
+ INSERT INTO days VALUES (1, 10), (2, 20);
+ INSERT INTO day_assignments VALUES (11, 1), (12, 1), (21, 2);`);
+ const db = {
+ get: (sql: string, ...params: unknown[]) => raw.prepare(sql).get(...params),
+ all: (sql: string, ...params: unknown[]) => raw.prepare(sql).all(...params),
+ run: (sql: string, ...params: unknown[]) => raw.prepare(sql).run(...params),
+ canAccessTrip: vi.fn(() => true),
+ };
+ const service = new DayBoundariesService(db as unknown as DatabaseService);
+ const realtime = { broadcast: vi.fn() };
+ const auth = { isDemoUser: vi.fn(() => false) };
+ const guards = { hasTripPermission: vi.fn(() => true) };
+ const mcp = new DayBoundariesMcp(service, db as unknown as DatabaseService, auth as never, guards as never, realtime as never, {} as never);
+ return { raw, service, controller: new DayBoundariesController(service, realtime as never), mcp, db, auth, guards, realtime };
+}
+const boundary = { day_number: 1, from_assignment_id: 11, to_assignment_id: 12, fraction: 0.4 };
+
+it('replaces one day only, persists place snapping and cascades deleted visits', () => {
+ const { service, raw } = setup();
+ service.save(10, boundary);
+ service.save(10, { ...boundary, day_number: 2, fraction: 0.8 });
+ expect(service.save(10, { ...boundary, to_assignment_id: null })).toEqual([
+ { ...boundary, to_assignment_id: null, fraction: 1 }, { ...boundary, day_number: 2, fraction: 0.8 },
+ ]);
+ expect(service.list(20)).toEqual([]);
+ service.remove(20, 1);
+ expect(service.list(10)).toHaveLength(2);
+ raw.prepare('DELETE FROM day_assignments WHERE id = 12').run();
+ expect(service.list(10)).toEqual([{ ...boundary, to_assignment_id: null, fraction: 1 }]);
+});
+
+it('rejects either endpoint from a different trip without writing', () => {
+ const { service } = setup();
+ expect(() => service.save(10, { ...boundary, from_assignment_id: 21 })).toThrow(HttpException);
+ expect(() => service.save(10, { ...boundary, to_assignment_id: 21 })).toThrow(HttpException);
+ expect(service.list(10)).toEqual([]);
+});
+
+it('REST changes broadcast the complete state and exclude the saving socket', () => {
+ const { controller, realtime } = setup();
+ controller.save('10', boundary, 'self');
+ expect(realtime.broadcast).toHaveBeenCalledWith('10', 'roadtripBoundary:changed', { boundaries: [boundary] }, 'self');
+ expect(controller.remove('10', 1)).toEqual({ boundaries: [] });
+});
+
+it('MCP checks demo, trip access and edit permission before saving', async () => {
+ const s = setup(), ctx = { userId: 1 } as McpContext;
+ const request = { tripId: 10, dayNumber: 1, boundary };
+ s.auth.isDemoUser.mockReturnValue(true);
+ await s.mcp.save(request, ctx);
+ s.auth.isDemoUser.mockReturnValue(false);
+ s.db.canAccessTrip.mockReturnValue(false);
+ await s.mcp.save(request, ctx);
+ s.db.canAccessTrip.mockReturnValue(true);
+ s.guards.hasTripPermission.mockReturnValue(false);
+ await s.mcp.save(request, ctx);
+ expect(s.service.list(10)).toEqual([]);
+ s.guards.hasTripPermission.mockReturnValue(true);
+ await s.mcp.save(request, ctx);
+ expect(s.service.list(10)).toEqual([boundary]);
+ await s.mcp.save({ ...request, boundary: null }, ctx);
+ expect(s.service.list(10)).toEqual([]);
+});
diff --git a/shared/src/assignment/assignment.schema.spec.ts b/shared/src/assignment/assignment.schema.spec.ts
index f75a03b73..31be55e01 100644
--- a/shared/src/assignment/assignment.schema.spec.ts
+++ b/shared/src/assignment/assignment.schema.spec.ts
@@ -1,5 +1,6 @@
import {
assignmentCreateRequestSchema,
+ assignmentEndDayRequestSchema,
assignmentMoveRequestSchema,
assignmentParticipantsRequestSchema,
assignmentTransportRequestSchema,
@@ -7,6 +8,14 @@ import {
import { describe, it, expect } from 'vitest';
+it('requires a boolean for an explicit day end', () => {
+ expect(assignmentEndDayRequestSchema.parse({ end_day: true })).toEqual({ end_day: true });
+ expect(assignmentEndDayRequestSchema.parse({ end_day: false })).toEqual({ end_day: false });
+ for (const end_day of [1, 'true', null, undefined]) {
+ expect(assignmentEndDayRequestSchema.safeParse({ end_day }).success).toBe(false);
+ }
+});
+
describe('assignmentCreateRequestSchema', () => {
it('requires a place_id; notes optional/nullable', () => {
expect(assignmentCreateRequestSchema.safeParse({ place_id: 2 }).success).toBe(true);
diff --git a/shared/src/assignment/assignment.schema.ts b/shared/src/assignment/assignment.schema.ts
index 3347003d8..64c5a7988 100644
--- a/shared/src/assignment/assignment.schema.ts
+++ b/shared/src/assignment/assignment.schema.ts
@@ -40,6 +40,7 @@ export const assignmentSchema = z.object({
notes: z.string().nullable().optional(),
assignment_time: z.string().nullable().optional(),
assignment_end_time: z.string().nullable().optional(),
+ end_day: z.boolean().optional(),
// Per-segment travel mode (#1281): the transport mode of the leg LEAVING this
// stop for the next one. null = inherit the day's default_transport_mode.
leg_transport_mode: z.string().nullable().optional(),
@@ -78,6 +79,11 @@ export const assignmentTimeRequestSchema = z.object({
});
export type AssignmentTimeRequest = z.infer;
+export const assignmentEndDayRequestSchema = z.object({
+ end_day: z.boolean(),
+});
+export type AssignmentEndDayRequest = z.infer;
+
/**
* PUT /:id/notes (#2163) — edit the per-assignment note after creation.
* Deliberately uncapped like the create contract above: the REST create body
diff --git a/shared/src/i18n/ar/roadtrip.ts b/shared/src/i18n/ar/roadtrip.ts
index 78b99dad4..06f4c5e7f 100644
--- a/shared/src/i18n/ar/roadtrip.ts
+++ b/shared/src/i18n/ar/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "عند الاتصال بالإنترنت، اسحب نهاية اليوم على المسار أو إلى مكان؛ انقر بزر الفأرة الأيمن لاستعادة النهاية التلقائية.",
+ 'roadtrip.window.resetBoundaries': "استعادة نهايات الأيام التلقائية",
+ 'roadtrip.window.endHere': 'إنهاء اليوم هنا',
+ 'roadtrip.window.endHereHint':
+ 'يمكنك إنهاء اليوم عند محطة محددة من تفاصيل المكان عندما يكون وضع Roadtrip وأوقات السفر اليومية مفعّلين.',
+ 'roadtrip.window.endAt': 'نهاية اليوم',
+ 'roadtrip.window.onRoute': 'على الطريق',
+ 'roadtrip.window.atStop': 'في آخر مكان',
+ 'roadtrip.window.routeHint': 'التوقف على الطريق عند بلوغ وقت نهاية اليوم.',
+ 'roadtrip.window.stopHint': 'البقاء في آخر مكان إذا تعذر الوصول إلى المكان التالي قبل نهاية اليوم.',
+ 'roadtrip.window.legTooLong':
+ 'تتجاوز مدة إحدى الرحلات الفترة اليومية. أضف مكانًا في الطريق أو اختر التوقف على الطريق.',
+ 'roadtrip.window.pointLabel': 'نهاية اليوم {day} عند الساعة {time}',
+ 'roadtrip.window.title': 'أوقات السفر اليومية',
+ 'roadtrip.window.start': 'بداية اليوم',
+ 'roadtrip.window.end': 'نهاية اليوم',
+ 'roadtrip.window.hint':
+ 'حدّد الوقتين لتخطيط الاستراحات اليومية. امسح أحدهما لإيقاف الميزة. الأوقات اليدوية لها الأولوية. يتم وصل الأيام تلقائيًا.',
+ 'roadtrip.window.invalid': 'يجب أن يكون وقت النهاية بعد وقت البداية.',
+ 'roadtrip.window.stop': 'نهاية اليوم',
+ 'roadtrip.window.resume': 'متابعة الرحلة',
+ 'roadtrip.window.pointHint': 'هذه نقطة التوقف الليلية المتوقعة لرحلتك.',
+ 'roadtrip.window.departure': 'المتابعة بعد بقية الزيارة الساعة {time}',
+ 'roadtrip.window.showPoint': 'عرض على الخريطة',
+ 'roadtrip.window.incomplete': 'يلزم توفر جميع المسارات الرابطة لحساب الاستراحات اليومية.',
+ 'roadtrip.window.conflict':
+ 'يتعارض وقت ثابت مع القيادة والاستراحات. تبقى الأوقات اليدوية كما هي؛ تم إيقاف التخطيط التلقائي مؤقتًا.',
+ 'roadtrip.window.tooLong': 'تتطلب هذه الأوقات أكثر من 365 يومًا إضافيًا. اختر فترة يومية أطول.',
'roadtrip.mode.roadtrip': 'رحلة برية',
'roadtrip.mode.days': 'الأيام',
'roadtrip.mode.label': 'عرض الخطة',
diff --git a/shared/src/i18n/ar/settings.ts b/shared/src/i18n/ar/settings.ts
index 287f1fd24..f66ee48f0 100644
--- a/shared/src/i18n/ar/settings.ts
+++ b/shared/src/i18n/ar/settings.ts
@@ -26,7 +26,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'محرك مسارات خاص',
'settings.routingBaseHint': 'خادم OSRM خاص بك. اتركه فارغًا لاستخدام الخوادم العامة التي تسمح بطلب واحد تقريبًا في الثانية — يكفي ليوم واحد، وضيّق لرحلة برية. يسري بعد إعادة تشغيل الخادم.',
'settings.valhallaBase': 'خادم Valhalla خاص بك',
- 'settings.valhallaBaseHint': 'خادم Valhalla خاص بك. يُسأل عندما يجب أن تتجنب المرحلة الرسوم أو الطرق السريعة أو العبّارات — الخوادم العامة لـ OSRM لا تستطيع الإجابة عن ذلك. الفراغ يستخدم Valhalla العام من FOSSGIS، إلا إذا حُدِّد أعلاه محرك توجيه خاص بك، فلا يُسأل أي محرك ثانٍ. يسري بعد إعادة تشغيل الخادم.',
+ 'settings.valhallaBaseHint':
+ 'يستخدم TREK خدمة Valhalla العامة من FOSSGIS افتراضيًا لتجنب الطرق ذات الرسوم والطرق السريعة والعبّارات. أدخل رابط خادم Valhalla الخاص بك هنا لاستخدامه بدلًا منها. إذا تم إعداد خادم توجيه خاص فقط، فلن تُستخدم خدمة Valhalla العامة. بعد إدخال رابط خاص، أعد تشغيل الخادم وحمّل الصفحة مجددًا.',
'settings.mapHint': 'قالب URL لبلاطات الخريطة',
'settings.mapProvider': 'مزود الخريطة',
'settings.mapProviderHint': 'يؤثر على خرائط Trip Planner و Journey. يستخدم Atlas دائمًا Leaflet.',
diff --git a/shared/src/i18n/br/roadtrip.ts b/shared/src/i18n/br/roadtrip.ts
index 23d42d19d..ccf67f845 100644
--- a/shared/src/i18n/br/roadtrip.ts
+++ b/shared/src/i18n/br/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online, arraste o fim do dia pela rota ou até um lugar; clique com o botão direito para restaurar o fim automático.",
+ 'roadtrip.window.resetBoundaries': "Restaurar fins de dia automáticos",
+ 'roadtrip.window.endHere': 'Encerrar o dia aqui',
+ 'roadtrip.window.endHereHint':
+ 'Você pode encerrar o dia em uma parada específica nos detalhes do local quando o modo Roadtrip e os horários diários estiverem ativos.',
+ 'roadtrip.window.endAt': 'Encerrar o dia',
+ 'roadtrip.window.onRoute': 'No trajeto',
+ 'roadtrip.window.atStop': 'No último local',
+ 'roadtrip.window.routeHint': 'Pausar no trajeto ao atingir o horário de término.',
+ 'roadtrip.window.stopHint': 'Ficar no último local se não for possível chegar ao próximo antes do fim do dia.',
+ 'roadtrip.window.legTooLong':
+ 'Um trecho excede o período diário. Adicione um local no caminho ou escolha pausar no trajeto.',
+ 'roadtrip.window.pointLabel': 'Fim do dia {day} às {time}',
+ 'roadtrip.window.title': 'Horários diários',
+ 'roadtrip.window.start': 'Início do dia',
+ 'roadtrip.window.end': 'Fim do dia',
+ 'roadtrip.window.hint':
+ 'Defina os dois horários para planejar pausas diárias. Limpe um deles para desativar. Horários manuais têm prioridade. Os dias são conectados automaticamente.',
+ 'roadtrip.window.invalid': 'O horário final deve ser posterior ao inicial.',
+ 'roadtrip.window.stop': 'Fim do dia',
+ 'roadtrip.window.resume': 'Continuar viagem',
+ 'roadtrip.window.pointHint': 'Este é o ponto estimado de pausa durante a noite.',
+ 'roadtrip.window.departure': 'Continuar após o restante da visita às {time}',
+ 'roadtrip.window.showPoint': 'Mostrar no mapa',
+ 'roadtrip.window.incomplete': 'Todas as rotas de conexão são necessárias para calcular as pausas diárias.',
+ 'roadtrip.window.conflict':
+ 'Um horário fixo conflita com o trajeto e as pausas. Os horários manuais são mantidos; o planejamento automático está pausado.',
+ 'roadtrip.window.tooLong': 'Esses horários exigiriam mais de 365 dias extras. Escolha um período diário maior.',
'roadtrip.mode.roadtrip': 'Viagem de carro',
'roadtrip.mode.days': 'Dias',
'roadtrip.mode.label': 'Visão do plano',
diff --git a/shared/src/i18n/br/settings.ts b/shared/src/i18n/br/settings.ts
index 892e35fa5..e8086a5ef 100644
--- a/shared/src/i18n/br/settings.ts
+++ b/shared/src/i18n/br/settings.ts
@@ -28,7 +28,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Servidor de rotas próprio',
'settings.routingBaseHint': 'Uma instância própria do OSRM. Vazio usa os servidores públicos, que permitem cerca de uma requisição por segundo — suficiente para um dia, apertado para uma viagem de carro. Passa a valer após reiniciar o servidor.',
'settings.valhallaBase': 'Instância Valhalla própria',
- 'settings.valhallaBaseHint': 'Uma instância Valhalla própria. Ela é consultada quando um trecho deve evitar pedágios, rodovias ou balsas — os servidores OSRM públicos não conseguem responder isso. Vazio usa a Valhalla pública da FOSSGIS, a não ser que acima esteja indicado um motor de rotas próprio; nesse caso nenhum segundo motor é consultado. Só vale após reiniciar o servidor.',
+ 'settings.valhallaBaseHint':
+ 'Por padrão, o TREK usa a Valhalla pública da FOSSGIS para evitar pedágios, rodovias e balsas. Insira aqui a URL da sua própria Valhalla para usá-la no lugar. Se apenas uma instância de roteamento própria estiver configurada, a Valhalla pública não será usada. Após inserir uma URL própria, reinicie o servidor e recarregue a página.',
'settings.mapHint': 'URL do modelo de blocos do mapa',
'settings.mapProvider': 'Provedor de mapa',
'settings.mapProviderHint': 'Afeta os mapas do Planejador de Viagem e Diário. Atlas sempre usa Leaflet.',
diff --git a/shared/src/i18n/ca/roadtrip.ts b/shared/src/i18n/ca/roadtrip.ts
index c4e4880c9..07d2813ed 100644
--- a/shared/src/i18n/ca/roadtrip.ts
+++ b/shared/src/i18n/ca/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "En línia, arrossega el final del dia per la ruta o fins a un lloc; fes clic amb el botó dret per restaurar el final automàtic.",
+ 'roadtrip.window.resetBoundaries': "Restaura els finals de dia automàtics",
+ 'roadtrip.window.endHere': 'Acaba el dia aquí',
+ 'roadtrip.window.endHereHint':
+ 'Pots acabar el dia en una parada concreta des dels seus detalls quan el mode Roadtrip i els horaris diaris estiguin actius.',
+ 'roadtrip.window.endAt': 'Final del dia',
+ 'roadtrip.window.onRoute': 'Durant el trajecte',
+ 'roadtrip.window.atStop': 'A l’últim lloc',
+ 'roadtrip.window.routeHint': 'Fer una pausa al trajecte en arribar a l’hora de finalització.',
+ 'roadtrip.window.stopHint': 'Quedar-se a l’últim lloc si no es pot arribar al següent abans del final del dia.',
+ 'roadtrip.window.legTooLong':
+ 'Un trajecte supera l’horari diari. Afegeix un lloc pel camí o tria fer una pausa durant el trajecte.',
+ 'roadtrip.window.pointLabel': 'Final del dia {day} a les {time}',
+ 'roadtrip.window.title': 'Horaris diaris',
+ 'roadtrip.window.start': 'Inici del dia',
+ 'roadtrip.window.end': 'Final del dia',
+ 'roadtrip.window.hint':
+ 'Indica les dues hores per planificar pauses diàries. Buida un camp per desactivar-les. Les hores manuals tenen prioritat. Els dies es connecten automàticament.',
+ 'roadtrip.window.invalid': 'L’hora final ha de ser posterior a la inicial.',
+ 'roadtrip.window.stop': 'Final del dia',
+ 'roadtrip.window.resume': 'Continuar el viatge',
+ 'roadtrip.window.pointHint': 'Aquest és el punt estimat de pausa durant la nit.',
+ 'roadtrip.window.departure': 'Continuar després de la resta de la visita a les {time}',
+ 'roadtrip.window.showPoint': 'Mostra al mapa',
+ 'roadtrip.window.incomplete': 'Calen totes les rutes de connexió per calcular les pauses diàries.',
+ 'roadtrip.window.conflict':
+ 'Una hora fixa entra en conflicte amb el trajecte i les pauses. Es mantenen les hores manuals; la planificació automàtica està en pausa.',
+ 'roadtrip.window.tooLong':
+ 'Aquests horaris requereixen més de 365 dies addicionals. Tria una franja diària més llarga.',
'roadtrip.mode.roadtrip': 'Viatge per carretera',
'roadtrip.mode.days': 'Dies',
'roadtrip.mode.label': 'Vista del pla',
diff --git a/shared/src/i18n/ca/settings.ts b/shared/src/i18n/ca/settings.ts
index c415ad51f..1f7007457 100644
--- a/shared/src/i18n/ca/settings.ts
+++ b/shared/src/i18n/ca/settings.ts
@@ -17,7 +17,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Motor de rutes propi',
'settings.routingBaseHint': 'Una instància pròpia d’OSRM. Buit fa servir els servidors públics, que permeten aproximadament una petició per segon: prou per a un dia, just per a un viatge llarg. Té efecte després de reiniciar el servidor.',
'settings.valhallaBase': 'Instància Valhalla pròpia',
- 'settings.valhallaBaseHint': 'Una instància Valhalla pròpia. Es consulta quan una etapa ha d’evitar peatges, autopistes o ferris: els servidors OSRM públics no poden respondre-ho. Buit fa servir el Valhalla públic de FOSSGIS, tret que a dalt s’indiqui un motor de rutes propi, cas en què no es consulta cap segon motor. Té efecte després de reiniciar el servidor.',
+ 'settings.valhallaBaseHint':
+ 'TREK utilitza per defecte la Valhalla pública de FOSSGIS per evitar peatges, autopistes i ferris. Introdueix aquí l’URL de la teva Valhalla per utilitzar-la en lloc de la pública. Si només hi ha una instància d’encaminament pròpia configurada, no s’utilitza la Valhalla pública. Després d’introduir una URL pròpia, reinicia el servidor i torna a carregar la pàgina.',
'settings.mapHint': "Plantilla d'URL per als mosaics del mapa",
'settings.mapProvider': 'Proveïdor de mapa',
'settings.mapProviderHint': 'Afecta els mapes de Trip Planner i Journey. Atles sempre utilitza Leaflet.',
diff --git a/shared/src/i18n/cs/roadtrip.ts b/shared/src/i18n/cs/roadtrip.ts
index 8f082dc43..7eea0b6f5 100644
--- a/shared/src/i18n/cs/roadtrip.ts
+++ b/shared/src/i18n/cs/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online můžete konec dne přetáhnout po trase nebo na místo; pravým tlačítkem obnovíte automatický konec.",
+ 'roadtrip.window.resetBoundaries': "Obnovit automatické konce dnů",
+ 'roadtrip.window.endHere': 'Ukončit den zde',
+ 'roadtrip.window.endHereHint':
+ 'V podrobnostech místa můžete určit zastávku jako konec dne, když je aktivní režim Roadtrip a denní časy cestování.',
+ 'roadtrip.window.endAt': 'Ukončení dne',
+ 'roadtrip.window.onRoute': 'Na trase',
+ 'roadtrip.window.atStop': 'Na posledním místě',
+ 'roadtrip.window.routeHint': 'Zastavit na trase při dosažení času konce dne.',
+ 'roadtrip.window.stopHint': 'Zůstat na posledním místě, pokud další nelze dosáhnout před koncem dne.',
+ 'roadtrip.window.legTooLong':
+ 'Jeden úsek přesahuje denní časové okno. Přidejte místo po cestě nebo zvolte zastávku na trase.',
+ 'roadtrip.window.pointLabel': 'Konec dne {day} v {time}',
+ 'roadtrip.window.title': 'Denní časy cestování',
+ 'roadtrip.window.start': 'Začátek dne',
+ 'roadtrip.window.end': 'Konec dne',
+ 'roadtrip.window.hint':
+ 'Pro denní přestávky nastavte oba časy. Vymazáním jednoho automatiku vypnete. Ruční časy mají přednost. Dny se automaticky propojí.',
+ 'roadtrip.window.invalid': 'Konec dne musí být později než začátek.',
+ 'roadtrip.window.stop': 'Konec dne',
+ 'roadtrip.window.resume': 'Pokračovat v cestě',
+ 'roadtrip.window.pointHint': 'Zde je odhadované místo noční přestávky.',
+ 'roadtrip.window.departure': 'Pokračovat po zbytku návštěvy v {time}',
+ 'roadtrip.window.showPoint': 'Zobrazit na mapě',
+ 'roadtrip.window.incomplete': 'Denní přestávky lze spočítat až po získání všech navazujících tras.',
+ 'roadtrip.window.conflict':
+ 'Pevný čas je v rozporu s jízdou a přestávkami. Ruční časy zůstávají zachovány; automatické plánování je pozastaveno.',
+ 'roadtrip.window.tooLong': 'Tyto časy vyžadují více než 365 dalších dní. Zvolte delší denní interval.',
'roadtrip.mode.roadtrip': 'Cesta autem',
'roadtrip.mode.days': 'Dny',
'roadtrip.mode.label': 'Zobrazení plánu',
diff --git a/shared/src/i18n/cs/settings.ts b/shared/src/i18n/cs/settings.ts
index 17e9d0572..099c66256 100644
--- a/shared/src/i18n/cs/settings.ts
+++ b/shared/src/i18n/cs/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Vlastní směrovací server',
'settings.routingBaseHint': 'Vlastní instance OSRM. Prázdné použije veřejné servery s limitem asi jednoho požadavku za sekundu — na den to stačí, na road trip je to málo. Projeví se po restartu serveru.',
'settings.valhallaBase': 'Vlastní instance Valhalla',
- 'settings.valhallaBaseHint': 'Vlastní instance Valhalla. Ptáme se jí, když má úsek objet mýtné, dálnice nebo trajekty — veřejné servery OSRM to neumí zodpovědět. Prázdné použije veřejnou Valhallu od FOSSGIS, ledaže je výše uveden vlastní směrovací engine; pak se žádný druhý engine neptá. Projeví se po restartu serveru.',
+ 'settings.valhallaBaseHint':
+ 'TREK ve výchozím nastavení používá veřejnou Valhallu FOSSGIS k vyhýbání se mýtnému, dálnicím a trajektům. Zde můžete zadat URL vlastní Valhally a používat ji místo veřejné. Pokud je nastavena pouze vlastní směrovací instance, veřejná Valhalla se nepoužije. Po zadání vlastní URL restartujte server a znovu načtěte stránku.',
'settings.mapHint': 'URL šablony pro mapové dlaždice',
'settings.mapProvider': 'Poskytovatel mapy',
'settings.mapProviderHint': 'Ovlivňuje mapy v Trip Planneru a Journey. Atlas vždy používá Leaflet.',
diff --git a/shared/src/i18n/de/roadtrip.ts b/shared/src/i18n/de/roadtrip.ts
index 4260d5cfd..75adcd85f 100644
--- a/shared/src/i18n/de/roadtrip.ts
+++ b/shared/src/i18n/de/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online kannst du ein Tagesende entlang der Route oder auf einen Ort ziehen; ein Rechtsklick stellt das automatische Ende wieder her.",
+ 'roadtrip.window.resetBoundaries': "Automatische Tagesenden wiederherstellen",
+ 'roadtrip.window.endHere': 'Tag hier beenden',
+ 'roadtrip.window.endHereHint':
+ 'In den Ortsdetails kannst du einen Ort als Tagesende festlegen, solange der Roadtrip-Modus und die täglichen Reisezeiten aktiv sind.',
+ 'roadtrip.window.endAt': 'Tagesende planen',
+ 'roadtrip.window.onRoute': 'Auf der Strecke',
+ 'roadtrip.window.atStop': 'Am letzten Ort',
+ 'roadtrip.window.routeHint': 'Zur Endzeit an der erreichten Stelle auf der Strecke pausieren.',
+ 'roadtrip.window.stopHint': 'Am letzten Ort bleiben, wenn der nächste vor Tagesende nicht mehr erreichbar ist.',
+ 'roadtrip.window.legTooLong':
+ 'Eine Fahrt ist länger als das tägliche Zeitfenster. Ergänze einen Ort unterwegs oder wähle die Pause auf der Strecke.',
+ 'roadtrip.window.pointLabel': 'Tagesende von Tag {day} um {time} Uhr',
+ 'roadtrip.window.title': 'Tägliche Reisezeiten',
+ 'roadtrip.window.start': 'Tagesbeginn',
+ 'roadtrip.window.end': 'Tagesende',
+ 'roadtrip.window.hint':
+ 'Beide Zeiten setzen, um tägliche Pausen zu planen. Ein leeres Feld schaltet dies aus. Manuelle Zeiten haben Vorrang. Tage werden automatisch verbunden.',
+ 'roadtrip.window.invalid': 'Das Tagesende muss nach dem Tagesbeginn liegen.',
+ 'roadtrip.window.stop': 'Tagesende',
+ 'roadtrip.window.resume': 'Weiterfahrt',
+ 'roadtrip.window.pointHint': 'Hier pausiert deine Reise voraussichtlich über Nacht.',
+ 'roadtrip.window.departure': 'Weiterfahrt nach dem restlichen Aufenthalt um {time}',
+ 'roadtrip.window.showPoint': 'Auf Karte zeigen',
+ 'roadtrip.window.incomplete': 'Tagespausen lassen sich erst berechnen, wenn alle Verbindungsrouten vorliegen.',
+ 'roadtrip.window.conflict':
+ 'Eine feste Uhrzeit passt nicht zu Fahrzeit und Tagespausen. Manuelle Zeiten bleiben unverändert; die automatische Aufteilung pausiert.',
+ 'roadtrip.window.tooLong':
+ 'Diese Reisezeiten erfordern mehr als 365 zusätzliche Tage. Wähle ein längeres Tagesfenster.',
'roadtrip.mode.roadtrip': 'Roadtrip',
'roadtrip.mode.days': 'Tage',
'roadtrip.mode.label': 'Plan-Ansicht',
diff --git a/shared/src/i18n/de/settings.ts b/shared/src/i18n/de/settings.ts
index 53bf6ba62..d9e10d945 100644
--- a/shared/src/i18n/de/settings.ts
+++ b/shared/src/i18n/de/settings.ts
@@ -28,7 +28,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Eigene Routing-Instanz',
'settings.routingBaseHint': 'Eine eigene OSRM-Instanz. Leer nutzt die öffentlichen Server, die etwa eine Anfrage pro Sekunde erlauben — für einen Tag genug, für einen Roadtrip knapp. Wirkt erst nach einem Serverneustart.',
'settings.valhallaBase': 'Eigene Valhalla-Instanz',
- 'settings.valhallaBaseHint': 'Eine eigene Valhalla-Instanz. Sie wird gefragt, wenn eine Etappe Maut, Autobahn oder Fähre meiden soll — die öffentlichen OSRM-Server können das nicht. Leer nutzt die öffentliche FOSSGIS-Valhalla, außer oben steht schon eine eigene Routing-Instanz; dann wird gar keine zweite Maschine gefragt. Wirkt erst nach einem Serverneustart.',
+ 'settings.valhallaBaseHint':
+ 'Zum Meiden von Mautstraßen, Autobahnen und Fähren nutzt TREK standardmäßig die öffentliche FOSSGIS-Valhalla. Hier kannst du stattdessen eine eigene Valhalla-URL eintragen. Ist nur eine eigene Routing-Instanz konfiguriert, wird die öffentliche Valhalla nicht verwendet. Nach dem Eintragen einer eigenen URL den Server neu starten und die Seite neu laden.',
'settings.mapHint': 'URL-Template für die Kartenkacheln',
'settings.mapProvider': 'Kartenanbieter',
'settings.mapProviderHint': 'Gilt für Trip Planner und Journey. Atlas nutzt immer Leaflet.',
diff --git a/shared/src/i18n/en/roadtrip.ts b/shared/src/i18n/en/roadtrip.ts
index e49283bba..3b574354c 100644
--- a/shared/src/i18n/en/roadtrip.ts
+++ b/shared/src/i18n/en/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "While online, drag a day ending along the route or onto a place; right-click it to restore the automatic ending.",
+ 'roadtrip.window.resetBoundaries': "Restore automatic day endings",
+ 'roadtrip.window.endHere': 'End the day here',
+ 'roadtrip.window.endHereHint':
+ 'You can end a day at a specific stop in its place details while Roadtrip mode and daily travel times are active.',
+ 'roadtrip.window.endAt': 'End the day',
+ 'roadtrip.window.onRoute': 'Along the route',
+ 'roadtrip.window.atStop': 'At the last place',
+ 'roadtrip.window.routeHint': 'Pause along the route when the end time is reached.',
+ 'roadtrip.window.stopHint': 'Stay at the last place if the next one cannot be reached before the end time.',
+ 'roadtrip.window.legTooLong':
+ 'A drive exceeds the daily travel window. Add a place along the way or choose to pause along the route.',
+ 'roadtrip.window.pointLabel': 'End of day {day} at {time}',
+ 'roadtrip.window.title': 'Daily travel times',
+ 'roadtrip.window.start': 'Day start time',
+ 'roadtrip.window.end': 'Day end time',
+ 'roadtrip.window.hint':
+ 'Set both times to plan daily breaks. Clear either to turn this off. Manual times take priority. Days are connected automatically.',
+ 'roadtrip.window.invalid': 'The end time must be later than the start time.',
+ 'roadtrip.window.stop': 'End of day',
+ 'roadtrip.window.resume': 'Continue journey',
+ 'roadtrip.window.pointHint': 'This is your estimated overnight pause point.',
+ 'roadtrip.window.departure': 'Continue after the remaining visit at {time}',
+ 'roadtrip.window.showPoint': 'Show on map',
+ 'roadtrip.window.incomplete': 'Daily breaks cannot be calculated until all connecting routes are available.',
+ 'roadtrip.window.conflict':
+ 'A fixed time conflicts with the drive and daily breaks. Manual times are unchanged; automatic scheduling is paused.',
+ 'roadtrip.window.tooLong': 'These travel times would require more than 365 extra days. Choose a longer daily window.',
'roadtrip.mode.roadtrip': 'Road trip',
'roadtrip.mode.days': 'Days',
'roadtrip.mode.label': 'Plan view',
diff --git a/shared/src/i18n/en/settings.ts b/shared/src/i18n/en/settings.ts
index b83ce71c4..bd2f21608 100644
--- a/shared/src/i18n/en/settings.ts
+++ b/shared/src/i18n/en/settings.ts
@@ -36,7 +36,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Own routing engine',
'settings.routingBaseHint': 'An OSRM instance of your own. Empty uses the public servers, which allow about one request a second — enough for a day, tight for a road trip. Takes effect after a server restart.',
'settings.valhallaBase': 'Own Valhalla instance',
- 'settings.valhallaBaseHint': 'A Valhalla of your own. It is asked when a leg should avoid tolls, motorways or ferries — the public OSRM servers cannot answer that. Empty uses the public FOSSGIS Valhalla, unless an own routing engine is named above, in which case no second engine is asked at all. Takes effect after a server restart.',
+ 'settings.valhallaBaseHint':
+ 'TREK uses the public FOSSGIS Valhalla by default to avoid toll roads, motorways and ferries. Enter your own Valhalla URL here to use it instead. If only a custom routing instance is configured, the public Valhalla is not used. After entering a custom URL, restart the server and reload the page.',
'settings.mapHint': 'URL template for map tiles',
'settings.mapProvider': 'Map Provider',
'settings.mapProviderHint': 'Affects Trip Planner and Journey maps. Atlas always uses Leaflet.',
diff --git a/shared/src/i18n/es/roadtrip.ts b/shared/src/i18n/es/roadtrip.ts
index 393624e18..f10478b16 100644
--- a/shared/src/i18n/es/roadtrip.ts
+++ b/shared/src/i18n/es/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Con conexión, arrastra el fin del día por la ruta o hasta un lugar; haz clic derecho para restaurar el final automático.",
+ 'roadtrip.window.resetBoundaries': "Restaurar finales de día automáticos",
+ 'roadtrip.window.endHere': 'Terminar el día aquí',
+ 'roadtrip.window.endHereHint':
+ 'Puedes terminar el día en una parada concreta desde sus detalles cuando el modo Roadtrip y los horarios diarios estén activos.',
+ 'roadtrip.window.endAt': 'Final del día',
+ 'roadtrip.window.onRoute': 'En la ruta',
+ 'roadtrip.window.atStop': 'En el último lugar',
+ 'roadtrip.window.routeHint': 'Pausar en la ruta al alcanzar la hora de finalización.',
+ 'roadtrip.window.stopHint': 'Quedarse en el último lugar si no se puede llegar al siguiente antes del final del día.',
+ 'roadtrip.window.legTooLong':
+ 'Un trayecto supera el horario diario. Añade un lugar por el camino o elige pausar en la ruta.',
+ 'roadtrip.window.pointLabel': 'Final del día {day} a las {time}',
+ 'roadtrip.window.title': 'Horario diario',
+ 'roadtrip.window.start': 'Inicio del día',
+ 'roadtrip.window.end': 'Fin del día',
+ 'roadtrip.window.hint':
+ 'Indica ambas horas para planificar pausas diarias. Vacía una para desactivarlas. Las horas manuales tienen prioridad. Los días se conectan automáticamente.',
+ 'roadtrip.window.invalid': 'La hora de fin debe ser posterior a la de inicio.',
+ 'roadtrip.window.stop': 'Fin del día',
+ 'roadtrip.window.resume': 'Continuar viaje',
+ 'roadtrip.window.pointHint': 'Este es el punto estimado de pausa durante la noche.',
+ 'roadtrip.window.departure': 'Continuar tras el resto de la visita a las {time}',
+ 'roadtrip.window.showPoint': 'Mostrar en el mapa',
+ 'roadtrip.window.incomplete': 'Las pausas diarias necesitan todas las rutas de conexión para calcularse.',
+ 'roadtrip.window.conflict':
+ 'Una hora fija entra en conflicto con el trayecto y las pausas. Las horas manuales se conservan; la planificación automática está en pausa.',
+ 'roadtrip.window.tooLong': 'Estos horarios requieren más de 365 días adicionales. Amplía el horario diario.',
'roadtrip.mode.roadtrip': 'Viaje por carretera',
'roadtrip.mode.days': 'Días',
'roadtrip.mode.label': 'Vista del plan',
diff --git a/shared/src/i18n/es/settings.ts b/shared/src/i18n/es/settings.ts
index bd918be0f..d8ab3e55c 100644
--- a/shared/src/i18n/es/settings.ts
+++ b/shared/src/i18n/es/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Motor de rutas propio',
'settings.routingBaseHint': 'Una instancia propia de OSRM. Vacío usa los servidores públicos, que permiten cerca de una petición por segundo: suficiente para un día, justo para una ruta larga. Surte efecto tras reiniciar el servidor.',
'settings.valhallaBase': 'Instancia de Valhalla propia',
- 'settings.valhallaBaseHint': 'Una instancia de Valhalla propia. Se consulta cuando un tramo debe evitar peajes, autopistas o ferris: los servidores OSRM públicos no pueden responder a eso. Vacío usa el Valhalla público de FOSSGIS, salvo que arriba se indique un motor de rutas propio, en cuyo caso no se consulta ningún segundo motor. Surte efecto tras reiniciar el servidor.',
+ 'settings.valhallaBaseHint':
+ 'TREK usa por defecto la Valhalla pública de FOSSGIS para evitar peajes, autopistas y ferris. Introduce aquí la URL de tu propia Valhalla para usarla en su lugar. Si solo se configura una instancia de rutas propia, no se utiliza la Valhalla pública. Tras introducir una URL propia, reinicia el servidor y recarga la página.',
'settings.mapHint': 'Plantilla de URL para los mosaicos del mapa',
'settings.mapProvider': 'Proveedor de mapa',
'settings.mapProviderHint': 'Afecta a los mapas de Trip Planner y Journey. Atlas siempre usa Leaflet.',
diff --git a/shared/src/i18n/fr/roadtrip.ts b/shared/src/i18n/fr/roadtrip.ts
index 56e401811..9f0f04d7a 100644
--- a/shared/src/i18n/fr/roadtrip.ts
+++ b/shared/src/i18n/fr/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "En ligne, faites glisser la fin de journée sur le trajet ou sur un lieu ; un clic droit rétablit la fin automatique.",
+ 'roadtrip.window.resetBoundaries': "Rétablir les fins de journée automatiques",
+ 'roadtrip.window.endHere': 'Terminer la journée ici',
+ 'roadtrip.window.endHereHint':
+ 'Vous pouvez terminer une journée à une étape précise dans ses détails lorsque le mode Roadtrip et les horaires quotidiens sont actifs.',
+ 'roadtrip.window.endAt': 'Fin de journée',
+ 'roadtrip.window.onRoute': 'Sur le trajet',
+ 'roadtrip.window.atStop': 'Au dernier lieu',
+ 'roadtrip.window.routeHint': 'Faire une pause sur le trajet à l’heure de fin.',
+ 'roadtrip.window.stopHint': 'Rester au dernier lieu si le suivant ne peut pas être atteint avant la fin de journée.',
+ 'roadtrip.window.legTooLong':
+ 'Un trajet dépasse la plage horaire quotidienne. Ajoutez un lieu en chemin ou choisissez une pause sur le trajet.',
+ 'roadtrip.window.pointLabel': 'Fin du jour {day} à {time}',
+ 'roadtrip.window.title': 'Horaires quotidiens',
+ 'roadtrip.window.start': 'Début de journée',
+ 'roadtrip.window.end': 'Fin de journée',
+ 'roadtrip.window.hint':
+ 'Renseignez les deux heures pour prévoir les pauses. Effacez-en une pour désactiver cette option. Les heures manuelles sont prioritaires. Les journées sont reliées automatiquement.',
+ 'roadtrip.window.invalid': 'La fin doit être postérieure au début de journée.',
+ 'roadtrip.window.stop': 'Fin de journée',
+ 'roadtrip.window.resume': 'Reprendre le trajet',
+ 'roadtrip.window.pointHint': 'Votre voyage devrait faire une pause ici pour la nuit.',
+ 'roadtrip.window.departure': 'Repartir après le reste de la visite à {time}',
+ 'roadtrip.window.showPoint': 'Voir sur la carte',
+ 'roadtrip.window.incomplete': 'Toutes les liaisons doivent être disponibles pour calculer les pauses quotidiennes.',
+ 'roadtrip.window.conflict':
+ 'Une heure fixe est incompatible avec le trajet et les pauses. Les heures manuelles sont conservées ; la planification automatique est suspendue.',
+ 'roadtrip.window.tooLong':
+ 'Ces horaires nécessitent plus de 365 jours supplémentaires. Élargissez la plage horaire quotidienne.',
'roadtrip.mode.roadtrip': 'Road trip',
'roadtrip.mode.days': 'Jours',
'roadtrip.mode.label': 'Vue du plan',
diff --git a/shared/src/i18n/fr/settings.ts b/shared/src/i18n/fr/settings.ts
index f71265138..a36a95eeb 100644
--- a/shared/src/i18n/fr/settings.ts
+++ b/shared/src/i18n/fr/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Moteur de calcul d’itinéraire propre',
'settings.routingBaseHint': 'Votre propre instance OSRM. Vide utilise les serveurs publics, limités à environ une requête par seconde : suffisant pour une journée, juste pour un road trip. Prend effet après un redémarrage du serveur.',
'settings.valhallaBase': 'Instance Valhalla propre',
- 'settings.valhallaBaseHint': 'Votre propre instance Valhalla. Elle est interrogée quand une étape doit éviter les péages, les autoroutes ou les ferries — les serveurs OSRM publics ne savent pas répondre à cela. Vide utilise le Valhalla public de FOSSGIS, sauf si un moteur de calcul d’itinéraire propre est indiqué ci-dessus, auquel cas aucun second moteur n’est interrogé. Prend effet après un redémarrage du serveur.',
+ 'settings.valhallaBaseHint':
+ 'TREK utilise par défaut la Valhalla publique de FOSSGIS pour éviter les péages, autoroutes et ferries. Saisissez ici l’URL de votre propre Valhalla pour l’utiliser à la place. Si seule une instance de routage personnalisée est configurée, la Valhalla publique n’est pas utilisée. Après avoir saisi une URL personnalisée, redémarrez le serveur et rechargez la page.',
'settings.mapHint': "Modèle d'URL pour les tuiles de carte",
'settings.mapProvider': 'Fournisseur de carte',
'settings.mapProviderHint': 'Affecte les cartes Trip Planner et Journey. Atlas utilise toujours Leaflet.',
diff --git a/shared/src/i18n/gr/roadtrip.ts b/shared/src/i18n/gr/roadtrip.ts
index 62a33b696..81cf55ae4 100644
--- a/shared/src/i18n/gr/roadtrip.ts
+++ b/shared/src/i18n/gr/roadtrip.ts
@@ -1,6 +1,36 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Με σύνδεση, σύρετε το τέλος της ημέρας στη διαδρομή ή σε ένα μέρος· με δεξί κλικ επαναφέρετε το αυτόματο τέλος.",
+ 'roadtrip.window.resetBoundaries': "Επαναφορά αυτόματων ορίων ημέρας",
+ 'roadtrip.window.endHere': 'Τέλος ημέρας εδώ',
+ 'roadtrip.window.endHereHint':
+ 'Μπορείτε να ορίσετε μια στάση ως τέλος ημέρας στις λεπτομέρειες του μέρους, όταν είναι ενεργά το Roadtrip και τα ημερήσια ωράρια ταξιδιού.',
+ 'roadtrip.window.endAt': 'Τέλος ημέρας',
+ 'roadtrip.window.onRoute': 'Στη διαδρομή',
+ 'roadtrip.window.atStop': 'Στο τελευταίο μέρος',
+ 'roadtrip.window.routeHint': 'Παύση στη διαδρομή όταν φτάσει η ώρα λήξης.',
+ 'roadtrip.window.stopHint':
+ 'Παραμονή στο τελευταίο μέρος αν το επόμενο δεν είναι προσβάσιμο πριν το τέλος της ημέρας.',
+ 'roadtrip.window.legTooLong':
+ 'Μια διαδρομή υπερβαίνει το ημερήσιο ωράριο. Προσθέστε ένα μέρος καθ’ οδόν ή επιλέξτε παύση στη διαδρομή.',
+ 'roadtrip.window.pointLabel': 'Τέλος ημέρας {day} στις {time}',
+ 'roadtrip.window.title': 'Καθημερινές ώρες ταξιδιού',
+ 'roadtrip.window.start': 'Έναρξη ημέρας',
+ 'roadtrip.window.end': 'Λήξη ημέρας',
+ 'roadtrip.window.hint':
+ 'Ορίστε και τις δύο ώρες για καθημερινές παύσεις. Αφήστε μία κενή για απενεργοποίηση. Οι χειροκίνητες ώρες έχουν προτεραιότητα. Οι ημέρες συνδέονται αυτόματα.',
+ 'roadtrip.window.invalid': 'Η ώρα λήξης πρέπει να είναι μετά την ώρα έναρξης.',
+ 'roadtrip.window.stop': 'Τέλος ημέρας',
+ 'roadtrip.window.resume': 'Συνέχεια ταξιδιού',
+ 'roadtrip.window.pointHint': 'Αυτό είναι το εκτιμώμενο σημείο της νυχτερινής σας στάσης.',
+ 'roadtrip.window.departure': 'Συνέχεια μετά την υπόλοιπη επίσκεψη στις {time}',
+ 'roadtrip.window.showPoint': 'Προβολή στον χάρτη',
+ 'roadtrip.window.incomplete': 'Απαιτούνται όλες οι συνδετικές διαδρομές για τον υπολογισμό των καθημερινών παύσεων.',
+ 'roadtrip.window.conflict':
+ 'Μια σταθερή ώρα συγκρούεται με την οδήγηση και τις παύσεις. Οι χειροκίνητες ώρες διατηρούνται· ο αυτόματος σχεδιασμός έχει παύσει.',
+ 'roadtrip.window.tooLong':
+ 'Αυτές οι ώρες απαιτούν πάνω από 365 επιπλέον ημέρες. Επιλέξτε μεγαλύτερο ημερήσιο διάστημα.',
'roadtrip.mode.roadtrip': 'Οδικό ταξίδι',
'roadtrip.mode.days': 'Ημέρες',
'roadtrip.mode.label': 'Προβολή σχεδίου',
diff --git a/shared/src/i18n/gr/settings.ts b/shared/src/i18n/gr/settings.ts
index 56b156ea7..61a125201 100644
--- a/shared/src/i18n/gr/settings.ts
+++ b/shared/src/i18n/gr/settings.ts
@@ -28,7 +28,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Δική σας μηχανή δρομολόγησης',
'settings.routingBaseHint': 'Δική σας εγκατάσταση OSRM. Κενό σημαίνει τους δημόσιους διακομιστές, που επιτρέπουν περίπου ένα αίτημα ανά δευτερόλεπτο: αρκεί για μία ημέρα, λίγο για ένα οδικό ταξίδι. Ισχύει μετά από επανεκκίνηση του διακομιστή.',
'settings.valhallaBase': 'Δική σας υπηρεσία Valhalla',
- 'settings.valhallaBaseHint': 'Δική σας υπηρεσία Valhalla. Ρωτιέται όταν ένα σκέλος πρέπει να αποφύγει διόδια, αυτοκινητόδρομους ή φέρι — οι δημόσιοι διακομιστές OSRM δεν μπορούν να απαντήσουν σε αυτό. Κενό χρησιμοποιεί το δημόσιο Valhalla του FOSSGIS, εκτός αν παραπάνω δηλώνεται δική σας μηχανή δρομολόγησης, οπότε δεν ρωτιέται καμία δεύτερη μηχανή. Ισχύει μετά από επανεκκίνηση του διακομιστή.',
+ 'settings.valhallaBaseHint':
+ 'Το TREK χρησιμοποιεί από προεπιλογή τη δημόσια Valhalla της FOSSGIS για την αποφυγή διοδίων, αυτοκινητοδρόμων και πορθμείων. Εισαγάγετε εδώ τη διεύθυνση URL της δικής σας Valhalla για να τη χρησιμοποιήσετε αντί της δημόσιας. Αν έχει ρυθμιστεί μόνο ιδιωτική υπηρεσία δρομολόγησης, η δημόσια Valhalla δεν χρησιμοποιείται. Αφού εισαγάγετε ιδιωτική διεύθυνση URL, επανεκκινήστε τον διακομιστή και φορτώστε ξανά τη σελίδα.',
'settings.mapHint': 'Πρότυπο URL για πλακίδια χάρτη',
'settings.mapProvider': 'Πάροχος Χάρτη',
'settings.mapProviderHint':
diff --git a/shared/src/i18n/hu/roadtrip.ts b/shared/src/i18n/hu/roadtrip.ts
index c99c320de..c14441c8b 100644
--- a/shared/src/i18n/hu/roadtrip.ts
+++ b/shared/src/i18n/hu/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online húzza a nap végét az útvonalon vagy egy helyre; jobb kattintással visszaállíthatja az automatikus befejezést.",
+ 'roadtrip.window.resetBoundaries': "Automatikus napvégek visszaállítása",
+ 'roadtrip.window.endHere': 'Nap befejezése itt',
+ 'roadtrip.window.endHereHint':
+ 'A hely részleteinél jelölhetsz ki megállót a nap végének, ha a Roadtrip mód és a napi utazási idők aktívak.',
+ 'roadtrip.window.endAt': 'Nap lezárása',
+ 'roadtrip.window.onRoute': 'Az útvonalon',
+ 'roadtrip.window.atStop': 'Az utolsó helyen',
+ 'roadtrip.window.routeHint': 'Megállás az útvonalon a befejezési idő elérésekor.',
+ 'roadtrip.window.stopHint': 'Maradjon az utolsó helyen, ha a következő nem érhető el a nap vége előtt.',
+ 'roadtrip.window.legTooLong':
+ 'Egy útszakasz hosszabb a napi időkeretnél. Adjon hozzá egy helyet útközben, vagy válasszon megállást az útvonalon.',
+ 'roadtrip.window.pointLabel': 'A(z) {day}. nap vége {time}-kor',
+ 'roadtrip.window.title': 'Napi utazási időszak',
+ 'roadtrip.window.start': 'Nap kezdete',
+ 'roadtrip.window.end': 'Nap vége',
+ 'roadtrip.window.hint':
+ 'A napi szünetekhez add meg mindkét időpontot. Egy mező törlése kikapcsolja az automatikát. A kézi időpontok elsőbbséget élveznek. A napok automatikusan összekapcsolódnak.',
+ 'roadtrip.window.invalid': 'A befejezésnek a kezdés után kell lennie.',
+ 'roadtrip.window.stop': 'Nap vége',
+ 'roadtrip.window.resume': 'Utazás folytatása',
+ 'roadtrip.window.pointHint': 'Ez az éjszakai pihenő becsült helye.',
+ 'roadtrip.window.departure': 'Továbbindulás a látogatás hátralévő része után: {time}',
+ 'roadtrip.window.showPoint': 'Megjelenítés a térképen',
+ 'roadtrip.window.incomplete': 'A napi szünetek kiszámításához minden összekötő útvonal szükséges.',
+ 'roadtrip.window.conflict':
+ 'Egy rögzített időpont ütközik az utazással és a szünetekkel. A kézi időpontok megmaradnak; az automatikus tervezés szünetel.',
+ 'roadtrip.window.tooLong':
+ 'Ezek az időpontok több mint 365 további napot igényelnének. Válassz hosszabb napi időszakot.',
'roadtrip.mode.roadtrip': 'Autós út',
'roadtrip.mode.days': 'Napok',
'roadtrip.mode.label': 'Terv nézet',
diff --git a/shared/src/i18n/hu/settings.ts b/shared/src/i18n/hu/settings.ts
index 70b7937b0..16054699d 100644
--- a/shared/src/i18n/hu/settings.ts
+++ b/shared/src/i18n/hu/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Saját útvonaltervező',
'settings.routingBaseHint': 'Saját OSRM-példány. Üresen hagyva a nyilvános kiszolgálókat használja, amelyek másodpercenként körülbelül egy kérést engednek — egy napra elég, egy autós útra kevés. A kiszolgáló újraindítása után lép életbe.',
'settings.valhallaBase': 'Saját Valhalla-példány',
- 'settings.valhallaBaseHint': 'Saját Valhalla-példány. Akkor kérdezzük meg, ha egy szakasznak kerülnie kell a fizetős utakat, az autópályákat vagy a kompokat — a nyilvános OSRM-kiszolgálók erre nem tudnak válaszolni. Üresen a FOSSGIS nyilvános Valhalláját használja, kivéve ha fent saját útvonaltervező szerepel; akkor egyáltalán nem kérdezünk második motort. A szerver újraindítása után lép életbe.',
+ 'settings.valhallaBaseHint':
+ 'A TREK alapértelmezés szerint a FOSSGIS nyilvános Valhalláját használja a fizetős utak, autópályák és kompok elkerüléséhez. Itt megadhatja saját Valhallája URL-jét, hogy azt használja helyette. Ha csak saját útvonaltervező van beállítva, a nyilvános Valhalla nem használatos. Saját URL megadása után indítsa újra a szervert, és töltse újra az oldalt.',
'settings.mapHint': 'URL sablon a térképcsempékhez',
'settings.mapProvider': 'Térkép szolgáltató',
'settings.mapProviderHint': 'A Trip Planner és Journey térképekre érvényes. Az Atlas mindig Leafletet használ.',
diff --git a/shared/src/i18n/id/roadtrip.ts b/shared/src/i18n/id/roadtrip.ts
index 9e0bd6d85..7c8aa65dd 100644
--- a/shared/src/i18n/id/roadtrip.ts
+++ b/shared/src/i18n/id/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Saat online, seret akhir hari di sepanjang rute atau ke suatu tempat; klik kanan untuk memulihkan akhir otomatis.",
+ 'roadtrip.window.resetBoundaries': "Pulihkan akhir hari otomatis",
+ 'roadtrip.window.endHere': 'Akhiri hari di sini',
+ 'roadtrip.window.endHereHint':
+ 'Anda dapat mengakhiri hari di pemberhentian tertentu melalui detail tempat saat mode Roadtrip dan waktu perjalanan harian aktif.',
+ 'roadtrip.window.endAt': 'Akhir hari',
+ 'roadtrip.window.onRoute': 'Di sepanjang rute',
+ 'roadtrip.window.atStop': 'Di tempat terakhir',
+ 'roadtrip.window.routeHint': 'Berhenti di sepanjang rute saat waktu akhir tercapai.',
+ 'roadtrip.window.stopHint': 'Tetap di tempat terakhir jika tempat berikutnya tidak dapat dicapai sebelum akhir hari.',
+ 'roadtrip.window.legTooLong':
+ 'Satu perjalanan melebihi rentang waktu harian. Tambahkan tempat di sepanjang jalan atau pilih berhenti di rute.',
+ 'roadtrip.window.pointLabel': 'Akhir hari {day} pukul {time}',
+ 'roadtrip.window.title': 'Waktu perjalanan harian',
+ 'roadtrip.window.start': 'Awal hari',
+ 'roadtrip.window.end': 'Akhir hari',
+ 'roadtrip.window.hint':
+ 'Atur kedua waktu untuk merencanakan jeda harian. Kosongkan salah satunya untuk menonaktifkan. Waktu manual diprioritaskan. Hari dihubungkan otomatis.',
+ 'roadtrip.window.invalid': 'Waktu akhir harus setelah waktu mulai.',
+ 'roadtrip.window.stop': 'Akhir hari',
+ 'roadtrip.window.resume': 'Lanjutkan perjalanan',
+ 'roadtrip.window.pointHint': 'Ini perkiraan titik jeda perjalanan Anda untuk bermalam.',
+ 'roadtrip.window.departure': 'Lanjutkan setelah sisa kunjungan pada {time}',
+ 'roadtrip.window.showPoint': 'Tampilkan di peta',
+ 'roadtrip.window.incomplete': 'Semua rute penghubung diperlukan untuk menghitung jeda harian.',
+ 'roadtrip.window.conflict':
+ 'Waktu tetap bertentangan dengan perjalanan dan jeda. Waktu manual tidak berubah; perencanaan otomatis dijeda.',
+ 'roadtrip.window.tooLong':
+ 'Waktu ini memerlukan lebih dari 365 hari tambahan. Pilih rentang waktu harian yang lebih panjang.',
'roadtrip.mode.roadtrip': 'Perjalanan darat',
'roadtrip.mode.days': 'Hari',
'roadtrip.mode.label': 'Tampilan rencana',
diff --git a/shared/src/i18n/id/settings.ts b/shared/src/i18n/id/settings.ts
index 5d1914075..d955567d9 100644
--- a/shared/src/i18n/id/settings.ts
+++ b/shared/src/i18n/id/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Mesin rute sendiri',
'settings.routingBaseHint': 'Instans OSRM milik sendiri. Kosong berarti server publik, yang mengizinkan sekitar satu permintaan per detik — cukup untuk sehari, mepet untuk perjalanan darat. Berlaku setelah server dimulai ulang.',
'settings.valhallaBase': 'Instans Valhalla sendiri',
- 'settings.valhallaBaseHint': 'Instans Valhalla sendiri. Ia ditanya ketika satu ruas harus menghindari tol, jalan bebas hambatan, atau feri — server OSRM publik tidak bisa menjawabnya. Kosong memakai Valhalla publik dari FOSSGIS, kecuali di atas sudah diisi mesin rute sendiri; maka tidak ada mesin kedua yang ditanya. Berlaku setelah server dijalankan ulang.',
+ 'settings.valhallaBaseHint':
+ 'Secara bawaan, TREK menggunakan Valhalla publik FOSSGIS untuk menghindari tol, jalan bebas hambatan, dan feri. Masukkan URL Valhalla Anda sendiri di sini untuk menggunakannya sebagai pengganti. Jika hanya instans perutean sendiri yang dikonfigurasi, Valhalla publik tidak digunakan. Setelah memasukkan URL sendiri, mulai ulang server dan muat ulang halaman.',
'settings.mapHint': 'Template URL untuk tile peta',
'settings.mapProvider': 'Penyedia peta',
'settings.mapProviderHint': 'Berlaku untuk peta Trip Planner dan Journey. Atlas selalu menggunakan Leaflet.',
diff --git a/shared/src/i18n/it/roadtrip.ts b/shared/src/i18n/it/roadtrip.ts
index 65c37104f..6f64e64a4 100644
--- a/shared/src/i18n/it/roadtrip.ts
+++ b/shared/src/i18n/it/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online, trascina la fine della giornata lungo il percorso o su un luogo; fai clic destro per ripristinare la fine automatica.",
+ 'roadtrip.window.resetBoundaries': "Ripristina le fini giornata automatiche",
+ 'roadtrip.window.endHere': 'Termina la giornata qui',
+ 'roadtrip.window.endHereHint':
+ 'Puoi terminare la giornata in una tappa specifica dai suoi dettagli quando la modalità Roadtrip e gli orari giornalieri sono attivi.',
+ 'roadtrip.window.endAt': 'Fine giornata',
+ 'roadtrip.window.onRoute': 'Lungo il percorso',
+ 'roadtrip.window.atStop': 'Nell’ultimo luogo',
+ 'roadtrip.window.routeHint': 'Fermarsi lungo il percorso all’ora di fine giornata.',
+ 'roadtrip.window.stopHint': 'Restare nell’ultimo luogo se non si può raggiungere il successivo entro fine giornata.',
+ 'roadtrip.window.legTooLong':
+ 'Un tragitto supera la fascia oraria giornaliera. Aggiungi un luogo lungo il percorso o scegli una pausa lungo il tragitto.',
+ 'roadtrip.window.pointLabel': 'Fine del giorno {day} alle {time}',
+ 'roadtrip.window.title': 'Orari giornalieri',
+ 'roadtrip.window.start': 'Inizio giornata',
+ 'roadtrip.window.end': 'Fine giornata',
+ 'roadtrip.window.hint':
+ 'Imposta entrambi gli orari per pianificare le pause. Svuota un campo per disattivarle. Gli orari manuali hanno priorità. I giorni vengono collegati automaticamente.',
+ 'roadtrip.window.invalid': "L'orario finale deve essere successivo a quello iniziale.",
+ 'roadtrip.window.stop': 'Fine giornata',
+ 'roadtrip.window.resume': 'Riprendi il viaggio',
+ 'roadtrip.window.pointHint': 'Questo è il punto previsto per la pausa notturna.',
+ 'roadtrip.window.departure': 'Ripartire dopo il resto della visita alle {time}',
+ 'roadtrip.window.showPoint': 'Mostra sulla mappa',
+ 'roadtrip.window.incomplete': 'Per calcolare le pause giornaliere servono tutti i percorsi di collegamento.',
+ 'roadtrip.window.conflict':
+ 'Un orario fisso è incompatibile con il tragitto e le pause. Gli orari manuali restano invariati; la pianificazione automatica è sospesa.',
+ 'roadtrip.window.tooLong':
+ 'Questi orari richiederebbero oltre 365 giorni aggiuntivi. Scegli un intervallo giornaliero più lungo.',
'roadtrip.mode.roadtrip': 'Viaggio su strada',
'roadtrip.mode.days': 'Giorni',
'roadtrip.mode.label': 'Vista del piano',
diff --git a/shared/src/i18n/it/settings.ts b/shared/src/i18n/it/settings.ts
index d60e09895..585b92183 100644
--- a/shared/src/i18n/it/settings.ts
+++ b/shared/src/i18n/it/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Motore di percorso proprio',
'settings.routingBaseHint': 'Una tua istanza OSRM. Vuoto usa i server pubblici, che consentono circa una richiesta al secondo: sufficiente per un giorno, poco per un viaggio in auto. Ha effetto dopo il riavvio del server.',
'settings.valhallaBase': 'Istanza Valhalla propria',
- 'settings.valhallaBaseHint': 'Una istanza Valhalla propria. Viene interrogata quando una tappa deve evitare pedaggi, autostrade o traghetti: i server OSRM pubblici non sanno rispondere. Vuoto usa il Valhalla pubblico di FOSSGIS, a meno che sopra non sia indicato un motore di routing proprio, nel qual caso non viene interrogato alcun secondo motore. Ha effetto dopo il riavvio del server.',
+ 'settings.valhallaBaseHint':
+ 'TREK usa per impostazione predefinita la Valhalla pubblica di FOSSGIS per evitare pedaggi, autostrade e traghetti. Inserisci qui l’URL della tua Valhalla per usarla al suo posto. Se è configurata solo un’istanza di routing personalizzata, la Valhalla pubblica non viene usata. Dopo aver inserito un URL personalizzato, riavvia il server e ricarica la pagina.',
'settings.mapHint': 'Modello URL per i tile della mappa',
'settings.mapProvider': 'Provider mappa',
'settings.mapProviderHint': 'Influisce sulle mappe Trip Planner e Journey. Atlas usa sempre Leaflet.',
diff --git a/shared/src/i18n/ja/roadtrip.ts b/shared/src/i18n/ja/roadtrip.ts
index 737707577..c8c2bff9d 100644
--- a/shared/src/i18n/ja/roadtrip.ts
+++ b/shared/src/i18n/ja/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "オンライン時は一日の終了地点をルート上や場所へドラッグできます。右クリックで自動の終了地点に戻せます。",
+ 'roadtrip.window.resetBoundaries': "一日の終了地点を自動に戻す",
+ 'roadtrip.window.endHere': 'ここで一日を終了',
+ 'roadtrip.window.endHereHint':
+ 'Roadtripモードと毎日の移動時間が有効な場合、場所の詳細から特定の立ち寄り先を一日の終点に設定できます。',
+ 'roadtrip.window.endAt': '1日の終了地点',
+ 'roadtrip.window.onRoute': 'ルートの途中',
+ 'roadtrip.window.atStop': '最後の場所',
+ 'roadtrip.window.routeHint': '終了時刻になったら、ルート上の到達地点で休止します。',
+ 'roadtrip.window.stopHint': '終了時刻までに次の場所へ到着できない場合は、最後の場所に留まります。',
+ 'roadtrip.window.legTooLong':
+ '1区間の移動時間が1日の時間枠を超えています。途中に場所を追加するか、ルートの途中で休止する設定を選んでください。',
+ 'roadtrip.window.pointLabel': '{day}日目の終了時刻は{time}',
+ 'roadtrip.window.title': '毎日の移動時間',
+ 'roadtrip.window.start': '一日の開始時刻',
+ 'roadtrip.window.end': '一日の終了時刻',
+ 'roadtrip.window.hint':
+ '両方の時刻を設定すると毎日の休憩を計画します。どちらかを空欄にすると無効になります。手動の時刻が優先され、各日のルートは自動で接続されます。',
+ 'roadtrip.window.invalid': '終了時刻は開始時刻より後にしてください。',
+ 'roadtrip.window.stop': '一日の終了',
+ 'roadtrip.window.resume': '移動を再開',
+ 'roadtrip.window.pointHint': 'ここが夜間の休止地点になる見込みです。',
+ 'roadtrip.window.departure': '残りの滞在後、{time}に出発',
+ 'roadtrip.window.showPoint': '地図で表示',
+ 'roadtrip.window.incomplete': '毎日の休憩を計算するには、すべての接続ルートが必要です。',
+ 'roadtrip.window.conflict':
+ '固定時刻が移動や休憩と両立しません。手動の時刻は保持され、自動計画は一時停止しています。',
+ 'roadtrip.window.tooLong': 'この設定では365日を超える追加日数が必要です。一日の移動時間を長くしてください。',
'roadtrip.mode.roadtrip': 'ロードトリップ',
'roadtrip.mode.days': '日ごと',
'roadtrip.mode.label': 'プラン表示',
diff --git a/shared/src/i18n/ja/settings.ts b/shared/src/i18n/ja/settings.ts
index 758d9c1f5..92254920e 100644
--- a/shared/src/i18n/ja/settings.ts
+++ b/shared/src/i18n/ja/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': '自前のルーティングサーバー',
'settings.routingBaseHint': '自前の OSRM インスタンス。空欄なら公開サーバーを使いますが、毎秒 1 リクエスト程度の制限があり、1 日分には足りてもロードトリップには足りません。サーバー再起動後に反映されます。',
'settings.valhallaBase': '自前の Valhalla インスタンス',
- 'settings.valhallaBaseHint': '自前の Valhalla インスタンス。有料道路・高速道路・フェリーを避けたい区間で問い合わせます。公開の OSRM サーバーはこれに答えられません。空欄なら FOSSGIS の公開 Valhalla を使いますが、上で自前のルーティングサーバーを指定している場合は二つ目のエンジンを一切問い合わせません。サーバー再起動後に反映されます。',
+ 'settings.valhallaBaseHint':
+ 'TREKは、有料道路、高速道路、フェリーを避けるために、標準でFOSSGISの公開Valhallaを使用します。独自のValhallaを代わりに使う場合は、ここにURLを入力してください。独自のルーティングサーバーのみが設定されている場合、公開Valhallaは使用されません。独自のURLを入力した後は、サーバーを再起動し、ページを再読み込みしてください。',
'settings.mapHint': '地図タイルのURLテンプレート',
'settings.mapProvider': '地図プロバイダー',
'settings.mapProviderHint': '旅程プランナーと日記地図に影響します。Atlas は常に Leaflet を使用します。',
diff --git a/shared/src/i18n/ko/roadtrip.ts b/shared/src/i18n/ko/roadtrip.ts
index ec892396e..890d97a0d 100644
--- a/shared/src/i18n/ko/roadtrip.ts
+++ b/shared/src/i18n/ko/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "온라인에서 하루 종료 지점을 경로나 장소로 드래그하고, 오른쪽 클릭으로 자동 종료를 복원할 수 있습니다.",
+ 'roadtrip.window.resetBoundaries': "자동 하루 종료 복원",
+ 'roadtrip.window.endHere': '여기서 하루 종료',
+ 'roadtrip.window.endHereHint':
+ 'Roadtrip 모드와 일일 이동 시간이 활성화된 경우 장소 상세에서 특정 경유지를 하루의 종점으로 설정할 수 있습니다.',
+ 'roadtrip.window.endAt': '하루 종료 지점',
+ 'roadtrip.window.onRoute': '경로 중간',
+ 'roadtrip.window.atStop': '마지막 장소',
+ 'roadtrip.window.routeHint': '종료 시간이 되면 경로의 도달 지점에서 멈춥니다.',
+ 'roadtrip.window.stopHint': '하루 종료 전 다음 장소에 도착할 수 없으면 마지막 장소에 머뭅니다.',
+ 'roadtrip.window.legTooLong':
+ '한 구간의 이동 시간이 하루 시간 범위를 초과합니다. 중간에 장소를 추가하거나 경로 중간에서 멈추도록 선택하세요.',
+ 'roadtrip.window.pointLabel': '{day}일차 종료 시간 {time}',
+ 'roadtrip.window.title': '일일 이동 시간',
+ 'roadtrip.window.start': '하루 시작 시간',
+ 'roadtrip.window.end': '하루 종료 시간',
+ 'roadtrip.window.hint':
+ '매일 휴식을 계획하려면 두 시간을 모두 설정하세요. 하나를 비우면 해제됩니다. 수동 시간이 우선하며 날짜별 경로는 자동으로 연결됩니다.',
+ 'roadtrip.window.invalid': '종료 시간은 시작 시간보다 늦어야 합니다.',
+ 'roadtrip.window.stop': '하루 일정 종료',
+ 'roadtrip.window.resume': '여행 계속',
+ 'roadtrip.window.pointHint': '여기가 예상되는 야간 휴식 지점입니다.',
+ 'roadtrip.window.departure': '남은 방문을 마친 후 {time}에 출발',
+ 'roadtrip.window.showPoint': '지도에서 보기',
+ 'roadtrip.window.incomplete': '매일 휴식을 계산하려면 모든 연결 경로가 필요합니다.',
+ 'roadtrip.window.conflict':
+ '고정 시간이 이동 및 휴식과 충돌합니다. 수동 시간은 유지되며 자동 계획이 일시 중지됩니다.',
+ 'roadtrip.window.tooLong': '이 시간 설정에는 365일이 넘는 추가 날짜가 필요합니다. 일일 이동 시간을 늘려 주세요.',
'roadtrip.mode.roadtrip': '로드트립',
'roadtrip.mode.days': '일자별',
'roadtrip.mode.label': '계획 보기',
diff --git a/shared/src/i18n/ko/settings.ts b/shared/src/i18n/ko/settings.ts
index 3c9e8ca0c..09b7cefd6 100644
--- a/shared/src/i18n/ko/settings.ts
+++ b/shared/src/i18n/ko/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': '자체 경로 서버',
'settings.routingBaseHint': '자체 OSRM 인스턴스입니다. 비워 두면 초당 약 한 번의 요청만 허용하는 공개 서버를 사용합니다. 하루치는 충분하지만 로드트립에는 빠듯합니다. 서버를 다시 시작해야 적용됩니다.',
'settings.valhallaBase': '자체 Valhalla 인스턴스',
- 'settings.valhallaBaseHint': '자체 Valhalla 인스턴스. 구간에서 통행료, 고속도로, 페리를 피해야 할 때 이 서버에 묻습니다. 공개 OSRM 서버는 이에 답하지 못합니다. 비워 두면 FOSSGIS의 공개 Valhalla를 쓰지만, 위에 자체 라우팅 서버를 적어 두었다면 두 번째 엔진은 아예 묻지 않습니다. 서버를 다시 시작한 뒤에 적용됩니다.',
+ 'settings.valhallaBaseHint':
+ 'TREK은 기본적으로 유료 도로, 고속도로, 페리를 피하기 위해 FOSSGIS의 공개 Valhalla를 사용합니다. 대신 자체 Valhalla를 사용하려면 여기에 URL을 입력하세요. 자체 라우팅 서버만 설정된 경우 공개 Valhalla는 사용되지 않습니다. 자체 URL을 입력한 후 서버를 재시작하고 페이지를 새로고침하세요.',
'settings.mapHint': '지도 타일 URL 템플릿',
'settings.mapProvider': '지도 공급자',
'settings.mapProviderHint': '여행 플래너 및 Journey 지도에 영향을 줍니다. Atlas는 항상 Leaflet을 사용합니다.',
diff --git a/shared/src/i18n/nl/roadtrip.ts b/shared/src/i18n/nl/roadtrip.ts
index 346547515..e4d24d9a6 100644
--- a/shared/src/i18n/nl/roadtrip.ts
+++ b/shared/src/i18n/nl/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Sleep online het dageinde langs de route of naar een plaats; klik met rechts om het automatische einde te herstellen.",
+ 'roadtrip.window.resetBoundaries': "Automatische dageinden herstellen",
+ 'roadtrip.window.endHere': 'Dag hier beëindigen',
+ 'roadtrip.window.endHereHint':
+ 'Je kunt een stop als dageinde instellen in de plaatsdetails wanneer de Roadtrip-modus en dagelijkse reistijden actief zijn.',
+ 'roadtrip.window.endAt': 'Dag afsluiten',
+ 'roadtrip.window.onRoute': 'Onderweg',
+ 'roadtrip.window.atStop': 'Bij de laatste plek',
+ 'roadtrip.window.routeHint': 'Pauzeer onderweg zodra de eindtijd is bereikt.',
+ 'roadtrip.window.stopHint': 'Blijf bij de laatste plek als de volgende niet voor het einde van de dag bereikbaar is.',
+ 'roadtrip.window.legTooLong':
+ 'Een rit duurt langer dan het dagelijkse tijdvenster. Voeg onderweg een plek toe of kies voor een pauze onderweg.',
+ 'roadtrip.window.pointLabel': 'Einde van dag {day} om {time}',
+ 'roadtrip.window.title': 'Dagelijkse reistijden',
+ 'roadtrip.window.start': 'Begin van de dag',
+ 'roadtrip.window.end': 'Einde van de dag',
+ 'roadtrip.window.hint':
+ 'Vul beide tijden in om dagelijkse pauzes te plannen. Maak één veld leeg om dit uit te zetten. Handmatige tijden gaan voor. Dagen worden automatisch verbonden.',
+ 'roadtrip.window.invalid': 'De eindtijd moet na de begintijd liggen.',
+ 'roadtrip.window.stop': 'Einde van de dag',
+ 'roadtrip.window.resume': 'Reis hervatten',
+ 'roadtrip.window.pointHint': 'Hier pauzeert je reis naar verwachting voor de nacht.',
+ 'roadtrip.window.departure': 'Verder na het resterende bezoek om {time}',
+ 'roadtrip.window.showPoint': 'Toon op kaart',
+ 'roadtrip.window.incomplete':
+ 'Dagelijkse pauzes kunnen pas worden berekend als alle verbindingsroutes beschikbaar zijn.',
+ 'roadtrip.window.conflict':
+ 'Een vaste tijd past niet bij de rit en pauzes. Handmatige tijden blijven behouden; automatische planning is gepauzeerd.',
+ 'roadtrip.window.tooLong': 'Deze tijden vragen meer dan 365 extra dagen. Kies een langer dagelijks tijdvak.',
'roadtrip.mode.roadtrip': 'Roadtrip',
'roadtrip.mode.days': 'Dagen',
'roadtrip.mode.label': 'Planweergave',
diff --git a/shared/src/i18n/nl/settings.ts b/shared/src/i18n/nl/settings.ts
index afe8ab0d5..1db115f8e 100644
--- a/shared/src/i18n/nl/settings.ts
+++ b/shared/src/i18n/nl/settings.ts
@@ -28,7 +28,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Eigen routeserver',
'settings.routingBaseHint': 'Een eigen OSRM-server. Leeg gebruikt de publieke servers, die ongeveer één verzoek per seconde toestaan — genoeg voor een dag, krap voor een roadtrip. Werkt na een herstart van de server.',
'settings.valhallaBase': 'Eigen Valhalla-instantie',
- 'settings.valhallaBaseHint': 'Een eigen Valhalla-instantie. Die wordt geraadpleegd wanneer een traject tol, snelwegen of veerboten moet vermijden — dat kunnen de publieke OSRM-servers niet beantwoorden. Leeg gebruikt de publieke FOSSGIS-Valhalla, tenzij hierboven een eigen routeringsmotor staat; dan wordt er helemaal geen tweede motor geraadpleegd. Werkt pas na een herstart van de server.',
+ 'settings.valhallaBaseHint':
+ 'TREK gebruikt standaard de publieke Valhalla van FOSSGIS om tolwegen, snelwegen en veerboten te vermijden. Vul hier de URL van je eigen Valhalla in om die te gebruiken. Als alleen een eigen routeringsinstantie is ingesteld, wordt de publieke Valhalla niet gebruikt. Herstart na het invoeren van een eigen URL de server en laad de pagina opnieuw.',
'settings.mapHint': 'URL-sjabloon voor kaarttegels',
'settings.mapProvider': 'Kaartprovider',
'settings.mapProviderHint': 'Geldt voor Trip Planner en Journey kaarten. Atlas gebruikt altijd Leaflet.',
diff --git a/shared/src/i18n/pl/roadtrip.ts b/shared/src/i18n/pl/roadtrip.ts
index e1d8f8200..b9a195697 100644
--- a/shared/src/i18n/pl/roadtrip.ts
+++ b/shared/src/i18n/pl/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Online przeciągnij koniec dnia wzdłuż trasy lub na miejsce; kliknij prawym przyciskiem, aby przywrócić automatyczny koniec.",
+ 'roadtrip.window.resetBoundaries': "Przywróć automatyczne końce dni",
+ 'roadtrip.window.endHere': 'Zakończ dzień tutaj',
+ 'roadtrip.window.endHereHint':
+ 'Możesz wybrać przystanek jako koniec dnia w szczegółach miejsca, gdy tryb Roadtrip i dzienne godziny podróży są aktywne.',
+ 'roadtrip.window.endAt': 'Koniec dnia',
+ 'roadtrip.window.onRoute': 'Na trasie',
+ 'roadtrip.window.atStop': 'W ostatnim miejscu',
+ 'roadtrip.window.routeHint': 'Zatrzymaj się na trasie o godzinie zakończenia dnia.',
+ 'roadtrip.window.stopHint': 'Zostań w ostatnim miejscu, jeśli nie można dotrzeć do następnego przed końcem dnia.',
+ 'roadtrip.window.legTooLong':
+ 'Jeden odcinek przekracza dzienny przedział czasu. Dodaj miejsce po drodze lub wybierz postój na trasie.',
+ 'roadtrip.window.pointLabel': 'Koniec dnia {day} o {time}',
+ 'roadtrip.window.title': 'Dzienne godziny podróży',
+ 'roadtrip.window.start': 'Początek dnia',
+ 'roadtrip.window.end': 'Koniec dnia',
+ 'roadtrip.window.hint':
+ 'Ustaw obie godziny, aby planować codzienne przerwy. Wyczyść jedną, aby wyłączyć automatykę. Ręczne godziny mają pierwszeństwo. Dni są łączone automatycznie.',
+ 'roadtrip.window.invalid': 'Godzina końca musi być późniejsza niż godzina początku.',
+ 'roadtrip.window.stop': 'Koniec dnia',
+ 'roadtrip.window.resume': 'Kontynuuj podróż',
+ 'roadtrip.window.pointHint': 'To przewidywane miejsce nocnej przerwy w podróży.',
+ 'roadtrip.window.departure': 'Dalsza podróż po pozostałej części wizyty o {time}',
+ 'roadtrip.window.showPoint': 'Pokaż na mapie',
+ 'roadtrip.window.incomplete': 'Obliczenie codziennych przerw wymaga wszystkich tras łączących.',
+ 'roadtrip.window.conflict':
+ 'Stała godzina koliduje z jazdą i przerwami. Ręczne godziny pozostają bez zmian; automatyczne planowanie jest wstrzymane.',
+ 'roadtrip.window.tooLong': 'Te godziny wymagają ponad 365 dodatkowych dni. Wybierz dłuższy dzienny przedział.',
'roadtrip.mode.roadtrip': 'Podróż samochodowa',
'roadtrip.mode.days': 'Dni',
'roadtrip.mode.label': 'Widok planu',
diff --git a/shared/src/i18n/pl/settings.ts b/shared/src/i18n/pl/settings.ts
index 2e65005ad..65b6c39f6 100644
--- a/shared/src/i18n/pl/settings.ts
+++ b/shared/src/i18n/pl/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Własny silnik tras',
'settings.routingBaseHint': 'Własna instancja OSRM. Puste używa serwerów publicznych, które pozwalają na około jedno zapytanie na sekundę — wystarczy na dzień, mało na road trip. Działa po restarcie serwera.',
'settings.valhallaBase': 'Własna instancja Valhalli',
- 'settings.valhallaBaseHint': 'Własna instancja Valhalli. Pytana wtedy, gdy odcinek ma omijać opłaty, autostrady lub promy — publiczne serwery OSRM nie potrafią na to odpowiedzieć. Puste używa publicznej Valhalli FOSSGIS, chyba że powyżej wskazano własny silnik tras; wtedy żaden drugi silnik nie jest pytany. Działa po ponownym uruchomieniu serwera.',
+ 'settings.valhallaBaseHint':
+ 'TREK domyślnie używa publicznej Valhalli FOSSGIS do omijania opłat, autostrad i promów. Wpisz tutaj URL własnej Valhalli, aby używać jej zamiast publicznej. Jeśli skonfigurowano tylko własną instancję wyznaczania tras, publiczna Valhalla nie jest używana. Po wpisaniu własnego adresu URL uruchom ponownie serwer i odśwież stronę.',
'settings.mapHint': 'Szablon URL dla kafelków mapy',
'settings.mapProvider': 'Dostawca mapy',
'settings.mapProviderHint': 'Dotyczy map Trip Planner i Journey. Atlas zawsze używa Leaflet.',
diff --git a/shared/src/i18n/ru/roadtrip.ts b/shared/src/i18n/ru/roadtrip.ts
index c2b383816..49e72bccf 100644
--- a/shared/src/i18n/ru/roadtrip.ts
+++ b/shared/src/i18n/ru/roadtrip.ts
@@ -1,6 +1,35 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "В сети перетащите конец дня по маршруту или на место; щёлкните правой кнопкой для возврата к автоматическому завершению.",
+ 'roadtrip.window.resetBoundaries': "Восстановить автоматические окончания дней",
+ 'roadtrip.window.endHere': 'Завершить день здесь',
+ 'roadtrip.window.endHereHint':
+ 'В сведениях о месте можно завершить день на выбранной остановке, когда активны режим Roadtrip и ежедневное время поездки.',
+ 'roadtrip.window.endAt': 'Завершение дня',
+ 'roadtrip.window.onRoute': 'На маршруте',
+ 'roadtrip.window.atStop': 'В последнем месте',
+ 'roadtrip.window.routeHint': 'Остановиться на маршруте при наступлении времени окончания дня.',
+ 'roadtrip.window.stopHint': 'Остаться в последнем месте, если до следующего нельзя доехать до конца дня.',
+ 'roadtrip.window.legTooLong':
+ 'Один переезд превышает дневной интервал. Добавьте место по пути или выберите остановку на маршруте.',
+ 'roadtrip.window.pointLabel': 'Конец дня {day} в {time}',
+ 'roadtrip.window.title': 'Ежедневное время в пути',
+ 'roadtrip.window.start': 'Начало дня',
+ 'roadtrip.window.end': 'Конец дня',
+ 'roadtrip.window.hint':
+ 'Задайте оба времени для ежедневных перерывов. Очистите одно поле, чтобы отключить расчёт. Ручные значения имеют приоритет. Дни соединяются автоматически.',
+ 'roadtrip.window.invalid': 'Конец дня должен быть позже начала.',
+ 'roadtrip.window.stop': 'Конец дня',
+ 'roadtrip.window.resume': 'Продолжить поездку',
+ 'roadtrip.window.pointHint': 'Здесь предполагается ночная остановка в пути.',
+ 'roadtrip.window.departure': 'Продолжить после оставшейся части посещения в {time}',
+ 'roadtrip.window.showPoint': 'Показать на карте',
+ 'roadtrip.window.incomplete': 'Для расчёта ежедневных перерывов нужны все соединяющие маршруты.',
+ 'roadtrip.window.conflict':
+ 'Фиксированное время противоречит поездке и перерывам. Ручные значения сохранены; автоматическое планирование приостановлено.',
+ 'roadtrip.window.tooLong':
+ 'При этих настройках потребуется более 365 дополнительных дней. Увеличьте ежедневный интервал.',
'roadtrip.mode.roadtrip': 'Автопутешествие',
'roadtrip.mode.days': 'Дни',
'roadtrip.mode.label': 'Вид плана',
diff --git a/shared/src/i18n/ru/settings.ts b/shared/src/i18n/ru/settings.ts
index 70c8c0dcc..8550d8243 100644
--- a/shared/src/i18n/ru/settings.ts
+++ b/shared/src/i18n/ru/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Собственный сервер маршрутов',
'settings.routingBaseHint': 'Собственный экземпляр OSRM. Пусто — используются публичные серверы с ограничением около одного запроса в секунду: на день хватает, для автопутешествия мало. Вступает в силу после перезапуска сервера.',
'settings.valhallaBase': 'Свой сервер Valhalla',
- 'settings.valhallaBaseHint': 'Свой сервер Valhalla. К нему обращаются, когда участок должен обойти платные дороги, автомагистрали или паромы — публичные серверы OSRM на это ответить не могут. Пусто использует публичный Valhalla от FOSSGIS, если выше не указан свой маршрутизатор; тогда второй движок не запрашивается вовсе. Действует после перезапуска сервера.',
+ 'settings.valhallaBaseHint':
+ 'По умолчанию TREK использует публичную Valhalla FOSSGIS для объезда платных дорог, автомагистралей и паромов. Введите здесь URL собственной Valhalla, чтобы использовать её вместо публичной. Если настроен только собственный сервер маршрутизации, публичная Valhalla не используется. После ввода собственного URL перезапустите сервер и обновите страницу.',
'settings.mapHint': 'URL-шаблон для тайлов карты',
'settings.mapProvider': 'Провайдер карты',
'settings.mapProviderHint': 'Применяется к Trip Planner и Journey. Atlas всегда использует Leaflet.',
diff --git a/shared/src/i18n/sv/roadtrip.ts b/shared/src/i18n/sv/roadtrip.ts
index 8fccfd389..4980f6204 100644
--- a/shared/src/i18n/sv/roadtrip.ts
+++ b/shared/src/i18n/sv/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Dra dagens slut längs rutten eller till en plats när du är online; högerklicka för att återställa det automatiska slutet.",
+ 'roadtrip.window.resetBoundaries': "Återställ automatiska dagsslut",
+ 'roadtrip.window.endHere': 'Avsluta dagen här',
+ 'roadtrip.window.endHereHint':
+ 'Du kan avsluta dagen vid ett visst stopp i platsens detaljer när Roadtrip-läget och dagliga restider är aktiva.',
+ 'roadtrip.window.endAt': 'Avsluta dagen',
+ 'roadtrip.window.onRoute': 'Längs rutten',
+ 'roadtrip.window.atStop': 'Vid sista platsen',
+ 'roadtrip.window.routeHint': 'Pausa längs rutten när sluttiden nås.',
+ 'roadtrip.window.stopHint': 'Stanna vid sista platsen om nästa inte kan nås före dagens slut.',
+ 'roadtrip.window.legTooLong':
+ 'En körsträcka överskrider dagens tidsram. Lägg till en plats längs vägen eller välj att pausa längs rutten.',
+ 'roadtrip.window.pointLabel': 'Slut på dag {day} kl. {time}',
+ 'roadtrip.window.title': 'Dagliga restider',
+ 'roadtrip.window.start': 'Dagens start',
+ 'roadtrip.window.end': 'Dagens slut',
+ 'roadtrip.window.hint':
+ 'Ange båda tiderna för att planera dagliga pauser. Töm ett fält för att stänga av. Manuella tider har företräde. Dagarna kopplas ihop automatiskt.',
+ 'roadtrip.window.invalid': 'Sluttiden måste vara senare än starttiden.',
+ 'roadtrip.window.stop': 'Dagens slut',
+ 'roadtrip.window.resume': 'Fortsätt resan',
+ 'roadtrip.window.pointHint': 'Här beräknas resan göra uppehåll över natten.',
+ 'roadtrip.window.departure': 'Fortsätt efter resten av besöket klockan {time}',
+ 'roadtrip.window.showPoint': 'Visa på kartan',
+ 'roadtrip.window.incomplete': 'Alla anslutande rutter behövs för att beräkna dagliga pauser.',
+ 'roadtrip.window.conflict':
+ 'En fast tid krockar med körningen och pauserna. Manuella tider behålls; automatisk planering är pausad.',
+ 'roadtrip.window.tooLong': 'Dessa tider kräver fler än 365 extra dagar. Välj ett längre dagligt tidsintervall.',
'roadtrip.mode.roadtrip': 'Bilresa',
'roadtrip.mode.days': 'Dagar',
'roadtrip.mode.label': 'Planvy',
diff --git a/shared/src/i18n/sv/settings.ts b/shared/src/i18n/sv/settings.ts
index 0c5e07858..5b3fac127 100644
--- a/shared/src/i18n/sv/settings.ts
+++ b/shared/src/i18n/sv/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Egen ruttmotor',
'settings.routingBaseHint': 'En egen OSRM-instans. Tomt använder de publika servrarna, som tillåter ungefär en förfrågan per sekund – nog för en dag, knappt för en bilresa. Träder i kraft efter omstart av servern.',
'settings.valhallaBase': 'Egen Valhalla-instans',
- 'settings.valhallaBaseHint': 'En egen Valhalla-instans. Den frågas när en etapp ska undvika vägavgifter, motorvägar eller färjor — de publika OSRM-servrarna kan inte svara på det. Tomt använder FOSSGIS publika Valhalla, om inte en egen ruttmotor angetts ovan; då frågas ingen andra motor alls. Börjar gälla efter en omstart av servern.',
+ 'settings.valhallaBaseHint':
+ 'TREK använder som standard FOSSGIS publika Valhalla för att undvika vägtullar, motorvägar och färjor. Ange URL:en till din egen Valhalla här för att använda den i stället. Om bara en egen ruttserver är konfigurerad används inte den publika Valhalla. Starta om servern och ladda om sidan efter att du angett en egen URL.',
'settings.mapHint': 'URL-mall för kartrutor',
'settings.mapProvider': 'Kartleverantör',
'settings.mapProviderHint': 'Påverkar resplaneraren och resedagbokens kartor. Atlas använder alltid Leaflet.',
diff --git a/shared/src/i18n/tr/roadtrip.ts b/shared/src/i18n/tr/roadtrip.ts
index 18127622f..c0bc9b547 100644
--- a/shared/src/i18n/tr/roadtrip.ts
+++ b/shared/src/i18n/tr/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Çevrimiçiyken gün sonunu rota boyunca veya bir yere sürükleyin; otomatik sonu geri yüklemek için sağ tıklayın.",
+ 'roadtrip.window.resetBoundaries': "Otomatik gün sonlarını geri yükle",
+ 'roadtrip.window.endHere': 'Günü burada bitir',
+ 'roadtrip.window.endHereHint':
+ 'Roadtrip modu ve günlük seyahat saatleri etkinken yer ayrıntılarından belirli bir durağı gün sonu olarak seçebilirsiniz.',
+ 'roadtrip.window.endAt': 'Günü bitir',
+ 'roadtrip.window.onRoute': 'Rota üzerinde',
+ 'roadtrip.window.atStop': 'Son yerde',
+ 'roadtrip.window.routeHint': 'Bitiş saatine ulaşıldığında rota üzerinde mola ver.',
+ 'roadtrip.window.stopHint': 'Bir sonraki yere gün bitmeden ulaşılamıyorsa son yerde kal.',
+ 'roadtrip.window.legTooLong':
+ 'Bir sürüş günlük zaman aralığını aşıyor. Yol üzerine bir yer ekleyin veya rota üzerinde mola vermeyi seçin.',
+ 'roadtrip.window.pointLabel': '{day}. günün bitişi saat {time}',
+ 'roadtrip.window.title': 'Günlük yolculuk saatleri',
+ 'roadtrip.window.start': 'Gün başlangıcı',
+ 'roadtrip.window.end': 'Gün bitişi',
+ 'roadtrip.window.hint':
+ 'Günlük molaları planlamak için iki saati de ayarlayın. Kapatmak için birini temizleyin. Elle girilen saatler önceliklidir. Günler otomatik bağlanır.',
+ 'roadtrip.window.invalid': 'Bitiş saati başlangıç saatinden sonra olmalıdır.',
+ 'roadtrip.window.stop': 'Gün sonu',
+ 'roadtrip.window.resume': 'Yolculuğa devam et',
+ 'roadtrip.window.pointHint': 'Burası yolculuğunuzun tahmini gece molası noktasıdır.',
+ 'roadtrip.window.departure': 'Ziyaretin kalan kısmından sonra {time} saatinde devam et',
+ 'roadtrip.window.showPoint': 'Haritada göster',
+ 'roadtrip.window.incomplete': 'Günlük molaları hesaplamak için tüm bağlantı rotaları gereklidir.',
+ 'roadtrip.window.conflict':
+ 'Sabit bir saat sürüş ve molalarla çakışıyor. Elle girilen saatler korunur; otomatik planlama duraklatıldı.',
+ 'roadtrip.window.tooLong': 'Bu saatler 365 günden fazla ek süre gerektiriyor. Daha uzun bir günlük aralık seçin.',
'roadtrip.mode.roadtrip': 'Yol gezisi',
'roadtrip.mode.days': 'Günler',
'roadtrip.mode.label': 'Plan görünümü',
diff --git a/shared/src/i18n/tr/settings.ts b/shared/src/i18n/tr/settings.ts
index ad9da7301..d88a99bfc 100644
--- a/shared/src/i18n/tr/settings.ts
+++ b/shared/src/i18n/tr/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Kendi rota motoru',
'settings.routingBaseHint': 'Kendi OSRM sunucunuz. Boş bırakılırsa saniyede yaklaşık bir istek veren genel sunucular kullanılır: bir gün için yeter, uzun yolculuk için az. Sunucu yeniden başlatıldığında etkin olur.',
'settings.valhallaBase': 'Kendi Valhalla sunucunuz',
- 'settings.valhallaBaseHint': 'Kendi Valhalla sunucunuz. Bir etabın gişeleri, otoyolları veya feribotları es geçmesi gerektiğinde ona sorulur — açık OSRM sunucuları bunu yanıtlayamaz. Boş bırakılırsa FOSSGIS’in açık Valhalla’sı kullanılır; yukarıda kendi rota motorunuz yazılıysa ikinci bir motor hiç sorulmaz. Sunucu yeniden başlatıldıktan sonra geçerli olur.',
+ 'settings.valhallaBaseHint':
+ 'TREK, ücretli yolları, otoyolları ve feribotları önlemek için varsayılan olarak FOSSGIS’in herkese açık Valhalla hizmetini kullanır. Bunun yerine kendi Valhalla sunucunuzu kullanmak için URL’sini buraya girin. Yalnızca özel bir rota sunucusu yapılandırılmışsa herkese açık Valhalla kullanılmaz. Özel URL girdikten sonra sunucuyu yeniden başlatın ve sayfayı yenileyin.',
'settings.mapHint': 'Harita kutucukları için URL şablonu',
'settings.mapProvider': 'Harita Sağlayıcısı',
'settings.mapProviderHint': 'Seyahat planlayıcı ve Journey haritalarını etkiler. Atlas her zaman Leaflet kullanır.',
diff --git a/shared/src/i18n/uk/roadtrip.ts b/shared/src/i18n/uk/roadtrip.ts
index 930990fd0..b59dfba12 100644
--- a/shared/src/i18n/uk/roadtrip.ts
+++ b/shared/src/i18n/uk/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Онлайн перетягніть кінець дня вздовж маршруту або на місце; клацніть правою кнопкою, щоб відновити автоматичне завершення.",
+ 'roadtrip.window.resetBoundaries': "Відновити автоматичні завершення днів",
+ 'roadtrip.window.endHere': 'Завершити день тут',
+ 'roadtrip.window.endHereHint':
+ 'У деталях місця можна завершити день на вибраній зупинці, коли активні режим Roadtrip і щоденний час подорожі.',
+ 'roadtrip.window.endAt': 'Завершення дня',
+ 'roadtrip.window.onRoute': 'На маршруті',
+ 'roadtrip.window.atStop': 'В останньому місці',
+ 'roadtrip.window.routeHint': 'Зупинитися на маршруті, коли настане час завершення дня.',
+ 'roadtrip.window.stopHint': 'Залишитися в останньому місці, якщо до наступного не можна дістатися до кінця дня.',
+ 'roadtrip.window.legTooLong':
+ 'Один переїзд перевищує денний інтервал. Додайте місце дорогою або виберіть зупинку на маршруті.',
+ 'roadtrip.window.pointLabel': 'Кінець дня {day} о {time}',
+ 'roadtrip.window.title': 'Щоденний час подорожі',
+ 'roadtrip.window.start': 'Початок дня',
+ 'roadtrip.window.end': 'Кінець дня',
+ 'roadtrip.window.hint':
+ 'Задайте обидва часи для щоденних перерв. Очистіть одне поле, щоб вимкнути розрахунок. Ручні значення мають пріоритет. Дні з’єднуються автоматично.',
+ 'roadtrip.window.invalid': 'Кінець дня має бути пізніше початку.',
+ 'roadtrip.window.stop': 'Кінець дня',
+ 'roadtrip.window.resume': 'Продовжити подорож',
+ 'roadtrip.window.pointHint': 'Тут передбачається нічна зупинка в дорозі.',
+ 'roadtrip.window.departure': 'Продовжити після решти відвідування о {time}',
+ 'roadtrip.window.showPoint': 'Показати на мапі',
+ 'roadtrip.window.incomplete': 'Для розрахунку щоденних перерв потрібні всі сполучні маршрути.',
+ 'roadtrip.window.conflict':
+ 'Фіксований час суперечить поїздці та перервам. Ручні значення збережено; автоматичне планування призупинено.',
+ 'roadtrip.window.tooLong': 'За цих налаштувань потрібно понад 365 додаткових днів. Збільште щоденний інтервал.',
'roadtrip.mode.roadtrip': 'Автоподорож',
'roadtrip.mode.days': 'Дні',
'roadtrip.mode.label': 'Вигляд плану',
diff --git a/shared/src/i18n/uk/settings.ts b/shared/src/i18n/uk/settings.ts
index 250fde61e..62bcc7e8a 100644
--- a/shared/src/i18n/uk/settings.ts
+++ b/shared/src/i18n/uk/settings.ts
@@ -28,7 +28,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Власний сервер маршрутів',
'settings.routingBaseHint': 'Власний примірник OSRM. Порожньо — використовуються публічні сервери з обмеженням близько одного запиту на секунду: на день вистачає, для автоподорожі мало. Діє після перезапуску сервера.',
'settings.valhallaBase': 'Власний сервер Valhalla',
- 'settings.valhallaBaseHint': 'Власний сервер Valhalla. До нього звертаються, коли ділянка має обійти платні дороги, автомагістралі або пороми — публічні сервери OSRM на це відповісти не можуть. Порожнє використовує публічний Valhalla від FOSSGIS, якщо вище не вказано власний маршрутизатор; тоді другий рушій не запитують узагалі. Діє після перезапуску сервера.',
+ 'settings.valhallaBaseHint':
+ 'За замовчуванням TREK використовує публічну Valhalla FOSSGIS для уникнення платних доріг, автомагістралей і поромів. Введіть тут URL власної Valhalla, щоб використовувати її замість публічної. Якщо налаштовано лише власний сервер маршрутизації, публічна Valhalla не використовується. Після введення власного URL перезапустіть сервер і оновіть сторінку.',
'settings.mapHint': 'URL-шаблон для тайлів карти',
'settings.mapProvider': 'Провайдер карти',
'settings.mapProviderHint': 'Застосовується до Trip Planner та Journey. Atlas завжди використовує Leaflet.',
diff --git a/shared/src/i18n/vi/roadtrip.ts b/shared/src/i18n/vi/roadtrip.ts
index 0dc5ac71b..0dab1f535 100644
--- a/shared/src/i18n/vi/roadtrip.ts
+++ b/shared/src/i18n/vi/roadtrip.ts
@@ -1,6 +1,34 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "Khi trực tuyến, kéo điểm kết thúc ngày dọc tuyến đường hoặc đến một địa điểm; nhấp chuột phải để khôi phục kết thúc tự động.",
+ 'roadtrip.window.resetBoundaries': "Khôi phục kết thúc ngày tự động",
+ 'roadtrip.window.endHere': 'Kết thúc ngày tại đây',
+ 'roadtrip.window.endHereHint':
+ 'Bạn có thể kết thúc ngày tại một điểm dừng trong chi tiết địa điểm khi chế độ Roadtrip và giờ di chuyển hằng ngày đang bật.',
+ 'roadtrip.window.endAt': 'Kết thúc ngày',
+ 'roadtrip.window.onRoute': 'Trên tuyến đường',
+ 'roadtrip.window.atStop': 'Tại địa điểm cuối',
+ 'roadtrip.window.routeHint': 'Tạm dừng trên tuyến đường khi đến giờ kết thúc.',
+ 'roadtrip.window.stopHint': 'Ở lại địa điểm cuối nếu không thể đến địa điểm tiếp theo trước giờ kết thúc ngày.',
+ 'roadtrip.window.legTooLong':
+ 'Một chặng lái xe vượt quá khung giờ hằng ngày. Thêm địa điểm dọc đường hoặc chọn tạm dừng trên tuyến đường.',
+ 'roadtrip.window.pointLabel': 'Kết thúc ngày {day} lúc {time}',
+ 'roadtrip.window.title': 'Giờ di chuyển hằng ngày',
+ 'roadtrip.window.start': 'Giờ bắt đầu ngày',
+ 'roadtrip.window.end': 'Giờ kết thúc ngày',
+ 'roadtrip.window.hint':
+ 'Đặt cả hai giờ để lên kế hoạch nghỉ mỗi ngày. Xóa một giờ để tắt. Giờ nhập thủ công được ưu tiên. Các ngày được nối tự động.',
+ 'roadtrip.window.invalid': 'Giờ kết thúc phải sau giờ bắt đầu.',
+ 'roadtrip.window.stop': 'Kết thúc ngày',
+ 'roadtrip.window.resume': 'Tiếp tục hành trình',
+ 'roadtrip.window.pointHint': 'Đây là điểm tạm dừng qua đêm dự kiến của hành trình.',
+ 'roadtrip.window.departure': 'Tiếp tục sau phần tham quan còn lại lúc {time}',
+ 'roadtrip.window.showPoint': 'Hiện trên bản đồ',
+ 'roadtrip.window.incomplete': 'Cần có tất cả tuyến đường nối để tính thời gian nghỉ hằng ngày.',
+ 'roadtrip.window.conflict':
+ 'Một giờ cố định xung đột với việc lái xe và nghỉ. Giờ thủ công được giữ nguyên; lập lịch tự động tạm dừng.',
+ 'roadtrip.window.tooLong': 'Các giờ này cần hơn 365 ngày bổ sung. Hãy chọn khoảng thời gian mỗi ngày dài hơn.',
'roadtrip.mode.roadtrip': 'Chuyến đi đường bộ',
'roadtrip.mode.days': 'Ngày',
'roadtrip.mode.label': 'Chế độ xem kế hoạch',
diff --git a/shared/src/i18n/vi/settings.ts b/shared/src/i18n/vi/settings.ts
index afa04b608..f3d2ad0d2 100644
--- a/shared/src/i18n/vi/settings.ts
+++ b/shared/src/i18n/vi/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': 'Máy chủ định tuyến riêng',
'settings.routingBaseHint': 'Máy chủ OSRM của riêng bạn. Để trống sẽ dùng máy chủ công cộng, cho phép khoảng một yêu cầu mỗi giây — đủ cho một ngày, chật cho chuyến đi dài. Có hiệu lực sau khi khởi động lại máy chủ.',
'settings.valhallaBase': 'Máy chủ Valhalla riêng',
- 'settings.valhallaBaseHint': 'Máy chủ Valhalla riêng. Nó được hỏi khi một chặng cần tránh trạm thu phí, đường cao tốc hoặc phà — các máy chủ OSRM công cộng không trả lời được việc đó. Để trống sẽ dùng Valhalla công cộng của FOSSGIS, trừ khi ở trên đã ghi một máy chủ định tuyến riêng; khi đó không hỏi máy chủ thứ hai nào cả. Có hiệu lực sau khi khởi động lại máy chủ.',
+ 'settings.valhallaBaseHint':
+ 'Theo mặc định, TREK dùng Valhalla công cộng của FOSSGIS để tránh đường thu phí, đường cao tốc và phà. Nhập URL Valhalla riêng tại đây để dùng thay thế. Nếu chỉ cấu hình máy chủ định tuyến riêng, Valhalla công cộng sẽ không được dùng. Sau khi nhập URL riêng, hãy khởi động lại máy chủ và tải lại trang.',
'settings.mapHint': 'Mẫu URL cho ô bản đồ',
'settings.mapProvider': 'Nhà cung cấp bản đồ',
'settings.mapProviderHint':
diff --git a/shared/src/i18n/zh-TW/roadtrip.ts b/shared/src/i18n/zh-TW/roadtrip.ts
index ee5178316..e68b07f47 100644
--- a/shared/src/i18n/zh-TW/roadtrip.ts
+++ b/shared/src/i18n/zh-TW/roadtrip.ts
@@ -1,6 +1,30 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "連線時可沿路線拖動當天終點或將其拖到某個地點，按右鍵可恢復自動終點。",
+ 'roadtrip.window.resetBoundaries': "恢復自動每日終點",
+ 'roadtrip.window.endHere': '在此結束當天行程',
+ 'roadtrip.window.endHereHint': '啟用 Roadtrip 模式和每日出行時間後，可在地點詳情中將指定停留點設為當天行程終點。',
+ 'roadtrip.window.endAt': '一天的結束地點',
+ 'roadtrip.window.onRoute': '路線途中',
+ 'roadtrip.window.atStop': '最後一個地點',
+ 'roadtrip.window.routeHint': '到達結束時間時，在路線上暫停。',
+ 'roadtrip.window.stopHint': '若無法在當天結束前抵達下一個地點，就停留在最後一個地點。',
+ 'roadtrip.window.legTooLong': '某段車程超出每日時間範圍。請在途中新增地點，或選擇在路線途中暫停。',
+ 'roadtrip.window.pointLabel': '第 {day} 天於 {time} 結束',
+ 'roadtrip.window.title': '每日出行時間',
+ 'roadtrip.window.start': '一天開始時間',
+ 'roadtrip.window.end': '一天結束時間',
+ 'roadtrip.window.hint': '設定兩個時間以規劃每日休息。清空任一項即可關閉。手動時間優先，各天路線會自動連接。',
+ 'roadtrip.window.invalid': '結束時間必須晚於開始時間。',
+ 'roadtrip.window.stop': '當天行程結束',
+ 'roadtrip.window.resume': '繼續行程',
+ 'roadtrip.window.pointHint': '這裡是預計的夜間暫停地點。',
+ 'roadtrip.window.departure': '完成剩餘停留後於 {time} 繼續',
+ 'roadtrip.window.showPoint': '在地圖上顯示',
+ 'roadtrip.window.incomplete': '所有連接路線可用後才能計算每日休息。',
+ 'roadtrip.window.conflict': '固定時間與行車和休息安排衝突。手動時間保持不變，自動規劃已暫停。',
+ 'roadtrip.window.tooLong': '這些時間需要超過365個額外天數。請延長每日出行時段。',
'roadtrip.mode.roadtrip': '公路旅行',
'roadtrip.mode.days': '依日',
'roadtrip.mode.label': '計畫檢視',
diff --git a/shared/src/i18n/zh-TW/settings.ts b/shared/src/i18n/zh-TW/settings.ts
index 71c4a204b..6c2f6e5e4 100644
--- a/shared/src/i18n/zh-TW/settings.ts
+++ b/shared/src/i18n/zh-TW/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': '自建路徑規劃服務',
'settings.routingBaseHint': '你自己的 OSRM 實例。留空則使用公共伺服器，約每秒一個請求 — 單日夠用，長途自駕則吃緊。需重新啟動伺服器後生效。',
'settings.valhallaBase': '自建 Valhalla 執行個體',
- 'settings.valhallaBaseHint': '自建的 Valhalla 執行個體。當某段路程需要避開收費站、高速公路或渡輪時會向它詢問，公開的 OSRM 伺服器無法回答這類問題。留空則使用 FOSSGIS 的公開 Valhalla；若上方已填寫自建路徑規劃服務，則完全不詢問第二個引擎。重新啟動伺服器後生效。',
+ 'settings.valhallaBaseHint':
+ 'TREK 預設使用 FOSSGIS 的公共 Valhalla 來避開收費道路、高速公路和渡輪。若要改用自己的 Valhalla，請在此輸入網址。如果只設定了自己的路線規劃伺服器，就不會使用公共 Valhalla。輸入自己的網址後，請重新啟動伺服器並重新載入頁面。',
'settings.mapHint': '地圖瓦片 URL 模板',
'settings.mapProvider': '地圖提供商',
'settings.mapProviderHint': '影響行程規劃和旅程地圖。Atlas 始終使用 Leaflet。',
diff --git a/shared/src/i18n/zh/roadtrip.ts b/shared/src/i18n/zh/roadtrip.ts
index f5f99635f..ad6231027 100644
--- a/shared/src/i18n/zh/roadtrip.ts
+++ b/shared/src/i18n/zh/roadtrip.ts
@@ -1,6 +1,30 @@
import type { TranslationStrings } from '../types';
const roadtrip: TranslationStrings = {
+ 'roadtrip.window.dragHint': "在线时可沿路线拖动当天终点或将其拖到某个地点，右键点击可恢复自动终点。",
+ 'roadtrip.window.resetBoundaries': "恢复自动每日终点",
+ 'roadtrip.window.endHere': '在此结束当天行程',
+ 'roadtrip.window.endHereHint': '启用 Roadtrip 模式和每日出行时间后，可在地点详情中将指定停留点设为当天行程终点。',
+ 'roadtrip.window.endAt': '一天的结束地点',
+ 'roadtrip.window.onRoute': '路线途中',
+ 'roadtrip.window.atStop': '最后一个地点',
+ 'roadtrip.window.routeHint': '到达结束时间时，在路线上暂停。',
+ 'roadtrip.window.stopHint': '若无法在当天结束前抵达下一个地点，就停留在最后一个地点。',
+ 'roadtrip.window.legTooLong': '某段车程超出每日时间范围。请在途中添加地点，或选择在路线途中暂停。',
+ 'roadtrip.window.pointLabel': '第 {day} 天于 {time} 结束',
+ 'roadtrip.window.title': '每日出行时间',
+ 'roadtrip.window.start': '一天开始时间',
+ 'roadtrip.window.end': '一天结束时间',
+ 'roadtrip.window.hint': '设置两个时间以规划每日休息。清空任一项即可关闭。手动时间优先，各天路线会自动连接。',
+ 'roadtrip.window.invalid': '结束时间必须晚于开始时间。',
+ 'roadtrip.window.stop': '当天行程结束',
+ 'roadtrip.window.resume': '继续行程',
+ 'roadtrip.window.pointHint': '这里是预计的夜间暂停地点。',
+ 'roadtrip.window.departure': '完成剩余停留后于 {time} 继续',
+ 'roadtrip.window.showPoint': '在地图上显示',
+ 'roadtrip.window.incomplete': '所有连接路线可用后才能计算每日休息。',
+ 'roadtrip.window.conflict': '固定时间与行车和休息安排冲突。手动时间保持不变，自动规划已暂停。',
+ 'roadtrip.window.tooLong': '这些时间需要超过365个额外天数。请延长每日出行时段。',
'roadtrip.mode.roadtrip': '公路旅行',
'roadtrip.mode.days': '按天',
'roadtrip.mode.label': '计划视图',
diff --git a/shared/src/i18n/zh/settings.ts b/shared/src/i18n/zh/settings.ts
index 4b1093e3b..a662db141 100644
--- a/shared/src/i18n/zh/settings.ts
+++ b/shared/src/i18n/zh/settings.ts
@@ -27,7 +27,8 @@ const settings: TranslationStrings = {
'settings.routingBase': '自建路径规划服务',
'settings.routingBaseHint': '你自己的 OSRM 实例。留空则使用公共服务器，约每秒一个请求 — 单日够用，长途自驾则吃紧。需重启服务器后生效。',
'settings.valhallaBase': '自建 Valhalla 实例',
- 'settings.valhallaBaseHint': '自建的 Valhalla 实例。当某段路程需要避开收费站、高速公路或轮渡时会向它询问，公共 OSRM 服务器无法回答这类问题。留空则使用 FOSSGIS 的公共 Valhalla；若上方已填写自建路径规划服务，则完全不询问第二个引擎。重启服务器后生效。',
+ 'settings.valhallaBaseHint':
+ 'TREK 默认使用 FOSSGIS 的公共 Valhalla 来避开收费道路、高速公路和渡轮。若要改用自己的 Valhalla，请在此输入网址。如果只配置了自己的路线规划服务器，就不会使用公共 Valhalla。输入自己的网址后，请重启服务器并重新加载页面。',
'settings.mapHint': '地图瓦片 URL 模板',
'settings.mapProvider': '地图提供商',
'settings.mapProviderHint': '影响行程规划器和旅程地图。足迹始终使用 Leaflet。',
diff --git a/shared/src/index.ts b/shared/src/index.ts
index 867b4290f..63366a524 100644
--- a/shared/src/index.ts
+++ b/shared/src/index.ts
@@ -62,6 +62,7 @@ export * from './admin/admin.schema';
// Realtime WS event contract registry (event names + payload schemas)
export * from './realtime/events.schema';
+export * from './roadtrip/day-boundary.schema';
// Sanitisation helpers — used by the client today, scoped here so the server
// has them ready if rich-text input ever ships.
diff --git a/shared/src/realtime/events.schema.spec.ts b/shared/src/realtime/events.schema.spec.ts
index 378ef549b..39505def3 100644
--- a/shared/src/realtime/events.schema.spec.ts
+++ b/shared/src/realtime/events.schema.spec.ts
@@ -30,6 +30,7 @@ const FIXTURES: Record> = {
'day:reordered': { orderedIds: [2, 1] },
'roadtripVia:changed': { dayId: 2, vias: [{ id: 9, lat: 53.5, lng: 9.9 }] },
'roadtripTrack:changed': { dayId: 2, track: null },
+ 'roadtripBoundary:changed': { boundaries: [{ day_number: 1, from_assignment_id: 9, to_assignment_id: null, fraction: 1 }] },
'dayNote:created': { dayId: 2, note: { id: 5 } },
'dayNote:updated': { dayId: 2, note: { id: 5 } },
'dayNote:deleted': { noteId: 5, dayId: 2 },
@@ -140,12 +141,12 @@ const DRIFT_VARIANTS: Partial[]>
};
describe('@trek/shared realtime event registry', () => {
- it('WSEVT-REG-001: pins the authoritative inventory counts (71 trip + 32 user = 103)', () => {
+ it('WSEVT-REG-001: pins the authoritative inventory counts (72 trip + 32 user = 104)', () => {
// 67th to 69th trip event: the three collab:link:* a shared link emits.
// 70th and 71st: the road trip's vias and tracks, which used to be written silently.
- expect(TREK_WS_TRIP_EVENT_NAMES).toHaveLength(71);
+ expect(TREK_WS_TRIP_EVENT_NAMES).toHaveLength(72);
expect(TREK_WS_USER_EVENT_NAMES).toHaveLength(32);
- expect(TREK_WS_EVENT_NAMES).toHaveLength(103);
+ expect(TREK_WS_EVENT_NAMES).toHaveLength(104);
});
it('WSEVT-REG-002: every name is domain:action shaped and outside the reserved plugin: namespace', () => {
diff --git a/shared/src/realtime/events.schema.ts b/shared/src/realtime/events.schema.ts
index fae358992..7f15ab9d5 100644
--- a/shared/src/realtime/events.schema.ts
+++ b/shared/src/realtime/events.schema.ts
@@ -1,4 +1,5 @@
import { z } from 'zod';
+import { roadtripDayBoundaryListSchema } from '../roadtrip/day-boundary.schema';
/**
* WS event contract registry — the single source of truth for every realtime
@@ -110,6 +111,7 @@ export const TREK_WS_EVENTS = {
scope: 'trip',
payload: z.object({ dayId: id, track: entity.nullable() }),
},
+ 'roadtripBoundary:changed': { scope: 'trip', payload: roadtripDayBoundaryListSchema },
// ── Day notes ────────────────────────────────────────────────────────────
'dayNote:created': { scope: 'trip', payload: z.object({ dayId: id, note: entity }) },
diff --git a/shared/src/roadtrip/day-boundary.schema.ts b/shared/src/roadtrip/day-boundary.schema.ts
new file mode 100644
index 000000000..88397c55d
--- /dev/null
+++ b/shared/src/roadtrip/day-boundary.schema.ts
@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const roadtripDayBoundarySchema = z.object({
+ day_number: z.number().int().min(1).max(366),
+ from_assignment_id: z.number().int().positive(),
+ to_assignment_id: z.number().int().positive().nullable(),
+ fraction: z.number().min(0).max(1),
+}).refine(b => b.to_assignment_id !== b.from_assignment_id, 'A boundary needs two different stops');
+
+export const roadtripDayBoundaryListSchema = z.object({
+ boundaries: z.array(roadtripDayBoundarySchema),
+});
+export type RoadtripDayBoundary = z.infer;
diff --git a/wiki/Admin-Panel-Overview.md b/wiki/Admin-Panel-Overview.md
index a331754c7..727c0ee26 100644
--- a/wiki/Admin-Panel-Overview.md
+++ b/wiki/Admin-Panel-Overview.md
@@ -30,6 +30,14 @@ The Admin Panel is divided into tabs. Most tabs are always visible; a few appear
+### Routing services
+
+On desktop and mobile, **User Defaults** includes optional **Custom routing instance** and **Custom Valhalla instance** fields in the map section. Changes save when you leave the field; **reset** restores the built-in default. These fields are hidden on managed instances.
+
+With both fields empty, TREK uses public OSRM servers for routing and the public FOSSGIS Valhalla for avoiding toll roads, motorways and ferries. Configuring only a custom routing instance disables the public Valhalla fallback. After entering a custom server URL, restart TREK and reload the page.
+
+> **AI / MCP:** These fields configure browser routing services and do not change stored trip data.
+
### Linking to a tab directly
Every panel is reachable by URL, so a bookmark, an onboarding mail or a support reply can point at the one tab it is about instead of at the top of a page with thirteen of them:
diff --git a/wiki/Trip-Planner-Overview.md b/wiki/Trip-Planner-Overview.md
index 957116dc0..6f1457284 100644
--- a/wiki/Trip-Planner-Overview.md
+++ b/wiki/Trip-Planner-Overview.md
@@ -45,6 +45,30 @@ The tab bar sits directly below the main navigation bar.
The active tab is saved in `sessionStorage` per trip, so switching between trips preserves your last position.
+## Roadtrip daily start and end times
+
+Nearby station search results group into count badges when zoomed out. Click a badge to zoom into its stations. Stations that still overlap at close zoom appear in a selectable list. Planned stops, including photo markers, also group into count badges when zoomed out. Day endings remain separate. This works with all supported map providers in Roadtrip mode.
+
+In the Roadtrip view, open **Driving settings** and enter a **Day start** and **Day end** in HH:mm format. Both values enable automatic daily scheduling and connect the drives between days. Clear either field to return to the existing schedule. These are personal driving preferences and apply to your Roadtrip views.
+
+Driving pauses at the end time and resumes from the same location at the next day's start time. Stops and visit durations determine where each pause falls. Editing, adding or removing stops recalculates the pauses and subsequent arrivals. If a visit crosses the end time, the remaining visit continues there the next morning before driving resumes.
+
+Choose **Along the route** to pause at the point reached at the cutoff, or **At the last place** to stay after the last visit when the next place cannot be reached before the cutoff. For example, arriving at 16:00 and staying for one hour ends the day at 17:00 if the next drive takes two hours and the cutoff is 18:00. That drive starts from the same place the next morning. If a single drive cannot fit within a full daily window, a message asks you to add an intermediate place or choose pauses along the route. The final destination does not generate an extra drive to fill the remaining time.
+
+The map and daily cards show the pause location without creating a place, accommodation or booking. The location within a drive is an estimate based on the elapsed share of the leg's duration along its route geometry. The next real stop is reached after the remaining drive, so its arrival can be later than the daily start time. Transport legs such as ferry crossings continue to their destination without a pause in the middle.
+
+Manual times take precedence. A first stop set to 07:00 still starts at 07:00 even with an automatic 08:00 start. A fixed late appointment can extend that day. If fixed appointments cannot be reached without changing their time or stored day, a visible message pauses automatic scheduling. Missing routes also show a message until a complete schedule can be calculated.
+
+The daily layout is calculated for the Roadtrip view. Stored day assignments stay intact, with **From day 1** labels identifying stops carried forward. Additional preview days appear when needed, including beyond the trip's existing days.
+
+To mix both behaviors, select a stop and enable **End the day here** in its place details. This ends the day after that visit and its stay, even when the daily cutoff has not been reached. The next drive starts the following morning. The switch is available only in Roadtrip mode with valid daily travel times. Turning those times off keeps each saved choice but stops applying it. The choice belongs to that particular visit, so another visit to the same place is independent. Disable the switch to follow the default again. The editable **STAY** duration appears beside this switch and opens the same editor as the sidebar.
+
+While online, drag an end-of-day map label along the driving route or onto a visit. A visit that automatically moved into the following day can become the previous day's final stop, even if its full stay ends after the automatic cutoff. Fixed visit times remain protected. Right-click a dragged label to restore its automatic ending, or restore all dragged endings in Driving settings. Focused labels also support the arrow keys and Delete. These overrides belong to the trip, survive reloads and are copied with the trip. They take effect only while daily travel times are enabled.
+
+The map marks pauses with a moon and day number beside a place or above the route. These markers disappear when zoomed out beyond level 6.
+
+> **AI / MCP:** Pauses are calculated in the Roadtrip view and are not stored as places or bookings. `set_assignment_end_day` sets or clears the boolean `end_day` on a specific visit; it takes effect only with daily travel times enabled. `list_day_boundaries` and `set_day_boundary` read, set or clear dragged day endings, anchored to assignment IDs and a fraction of the route. Place and assignment tools continue to read the original assignments and manually entered times.
+
## Mobile Layout
On screens narrower than 768 px, TREK does not squeeze the three-pane layout — it opens a dedicated mobile trip screen instead: a day-chip rail under the top bar, a switch between the day plan and a full-screen map, and a bottom dock for the other tabs. Tablets and desktops (768 px and up) get the three-pane layout described above.