@autobusal/operator-routes 1.6.1 → 1.10.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.10.0 (2026-08-29)
+
+- Editors offer Save & Close alongside Save & Stay, so correcting a record no longer bounces you back to its list every time (opt-in per page, editing only).
+
+## 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

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

@@ -46,12 +46,14 @@ const Manage = ({ url, t }: Props): JSX.Element => {
 
   const drivers = useOperatorDrivers('id');
 
-  const onSave = (data: RouteData): void => {
+  const onSave = (data: RouteData, stay?: boolean): void => {
     Update(data, {
       onSuccess: () => {
         success(t('operator_routes.manage.messages.saved', { ns: 'common' }));
 
-        navigate(url);
+        if (!stay) {
+          navigate(url);
+        }
       }
     });
   };
@@ -282,7 +284,7 @@ const Manage = ({ url, t }: Props): JSX.Element => {
         pending={ isPendingSave || isPendingDelete }
         t={ t }
         actions={ [
-          'save', 'delete'
+          'save', 'save_stay', 'delete'
         ]}
         onSave={ onSave }
         onDelete={ onDelete }

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();
 
@@ -42,12 +56,14 @@ const Manage = ({ url, t }: Props): JSX.Element => {
     return <Navigate to={ url } />;
   }
 
-  const onSave = (data: AvailableData): void => {
+  const onSave = (data: AvailableData, stay?: boolean): void => {
     Update(data, {
       onSuccess: () => {
         success(t('schedules_manage.messages.saved', { ns: 'common' }));
 
-        navigate(url);
+        if (!stay) {
+          navigate(url);
+        }
       }
     });
   };
@@ -63,13 +79,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',
@@ -81,7 +102,7 @@ const Manage = ({ url, t }: Props): JSX.Element => {
         pending={ isPending }
         t={ t }
         actions={ [
-          'update'
+          'update', 'save_stay'
         ]}
         onSave={ onSave }
       />

package/Unavailable/Manage.tsx

@@ -47,12 +47,14 @@ const Manage = ({ url, t }: Props): JSX.Element => {
     return <Navigate to={ url } />;
   }
 
-  const onSave = (data: UnavailableData): void => {
+  const onSave = (data: UnavailableData, stay?: boolean): void => {
     Update(data, {
       onSuccess: () => {
         success(t('unavailable.manage.messages.saved', { ns: 'common' }));
 
-        navigate(url);
+        if (!stay) {
+          navigate(url);
+        }
       }
     });
   };
@@ -80,19 +82,24 @@ 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 }
         t={ t }
         actions={ [
-          'save', 'delete'
+          'save', 'save_stay', 'delete'
         ]}
         onSave={ onSave }
         onDelete={ onDelete }

package/package.json

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