@autobusal/routes-order 1.8.0 → 1.9.1

package/Facts/Facts.tsx

@@ -0,0 +1,271 @@
+import { TFunction } from 'i18next';
+import { Container, Grid, Fact, Label, Value, Note, Notice, Operators, Prose } from './styles';
+import { FactsData } from './types';
+import { DAYS, duration } from './questions';
+import { stopped, detail } from './service';
+
+interface Props {
+  id: string
+  // Edited: Ferjolt Ozuni - Date: 2026-08-03
+  // Handed in rather than fetched here. The schedule table is built from the
+  // same response, and two components each running the same query would have
+  // meant the prerender crawl paying for every pair twice.
+  facts: FactsData
+  t: TFunction<'common'>
+}
+
+/**
+ * The facts about this city pair.
+ *
+ * Edited: Ferjolt Ozuni - Date: 2026-08-03
+ *
+ * Roadmap Tier 3.2. What somebody searching "Tirana to Durres bus" wants
+ * answered before they trust the page: cost, length, when the first and last
+ * coach go, how many there are, how far, and who runs it.
+ *
+ * Everything here is read off the TIMETABLE rather than a dated search, so it
+ * does not change with the date in the URL. That is deliberate: a "from EUR
+ * 12" that moved depending on which day a crawler arrived would look unstable
+ * to a search engine and dishonest to a reader who came back.
+ *
+ * Renders nothing at all when the API has no facts for the pair. An empty
+ * facts block is worse than none - it is exactly the thin content this tier
+ * exists to remove.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * It now also answers "what is this journey LIKE", which is the half a
+ * grid of numbers cannot: how often it runs, how many of the coaches are
+ * non-stop, how many travel overnight, where they call, what is on board,
+ * and whether it crosses a border. Sentences rather than more tiles,
+ * because that is the half a reader takes away and a machine can quote.
+ *
+ * The same restraint applies to all of it: a sentence whose data is
+ * missing is not printed, and one whose data supports only a weaker claim
+ * is printed in the weaker wording. A pair with one weekly coach ends up
+ * with a short honest block, not a padded one.
+ */
+const Facts = ({ id, facts, t }: Props): JSX.Element => {
+  /**
+   * Edited: Claude - Date: 2026-08-20
+   *
+   * Whether this coach leaves the country, which is the first thing a
+   * traveller wants settled and the one fact here that is not about the
+   * timetable at all - it is about the two cities. Silent when either
+   * country is unknown rather than assuming the pair is domestic, and
+   * silent on the wording of what a border crossing REQUIRES: entry rules
+   * are the traveller's own and this page has no business inventing them.
+   */
+  const countries = (() => {
+    if (!facts.from_country || !facts.to_country) {
+      return null;
+    }
+
+    return facts.from_country === facts.to_country
+      ? <p>{ t('routes_order.facts.domestic', { country: facts.from_country }) }</p>
+      : <p>{ t('routes_order.facts.international', { from_country: facts.from_country, to_country: facts.to_country }) }</p>;
+  })();
+
+  const via = facts.via && facts.via.cities.length > 0 ? facts.via : null;
+
+  const amenities = facts.amenities && facts.amenities.names.length > 0 ? facts.amenities : null;
+
+  // Edited: Claude - Date: 2026-08-20
+  // A thin pair can have none of the four sentences below, and an empty
+  // <Prose> is still a box with a top margin - a gap under the grid that
+  // reads as something failing to load.
+  const prose = Boolean(countries || via || amenities || facts.operators.length > 0);
+
+  const range = facts.duration_min !== null && facts.duration_max !== null
+    ? (facts.duration_min === facts.duration_max
+        ? duration(facts.duration_min, t)
+        : `${ duration(facts.duration_min, t) } – ${ duration(facts.duration_max, t) }`)
+    : null;
+
+  /**
+   * Edited: Claude - Date: 2026-08-21
+   *
+   * SAY IT, rather than leaving a reader to work it out. A route is
+   * published to the sitemap on a flag nothing re-checks, so a season
+   * ending never un-publishes its page - and the page's only tell was a
+   * missing frequency tile and a booking wizard that came back empty on
+   * every date tried. That is a visitor doing our diagnostics for us and
+   * concluding the site is broken.
+   *
+   * DORMANT NAMES THE DATE. "Not currently scheduled" alone reads as a
+   * fault; "the last service ran on 30 September 2024" reads as a season,
+   * which is what it usually is, and tells a traveller whether to come back
+   * in the summer or give up. A route that never had a timetable has no
+   * such date and gets the sentence that says so instead of a borrowed one.
+   *
+   * AND IT POINTS ONWARD in the same breath. The nearby-pair links below
+   * are live journeys on live routes; somebody who came here for a bus is
+   * one click from one, and the whole reason this page keeps its ranking
+   * rather than being de-listed is that it can make that click happen.
+   */
+  const dead = stopped(facts);
+
+  const said = dead ? detail(dead, t) : null;
+
+  return (
+    <Container id={ id } className="box">
+      <h2>{ t('routes_order.facts.title', { from: facts.from, to: facts.to }) }</h2>
+
+      { dead && (
+        <Notice>
+          <strong>{ t('routes_order.facts.not_scheduled') }</strong>
+
+          <p>
+            { said && `${ said } ` }
+            { t('routes_order.facts.not_scheduled_links') }
+          </p>
+        </Notice>
+      ) }
+
+      <Grid>
+        { facts.price_from_display && (
+          <Fact>
+            <Label>{ t('routes_order.facts.price') }</Label>
+            <Value>{ facts.price_from_display }</Value>
+          </Fact>
+        ) }
+
+        { range && (
+          <Fact>
+            <Label>{ t('routes_order.facts.duration') }</Label>
+            <Value>{ range }</Value>
+          </Fact>
+        ) }
+
+        { facts.departure_first && (
+          <Fact>
+            <Label>{ t('routes_order.facts.first') }</Label>
+            <Value>{ facts.departure_first }</Value>
+          </Fact>
+        ) }
+
+        { facts.departure_last && (
+          <Fact>
+            <Label>{ t('routes_order.facts.last') }</Label>
+            <Value>{ facts.departure_last }</Value>
+          </Fact>
+        ) }
+
+        <Fact>
+          <Label>{ t('routes_order.facts.departures') }</Label>
+          <Value>{ facts.departures }</Value>
+        </Fact>
+
+        { /* Edited: Claude - Date: 2026-08-20
+             HOW OFTEN, which the departure count above cannot say - ten
+             services means something very different once a week than it
+             does every day. Absent entirely when no coach on the pair has a
+             usable timetable row, including the case that matters: a season
+             that has already ended. Saying nothing there is the honest
+             answer; "runs 3 times a week" about a coach that stopped
+             running last September is not. */ }
+        { facts.frequency && (
+          <Fact>
+            <Label>{ t('routes_order.facts.frequency') }</Label>
+
+            <Value>
+              { facts.frequency.daily
+                ? t('routes_order.facts.frequency_daily')
+                : facts.frequency.days.map(day => t(`data.days.${ DAYS[day] }`)).join(', ') }
+
+              <Note>
+                { facts.frequency.weekly === 1
+                  ? t('routes_order.facts.frequency_weekly_single')
+                  : t('routes_order.facts.frequency_weekly', { count: facts.frequency.weekly }) }
+              </Note>
+            </Value>
+          </Fact>
+        ) }
+
+        { /* Edited: Claude - Date: 2026-08-20
+             Counted out of the total rather than shown as a yes/no. "Direct
+             service: yes" on a pair where one coach in ten is direct is
+             true and useless; "1 of 10" is what a reader needs to know
+             before they start comparing departures. */ }
+        { facts.direct > 0 && (
+          <Fact>
+            <Label>{ t('routes_order.facts.direct') }</Label>
+            <Value>{ t('routes_order.facts.of_total', { count: facts.direct, total: facts.departures }) }</Value>
+          </Fact>
+        ) }
+
+        { facts.overnight > 0 && (
+          <Fact>
+            <Label>{ t('routes_order.facts.overnight') }</Label>
+            <Value>{ t('routes_order.facts.of_total', { count: facts.overnight, total: facts.departures }) }</Value>
+          </Fact>
+        ) }
+
+        { facts.distance && (
+          <Fact>
+            <Label>{ t('routes_order.facts.distance') }</Label>
+
+            <Value>
+              { t('routes_order.facts.distance_value', {
+                km: facts.distance.road ?? facts.distance.approx
+              }) }
+
+              { /* The caveat appears only on the approximation. A real road
+                   distance needs no apology; a sum of straight lines does,
+                   because it understates every journey - 309 km against 401
+                   km of tarmac on Tirana-Thessaloniki. Printing that bare, as
+                   though it were the driving distance, would be quietly wrong
+                   on every single pair. */ }
+              { facts.distance.road === null && (
+                <Note>{ t('routes_order.facts.distance_note') }</Note>
+              ) }
+            </Value>
+          </Fact>
+        ) }
+      </Grid>
+
+      { /* Edited: Claude - Date: 2026-08-20
+           The part somebody reads rather than scans. Four sentences at most,
+           each one printed only when the data behind it exists, and none of
+           them a generality - a pair served by one weekly coach gets one
+           sentence and it is true, which is a better page than four
+           sentences of hedging.
+
+           EVERY/SOME IS THE WHOLE CARE HERE. Buses on one route are not
+           interchangeable: six of the ten Tirana-Thessaloniki coaches run
+           non-stop and they carry different equipment. "Every bus calls at
+           Korca" and "some buses also call at Korca" are different claims
+           and obtapi says which one the data supports, so the copy never
+           has to guess. */ }
+      { prose && (
+        <Prose>
+          { countries }
+
+          { via && (
+            <p>
+              { t(via.every ? 'routes_order.facts.via_every' : 'routes_order.facts.via_some', {
+                cities: via.cities.join(', ')
+              }) }
+            </p>
+          ) }
+
+          { amenities && (
+            <p>
+              { t(amenities.every ? 'routes_order.facts.amenities_every' : 'routes_order.facts.amenities_some', {
+                amenities: amenities.names.join(', ')
+              }) }
+            </p>
+          ) }
+
+          { facts.operators.length > 0 && (
+            <Operators>
+              { t('routes_order.facts.operators', { operators: facts.operators.join(', ') }) }
+            </Operators>
+          ) }
+        </Prose>
+      ) }
+    </Container>
+  );
+};
+
+export default Facts;

