minotor 5.0.1 → 6.0.0

package/src/stops/stopsIndex.ts

@@ -6,13 +6,7 @@ import { addAll, createIndex, search, SearchResult } from 'slimsearch';
 import { generateAccentVariants } from './i18n.js';
 import { deserializeStopsMap, serializeStopsMap } from './io.js';
 import { StopsMap as ProtoStopsMap } from './proto/stops.js';
-import {
-  SourceStopId,
-  SourceStopsMap,
-  Stop,
-  StopId,
-  StopsMap,
-} from './stops.js';
+import { SourceStopId, SourceStopsMap, Stop, StopId } from './stops.js';
 
 type StopPoint = { id: StopId; lat: number; lon: number };
 
@@ -22,18 +16,18 @@ type StopPoint = { id: StopId; lat: number; lon: number };
  * to efficiently find stops based on user queries.
  */
 export class StopsIndex {
-  private readonly stopsMap: StopsMap;
+  private readonly stops: Stop[];
   private readonly sourceStopsMap: SourceStopsMap;
   private readonly textIndex;
   private readonly geoIndex: KDTree;
   private readonly stopPoints: StopPoint[];
 
-  constructor(stopsMap: StopsMap) {
-    this.stopsMap = stopsMap;
+  constructor(stops: Stop[]) {
+    this.stops = stops;
     this.sourceStopsMap = new Map<SourceStopId, StopId>();
-    for (const [id, stop] of stopsMap.entries()) {
+    stops.forEach((stop, id) => {
       this.sourceStopsMap.set(stop.sourceStopId, id);
-    }
+    });
     this.textIndex = createIndex({
       fields: ['name'],
       storeFields: ['id'],
@@ -41,25 +35,25 @@ export class StopsIndex {
       processTerm: generateAccentVariants,
     });
     const stopsSet = new Map<StopId, { id: StopId; name: string }>();
-    for (const [id, stop] of stopsMap.entries()) {
+    stops.forEach((stop, id) => {
       const effectiveStopId = stop.parent ?? id;
       if (!stopsSet.has(effectiveStopId)) {
         stopsSet.set(effectiveStopId, {
           id: effectiveStopId,
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          name: stop.parent ? this.stopsMap.get(stop.parent)!.name : stop.name,
+          name: stop.parent ? this.stops[stop.parent]!.name : stop.name,
         });
       }
-    }
+    });
     const stopsArray = Array.from(stopsSet.values());
     addAll(this.textIndex, stopsArray);
 
-    this.stopPoints = Array.from(this.stopsMap.entries())
-      .filter(([, stop]) => {
+    this.stopPoints = this.stops
+      .filter((stop) => {
         if (stop.lat && stop.lon) return true;
         return false;
       })
-      .map(([id, stop]) => ({
+      .map((stop, id) => ({
         id: id,
         lat: stop.lat as number,
         lon: stop.lon as number,
@@ -90,7 +84,7 @@ export class StopsIndex {
    * @returns The serialized binary data.
    */
   serialize(): Uint8Array {
-    const protoStopsMap: ProtoStopsMap = serializeStopsMap(this.stopsMap);
+    const protoStopsMap: ProtoStopsMap = serializeStopsMap(this.stops);
 
     const writer = new BinaryWriter();
     ProtoStopsMap.encode(protoStopsMap, writer);
@@ -103,7 +97,7 @@ export class StopsIndex {
    * @returns The total number of stops.
    */
   size(): number {
-    return this.stopsMap.size;
+    return this.stops.length;
   }
 
   /**
@@ -115,7 +109,7 @@ export class StopsIndex {
    */
   findStopsByName(query: string, maxResults = 5): Stop[] {
     const results = search(this.textIndex, query).map(
-      (result: SearchResult) => this.stopsMap.get(result.id as number) as Stop,
+      (result: SearchResult) => this.stops[result.id as number] as Stop,
     );
     return results.slice(0, maxResults);
   }
@@ -143,7 +137,7 @@ export class StopsIndex {
       radius,
     ).map((id) => {
       const stopPoint = this.stopPoints[id as number] as StopPoint;
-      return this.stopsMap.get(stopPoint.id) as Stop;
+      return this.stops[stopPoint.id] as Stop;
     });
     return nearestStops;
   }
@@ -155,7 +149,7 @@ export class StopsIndex {
    * @returns The Stop object that matches the specified ID, or undefined if not found.
    */
   findStopById(id: StopId): Stop | undefined {
-    return this.stopsMap.get(id);
+    return this.stops[id];
   }
 
   /**
@@ -180,15 +174,15 @@ export class StopsIndex {
     if (id === undefined) {
       return [];
     }
-    const stop = this.stopsMap.get(id);
+    const stop = this.stops[id];
     if (!stop) {
       return [];
     }
     const equivalentStops = stop.parent
-      ? (this.stopsMap.get(stop.parent)?.children ?? [])
+      ? (this.stops[stop.parent]?.children ?? [])
       : stop.children;
     return Array.from(new Set([id, ...equivalentStops])).map(
-      (stopId) => this.stopsMap.get(stopId) as Stop,
+      (stopId) => this.stops[stopId] as Stop,
     );
   }
 }

package/src/timetable/__tests__/io.test.ts

@@ -12,31 +12,25 @@ import {
 } from '../io.js';
 import { REGULAR, Route } from '../route.js';
 import { Time } from '../time.js';
-import { ServiceRoutesMap, StopsAdjacency } from '../timetable.js';
+import { ServiceRoute, StopAdjacency } from '../timetable.js';
 
 describe('Timetable IO', () => {
-  const stopsAdjacency: StopsAdjacency = new Map([
-    [
-      1,
-      {
-        transfers: [{ destination: 2, type: 'RECOMMENDED' }],
-        routes: [0],
-      },
-    ],
-    [
-      2,
-      {
-        transfers: [
-          {
-            destination: 1,
-            type: 'GUARANTEED',
-            minTransferTime: Duration.fromMinutes(3),
-          },
-        ],
-        routes: [1],
-      },
-    ],
-  ]);
+  const stopsAdjacency: StopAdjacency[] = [
+    {
+      transfers: [{ destination: 2, type: 'RECOMMENDED' }],
+      routes: [0],
+    },
+    {
+      transfers: [
+        {
+          destination: 1,
+          type: 'GUARANTEED',
+          minTransferTime: Duration.fromMinutes(3),
+        },
+      ],
+      routes: [1],
+    },
+  ];
   const routesAdjacency = [
     new Route(
       new Uint16Array([
@@ -45,7 +39,7 @@ describe('Timetable IO', () => {
       ]),
       new Uint8Array([REGULAR, REGULAR]),
       new Uint32Array([1, 2]),
-      'gtfs1',
+      0,
     ),
     new Route(
       new Uint16Array([
@@ -54,31 +48,29 @@ describe('Timetable IO', () => {
       ]),
       new Uint8Array([REGULAR, REGULAR]),
       new Uint32Array([2, 1]),
-      'gtfs2',
+      1,
     ),
   ];
-  const routes: ServiceRoutesMap = new Map([
-    ['gtfs1', { type: 'RAIL', name: 'Route 1', routes: [0] }],
-    ['gtfs2', { type: 'RAIL', name: 'Route 2', routes: [1] }],
-  ]);
-  const stopsAdjacencyProto = {
-    stops: {
-      '1': {
-        transfers: [{ destination: 2, type: 0 }],
-        routes: [0],
-      },
-      '2': {
-        transfers: [
-          {
-            destination: 1,
-            type: 1,
-            minTransferTime: 180,
-          },
-        ],
-        routes: [1],
-      },
+  const routes: ServiceRoute[] = [
+    { type: 'RAIL', name: 'Route 1', routes: [0] },
+    { type: 'RAIL', name: 'Route 2', routes: [1] },
+  ];
+  const stopsAdjacencyProto = [
+    {
+      transfers: [{ destination: 2, type: 0 }],
+      routes: [0],
+    },
+    {
+      transfers: [
+        {
+          destination: 1,
+          type: 1,
+          minTransferTime: 180,
+        },
+      ],
+      routes: [1],
     },
-  };
+  ];
 
   const routesAdjacencyProto = [
     {
@@ -90,7 +82,7 @@ describe('Timetable IO', () => {
       ),
       pickUpDropOffTypes: new Uint8Array([REGULAR, REGULAR]),
       stops: new Uint8Array(new Uint32Array([1, 2]).buffer),
-      serviceRouteId: 'gtfs1',
+      serviceRouteId: 0,
     },
     {
       stopTimes: new Uint8Array(
@@ -101,16 +93,14 @@ describe('Timetable IO', () => {
       ),
       pickUpDropOffTypes: new Uint8Array([REGULAR, REGULAR]),
       stops: new Uint8Array(new Uint32Array([2, 1]).buffer),
-      serviceRouteId: 'gtfs2',
+      serviceRouteId: 1,
     },
   ];
 
-  const routesProto = {
-    routes: {
-      gtfs1: { type: 2, name: 'Route 1', routes: [0] },
-      gtfs2: { type: 2, name: 'Route 2', routes: [1] },
-    },
-  };
+  const routesProto = [
+    { type: 2, name: 'Route 1', routes: [0] },
+    { type: 2, name: 'Route 2', routes: [1] },
+  ];
 
   it('should serialize a stops adjacency matrix to a Uint8Array', () => {
     const serializedData = serializeStopsAdjacency(stopsAdjacency);

package/src/timetable/__tests__/route.test.ts

@@ -56,7 +56,7 @@ describe('Route', () => {
   );
 
   const stops = new Uint32Array([1001, 1002]);
-  const serviceRouteId = 'test-route-1';
+  const serviceRouteId = 0;
 
   const route = new Route(stopTimes, pickUpDropOffTypes, stops, serviceRouteId);
 
@@ -71,10 +71,10 @@ describe('Route', () => {
         new Uint16Array([]),
         new Uint8Array([]),
         new Uint32Array([]),
-        'empty-route',
+        1,
       );
       assert.strictEqual(emptyRoute.getNbStops(), 0);
-      assert.strictEqual(emptyRoute.serviceRoute(), 'empty-route');
+      assert.strictEqual(emptyRoute.serviceRoute(), 1);
     });
   });
 
@@ -104,14 +104,14 @@ describe('Route', () => {
     it('should throw error when stopA is not found', () => {
       assert.throws(
         () => route.isBefore(9999, 1002),
-        /Stop index undefined not found in route test-route-1/,
+        /Stop index undefined not found in route 0/,
       );
     });
 
     it('should throw error when stopB is not found', () => {
       assert.throws(
         () => route.isBefore(1001, 9999),
-        /Stop index undefined not found in route test-route-1/,
+        /Stop index undefined not found in route 0/,
       );
     });
   });
@@ -148,7 +148,7 @@ describe('Route', () => {
     it('should throw error for invalid stop ID', () => {
       assert.throws(
         () => route.arrivalAt(9999, 0),
-        /Stop index for 9999 not found in route test-route-1/,
+        /Stop index for 9999 not found in route 0/,
       );
     });
 
@@ -180,7 +180,7 @@ describe('Route', () => {
     it('should throw error for invalid stop ID', () => {
       assert.throws(
         () => route.departureFrom(9999, 0),
-        /Stop index for 9999 not found in route test-route-1/,
+        /Stop index for 9999 not found in route 0/,
       );
     });
 
@@ -211,7 +211,7 @@ describe('Route', () => {
     it('should throw error for invalid stop ID', () => {
       assert.throws(
         () => route.pickUpTypeFrom(9999, 0),
-        /Stop index for 9999 not found in route test-route-1/,
+        /Stop index for 9999 not found in route 0/,
       );
     });
 
@@ -237,7 +237,7 @@ describe('Route', () => {
     it('should throw error for invalid stop ID', () => {
       assert.throws(
         () => route.dropOffTypeAt(9999, 0),
-        /Stop index for 9999 not found in route test-route-1/,
+        /Stop index for 9999 not found in route 0/,
       );
     });
 
@@ -263,7 +263,7 @@ describe('Route', () => {
     it('should throw error for invalid start stop ID', () => {
       assert.throws(
         () => Array.from(route.stopsIterator(9999)),
-        /Start stop 9999 not found in route test-route-1/,
+        /Start stop 9999 not found in route 0/,
       );
     });
   });
@@ -318,7 +318,7 @@ describe('Route', () => {
     it('should throw error for invalid stop ID', () => {
       assert.throws(
         () => route.findEarliestTrip(9999),
-        /Stop index for 9999 not found in route test-route-1/,
+        /Stop index for 9999 not found in route 0/,
       );
     });
   });

package/src/timetable/__tests__/timetable.test.ts

@@ -7,41 +7,33 @@ import { NOT_AVAILABLE, REGULAR, Route } from '../route.js';
 import { Time } from '../time.js';
 import {
   RouteType,
-  ServiceRoutesMap,
-  StopsAdjacency,
+  ServiceRoute,
+  StopAdjacency,
   Timetable,
 } from '../timetable.js';
 
 describe('Timetable', () => {
-  const stopsAdjacency: StopsAdjacency = new Map([
-    [
-      1,
-      {
-        transfers: [{ destination: 2, type: 'RECOMMENDED' }],
-        routes: [0, 1],
-      },
-    ],
-    [
-      2,
-      {
-        transfers: [
-          {
-            destination: 1,
-            type: 'GUARANTEED',
-            minTransferTime: Duration.fromMinutes(3),
-          },
-        ],
-        routes: [1, 0],
-      },
-    ],
-    [
-      3,
-      {
-        transfers: [],
-        routes: [],
-      },
-    ],
-  ]);
+  const stopsAdjacency: StopAdjacency[] = [
+    { transfers: [], routes: [] },
+    {
+      transfers: [{ destination: 2, type: 'RECOMMENDED' }],
+      routes: [0, 1],
+    },
+    {
+      transfers: [
+        {
+          destination: 1,
+          type: 'GUARANTEED',
+          minTransferTime: Duration.fromMinutes(3),
+        },
+      ],
+      routes: [1, 0],
+    },
+    {
+      transfers: [],
+      routes: [],
+    },
+  ];
 
   const route1 = new Route(
     new Uint16Array([
@@ -59,7 +51,7 @@ describe('Timetable', () => {
       [REGULAR, REGULAR, REGULAR, REGULAR],
     ),
     new Uint32Array([1, 2]),
-    'gtfs1',
+    0,
   );
   const route2 = new Route(
     new Uint16Array([
@@ -70,13 +62,13 @@ describe('Timetable', () => {
     ]),
     encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
     new Uint32Array([2, 1]),
-    'gtfs2',
+    1,
   );
   const routesAdjacency = [route1, route2];
-  const routes: ServiceRoutesMap = new Map([
-    ['gtfs1', { type: 'RAIL', name: 'Route 1', routes: [0] }],
-    ['gtfs2', { type: 'RAIL', name: 'Route 2', routes: [1] }],
-  ]);
+  const routes: ServiceRoute[] = [
+    { type: 'RAIL', name: 'Route 1', routes: [0] },
+    { type: 'RAIL', name: 'Route 2', routes: [1] },
+  ];
 
   const sampleTimetable: Timetable = new Timetable(
     stopsAdjacency,

package/src/timetable/io.ts

@@ -2,17 +2,17 @@ import { Duration } from './duration.js';
 import {
   Route as ProtoRoute,
   RouteType as ProtoRouteType,
-  ServiceRoutesMap as ProtoServiceRoutesMap,
-  StopsAdjacency as ProtoStopsAdjacency,
+  ServiceRoute as ProtoServiceRoute,
+  StopAdjacency as ProtoStopAdjacency,
   Transfer as ProtoTransfer,
   TransferType as ProtoTransferType,
 } from './proto/timetable.js';
-import { Route, RouteId } from './route.js';
+import { Route } from './route.js';
 import {
   RouteType,
+  ServiceRoute,
   ServiceRouteId,
-  ServiceRoutesMap,
-  StopsAdjacency,
+  StopAdjacency,
   Transfer,
   TransferType,
 } from './timetable.js';
@@ -122,28 +122,20 @@ const bytesToUint16Array = (bytes: Uint8Array): Uint16Array => {
 };
 
 export const serializeStopsAdjacency = (
-  stopsAdjacency: StopsAdjacency,
-): ProtoStopsAdjacency => {
-  const protoStopsAdjacency: ProtoStopsAdjacency = {
-    stops: {},
-  };
-
-  stopsAdjacency.forEach(
-    (value: { transfers: Transfer[]; routes: number[] }, key: number) => {
-      protoStopsAdjacency.stops[key] = {
-        transfers: value.transfers.map((transfer) => ({
-          destination: transfer.destination,
-          type: serializeTransferType(transfer.type),
-          ...(transfer.minTransferTime !== undefined && {
-            minTransferTime: transfer.minTransferTime.toSeconds(),
-          }),
-        })),
-        routes: value.routes,
-      };
-    },
-  );
-
-  return protoStopsAdjacency;
+  stopsAdjacency: StopAdjacency[],
+): ProtoStopAdjacency[] => {
+  return stopsAdjacency.map((value) => {
+    return {
+      transfers: value.transfers.map((transfer) => ({
+        destination: transfer.destination,
+        type: serializeTransferType(transfer.type),
+        ...(transfer.minTransferTime !== undefined && {
+          minTransferTime: transfer.minTransferTime.toSeconds(),
+        }),
+      })),
+      routes: value.routes,
+    };
+  });
 };
 
 export const serializeRoutesAdjacency = (
@@ -165,36 +157,22 @@ export const serializeRoutesAdjacency = (
 };
 
 export const serializeServiceRoutesMap = (
-  serviceRoutesMap: ServiceRoutesMap,
-): ProtoServiceRoutesMap => {
-  const protoServiceRoutesMap: ProtoServiceRoutesMap = {
-    routes: {},
-  };
-
-  serviceRoutesMap.forEach(
-    (
-      value: { type: RouteType; name: string; routes: RouteId[] },
-      key: string,
-    ) => {
-      protoServiceRoutesMap.routes[key] = {
-        type: serializeRouteType(value.type),
-        name: value.name,
-        routes: value.routes,
-      };
-    },
-  );
-
-  return protoServiceRoutesMap;
+  serviceRoutes: ServiceRoute[],
+): ProtoServiceRoute[] => {
+  return serviceRoutes.map((value) => {
+    return {
+      type: serializeRouteType(value.type),
+      name: value.name,
+      routes: value.routes,
+    };
+  });
 };
 
 export const deserializeStopsAdjacency = (
-  protoStopsAdjacency: ProtoStopsAdjacency,
-): StopsAdjacency => {
-  const stopsAdjacency: StopsAdjacency = new Map();
-
-  Object.entries(protoStopsAdjacency.stops).forEach(([keyStr, value]) => {
-    const key = parseInt(keyStr, 10);
-    stopsAdjacency.set(key, {
+  protoStopsAdjacency: ProtoStopAdjacency[],
+): StopAdjacency[] => {
+  return protoStopsAdjacency.map((value) => {
+    return {
       transfers: value.transfers.map(
         (transfer: ProtoTransfer): Transfer => ({
           destination: transfer.destination,
@@ -205,10 +183,8 @@ export const deserializeStopsAdjacency = (
         }),
       ),
       routes: value.routes,
-    });
+    };
   });
-
-  return stopsAdjacency;
 };
 
 export const deserializeRoutesAdjacency = (
@@ -232,19 +208,15 @@ export const deserializeRoutesAdjacency = (
 };
 
 export const deserializeServiceRoutesMap = (
-  protoServiceRoutesMap: ProtoServiceRoutesMap,
-): ServiceRoutesMap => {
-  const serviceRoutesMap: ServiceRoutesMap = new Map();
-
-  Object.entries(protoServiceRoutesMap.routes).forEach(([key, value]) => {
-    serviceRoutesMap.set(key, {
+  protoServiceRoutes: ProtoServiceRoute[],
+): ServiceRoute[] => {
+  return protoServiceRoutes.map((value) => {
+    return {
       type: parseRouteType(value.type),
       name: value.name,
       routes: value.routes,
-    });
+    };
   });
-
-  return serviceRoutesMap;
 };
 
 const parseTransferType = (type: ProtoTransferType): TransferType => {

package/src/timetable/proto/timetable.proto

@@ -24,7 +24,7 @@ message Route {
    * Format: [stop1, stop2, stop3, etc.]
    */
   bytes stops = 3;
-  string serviceRouteId = 4;
+  uint32 serviceRouteId = 4;
 }
 
 enum TransferType {
@@ -40,12 +40,9 @@ message Transfer {
   optional uint32 minTransferTime = 3;
 }
 
-message StopsAdjacency {
-  message StopAdjacency {
-    repeated Transfer transfers = 1;
-    repeated int32 routes = 2;
-  }
-  map<uint32, StopAdjacency> stops = 1;
+message StopAdjacency {
+  repeated Transfer transfers = 1;
+  repeated int32 routes = 2;
 }
 
 enum RouteType {
@@ -67,13 +64,9 @@ message ServiceRoute {
   repeated int32 routes = 3;
 }
 
-message ServiceRoutesMap {
-  map<string, ServiceRoute> routes = 1;
-}
-
 message Timetable {
   string version = 1;
-  StopsAdjacency stopsAdjacency = 2;
+  repeated StopAdjacency stopsAdjacency = 2;
   repeated Route routesAdjacency = 3;
-  ServiceRoutesMap routes = 4;
+  repeated ServiceRoute serviceRoutes = 4;
 }