Files
TREK/client/src/components/Planner/flightLive/useFlightLiveCard.ts
T
Maurice 856d1e5ea5 fix(flight-live): keep a past flight's times in its booking view
The booking dialog and the phone sheet hid their departure and arrival tiles
as soon as the store held any leg of the flight, but a leg long over or never
seen by the feed draws no live card, so such a flight showed no times at
all. Both views now hide the tiles only for legs that get a card.
2026-11-16 10:45:23 +01:00

241 lines
9.5 KiB
TypeScript

import type { FlightLiveLeg } from '@trek/shared';
import { useEffect, useState } from 'react';
import { useTranslation } from '../../../i18n';
import { useFlightLiveAttribution, useFlightLiveLeg, useFlightLiveLegs } from '../../../store/flightLiveStore';
import { useSettingsStore } from '../../../store/settingsStore';
import {
airportTime,
currentLeg,
delayTone,
flightLiveView,
splitDuration,
type DelayTone,
type FlightLiveView,
type FlightStage,
} from '../../../utils/flightLiveModel';
type T = ReturnType<typeof useTranslation>['t'];
export interface FlightTimeCell {
/** The time that counts now: observed, estimated or planned. */
value: string;
/** The planned time, only when it differs from `value`, shown struck beside it. */
planned: string | null;
}
interface FlightStat {
label: string;
value: string;
}
interface FlightLiveCard {
leg: FlightLiveLeg;
view: FlightLiveView;
/** Where the flight stands: "Scheduled", "In the air", "Landed". */
headline: string;
/** What comes next: "Departs in 2 h 10 min", "Lands in 5 h", or null. */
detail: string | null;
/** Both in one line for the strips and plan rows, in the language's own joining. */
line: string;
delay: { text: string; tone: DelayTone } | null;
dep: FlightTimeCell;
arr: FlightTimeCell;
stats: FlightStat[];
/** Who the live data came from, credited quietly on the map once the feed has seen this flight. */
attribution: string | null;
/** Around boarding, where a traveller looks for a gate open data does not have. */
gateHint: boolean;
/** True while the aircraft is moving. */
live: boolean;
/** The colour family of the stage, for the tinted head of the card. */
tone: 'live' | 'done' | 'planned';
}
/**
* The current time, ticking every `ms` while `active`, for countdowns that move.
* Idle without a flight to show, so a booking TREK follows no state for sets
* no timer at all.
*/
function useNow(ms: number, active: boolean): number {
const [now, setNow] = useState(() => Date.now());
useEffect(() => {
if (!active) return;
const id = window.setInterval(() => setNow(Date.now()), ms);
return () => window.clearInterval(id);
}, [ms, active]);
return now;
}
function durationText(ms: number, t: T): string {
const { days, hours, minutes } = splitDuration(ms);
if (days > 0) return t('flightLive.durDaysHours', { d: days, h: hours });
if (hours > 0) return t('flightLive.durHoursMinutes', { h: hours, m: minutes });
return t('flightLive.durMinutes', { m: Math.max(1, minutes) });
}
function delayText(minutes: number | null, t: T): { text: string; tone: DelayTone } | null {
if (minutes == null) return null;
if (minutes > 5) return { text: t('flightLive.late', { m: minutes }), tone: delayTone(minutes) };
if (minutes < -5) return { text: t('flightLive.early', { m: -minutes }), tone: 'ok' };
return { text: t('flightLive.onTime'), tone: 'ok' };
}
/** The stages a card speaks for; without live data (past, unknown) there is no card. */
type ShownStage = Exclude<FlightStage, 'past' | 'unknown'>;
const isShown = (stage: FlightStage): stage is ShownStage => stage !== 'past' && stage !== 'unknown';
function headlineOf(
stage: ShownStage,
view: FlightLiveView,
leg: FlightLiveLeg,
t: T,
time: (ms: number, tz: string | null) => string
): { headline: string; detail: string | null } {
switch (stage) {
case 'upcoming':
case 'soon':
return {
headline: t('flightLive.scheduled'),
detail:
view.countdownMs != null ? t('flightLive.departsIn', { time: durationText(view.countdownMs, t) }) : null,
};
case 'taxiing':
return { headline: t('flightLive.taxiing'), detail: t('flightLive.atAirport', { code: leg.origin.code }) };
case 'airborne':
return {
headline: t('flightLive.airborne'),
detail: view.countdownMs != null ? t('flightLive.landsIn', { time: durationText(view.countdownMs, t) }) : null,
};
case 'landed':
return {
headline: t('flightLive.landed'),
detail:
view.arrExpected != null
? t('flightLive.landedAt', {
time: time(view.arrExpected, leg.destination.timezone),
code: leg.destination.code,
})
: null,
};
}
}
/** One end's time: what counts now (observed or estimated), the planned one beside it when they differ. */
function timeCell(
actual: number | null,
planned: number | null,
tz: string | null,
time: (ms: number, tz: string | null) => string
): FlightTimeCell {
const shown = actual ?? planned;
if (shown == null) return { value: '--:--', planned: null };
const value = time(shown, tz);
const plannedText = planned != null ? time(planned, tz) : null;
return { value, planned: actual != null && plannedText !== value ? plannedText : null };
}
const TONE: Record<ShownStage, FlightLiveCard['tone']> = {
upcoming: 'planned',
soon: 'planned',
taxiing: 'live',
airborne: 'live',
landed: 'done',
};
/** Altitude, speed and distance in the user's units while in the air, and the aircraft when known. */
function statsOf(leg: FlightLiveLeg, view: FlightLiveView, imperial: boolean, locale: string, t: T): FlightStat[] {
const stats: FlightStat[] = [];
const pos = view.stage === 'airborne' ? leg.position : null;
const n = (value: number) => Math.round(value).toLocaleString(locale);
if (pos?.altitude_ft != null) {
const value = imperial
? t('flightLive.feet', { n: n(pos.altitude_ft) })
: t('flightLive.meters', { n: n(pos.altitude_ft * 0.3048) });
stats.push({ label: t('flightLive.altitude'), value });
}
if (pos?.ground_speed_kt != null) {
const value = imperial
? t('flightLive.mph', { n: n(pos.ground_speed_kt * 1.15078) })
: t('flightLive.kmh', { n: n(pos.ground_speed_kt * 1.852) });
stats.push({ label: t('flightLive.speed'), value });
}
if (view.stage === 'airborne' && leg.distance_remaining_km != null) {
const km = leg.distance_remaining_km;
stats.push({
label: t('flightLive.remaining'),
value: imperial ? t('flightLive.mi', { n: n(km / 1.609344) }) : t('flightLive.km', { n: n(km) }),
});
}
const aircraft = [leg.aircraft?.type, leg.aircraft?.registration].filter(Boolean).join(' ');
if (aircraft) stats.push({ label: t('flightLive.aircraft'), value: aircraft });
return stats;
}
/** In the air and on the ground the arrival delay counts, before take-off the departure delay. */
function delayOf(view: FlightLiveView, t: T): { text: string; tone: DelayTone } | null {
const flying = view.stage === 'airborne' || view.stage === 'landed';
return delayText(flying ? (view.arrDelay ?? view.depDelay) : view.depDelay, t);
}
/**
* Everything a live flight card shows for one leg, or null while TREK has no
* state for it (the feature switched off, an airline it cannot map, a server
* without the feature). Desktop and phone call this and only lay it out.
*/
export function useFlightLiveCard(tripId: number, reservationId: number, legIndex: number): FlightLiveCard | null {
const { t, locale } = useTranslation();
const timeFormat = useSettingsStore((s) => s.settings.time_format) || '24h';
const imperial = useSettingsStore((s) => s.settings.distance_unit) === 'imperial';
const leg = useFlightLiveLeg(tripId, reservationId, legIndex);
const attribution = useFlightLiveAttribution(tripId);
// A second-level countdown is noise; the minute tick is what a traveller reads.
const now = useNow(30_000, !!leg);
if (!leg) return null;
const view = flightLiveView(leg, now);
// No live data to show: the flight is long over, or the feed never heard it. Nothing at all then.
if (!isShown(view.stage)) return null;
const time = (ms: number, tz: string | null) => airportTime(ms, tz, locale, timeFormat);
const { headline, detail } = headlineOf(view.stage, view, leg, t, time);
return {
leg,
view,
headline,
detail,
line: detail && view.stage === 'airborne' ? t('flightLive.headlineDetail', { headline, detail }) : headline,
delay: delayOf(view, t),
dep: timeCell(view.depActual, view.depPlanned, leg.origin.timezone, time),
arr: timeCell(view.arrExpected, view.arrPlanned, leg.destination.timezone, time),
stats: statsOf(leg, view, imperial, locale, t),
// The feed is credited only for data it gave.
attribution: leg.last_seen_at ? attribution : null,
gateHint: view.stage === 'soon' || view.stage === 'taxiing',
live: view.stage === 'airborne' || view.stage === 'taxiing',
tone: TONE[view.stage],
};
}
/**
* The legs of one booking a live card is drawn for, in leg order. The server
* hands over every followed leg at any date, but a flight long over or never
* heard by the feed gets no card (see useFlightLiveCard). The booking views
* hide their own time tiles only for these, so such a flight keeps its times.
*/
export function useFlightLiveCardLegs(tripId: number, reservationId: number): FlightLiveLeg[] {
const legs = useFlightLiveLegs(tripId, reservationId);
// The card's own pace, so a leg drops out here about when its card goes.
const now = useNow(30_000, legs.length > 0);
return legs.filter((leg) => isShown(flightLiveView(leg, now).stage));
}
/**
* The leg a one-line summary of a booking speaks for (see currentLeg), as a
* leg index, or null while TREK follows none of its legs.
*/
export function useCurrentFlightLegIndex(tripId: number, reservationId: number): number | null {
const legs = useFlightLiveLegs(tripId, reservationId);
const now = useNow(60_000, legs.length > 0);
return currentLeg(legs, now)?.leg_index ?? null;
}