package/Facts/questions.ts

@@ -0,0 +1,250 @@
+import { TFunction } from 'i18next';
+import { FactsData } from './types';
+import { stopped, sentence } from './service';
+
+export interface Question {
+  // stable enough to key a list on, and never rendered
+  id: string
+  q: string
+  a: string
+}
+
+/**
+ * ISO weekday to the short day names the rest of the site already ships in
+ * all fifteen languages (`data.days.*`) - "Mon, Wed, Fri" rather than a new
+ * set of long names nobody would have translated for a week.
+ */
+export const DAYS: Record<number, string> = {
+  1: 'mon', 2: 'tue', 3: 'wed', 4: 'thu', 5: 'fri', 6: 'sat', 7: 'sun'
+};
+
+/**
+ * The questions a pair page answers, and their answers.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * ONE BUILDER, TWO CONSUMERS, AND THAT IS THE ENTIRE POINT. The FAQPage
+ * structured data and the FAQ a human reads are built from this same array,
+ * so the schema's `acceptedAnswer` is the identical string the page renders
+ * a few hundred pixels away - character for character, in whatever language
+ * the reader is in. Google requires that match and pulls a site's rich
+ * results when it fails; two lists of hand-written questions kept in step by
+ * good intentions is exactly how it fails, six months later, in one locale
+ * nobody re-read.
+ *
+ * EVERY ANSWER IS A FACT obtapi COMPUTED, never an estimate and never a
+ * generality. A question whose data is missing is not asked: no "typically
+ * around 6 hours", no "usually several a day". A pair served by one coach a
+ * week gets four questions and they are all true, which is a better page
+ * than eight questions padded with hedges.
+ *
+ * Ordered by how often the question is actually typed - how long, how much,
+ * how often - rather than by how the payload happens to be shaped.
+ */
+/**
+ * A journey length, in words.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * "07:30" built from a duration in minutes reads as a time of day, so the
+ * hours and minutes are spelled out - and a whole number of hours drops the
+ * "0m" rather than printing it.
+ *
+ * Exported because the facts block prints the same number a few hundred
+ * pixels from the FAQ answer that quotes it, and it had its own copy of
+ * this without the whole-hour rule: a three-hour coach read "3h 0m" in the
+ * grid and "3h" in the answer directly below it, on the same page, about
+ * the same bus.
+ */
+export const duration = (minutes: number, t: TFunction<'common'>): string => (
+  minutes % 60 === 0
+    ? t('routes_order.facts.duration_hours', { hours: minutes / 60 })
+    : t('routes_order.facts.duration_value', { hours: Math.floor(minutes / 60), minutes: minutes % 60 })
+);
+
+const questions = (facts: FactsData, t: TFunction<'common'>): Question[] => {
+  const all: Question[] = [];
+
+  const cities = { from: facts.from, to: facts.to };
+
+  /**
+   * Edited: Claude - Date: 2026-08-21
+   *
+   * THE FIRST QUESTION, WHEN THE ANSWER IS NO. "Is there a bus from Tirana
+   * to Prizren?" is the question a pair page exists to answer, and on a
+   * pair whose every timetable window has closed the honest answer is not
+   * currently, with the day it last ran.
+   *
+   * It also dictates which of the questions BELOW may be asked, which is
+   * the part that matters more than the extra entry. Every answer here is
+   * a standalone sentence that Google may lift into a rich result with no
+   * page around it, so "There are 4 scheduled services from Tirana to
+   * Prizren" quoted on its own about a route that stopped in 2025 is a
+   * claim we published, not a nuance a reader will supply. The four
+   * present-tense SERVICE COUNTS - how many run, what time they leave,
+   * how many are direct, how many are overnight - are dropped there.
+   * (Frequency drops itself: obtapi already sends null for it.)
+   *
+   * What stays is what remains true of the journey as published: how long
+   * it takes, what it cost, where it calls, what is on board, who runs it,
+   * how far it is. Those describe the route rather than assert this
+   * morning's departures, and each of them sits under an answer that has
+   * already said the route is not running.
+   */
+  const dead = stopped(facts);
+
+  if (dead) {
+    all.push({
+      id: 'service',
+      q: t('routes_order.schema.service_q', cities),
+      a: sentence(dead, t)
+    });
+  }
+
+  if (facts.duration_min !== null && facts.duration_max !== null) {
+    all.push({
+      id: 'duration',
+      q: t('routes_order.schema.duration_q', cities),
+      a: facts.duration_min === facts.duration_max
+        ? t('routes_order.schema.duration_a', { ...cities, duration: duration(facts.duration_min, t) })
+        : t('routes_order.schema.duration_a_range', { ...cities, min: duration(facts.duration_min, t), max: duration(facts.duration_max, t) })
+    });
+  }
+
+  if (facts.price_from_display) {
+    all.push({
+      id: 'price',
+      q: t('routes_order.schema.price_q', cities),
+
+      // A range only where there is one. On a pair whose services all cost
+      // the same, "from 15.00 EUR to 15.00 EUR" is a sentence that makes a
+      // reader distrust the rest of the page.
+      a: facts.price_to_display && facts.price_to !== facts.price_from
+        ? t('routes_order.schema.price_a_range', { ...cities, low: facts.price_from_display, high: facts.price_to_display })
+        : t('routes_order.schema.price_a', { ...cities, price: facts.price_from_display })
+    });
+  }
+
+  if (facts.frequency) {
+    const days = facts.frequency.days.map(day => t(`data.days.${ DAYS[day] }`)).join(', ');
+
+    all.push({
+      id: 'frequency',
+      q: t('routes_order.schema.frequency_q', cities),
+      a: facts.frequency.daily
+        ? t('routes_order.schema.frequency_a_daily', { ...cities, count: facts.frequency.weekly })
+        : (facts.frequency.weekly === 1
+            ? t('routes_order.schema.frequency_a_single', { ...cities, days })
+            : t('routes_order.schema.frequency_a', { ...cities, days, count: facts.frequency.weekly }))
+    });
+  }
+
+  if (facts.departures > 0 && !dead) {
+    all.push({
+      id: 'departures',
+      q: t('routes_order.schema.departures_q', cities),
+
+      // SERVICES, not departures. `facts.departures` counts the distinct
+      // coaches in the timetable, and a single daily one of them makes
+      // seven departures a week - so beside the frequency answer above,
+      // the old wording ("10 scheduled departures" next to "70 a week")
+      // read as a contradiction rather than as two facts. Both strings
+      // were reworded; the number they print never changed.
+      //
+      // And "There are 1 scheduled departures" was the sentence a thin
+      // pair got for as long as this block has existed - a thin pair being
+      // most of them. A separate key rather than an i18next plural: the
+      // plural categories of the eight Slavic locales here are not
+      // something a single English-shaped rule gets right.
+      a: facts.departures === 1
+        ? t('routes_order.schema.departures_a_single', cities)
+        : t('routes_order.schema.departures_a', { ...cities, count: facts.departures })
+    });
+  }
+
+  if (facts.departure_first && facts.departure_last && !dead) {
+    all.push({
+      id: 'times',
+      q: t('routes_order.schema.times_q', cities),
+      a: t('routes_order.schema.times_a', { first: facts.departure_first, last: facts.departure_last })
+    });
+  }
+
+  // Asked only where the answer is a real count. `direct` is meaningless
+  // without a total to read it against, and `departures` is that total.
+  if (facts.departures > 0 && !dead) {
+    all.push({
+      id: 'direct',
+      q: t('routes_order.schema.direct_q', cities),
+      a: facts.direct === 0
+        ? t('routes_order.schema.direct_a_none', cities)
+        : (facts.direct === facts.departures
+            ? t('routes_order.schema.direct_a_all', cities)
+            : t('routes_order.schema.direct_a', { ...cities, count: facts.direct, total: facts.departures }))
+    });
+  }
+
+  // Only when there IS a night service. "No, none of these run overnight" is
+  // a question asked to be answered no, which is padding.
+  if (facts.overnight > 0 && !dead) {
+    all.push({
+      id: 'overnight',
+      q: t('routes_order.schema.overnight_q', cities),
+      a: facts.overnight === facts.departures
+        ? t('routes_order.schema.overnight_a_all', cities)
+        : t('routes_order.schema.overnight_a', { ...cities, count: facts.overnight, total: facts.departures })
+    });
+  }
+
+  if (facts.via && facts.via.cities.length > 0) {
+    all.push({
+      id: 'via',
+      q: t('routes_order.schema.via_q', cities),
+
+      // The same sentence the facts block shows, deliberately - it is the
+      // one wording that distinguishes "every coach calls here" from "one of
+      // them does", and the answer must not be a looser paraphrase of it.
+      a: t(facts.via.every ? 'routes_order.facts.via_every' : 'routes_order.facts.via_some', {
+        cities: facts.via.cities.join(', ')
+      })
+    });
+  }
+
+  if (facts.amenities && facts.amenities.names.length > 0) {
+    all.push({
+      id: 'amenities',
+      q: t('routes_order.schema.amenities_q', cities),
+      a: t(facts.amenities.every ? 'routes_order.facts.amenities_every' : 'routes_order.facts.amenities_some', {
+        amenities: facts.amenities.names.join(', ')
+      })
+    });
+  }
+
+  if (facts.operators.length > 0) {
+    all.push({
+      id: 'operators',
+      q: t('routes_order.schema.operators_q', cities),
+      a: t('routes_order.facts.operators', { operators: facts.operators.join(', ') })
+    });
+  }
+
+  if (facts.distance) {
+    all.push({
+      id: 'distance',
+      q: t('routes_order.schema.distance_q', cities),
+
+      // The approximation gets its own sentence rather than the same one
+      // with a hedge bolted on. It is a sum of straight lines and it is
+      // ALWAYS short - 309 km against 412 km of tarmac on
+      // Tirana-Thessaloniki - so an answer that called it the road distance
+      // "approximately" would be wrong by a quarter on every pair.
+      a: facts.distance.road !== null
+        ? t('routes_order.schema.distance_a', { ...cities, km: facts.distance.road })
+        : t('routes_order.schema.distance_a_approx', { ...cities, km: facts.distance.approx })
+    });
+  }
+
+  return all;
+};
+
+export default questions;

