@autobusal/operator-routes 1.6.0 → 1.9.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 1.9.0 (2026-08-29)
+
+- Route schedules and unavailability periods can be planned five years ahead, not one - the picker's ceiling was the only limit.
+- The 'add a stop' picker is searchable: every station on the platform was one native select, so finding your own city meant scrolling hundreds of options in an order nothing sorted for you.
+
+## 1.6.1
+
+### Fixed
+
+- **A copied or reversed route could not be opened.** The manage page read `data.drivers.registered` with the optional chain stopping one level short, so a route whose `drivers` relation was null crashed the whole page. Guarded. (Platform audit RT-09e; the backend now also copies the drivers row.)
+
 ## 1.6.0
 
 ### Added

package/Locations/Add/Add.tsx

@@ -1,10 +1,10 @@
 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, notify } from '@autobusal/utilities';
+import { Button, SearchableSelect } from '@autobusal/common';
+import { Display, success, notify } from '@autobusal/utilities';
 import Loading from './Loading';
-import { getStops } from '../utilities';
+import { getStopOptions } from '../utilities';
 import { Container, Title, ContainerAdd, Choose, Notice } from './styles';
 import { AddForm } from '../types';
 import { useGetStops, useAddLocation } from '../services';
@@ -16,7 +16,7 @@ interface Props {
 }
 
 const Add = ({ routeId, t, onReload }: Props): JSX.Element => {
-  const { register, handleSubmit, formState: { errors } } = useForm<AddForm>();
+  const { register, handleSubmit, setValue, formState: { errors } } = useForm<AddForm>();
 
   const { data, isLoading } = useGetStops(routeId);
 
@@ -60,9 +60,20 @@ const Add = ({ routeId, t, onReload }: Props): JSX.Element => {
       <form onSubmit={ handleSubmit(onSubmit) }>
         <ContainerAdd>
           <Choose>
-            <select { ...register('group_id', Validate('required', t)) }>
-              { getStops(t, data) }
-            </select>
+            { /* Edited: Claude - Date: 2026-08-29: typeable. Every station on
+                 the platform was listed in one native select, so an operator
+                 looking for their own city scrolled hundreds of options in an
+                 order nothing sorted for them. */ }
+            <SearchableSelect
+              name="group_id"
+              options={ getStopOptions(t, data) }
+              placeholder={ t('locations_manage.add_city.choose', { ns: 'common' }) }
+              empty={ t('locations_manage.add_city.empty', { ns: 'common' }) }
+              validation="required"
+              t={ t }
+              refs={ register }
+              onUpdate={ setValue }
+            />
 
             { Display(errors.group_id) }
           </Choose>

package/Locations/utilities.tsx

@@ -1,46 +1,45 @@
 import { TFunction } from 'i18next';
-import { CityData, CountryData } from '@autobusal/providers/types/locations';
+import { CountryData } from '@autobusal/providers/types/locations';
+import { SearchableOption } from '@autobusal/common/SearchableSelect/types';
 
-export const getStops = (t: TFunction<'normal'>, countries?: CountryData[]): JSX.Element[] => {
-  const options: JSX.Element[] = [
-    <option key="-none=" value="">{ t('locations_manage.add_city.choose', { ns: 'common' }) }</option>
-  ];
+/**
+ * The stations an operator may add to a route, as searchable options.
+ *
+ * Edited: Claude - Date: 2026-08-29
+ *
+ * Was a list of <option>/<optgroup> elements for a native select. It is a
+ * DATA list now, for SearchableSelect - every station on the platform is in
+ * here (hundreds of them, grouped by country), and until this became
+ * typeable the only way to find one's own city was to scroll the lot.
+ * `search` carries the country name too, so typing "greece" narrows to
+ * Greek stations even though the option itself shows only "city > stop".
+ */
+export const getStopOptions = (t: TFunction<'normal'>, countries?: CountryData[]): SearchableOption[] => {
+  const options: SearchableOption[] = [];
 
   countries?.forEach(country => {
-    options.push(
-      <optgroup key={ country.id } label={ country.name }>
-        { getOptions(country.cities, t) }
-      </optgroup>
-    );
-  });
-
-  return options;
-};
-
-const getOptions = (cities?: CityData[], t?: TFunction<'normal'>): JSX.Element[] => {
-  const options: JSX.Element[] = [];
-
-  cities?.forEach(city => {
-    city.stops?.forEach(stop => {
-      const value = `${ city.id }#${ stop.id }`;
-
-      /*
-       * Edited: Claude - Date: 2026-08-21
-       *
-       * A stop an operator proposed is listed but DISABLED until an admin
-       * approves it. Leaving it out entirely would look like the proposal
-       * had been lost - and obtapi refuses it anyway (Locations\
-       * OperatorController::add scopes to verified()), so an enabled option
-       * would just be an error waiting to happen.
-       */
-      const pending = stop.verified === false;
+    country.cities?.forEach(city => {
+      city.stops?.forEach(stop => {
+        /*
+         * Edited: Claude - Date: 2026-08-21
+         *
+         * A stop an operator proposed is listed but DISABLED until an admin
+         * approves it. Leaving it out entirely would look like the proposal
+         * had been lost - and obtapi refuses it anyway (Locations\
+         * OperatorController::add scopes to verified()), so an enabled option
+         * would just be an error waiting to happen.
+         */
+        const pending = stop.verified === false;
 
-      options.push(
-        <option key={ value } value={ value } disabled={ pending }>
-          { city.name } &rsaquo; { stop.name }
-          { pending && t ? ` (${ t('locations_manage.add_city.pending', { ns: 'common' }) })` : '' }
-        </option>
-      );
+        options.push({
+          value: `${ city.id }#${ stop.id }`,
+          label: `${ city.name } \u203a ${ stop.name }`,
+          group: country.name,
+          disabled: pending,
+          note: pending ? t('locations_manage.add_city.pending', { ns: 'common' }) : undefined,
+          search: [ country.name, city.name, stop.name ]
+        });
+      });
     });
   });
 

package/Manage.tsx

@@ -218,7 +218,7 @@ const Manage = ({ url, t }: Props): JSX.Element => {
           label: t('operator_routes.manage.drivers', { ns: 'common' }),
           name: 'drivers',
           type: 'checkbox-list-all',
-          selected: data?.drivers.registered ?? [],
+          selected: data?.drivers?.registered ?? [],
           values: drivers
         }, {}, {
           label: t('operator_routes.manage.searchable', { ns: 'common' }),

package/Schedule/Manage.tsx

@@ -12,6 +12,20 @@ interface Props {
   t: TFunction<'common'>
 }
 
+/**
+ * How far ahead a route schedule may be planned.
+ *
+ * Edited: Claude - Date: 2026-08-29
+ *
+ * The picker allowed one year - the ceiling every booking calendar has -
+ * so an operator running a stable seasonal line had to come back and redo
+ * the same dates every twelve months. obtapi never capped this (its rules
+ * are date_format + after:start_date), so the limit was only ever the
+ * calendar's. Six months before the end date, `schedules:expiring` now
+ * emails the operator and raises the alert on their dashboard.
+ */
+const SCHEDULE_YEARS = 5;
+
 const Manage = ({ url, t }: Props): JSX.Element => {
   const params = useParams();
 
@@ -63,13 +77,18 @@ const Manage = ({ url, t }: Props): JSX.Element => {
           name: 'start_date',
           type: 'picker',
           value: data?.available.start_date,
-          rules: 'required'
+          rules: 'required',
+          // Edited: Claude - Date: 2026-08-29: a schedule is planned in
+          // seasons, not in the one-year window seats are sold in - both
+          // ends of it now reach five years out (see Calendar's maxYears)
+          maxYears: SCHEDULE_YEARS
         }, {
           label: t('schedules_manage.end_date', { ns: 'common' }),
           name: 'end_date',
           type: 'picker',
           value: data?.available.end_date,
-          rules: 'required'
+          rules: 'required',
+          maxYears: SCHEDULE_YEARS
         }, {}, {
           label: t('schedules_manage.schedule', { ns: 'common' }),
           name: 'schedule',

package/Unavailable/Manage.tsx

@@ -80,13 +80,18 @@ const Manage = ({ url, t }: Props): JSX.Element => {
           name: 'start_inactive',
           type: 'picker',
           value: unavailable?.start_inactive,
-          rules: 'required'
+          rules: 'required',
+          // Edited: Claude - Date: 2026-08-29: an unavailability falls INSIDE
+          // the route's schedule, which now runs up to five years out - a
+          // one-year picker could not describe a closure in year three
+          maxYears: 5
         }, {
           label: t('unavailable.manage.end_inactive', { ns: 'common' }),
           name: 'end_inactive',
           type: 'picker',
           value: unavailable?.end_inactive,
-          rules: 'required'
+          rules: 'required',
+          maxYears: 5
         }] }
         fetching={ isFetching }
         pending={ isPendingSave || isPendingDelete }

package/package.json

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