diff --git a/client/src/components/Journey/journeyOpenAt.test.ts b/client/src/components/Journey/journeyOpenAt.test.ts new file mode 100644 index 000000000..fbb25f0c5 --- /dev/null +++ b/client/src/components/Journey/journeyOpenAt.test.ts @@ -0,0 +1,34 @@ +// FE-JRN-OPENAT-001 to FE-JRN-OPENAT-005 +import { describe, expect, it } from 'vitest'; +import { journeyOpenAtEntryId } from './journeyOpenAt'; + +const entries = [ + { id: 3, entry_date: '2026-05-03' }, + { id: 1, entry_date: '2026-05-01' }, + { id: 2, entry_date: '2026-05-01' }, + { id: 5, entry_date: '2026-05-05' }, +]; + +describe('journeyOpenAtEntryId', () => { + it('FE-JRN-OPENAT-001: a running journey opens on the first entry of today', () => { + expect(journeyOpenAtEntryId(entries, { today: '2026-05-03' })).toBe('3'); + }); + + it('FE-JRN-OPENAT-002: a rest day lands on the last day written before it', () => { + expect(journeyOpenAtEntryId(entries, { today: '2026-05-04' })).toBe('3'); + }); + + it('FE-JRN-OPENAT-003: a journey that is over, or not begun, opens at its start', () => { + expect(journeyOpenAtEntryId(entries, { today: '2026-06-01' })).toBeNull(); + expect(journeyOpenAtEntryId(entries, { today: '2026-04-01' })).toBeNull(); + }); + + it('FE-JRN-OPENAT-004: newest-first opens on the latest day, also after the trip', () => { + expect(journeyOpenAtEntryId(entries, { today: '2026-06-01', newestFirst: true })).toBe('5'); + expect(journeyOpenAtEntryId(entries, { today: '2026-05-03', newestFirst: true })).toBe('5'); + }); + + it('FE-JRN-OPENAT-005: an empty journey has nothing to open on', () => { + expect(journeyOpenAtEntryId([], { today: '2026-05-03', newestFirst: true })).toBeNull(); + }); +}); diff --git a/client/src/components/Journey/journeyOpenAt.ts b/client/src/components/Journey/journeyOpenAt.ts new file mode 100644 index 000000000..1eb5dfeca --- /dev/null +++ b/client/src/components/Journey/journeyOpenAt.ts @@ -0,0 +1,39 @@ +interface DatedEntry { + id: number | string; + entry_date: string; +} + +/** + * The entry a journey opens on, or null for its first one. + * + * Every load used to start at the first entry, so keeping a journal on a trip + * meant scrolling past everything already written before you could add to it + * (discussion #2299). "Today" means the last day at or before now: a rest day + * with nothing written still lands you at yesterday rather than at the start. + * + * Only while the journey is running, though. A journey that ended last spring + * is something you read, and reading starts at the beginning; opening it at the + * last page would be the worse of the two mistakes. + * + * A link the owner published newest-first reads like a blog (#1614), so it + * opens on the latest day whether or not the trip is still running (#2851). + * + * Always the first entry OF the chosen day, not the last one before now: a day + * is read from its beginning. + */ +export function journeyOpenAtEntryId( + entries: readonly DatedEntry[], + { today, newestFirst = false }: { today: string; newestFirst?: boolean } +): string | null { + const dated = [...entries].sort((a, b) => a.entry_date.localeCompare(b.entry_date)); + const first = dated.at(0); + const last = dated.at(-1); + if (!first || !last) return null; + let day = last.entry_date; + if (!newestFirst) { + if (today < first.entry_date || today > last.entry_date) return null; + day = dated.filter((e) => e.entry_date <= today).at(-1)?.entry_date ?? first.entry_date; + } + const dayStart = dated.find((e) => e.entry_date === day) ?? first; + return String(dayStart.id); +} diff --git a/client/src/components/Journey/useJourneyCarouselSync.test.ts b/client/src/components/Journey/useJourneyCarouselSync.test.ts index 1204664f4..0b19415b8 100644 --- a/client/src/components/Journey/useJourneyCarouselSync.test.ts +++ b/client/src/components/Journey/useJourneyCarouselSync.test.ts @@ -1,4 +1,4 @@ -// FE-JRN-CAROUSEL-001 to FE-JRN-CAROUSEL-008: the card carousel over the journey map, +// FE-JRN-CAROUSEL-001 to FE-JRN-CAROUSEL-009: the card carousel over the journey map, // behind both the phone journey screen and the narrow desktop and public timeline. import { act, renderHook } from '@testing-library/react'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; @@ -145,4 +145,41 @@ describe('useJourneyCarouselSync', () => { act(() => result.current.openEntryById('99')); expect(props.onOpenEntry).toHaveBeenCalledTimes(1); }); + + it('FE-JRN-CAROUSEL-009: a carousel scrolled to either end settles on the card at that end (#2851)', () => { + const carousel = document.createElement('div'); + carousel.getBoundingClientRect = () => ({ left: 0 }) as DOMRect; + Object.defineProperty(carousel, 'clientWidth', { value: 300 }); + Object.defineProperty(carousel, 'scrollWidth', { value: 600 }); + const hook = renderHook( + (p: Options) => { + const sync = useJourneyCarouselSync(p); + (sync.carouselRef as { current: HTMLDivElement | null }).current = carousel; + return sync; + }, + { initialProps: { entries: [], mapEntries: [], onOpenEntry: vi.fn() } } + ); + hook.rerender({ entries: ENTRIES, mapEntries: [], onOpenEntry: vi.fn() }); + // Card 1 sits at the centre (150) in both positions: only the ends decide. + [0, 100, 200].forEach((left, i) => { + const node = document.createElement('div'); + node.getBoundingClientRect = () => ({ left, width: 100 }) as DOMRect; + hook.result.current.cardRefs.current.set(i, node); + }); + const settleAt = (scrollLeft: number) => { + Object.defineProperty(carousel, 'scrollLeft', { value: scrollLeft, configurable: true }); + carousel.dispatchEvent(new Event('scroll')); + act(() => vi.advanceTimersByTime(150)); + }; + + settleAt(300); + expect(hook.result.current.activeIndex).toBe(2); + settleAt(150); + expect(hook.result.current.activeIndex).toBe(1); + // Right to left: the scroll position runs negative from the start. + settleAt(-300); + expect(hook.result.current.activeIndex).toBe(2); + settleAt(0); + expect(hook.result.current.activeIndex).toBe(0); + }); }); diff --git a/client/src/components/Journey/useJourneyCarouselSync.ts b/client/src/components/Journey/useJourneyCarouselSync.ts index 39adf1ce1..aca36265b 100644 --- a/client/src/components/Journey/useJourneyCarouselSync.ts +++ b/client/src/components/Journey/useJourneyCarouselSync.ts @@ -71,6 +71,14 @@ export function useJourneyCarouselSync({ bestIdx = idx; } }); + // The first and the last card can never reach the centre, so a carousel scrolled + // as far as it goes means the card at that end: without this, opening on the + // latest day settled on the one before it (#2851). Measured from the start in + // either direction: in a right-to-left layout scrollLeft runs negative. + const travel = el.scrollWidth - el.clientWidth; + const scrolled = Math.abs(el.scrollLeft); + if (travel > 1 && scrolled >= travel - 1) bestIdx = cardRefs.current.size - 1; + else if (travel > 1 && scrolled <= 0) bestIdx = 0; setActiveIndex((prev) => { if (prev !== bestIdx) syncMapToCard(bestIdx); return bestIdx; diff --git a/client/src/pages/JourneyPublicPage.tsx b/client/src/pages/JourneyPublicPage.tsx index 8a1e7690f..d3e8cf367 100644 --- a/client/src/pages/JourneyPublicPage.tsx +++ b/client/src/pages/JourneyPublicPage.tsx @@ -133,6 +133,7 @@ export default function JourneyPublicPage() { sortedDates, displayDates, newestFirst, + openAtEntryId, setNewestFirst, sidebarMapItems, allPhotos, @@ -695,6 +696,7 @@ export default function JourneyPublicPage() { {isMobile && view === 'timeline' && perms.share_timeline && perms.share_map && ( { const entries = current?.entries ?? [] - if (entries.length === 0) return null if (linkedEntryId !== null && entries.some(e => String(e.id) === linkedEntryId)) return linkedEntryId - const dated = [...entries].sort((a, b) => a.entry_date.localeCompare(b.entry_date)) - const today = new Date() - const todayKey = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}` - const first = dated[0]!.entry_date - const last = dated[dated.length - 1]!.entry_date - if (todayKey < first || todayKey > last) return null - const reached = dated.filter(e => e.entry_date <= todayKey) - const target = reached[reached.length - 1] ?? dated[0]! - // The first entry OF that day, not the last one before now: a day is read - // from its beginning. - const dayStart = dated.find(e => e.entry_date === target.entry_date) ?? target - return String(dayStart.id) + return journeyOpenAtEntryId(entries, { today: localIsoDate() }) }, [current?.entries, linkedEntryId]) // Desktop only: scroll it into the feed once per journey and once per link, after diff --git a/client/src/pages/journeyPublic/useJourneyPublic.test.tsx b/client/src/pages/journeyPublic/useJourneyPublic.test.tsx index 13f89c003..80290137f 100644 --- a/client/src/pages/journeyPublic/useJourneyPublic.test.tsx +++ b/client/src/pages/journeyPublic/useJourneyPublic.test.tsx @@ -1,4 +1,4 @@ -// FE-JRN-PUBHOOK-001 to FE-JRN-PUBHOOK-002 +// FE-JRN-PUBHOOK-001 to FE-JRN-PUBHOOK-003 import { http, HttpResponse } from 'msw'; import { describe, expect, it, vi } from 'vitest'; import { server } from '../../../tests/helpers/msw/server'; @@ -32,14 +32,14 @@ function buildEntry(over: Partial & { id: number }): PublicEntry { }; } -function serveShare(entries: PublicEntry[]): void { +function serveShare(entries: PublicEntry[], permissions: Record = {}): void { server.use( http.get('/api/public/journey/tok-1', () => HttpResponse.json({ journey: { title: 'Japan' }, entries, gallery: [], - permissions: { share_timeline: true, share_gallery: true, share_map: false }, + permissions: { share_timeline: true, share_gallery: true, share_map: false, ...permissions }, stats: {}, }) ) @@ -91,4 +91,21 @@ describe('useJourneyPublic', () => { ]); expect(result.current.stopNumberById.has('7')).toBe(false); }); + + it('FE-JRN-PUBHOOK-003: a link published newest-first opens on the first entry of the latest day', async () => { + serveShare( + [ + buildEntry({ id: 1, entry_date: '2020-03-01' }), + buildEntry({ id: 2, entry_date: '2020-03-02' }), + buildEntry({ id: 3, entry_date: '2020-03-02', sort_order: 1 }), + ], + { newest_first: true } + ); + const { result } = renderHook(() => useJourneyPublic()); + + await waitFor(() => expect(result.current.openAtEntryId).toBe('2')); + result.current.setNewestFirst(false); + // A journey that ended long ago, read oldest-first, starts at the beginning. + await waitFor(() => expect(result.current.openAtEntryId).toBeNull()); + }); }); diff --git a/client/src/pages/journeyPublic/useJourneyPublic.ts b/client/src/pages/journeyPublic/useJourneyPublic.ts index f09fd72ae..24241a0d9 100644 --- a/client/src/pages/journeyPublic/useJourneyPublic.ts +++ b/client/src/pages/journeyPublic/useJourneyPublic.ts @@ -9,6 +9,8 @@ import { journeyMapStops } from '../../components/Journey/journeyMapStops' import { posterlessVideo } from '../journeyDetail/JourneyDetailPage.helpers' import { groupByDate, type PublicEntry, type PublicGalleryPhoto } from './journeyPublicModel' import { useJourneyMapLayers } from '../../components/Journey/useJourneyMapLayers' +import { journeyOpenAtEntryId } from '../../components/Journey/journeyOpenAt' +import { localIsoDate } from '../../utils/localDate' /** * Public-journey (read-only share) data hook — owns the token fetch, the @@ -144,6 +146,12 @@ export function useJourneyPublic() { () => (effectiveNewestFirst ? [...sortedDates].reverse() : sortedDates), [sortedDates, effectiveNewestFirst], ) + // The phone's map carousel keeps the trip in time order, so newest-first there means + // opening on the latest day instead of reversing the cards (#2851). + const openAtEntryId = useMemo( + () => journeyOpenAtEntryId(timelineEntries, { today: localIsoDate(), newestFirst: effectiveNewestFirst }), + [timelineEntries, effectiveNewestFirst], + ) // Two-column desktop layout: timeline feed left + sticky map right const desktopTwoColumn = !isMobile && perms.share_timeline && perms.share_map @@ -166,7 +174,7 @@ export function useJourneyPublic() { perms, journey, stats, timelineEntries, groupedEntries, sortedDates, displayDates, sidebarMapItems, allPhotos, stopNumberById, mapPhotos, mapLayers, entryTitleOf, - newestFirst: effectiveNewestFirst, setNewestFirst, + newestFirst: effectiveNewestFirst, setNewestFirst, openAtEntryId, desktopTwoColumn, } }