minotor 1.0.6 → 2.0.0

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

@@ -13,18 +13,18 @@ import {
 describe('timetable io', () => {
   const stopsAdjacency: StopsAdjacency = new Map([
     [
-      'stop1',
+      1,
       {
-        transfers: [{ destination: 'stop2', type: 'RECOMMENDED' }],
+        transfers: [{ destination: 2, type: 'RECOMMENDED' }],
         routes: ['route1'],
       },
     ],
     [
-      'stop2',
+      2,
       {
         transfers: [
           {
-            destination: 'stop1',
+            destination: 1,
             type: 'GUARANTEED',
             minTransferTime: Duration.fromMinutes(3),
           },
@@ -37,36 +37,30 @@ describe('timetable io', () => {
     [
       'route1',
       {
-        stopTimes: [
-          {
-            arrival: Time.fromHMS(0, 16, 40),
-            departure: Time.fromHMS(0, 16, 50),
-            pickUpType: 'REGULAR',
-            dropOffType: 'REGULAR',
-          },
-          {
-            arrival: Time.fromHMS(0, 33, 20),
-            departure: Time.fromHMS(0, 33, 30),
-            pickUpType: 'NOT_AVAILABLE',
-            dropOffType: 'REGULAR',
-          },
-          {
-            arrival: Time.fromHMS(0, 50, 0),
-            departure: Time.fromHMS(0, 50, 10),
-            pickUpType: 'REGULAR',
-            dropOffType: 'REGULAR',
-          },
-          {
-            arrival: Time.fromHMS(1, 10, 0),
-            departure: Time.fromHMS(1, 10, 10),
-            pickUpType: 'REGULAR',
-            dropOffType: 'REGULAR',
-          },
-        ],
-        stops: ['stop1', 'stop2'],
+        stopTimes: new Uint32Array([
+          Time.fromHMS(0, 16, 40).toSeconds(),
+          Time.fromHMS(0, 16, 50).toSeconds(),
+          Time.fromHMS(0, 33, 20).toSeconds(),
+          Time.fromHMS(0, 33, 30).toSeconds(),
+          Time.fromHMS(0, 50, 0).toSeconds(),
+          Time.fromHMS(0, 50, 10).toSeconds(),
+          Time.fromHMS(1, 10, 0).toSeconds(),
+          Time.fromHMS(1, 10, 10).toSeconds(),
+        ]),
+        pickUpDropOffTypes: new Uint8Array([
+          0,
+          0, // REGULAR
+          1,
+          0, // NOT_AVAILABLE, REGULAR
+          0,
+          0, // REGULAR
+          0,
+          0, // REGULAR
+        ]),
+        stops: new Uint32Array([1, 2]),
         stopIndices: new Map([
-          ['stop1', 0],
-          ['stop2', 1],
+          [1, 0],
+          [2, 1],
         ]),
         serviceRouteId: 'gtfs1',
       },
@@ -74,24 +68,22 @@ describe('timetable io', () => {
     [
       'route2',
       {
-        stopTimes: [
-          {
-            arrival: Time.fromHMS(1, 6, 40),
-            departure: Time.fromHMS(1, 6, 50),
-            pickUpType: 'REGULAR',
-            dropOffType: 'REGULAR',
-          },
-          {
-            arrival: Time.fromHMS(1, 23, 20),
-            departure: Time.fromHMS(1, 23, 30),
-            pickUpType: 'REGULAR',
-            dropOffType: 'REGULAR',
-          },
-        ],
-        stops: ['stop2', 'stop1'],
+        stopTimes: new Uint32Array([
+          Time.fromHMS(1, 6, 40).toSeconds(),
+          Time.fromHMS(1, 6, 50).toSeconds(),
+          Time.fromHMS(1, 23, 20).toSeconds(),
+          Time.fromHMS(1, 23, 30).toSeconds(),
+        ]),
+        pickUpDropOffTypes: new Uint8Array([
+          0,
+          0, // REGULAR
+          0,
+          0, // REGULAR
+        ]),
+        stops: new Uint32Array([2, 1]),
         stopIndices: new Map([
-          ['stop2', 0],
-          ['stop1', 1],
+          [2, 0],
+          [1, 1],
         ]),
         serviceRouteId: 'gtfs2',
       },
@@ -122,7 +114,7 @@ describe('timetable io', () => {
   it('should find the earliest trip for stop1 on route1', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute('route1')!;
-    const tripIndex = sampleTimetable.findEarliestTrip(route, 'stop1');
+    const tripIndex = sampleTimetable.findEarliestTrip(route, 1);
     assert.strictEqual(tripIndex, 0);
   });
 
@@ -132,7 +124,7 @@ describe('timetable io', () => {
     const afterTime = Time.fromHMS(0, 25, 0);
     const tripIndex = sampleTimetable.findEarliestTrip(
       route,
-      'stop1',
+      1,
       undefined,
       afterTime,
     );
@@ -145,7 +137,7 @@ describe('timetable io', () => {
     const afterTime = Time.fromHMS(0, 58, 20);
     const tripIndex = sampleTimetable.findEarliestTrip(
       route,
-      'stop1',
+      1,
       undefined,
       afterTime,
     );
@@ -154,24 +146,24 @@ describe('timetable io', () => {
   it('should return undefined if the stop on a trip has pick up not available', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute('route1')!;
-    const tripIndex = sampleTimetable.findEarliestTrip(route, 'stop2');
+    const tripIndex = sampleTimetable.findEarliestTrip(route, 2);
     assert.strictEqual(tripIndex, 1);
   });
   it('should find reachable routes from a set of stop IDs', () => {
-    const fromStops = new Set(['stop1']);
+    const fromStops = new Set([1]);
     const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
     assert.strictEqual(reachableRoutes.size, 1);
-    assert.strictEqual(reachableRoutes.get('route1'), 'stop1');
+    assert.strictEqual(reachableRoutes.get('route1'), 1);
   });
 
   it('should find no reachable routes if starting from a non-existent stop', () => {
-    const fromStops = new Set(['non_existent_stop']);
+    const fromStops = new Set([5]);
     const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
     assert.strictEqual(reachableRoutes.size, 0);
   });
 
   it('should find reachable routes filtered by transport modes', () => {
-    const fromStops = new Set(['stop1']);
+    const fromStops = new Set([1]);
     const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops, [
       'BUS',
     ]);

package/src/timetable/io.ts

@@ -1,6 +1,5 @@
 import { Duration } from './duration.js';
 import {
-  PickUpDropOffType as ProtoPickUpDropOffType,
   RoutesAdjacency as ProtoRoutesAdjacency,
   RouteType as ProtoRouteType,
   ServiceRoutesMap as ProtoServiceRoutesMap,
@@ -8,9 +7,7 @@ import {
   Transfer as ProtoTransfer,
   TransferType as ProtoTransferType,
 } from './proto/timetable.js';
-import { Time } from './time.js';
 import {
-  PickUpDropOffType,
   Route,
   RoutesAdjacency,
   RouteType,
@@ -20,6 +17,59 @@ import {
   TransferType,
 } from './timetable.js';
 
+const isLittleEndian = (() => {
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setUint32(0, 0x12345678);
+  return new Uint8Array(buffer)[0] === 0x78;
+})();
+
+const STANDARD_ENDIANNESS = true; // true = little-endian
+
+function uint32ArrayToBytes(array: Uint32Array): Uint8Array {
+  if (isLittleEndian === STANDARD_ENDIANNESS) {
+    return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+  }
+
+  // If endianness doesn't match, we need to swap byte order
+  const result = new Uint8Array(array.length * 4);
+  const view = new DataView(result.buffer);
+
+  for (let i = 0; i < array.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    view.setUint32(i * 4, array[i]!, STANDARD_ENDIANNESS);
+  }
+
+  return result;
+}
+
+function bytesToUint32Array(bytes: Uint8Array): Uint32Array {
+  if (bytes.byteLength % 4 !== 0) {
+    throw new Error(
+      'Byte array length must be a multiple of 4 to convert to Uint32Array',
+    );
+  }
+
+  // If system endianness matches our standard, we can create a view directly
+  if (isLittleEndian === STANDARD_ENDIANNESS) {
+    return new Uint32Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength / 4,
+    );
+  }
+
+  // If endianness doesn't match, we need to swap byte order
+  const result = new Uint32Array(bytes.byteLength / 4);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  for (let i = 0; i < result.length; i++) {
+    result[i] = view.getUint32(i * 4, STANDARD_ENDIANNESS);
+  }
+
+  return result;
+}
+
 export const serializeStopsAdjacency = (
   stopsAdjacency: StopsAdjacency,
 ): ProtoStopsAdjacency => {
@@ -28,7 +78,7 @@ export const serializeStopsAdjacency = (
   };
 
   stopsAdjacency.forEach(
-    (value: { transfers: Transfer[]; routes: string[] }, key: string) => {
+    (value: { transfers: Transfer[]; routes: string[] }, key: number) => {
       protoStopsAdjacency.stops[key] = {
         transfers: value.transfers.map((transfer) => ({
           destination: transfer.destination,
@@ -54,13 +104,9 @@ export const serializeRoutesAdjacency = (
 
   routesAdjacency.forEach((value: Route, key: string) => {
     protoRoutesAdjacency.routes[key] = {
-      stopTimes: value.stopTimes.map((stopTimes) => ({
-        arrival: stopTimes.arrival.toSeconds(),
-        departure: stopTimes.departure.toSeconds(),
-        pickUpType: serializePickUpDropOffType(stopTimes.pickUpType),
-        dropOffType: serializePickUpDropOffType(stopTimes.dropOffType),
-      })),
-      stops: value.stops,
+      stopTimes: uint32ArrayToBytes(value.stopTimes),
+      pickUpDropOffTypes: value.pickUpDropOffTypes,
+      stops: uint32ArrayToBytes(value.stops),
       serviceRouteId: value.serviceRouteId,
     };
   });
@@ -92,7 +138,8 @@ export const deserializeStopsAdjacency = (
 ): StopsAdjacency => {
   const stopsAdjacency: StopsAdjacency = new Map();
 
-  Object.entries(protoStopsAdjacency.stops).forEach(([key, value]) => {
+  Object.entries(protoStopsAdjacency.stops).forEach(([keyStr, value]) => {
+    const key = parseInt(keyStr, 10);
     stopsAdjacency.set(key, {
       transfers: value.transfers.map(
         (transfer: ProtoTransfer): Transfer => ({
@@ -116,21 +163,17 @@ export const deserializeRoutesAdjacency = (
   const routesAdjacency: RoutesAdjacency = new Map();
 
   Object.entries(protoRoutesAdjacency.routes).forEach(([key, value]) => {
+    const stops = bytesToUint32Array(value.stops);
+    const indices = new Map<number, number>();
+    for (let i = 0; i < stops.length; i++) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      indices.set(stops[i]!, i);
+    }
     routesAdjacency.set(key, {
-      stopTimes: value.stopTimes.map((stopTimes) => ({
-        arrival: Time.fromSeconds(stopTimes.arrival),
-        departure: Time.fromSeconds(stopTimes.departure),
-        pickUpType:
-          stopTimes.pickUpType !== undefined
-            ? parsePickUpDropOffType(stopTimes.pickUpType)
-            : 'REGULAR',
-        dropOffType:
-          stopTimes.dropOffType !== undefined
-            ? parsePickUpDropOffType(stopTimes.dropOffType)
-            : 'REGULAR',
-      })),
-      stops: value.stops,
-      stopIndices: new Map(value.stops.map((stop, index) => [stop, index])),
+      stopTimes: bytesToUint32Array(value.stopTimes),
+      pickUpDropOffTypes: value.pickUpDropOffTypes,
+      stops: stops,
+      stopIndices: indices,
       serviceRouteId: value.serviceRouteId,
     });
   });
@@ -233,33 +276,3 @@ const serializeRouteType = (type: RouteType): ProtoRouteType => {
       return ProtoRouteType.MONORAIL;
   }
 };
-
-const parsePickUpDropOffType = (
-  type: ProtoPickUpDropOffType,
-): PickUpDropOffType => {
-  switch (type) {
-    case ProtoPickUpDropOffType.MUST_PHONE_AGENCY:
-      return 'MUST_PHONE_AGENCY';
-    case ProtoPickUpDropOffType.MUST_COORDINATE_WITH_DRIVER:
-      return 'MUST_COORDINATE_WITH_DRIVER';
-    case ProtoPickUpDropOffType.NOT_AVAILABLE:
-      return 'NOT_AVAILABLE';
-    default:
-      return 'REGULAR';
-  }
-};
-
-const serializePickUpDropOffType = (
-  type: PickUpDropOffType,
-): ProtoPickUpDropOffType | undefined => {
-  switch (type) {
-    case 'REGULAR':
-      return undefined;
-    case 'NOT_AVAILABLE':
-      return ProtoPickUpDropOffType.NOT_AVAILABLE;
-    case 'MUST_COORDINATE_WITH_DRIVER':
-      return ProtoPickUpDropOffType.MUST_COORDINATE_WITH_DRIVER;
-    case 'MUST_PHONE_AGENCY':
-      return ProtoPickUpDropOffType.MUST_PHONE_AGENCY;
-  }
-};

package/src/timetable/proto/timetable.proto

@@ -2,23 +2,28 @@ syntax = "proto3";
 
 package minotor.timetable;
 
-enum PickUpDropOffType {
-  NOT_AVAILABLE = 0;
-  MUST_PHONE_AGENCY = 1;
-  MUST_COORDINATE_WITH_DRIVER = 2;
-}
-
-message StopTimes {
-  int32 arrival = 1;
-  int32 departure = 2;
-  optional PickUpDropOffType pickUpType = 3;
-  optional PickUpDropOffType dropOffType = 4;
-}
-
 message Route {
-  repeated StopTimes stopTimes = 1;
-  repeated string stops = 2;
-  string serviceRouteId = 3;
+  /**
+   * Arrivals and departures encoded as a 32 bit uint array.
+   * Format: [arrival1, departure1, arrival2, departure2, etc.]
+   */
+  bytes stopTimes = 1;
+  /**
+   * PickUp and DropOff types represented as an 8 bit uint array.
+   * Values:
+   *   0: REGULAR
+   *   1: NOT_AVAILABLE
+   *   2: MUST_PHONE_AGENCY
+   *   3: MUST_COORDINATE_WITH_DRIVER
+   * Format: [pickupTypeStop1, dropOffTypeStop1, pickupTypeStop2, dropOffTypeStop2, etc.]
+   */
+  bytes pickUpDropOffTypes = 2;
+  /**
+   * Stops encoded as a 32 bit uint array.
+   * Format: [stop1, stop2, stop3, etc.]
+   */
+  bytes stops = 3;
+  string serviceRouteId = 4;
 }
 
 message RoutesAdjacency {
@@ -33,7 +38,7 @@ enum TransferType {
 }
 
 message Transfer {
-  string destination = 1;
+  uint32 destination = 1;
   TransferType type = 2;
   optional int32 minTransferTime = 3;
 }