@autobusal/operator-routes 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 1.3.2
+
+### Added
+
+- **A stop added in a multi-zone country says so.** Times are stored local
+  to their stop, and a country with no zone recorded falls back to the
+  application's clock - a duration that reads plausibly and is wrong by
+  hours. The API now answers `warning: 'timezone'` and the operator is told,
+  because the operator is who sees the wrong number and would otherwise
+  "fix" it by editing times that are correct as stored.
+
+### Fixed
+
+- **`useAddLocation` returns its response.** It was awaited and discarded,
+  so `onSuccess` received undefined - harmless while the endpoint answered
+  with an empty object, and it would have swallowed the warning above.
+
+## [1.3.1] - 2026-08-07
+
+### Fixed
+
+- **Transiting country select no longer defaults to Afghanistan.** `value`
+  was `0`, so submitting without touching the field added the first country
+  in the list to the route's transit list.
+
 ## 1.3.0
 
 **The operator's own notice windows.**

package/Locations/Add/Add.tsx

@@ -2,7 +2,7 @@ import { TFunction } from 'i18next';
 import { useForm } from 'react-hook-form';
 import { FiPlus } from 'react-icons/fi';
 import { Button } from '@autobusal/common';
-import { Validate, Display, success } from '@autobusal/utilities';
+import { Validate, Display, success, notify } from '@autobusal/utilities';
 import Loading from './Loading';
 import { getStops } from '../utilities';
 import { Container, Title, ContainerAdd, Choose, Notice } from './styles';
@@ -28,9 +28,26 @@ const Add = ({ routeId, t, onReload }: Props): JSX.Element => {
 
   const onSubmit = (data: AddForm): void => {
     Save(data, {
-      onSuccess: () => {
+      onSuccess: (response) => {
         success(t('locations_manage.messages.added', { ns: 'common' }));
 
+        /*
+         * Edited: Ferjolt Ozuni - Date: 2026-08-07
+         *
+         * The stop was added - this is a caveat, not a failure, so it comes
+         * after the success and does not stop the reload.
+         *
+         * It is worth saying out loud because the consequence is a wrong
+         * NUMBER rather than an error: times at this stop fall back to our
+         * clock, so a duration can read short or long by hours. An operator
+         * who sees that without being told why is likely to correct it by
+         * editing the stored times, and that turns something we can fix
+         * centrally into data nobody can untangle later.
+         */
+        if (response?.warning === 'timezone') {
+          notify(t('locations_manage.messages.timezone', { ns: 'common' }));
+        }
+
         onReload();
       }
     });

package/Locations/services.ts

@@ -2,7 +2,7 @@ import { UseMutationResult, UseQueryResult, UseSuspenseQueryResult, useMutation,
 import { apiClient } from '@autobusal/providers';
 import { RouteData } from '@autobusal/providers/types/routes';
 import { CountryData } from '@autobusal/providers/types/locations';
-import { AddForm, LocationForm } from './types';
+import { AddForm, AddResponse, LocationForm } from './types';
 
 export const useGetLocations = (id: number): UseSuspenseQueryResult<RouteData> => (
   useSuspenseQuery({
@@ -36,19 +36,27 @@ export const useGetStops = (routeId: number): UseQueryResult<CountryData[]> => (
   })
 );
 
-export const useAddLocation = (id: number): UseMutationResult<void, Error, AddForm, unknown> => (
+/*
+ * Edited: Ferjolt Ozuni - Date: 2026-08-07
+ *
+ * Returns the response instead of discarding it. It was awaited and thrown
+ * away, so `onSuccess` was handed undefined - which was invisible while the
+ * endpoint answered with an empty object, and would have quietly swallowed
+ * the `warning` it can now carry.
+ */
+export const useAddLocation = (id: number): UseMutationResult<AddResponse, Error, AddForm, unknown> => (
   useMutation({
     mutationKey: ['operator-locations-add', { id }],
-    mutationFn: async (data: AddForm) => {
-      await apiClient
+    mutationFn: async (data: AddForm) => (
+      apiClient
         .post('/api/locations/operator/add', {
           ...data,
           id
         })
         .then(response => (
-          response.data
+          response.data as AddResponse
         ))
-    }
+    )
   })
 );
 

package/Locations/types.ts

@@ -2,6 +2,19 @@ export interface AddForm {
   group_id: string
 }
 
+/**
+ * What adding a stop answers with.
+ *
+ * Empty on the ordinary path. `warning` is a CODE rather than a sentence -
+ * the API has no business writing operator-facing prose in fifteen
+ * languages - and 'timezone' means the stop's country spans several zones,
+ * so the times shown for it fall back to the application's clock rather
+ * than its own.
+ */
+export interface AddResponse {
+  warning?: 'timezone'
+}
+
 export interface LocationForm {
   tomorrow: number
   departure: string

package/Transiting/Manage.tsx

@@ -85,7 +85,15 @@ const Manage = ({ url, t }: Props): JSX.Element => {
           name: 'country_id',
           type: 'select',
           values: filterCountries(data?.transiting ?? [], CountriesData),
-          value: 0,
+          /*
+           * Edited: Ferjolt Ozuni - Date: 2026-08-07
+           * `value: 0` matches no country, so this opened showing the first
+           * one - and submitting without touching it added THAT country to
+           * the route's transit list. An empty value plus a placeholder
+           * makes the operator pick.
+           */
+          placeholder: t('routes_order.step5.billing.country_choose', { ns: 'common' }),
+          value: '',
           rules: 'required'
         }] }
         fetching={ isFetching }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobusal/operator-routes",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "author": "Ferjolt Ozuni",
   "type": "module",
   "main": "index.ts"