package/Facts/service.ts

@@ -0,0 +1,111 @@
+import { TFunction } from 'i18next';
+import { FactsData } from './types';
+
+/**
+ * A pair that is published but has nothing left to sell.
+ *
+ * Edited: Claude - Date: 2026-08-21
+ *
+ * ONE READING OF THE FLAG, shared by everything that reacts to it - the
+ * notice in the facts block, the FAQ answer that a search engine quotes,
+ * and the schema.org availability. Three separate `facts.service?.scheduled
+ * === false` checks would be three chances for the page to say one thing
+ * and its own structured data to say another, which is the exact mismatch
+ * that gets a site's rich results pulled.
+ *
+ * `dormant` is a pair that RAN and stopped, and `last` is the day it last
+ * ran. `never` is a route published before anybody gave it a timetable -
+ * there is no last day to name, and the copy must not imply there was one.
+ *
+ * NULL for a live pair AND for an old cached payload with no `service` key
+ * at all (obtapi caches these for six hours, so the field is missing from
+ * warm entries for six hours after a deploy). Both mean "say nothing",
+ * which is right: an absent field is not evidence that a route is dead.
+ */
+export interface Stopped {
+  state: 'dormant' | 'never'
+  last: string | null
+}
+
+export const stopped = (facts: FactsData): (Stopped | null) => {
+  if (!facts.service || facts.service.scheduled !== false) {
+    return null;
+  }
+
+  return facts.service.last
+    ? { state: 'dormant', last: facts.service.last }
+    : { state: 'never', last: null };
+};
+
+/**
+ * ISO month index to the month names the site already ships in all fifteen
+ * languages (`data.months.*`), rather than a new set nobody would have
+ * translated for one sentence.
+ */
+const MONTHS = [
+  'january', 'february', 'march', 'april', 'may', 'june',
+  'july', 'august', 'september', 'october', 'november', 'december'
+];
+
+/**
+ * "The last service ran on 30 September 2024", in the reader's language.
+ *
+ * Edited: Claude - Date: 2026-08-21
+ *
+ * The day, month and year go in as THREE interpolations rather than one
+ * pre-joined string, so a locale that orders them differently can. obtapi
+ * sends the date as ISO precisely because it is the one format that does
+ * not already contain somebody's opinion about that ordering.
+ *
+ * Returns null on anything that is not an ISO date rather than printing a
+ * half-parsed one. A malformed date here would be printed as fact in a
+ * sentence about when a bus last ran, and no date at all is better than a
+ * wrong one - the headline above it already carries the actual message.
+ */
+export const ran = (iso: string, t: TFunction<'common'>): (string | null) => {
+  const parts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(iso);
+
+  if (!parts) {
+    return null;
+  }
+
+  const month = MONTHS[Number(parts[2]) - 1];
+
+  if (!month) {
+    return null;
+  }
+
+  return t('routes_order.facts.not_scheduled_last', {
+    day: String(Number(parts[3])),
+    month: t(`data.months.${ month }`),
+    year: parts[1]
+  });
+};
+
+/**
+ * The second sentence: when it last ran, or that it never has.
+ *
+ * Null rather than the never-scheduled wording when a DORMANT pair's date
+ * fails to parse - "a timetable has not been published yet" about a coach
+ * that ran for two years is a different false statement, not a graceful
+ * fallback. The headline carries the message on its own there.
+ */
+export const detail = (item: Stopped, t: TFunction<'common'>): (string | null) => (
+  item.last ? ran(item.last, t) : (item.state === 'never' ? t('routes_order.facts.not_scheduled_never') : null)
+);
+
+/**
+ * The whole message as one paragraph of running text.
+ *
+ * Shared with the FAQ answer for the same reason the flag is: Google
+ * requires the `acceptedAnswer` in the markup to be the text on the page,
+ * and the only way to guarantee that across fifteen languages is for there
+ * to be one string rather than two that agree today.
+ */
+export const sentence = (item: Stopped, t: TFunction<'common'>): string => {
+  const second = detail(item, t);
+
+  return second
+    ? `${ t('routes_order.facts.not_scheduled') } ${ second }`
+    : t('routes_order.facts.not_scheduled');
+};

package/Facts/services.ts

@@ -0,0 +1,19 @@
+import { UseQueryResult, useQuery } from '@tanstack/react-query';
+import { apiClient } from '@autobusal/providers';
+import { FactsResponse } from './types';
+
+export const useGetFacts = (from?: string, to?: string): UseQueryResult<FactsResponse> => (
+  useQuery({
+    queryKey: ['route-facts', from, to],
+    queryFn: async () => (
+      await apiClient
+        .get('/api/routes/search/facts', {
+          params: { from, to }
+        })
+        .then(response => (
+          response.data
+        ))
+    ),
+    enabled: Boolean(from && to)
+  })
+);