From b41f6e3542acb1a19eb54ae3c6e6129ed348d050 Mon Sep 17 00:00:00 2001 From: Maurice Date: Wed, 4 Nov 2026 17:53:15 +0100 Subject: [PATCH] fix(journey): a newest-first share link opens on the latest day on the phone The public journey page on a phone shows the map with a card carousel, which always opened on the first entry. The owner's "newest first" choice for the link was ignored there, so readers following a running trip had to swipe through every day to reach the latest one (discussion #2851). The rule for where a journey opens moves out of the journal hook into journeyOpenAtEntryId, which the public page now uses as well: a newest-first link opens on the latest day, otherwise a running journey opens on today as the journal already does. The carousel also settles on the card at the end it is scrolled to. The last card can never reach the centre, so opening on the latest day used to activate the day before it, in the journal as well. --- .../components/Journey/journeyOpenAt.test.ts | 34 ++++++++++++++++ .../src/components/Journey/journeyOpenAt.ts | 39 +++++++++++++++++++ .../Journey/useJourneyCarouselSync.test.ts | 39 ++++++++++++++++++- .../Journey/useJourneyCarouselSync.ts | 8 ++++ client/src/pages/JourneyPublicPage.tsx | 2 + .../pages/journeyDetail/useJourneyDetail.ts | 29 ++------------ .../journeyPublic/useJourneyPublic.test.tsx | 23 +++++++++-- .../pages/journeyPublic/useJourneyPublic.ts | 10 ++++- 8 files changed, 154 insertions(+), 30 deletions(-) create mode 100644 client/src/components/Journey/journeyOpenAt.test.ts create mode 100644 client/src/components/Journey/journeyOpenAt.ts 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, } }