333 lines
11 KiB
TypeScript
333 lines
11 KiB
TypeScript
// composables/useFlightStats.ts
|
|
import {computed, ComputedRef, Ref} from 'vue'
|
|
import type {Airport, Flight} from '@/Types/types'
|
|
|
|
const flightYear = (f: Flight): number =>
|
|
Number(new Intl.DateTimeFormat('en', {
|
|
timeZone: f.departure_airport.timezone,
|
|
year: 'numeric',
|
|
}).format(new Date(f.departure_date)))
|
|
|
|
const DAYS = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
|
|
const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
|
|
|
|
|
|
const dayIndex = (f: Flight): number => {
|
|
const localDay = new Intl.DateTimeFormat('en', {
|
|
timeZone: f.departure_airport.timezone,
|
|
weekday: 'long',
|
|
}).format(new Date(f.departure_date))
|
|
const idx = DAYS.indexOf(localDay)
|
|
return idx === -1 ? 0 : idx
|
|
}
|
|
|
|
export function getFlightsPerDay(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const countByDay = (list: Flight[]) =>
|
|
DAYS.map((_, i) => list.filter(f => dayIndex(f) === i).length)
|
|
|
|
return {
|
|
days: DAYS,
|
|
series: [
|
|
{ name: 'Flown', data: countByDay(flights) },
|
|
{ name: 'Upcoming', data: countByDay(upcomingFlights) },
|
|
],
|
|
}
|
|
}
|
|
|
|
const monthIndex = (f: Flight): number =>
|
|
Number(new Intl.DateTimeFormat('en', {
|
|
timeZone: f.departure_airport.timezone,
|
|
month: 'numeric',
|
|
}).format(new Date(f.departure_date))) - 1
|
|
|
|
export function getFlightsPerMonth(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const countByMonth = (list: Flight[]) =>
|
|
MONTHS.map((_, i) => list.filter(f => monthIndex(f) === i).length)
|
|
|
|
return {
|
|
months: MONTHS,
|
|
series: [
|
|
{ name: 'Flown', data: countByMonth(flights) },
|
|
{ name: 'Upcoming', data: countByMonth(upcomingFlights) },
|
|
],
|
|
}
|
|
}
|
|
|
|
export function getFlightsPerYear(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const allFlights = [...flights, ...upcomingFlights]
|
|
|
|
const allYears = new Set<number>()
|
|
allFlights.forEach(f => allYears.add(flightYear(f)))
|
|
const sorted = [...allYears].sort((a, b) => a - b)
|
|
|
|
let min = sorted[0]
|
|
let max = sorted[sorted.length - 1]
|
|
while (max - min + 1 < 5) {
|
|
min--
|
|
if (max - min + 1 < 5) max++
|
|
}
|
|
|
|
const years = Array.from({ length: max - min + 1 }, (_, i) => min + i)
|
|
const countByYear = (list: Flight[]) =>
|
|
years.map(year => list.filter(f => flightYear(f) === year).length)
|
|
|
|
return {
|
|
years,
|
|
series: [
|
|
{ name: 'Flown', data: countByYear(flights) },
|
|
{ name: 'Upcoming', data: countByYear(upcomingFlights) },
|
|
],
|
|
}
|
|
}
|
|
|
|
function groupByName(flights: Flight[], accessor: (f: Flight) => string) {
|
|
const counts = new Map<string, number>()
|
|
flights.forEach(f => {
|
|
const key = accessor(f) ?? 'Unknown'
|
|
counts.set(key, (counts.get(key) ?? 0) + 1)
|
|
})
|
|
const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1])
|
|
return {
|
|
labels: sorted.map(([name]) => name),
|
|
series: sorted.map(([, count]) => count),
|
|
}
|
|
}
|
|
|
|
export function getFlightReasons(flights: Flight[]) {
|
|
return groupByName(flights, f => f.flight_reason?.name ?? 'Unknown')
|
|
}
|
|
|
|
export function getFlightClasses(flights: Flight[]) {
|
|
return groupByName(flights, f => f.flight_class?.name ?? 'Unknown')
|
|
}
|
|
|
|
export function getSeatTypes(flights: Flight[]) {
|
|
return groupByName(flights, f => f.seat_type?.name ?? 'Unknown')
|
|
}
|
|
|
|
function countCountries(flights: Flight[]) {
|
|
const counts = new Map<string, { count: number; code: string }>()
|
|
flights.forEach(f => {
|
|
const dep = f.departure_airport?.region?.country
|
|
const arr = f.arrival_airport?.region?.country
|
|
|
|
if (dep?.name) {
|
|
const existing = counts.get(dep.name) ?? { count: 0, code: dep.code }
|
|
existing.count++
|
|
counts.set(dep.name, existing)
|
|
}
|
|
if (arr?.name && arr.name !== dep?.name) {
|
|
const existing = counts.get(arr.name) ?? { count: 0, code: arr.code }
|
|
existing.count++
|
|
counts.set(arr.name, existing)
|
|
}
|
|
})
|
|
return counts
|
|
}
|
|
|
|
export function getCountries(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const past = countCountries(flights)
|
|
const upcoming = countCountries(upcomingFlights)
|
|
const allCountries = new Set([...past.keys(), ...upcoming.keys()])
|
|
|
|
const sorted = [...allCountries]
|
|
.map(name => ({
|
|
name,
|
|
code: (past.get(name) ?? upcoming.get(name))!.code,
|
|
past: past.get(name)?.count ?? 0,
|
|
upcoming: upcoming.get(name)?.count ?? 0,
|
|
}))
|
|
.sort((a, b) => (b.past + b.upcoming) - (a.past + a.upcoming))
|
|
|
|
return {
|
|
countries: sorted,
|
|
series: [
|
|
{ name: 'Flights', data: sorted.map(s => s.past) },
|
|
{ name: 'Upcoming', data: sorted.map(s => s.upcoming) },
|
|
],
|
|
}
|
|
}
|
|
|
|
export function getContinents(flights: Flight[]) {
|
|
const counts = new Map<string, number>()
|
|
flights.forEach(f => {
|
|
const continents = new Set<string>()
|
|
const dep = f.departure_airport.region?.continent?.name
|
|
const arr = f.arrival_airport.region?.continent?.name
|
|
if (dep) continents.add(dep)
|
|
if (arr) continents.add(arr)
|
|
continents.forEach(c => counts.set(c, (counts.get(c) ?? 0) + 1))
|
|
})
|
|
const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1])
|
|
return {
|
|
labels: sorted.map(([name]) => name),
|
|
series: sorted.map(([, count]) => count),
|
|
}
|
|
}
|
|
|
|
function countAirlines(flights: Flight[]) {
|
|
const counts = new Map<string, { count: number; id: number }>()
|
|
flights.forEach(f => {
|
|
const airline = f.airline
|
|
if (!airline?.name) return
|
|
const existing = counts.get(airline.name) ?? { count: 0, id: airline.id }
|
|
existing.count++
|
|
counts.set(airline.name, existing)
|
|
})
|
|
return counts
|
|
}
|
|
|
|
export function getTopAirlines(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const past = countAirlines(flights)
|
|
const upcoming = countAirlines(upcomingFlights)
|
|
const allAirlines = new Set([...past.keys(), ...upcoming.keys()])
|
|
|
|
const sorted = [...allAirlines]
|
|
.map(name => ({
|
|
name,
|
|
id: (past.get(name) ?? upcoming.get(name))!.id,
|
|
past: past.get(name)?.count ?? 0,
|
|
upcoming: upcoming.get(name)?.count ?? 0,
|
|
}))
|
|
.sort((a, b) => (b.past + b.upcoming) - (a.past + a.upcoming))
|
|
|
|
return {
|
|
airlines: sorted,
|
|
series: [
|
|
{ name: 'Flights', data: sorted.map(s => s.past) },
|
|
{ name: 'Upcoming', data: sorted.map(s => s.upcoming) },
|
|
],
|
|
}
|
|
}
|
|
|
|
interface AirportItem {
|
|
label: string
|
|
fullName: string
|
|
departures: number
|
|
arrivals: number
|
|
upcoming: number
|
|
}
|
|
|
|
function airportLabel(airport: Airport | null | undefined): string | null {
|
|
if (!airport) return null
|
|
return airport.iata_code ?? airport.icao_code ?? airport.name ?? null
|
|
}
|
|
|
|
export function getTopAirports(flights: Flight[], upcomingFlights: Flight[]) {
|
|
const map = new Map<string, AirportItem>()
|
|
const empty = (): AirportItem => ({ departures: 0, arrivals: 0, upcoming: 0, label: '', fullName: '' })
|
|
|
|
flights.forEach(f => {
|
|
const depLabel = airportLabel(f.departure_airport)
|
|
const arrLabel = airportLabel(f.arrival_airport)
|
|
|
|
if (depLabel) {
|
|
const e = map.get(depLabel) ?? empty()
|
|
e.departures++
|
|
e.label = depLabel
|
|
e.fullName = f.departure_airport?.name ?? depLabel
|
|
map.set(depLabel, e)
|
|
}
|
|
if (arrLabel) {
|
|
const e = map.get(arrLabel) ?? empty()
|
|
e.arrivals++
|
|
e.label = arrLabel
|
|
e.fullName = f.arrival_airport?.name ?? arrLabel
|
|
map.set(arrLabel, e)
|
|
}
|
|
})
|
|
|
|
upcomingFlights.forEach(f => {
|
|
const depLabel = airportLabel(f.departure_airport)
|
|
const arrLabel = airportLabel(f.arrival_airport)
|
|
|
|
if (depLabel) {
|
|
const e = map.get(depLabel) ?? empty()
|
|
e.upcoming++
|
|
e.label = depLabel
|
|
e.fullName = f.departure_airport?.name ?? depLabel
|
|
map.set(depLabel, e)
|
|
}
|
|
if (arrLabel) {
|
|
const e = map.get(arrLabel) ?? empty()
|
|
e.upcoming++
|
|
e.label = arrLabel
|
|
e.fullName = f.arrival_airport?.name ?? arrLabel
|
|
map.set(arrLabel, e)
|
|
}
|
|
})
|
|
|
|
const sorted = [...map.values()]
|
|
.sort((a, b) =>
|
|
(b.departures + b.arrivals + b.upcoming) - (a.departures + a.arrivals + a.upcoming)
|
|
)
|
|
|
|
return {
|
|
airports: sorted,
|
|
series: [
|
|
{ name: 'Departures', data: sorted.map(s => s.departures) },
|
|
{ name: 'Arrivals', data: sorted.map(s => s.arrivals) },
|
|
{ name: 'Upcoming', data: sorted.map(s => s.upcoming) },
|
|
],
|
|
}
|
|
}
|
|
|
|
export function getFlightTypes(flights: Flight[]) {
|
|
const counts = { International: 0, Domestic: 0 }
|
|
flights.forEach(f => {
|
|
const dep = f.departure_airport.region?.country?.id
|
|
const arr = f.arrival_airport.region?.country?.id
|
|
if (dep && arr) {
|
|
dep === arr ? counts.Domestic++ : counts.International++
|
|
}
|
|
})
|
|
const sorted = Object.entries(counts).filter(([, count]) => count > 0)
|
|
return {
|
|
labels: sorted.map(([name]) => name),
|
|
series: sorted.map(([, count]) => count),
|
|
}
|
|
}
|
|
|
|
export type FlightStats = ReturnType<typeof useFlightStats>
|
|
|
|
export function useFlightStats(flights: Ref<Flight[]>) {
|
|
const now = new Date()
|
|
|
|
const pastFlights = computed(() =>
|
|
flights.value.filter(f => new Date(f.departure_date) <= now)
|
|
)
|
|
const upcomingFlights = computed(() =>
|
|
flights.value.filter(f => new Date(f.departure_date) > now)
|
|
)
|
|
|
|
const allFlights = computed(() => flights.value)
|
|
|
|
const perYear = computed(() => getFlightsPerYear(pastFlights.value, upcomingFlights.value))
|
|
const perMonth = computed(() => getFlightsPerMonth(pastFlights.value, upcomingFlights.value))
|
|
const perDay = computed(() => getFlightsPerDay(pastFlights.value, upcomingFlights.value))
|
|
const reasons = computed(() => getFlightReasons(allFlights.value))
|
|
const classes = computed(() => getFlightClasses(allFlights.value))
|
|
const seatTypes = computed(() => getSeatTypes(allFlights.value))
|
|
const countries = computed(() => getCountries(pastFlights.value, upcomingFlights.value))
|
|
const continents = computed(() => getContinents(allFlights.value))
|
|
const topAirlines = computed(() => getTopAirlines(pastFlights.value, upcomingFlights.value))
|
|
const topAirports = computed(() => getTopAirports(pastFlights.value, upcomingFlights.value))
|
|
const flightTypes = computed(() => getFlightTypes(allFlights.value))
|
|
|
|
return {
|
|
pastFlights,
|
|
upcomingFlights,
|
|
perYear,
|
|
perMonth,
|
|
perDay,
|
|
reasons,
|
|
classes,
|
|
seatTypes,
|
|
countries,
|
|
continents,
|
|
flightTypes,
|
|
topAirlines,
|
|
topAirports,
|
|
}
|
|
}
|