minotor 7.0.2 → 8.0.0

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

@@ -58,7 +58,13 @@ describe('Route', () => {
   const stops = new Uint32Array([1001, 1002]);
   const serviceRouteId = 0;
 
-  const route = new Route(stopTimes, pickUpDropOffTypes, stops, serviceRouteId);
+  const route = new Route(
+    0,
+    stopTimes,
+    pickUpDropOffTypes,
+    stops,
+    serviceRouteId,
+  );
 
   describe('constructor', () => {
     it('should create a route with correct properties', () => {
@@ -68,6 +74,7 @@ describe('Route', () => {
 
     it('should handle empty route', () => {
       const emptyRoute = new Route(
+        0,
         new Uint16Array([]),
         new Uint8Array([]),
         new Uint32Array([]),
@@ -104,14 +111,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 0/,
+        /Stop index not found for 9999 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 0/,
+        /Stop index not found for 9999 in route 0/,
       );
     });
   });

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

@@ -1,20 +1,21 @@
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
 
-import { encodePickUpDropOffTypes } from '../../gtfs/trips.js';
 import { Duration } from '../duration.js';
-import { NOT_AVAILABLE, REGULAR, Route } from '../route.js';
+import { NOT_AVAILABLE, Route } from '../route.js';
 import { Time } from '../time.js';
 import {
   RouteType,
   ServiceRoute,
   StopAdjacency,
   Timetable,
+  TripBoarding,
 } from '../timetable.js';
+import { encode } from '../tripId.js';
 
 describe('Timetable', () => {
   const stopsAdjacency: StopAdjacency[] = [
-    { transfers: [], routes: [] },
+    { routes: [] },
     {
       transfers: [{ destination: 2, type: 'RECOMMENDED' }],
       routes: [0, 1],
@@ -30,40 +31,65 @@ describe('Timetable', () => {
       routes: [1, 0],
     },
     {
-      transfers: [],
       routes: [],
     },
   ];
 
-  const route1 = new Route(
-    new Uint16Array([
-      Time.fromHMS(16, 40, 0).toMinutes(),
-      Time.fromHMS(16, 50, 0).toMinutes(),
-      Time.fromHMS(17, 20, 0).toMinutes(),
-      Time.fromHMS(17, 30, 0).toMinutes(),
-      Time.fromHMS(18, 0, 0).toMinutes(),
-      Time.fromHMS(18, 10, 0).toMinutes(),
-      Time.fromHMS(19, 0, 0).toMinutes(),
-      Time.fromHMS(19, 10, 0).toMinutes(),
-    ]),
-    encodePickUpDropOffTypes(
-      [REGULAR, NOT_AVAILABLE, REGULAR, REGULAR],
-      [REGULAR, REGULAR, REGULAR, REGULAR],
-    ),
-    new Uint32Array([1, 2]),
-    0,
-  );
-  const route2 = new Route(
-    new Uint16Array([
-      Time.fromHMS(18, 20, 0).toMinutes(),
-      Time.fromHMS(18, 30, 0).toMinutes(),
-      Time.fromHMS(23, 20, 0).toMinutes(),
-      Time.fromHMS(23, 30, 0).toMinutes(),
-    ]),
-    encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
-    new Uint32Array([2, 1]),
-    1,
-  );
+  const route1 = Route.of({
+    id: 0,
+    serviceRouteId: 0,
+    trips: [
+      {
+        stops: [
+          {
+            id: 1,
+            arrivalTime: Time.fromHMS(16, 40, 0),
+            departureTime: Time.fromHMS(16, 50, 0),
+          },
+          {
+            id: 2,
+            arrivalTime: Time.fromHMS(17, 20, 0),
+            departureTime: Time.fromHMS(17, 30, 0),
+            pickUpType: NOT_AVAILABLE,
+          },
+        ],
+      },
+      {
+        stops: [
+          {
+            id: 1,
+            arrivalTime: Time.fromHMS(18, 0, 0),
+            departureTime: Time.fromHMS(18, 10, 0),
+          },
+          {
+            id: 2,
+            arrivalTime: Time.fromHMS(19, 0, 0),
+            departureTime: Time.fromHMS(19, 10, 0),
+          },
+        ],
+      },
+    ],
+  });
+  const route2 = Route.of({
+    id: 1,
+    serviceRouteId: 1,
+    trips: [
+      {
+        stops: [
+          {
+            id: 2,
+            arrivalTime: Time.fromHMS(18, 20, 0),
+            departureTime: Time.fromHMS(18, 30, 0),
+          },
+          {
+            id: 1,
+            arrivalTime: Time.fromHMS(19, 0, 0),
+            departureTime: Time.fromHMS(19, 10, 0),
+          },
+        ],
+      },
+    ],
+  });
   const routesAdjacency = [route1, route2];
   const routes: ServiceRoute[] = [
     { type: 'RAIL', name: 'Route 1', routes: [0] },
@@ -115,31 +141,173 @@ describe('Timetable', () => {
     const tripIndex = route.findEarliestTrip(2);
     assert.strictEqual(tripIndex, 1);
   });
-  it('should find reachable routes from a set of stop IDs', () => {
-    const fromStops = new Set([1]);
-    const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
-    assert.strictEqual(reachableRoutes.size, 2);
-    assert.deepStrictEqual(
-      reachableRoutes,
-      new Map([
-        [route1, 1],
-        [route2, 1],
-      ]),
-    );
-  });
+  describe('findReachableRoutes', () => {
+    it('should find reachable routes from a single stop', () => {
+      const fromStops = new Set([1]);
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+      assert.strictEqual(reachableRoutes.size, 2);
+      assert.deepStrictEqual(
+        reachableRoutes,
+        new Map([
+          [route1, 1],
+          [route2, 1],
+        ]),
+      );
+    });
 
-  it('should find no reachable routes if starting from a non-existent stop', () => {
-    const fromStops = new Set([3]);
-    const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
-    assert.strictEqual(reachableRoutes.size, 0);
-  });
+    it('should find reachable routes from multiple stops', () => {
+      const fromStops = new Set([1, 2]);
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+      assert.strictEqual(reachableRoutes.size, 2);
+
+      assert.deepStrictEqual(
+        reachableRoutes,
+        new Map([
+          [route1, 1],
+          [route2, 2],
+        ]),
+      );
+    });
+
+    it('should find no reachable routes from stops with no routes', () => {
+      const fromStops = new Set([3]); // Stop 3 has no routes in sample timetable
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+      assert.strictEqual(reachableRoutes.size, 0);
+      assert.deepStrictEqual(reachableRoutes, new Map());
+    });
+
+    it('should find no reachable routes from empty stop set', () => {
+      const fromStops = new Set<number>();
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+      assert.strictEqual(reachableRoutes.size, 0);
+      assert.deepStrictEqual(reachableRoutes, new Map());
+    });
+
+    it('should find no reachable routes from non-existent stops', () => {
+      const fromStops = new Set([999, 1000]); // Non-existent stops
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+      assert.strictEqual(reachableRoutes.size, 0);
+      assert.deepStrictEqual(reachableRoutes, new Map());
+    });
+
+    it('should filter routes by transport modes correctly', () => {
+      const fromStops = new Set([1]);
+
+      const railRoutes = sampleTimetable.findReachableRoutes(
+        fromStops,
+        new Set<RouteType>(['RAIL']),
+      );
+      assert.strictEqual(railRoutes.size, 2);
+      assert.deepStrictEqual(
+        railRoutes,
+        new Map([
+          [route1, 1],
+          [route2, 1],
+        ]),
+      );
+
+      const busRoutes = sampleTimetable.findReachableRoutes(
+        fromStops,
+        new Set<RouteType>(['BUS']),
+      );
+      assert.strictEqual(busRoutes.size, 0);
+      assert.deepStrictEqual(busRoutes, new Map());
+
+      const multiModeRoutes = sampleTimetable.findReachableRoutes(
+        fromStops,
+        new Set<RouteType>(['RAIL', 'BUS', 'SUBWAY']),
+      );
+      assert.strictEqual(multiModeRoutes.size, 2);
+    });
+
+    it('should return earliest hop-on stop when route is accessible from multiple stops', () => {
+      // Create scenario where same route is accessible from multiple stops in the query
+      // route1 has stops [1, 2] in that order, so we need to test with those actual stops
+      const fromStops = new Set([1, 2]); // Both stops are on route1
+      const reachableRoutes = sampleTimetable.findReachableRoutes(fromStops);
+
+      // route1 should use stop 1 (earlier on the route than stop 2)
+      // route2 should use stop 2 (earlier on route2 which has [2, 1])
+      assert.strictEqual(reachableRoutes.size, 2);
+      assert.deepStrictEqual(
+        reachableRoutes,
+        new Map([
+          [route1, 1], // Stop 1 comes before stop 2 on route1
+          [route2, 2], // Stop 2 comes before stop 1 on route2
+        ]),
+      );
+    });
+
+    describe('getContinuousTrips', () => {
+      it('should return empty array when stop has no trip continuations', () => {
+        const continuousTrips = sampleTimetable.getContinuousTrips(1, 0, 0);
+        assert.deepStrictEqual(continuousTrips, []);
+      });
+
+      it('should return empty array when stop has trip continuations but not for the specified trip', () => {
+        // Create a timetable with trip continuations that don't match the query
+        const stopsWithContinuations: StopAdjacency[] = [
+          { routes: [] },
+          {
+            routes: [0, 1],
+            tripContinuations: new Map([
+              [encode(0, 1), [{ hopOnStop: 2, routeId: 1, tripIndex: 0 }]], // Different trip index
+            ]),
+          },
+          { routes: [1] },
+        ];
+
+        const timetableWithContinuations = new Timetable(
+          stopsWithContinuations,
+          routesAdjacency,
+          routes,
+        );
+
+        const continuousTrips = timetableWithContinuations.getContinuousTrips(
+          1,
+          0,
+          0,
+        ); // Query trip index 0, but continuations are for trip index 1
+        assert.deepStrictEqual(continuousTrips, []);
+      });
+
+      it('should return trip continuations when they exist for the specified trip', () => {
+        const expectedContinuations: TripBoarding[] = [
+          { hopOnStop: 2, routeId: 1, tripIndex: 0 },
+          { hopOnStop: 2, routeId: 1, tripIndex: 1 },
+        ];
+
+        const stopsWithContinuations: StopAdjacency[] = [
+          { routes: [] },
+          {
+            routes: [0, 1],
+            tripContinuations: new Map([
+              [encode(0, 0), expectedContinuations], // Trip continuations for route 0, trip 0
+            ]),
+          },
+          { routes: [1] },
+        ];
+
+        const timetableWithContinuations = new Timetable(
+          stopsWithContinuations,
+          routesAdjacency,
+          routes,
+        );
+
+        const continuousTrips = timetableWithContinuations.getContinuousTrips(
+          1,
+          0,
+          0,
+        );
+        assert.deepStrictEqual(continuousTrips, expectedContinuations);
+      });
 
-  it('should find reachable routes filtered by transport modes', () => {
-    const fromStops = new Set([1]);
-    const reachableRoutes = sampleTimetable.findReachableRoutes(
-      fromStops,
-      new Set<RouteType>(['BUS']),
-    );
-    assert.strictEqual(reachableRoutes.size, 0);
+      it('should throw error when querying non-existent stop', () => {
+        assert.throws(
+          () => sampleTimetable.getContinuousTrips(999, 0, 0),
+          /Stop ID 999 not found/,
+        );
+      });
+    });
   });
 });

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

@@ -0,0 +1,27 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { RouteId, TripRouteIndex } from '../route.js';
+import { decode, encode } from '../tripId.js';
+
+describe('tripId', () => {
+  it('should maintain identity for encode/decode round-trip', () => {
+    const testCases: [RouteId, TripRouteIndex][] = [
+      [0, 0],
+      [1, 1],
+      [1000, 500],
+      [65535, 32767],
+      [131071, 0],
+      [0, 32767],
+      [(1 << 17) - 1, (1 << 15) - 1], // Maximum values
+    ];
+
+    testCases.forEach(([routeId, tripIndex]) => {
+      const tripId = encode(routeId, tripIndex);
+      const [decodedRouteId, decodedTripIndex] = decode(tripId);
+
+      assert.strictEqual(decodedRouteId, routeId);
+      assert.strictEqual(decodedTripIndex, tripIndex);
+    });
+  });
+});

package/src/timetable/io.ts

@@ -5,6 +5,7 @@ import {
   ServiceRoute as ProtoServiceRoute,
   StopAdjacency as ProtoStopAdjacency,
   TransferType as ProtoTransferType,
+  TripContinuationEntry as ProtoTripContinuationEntry,
 } from './proto/timetable.js';
 import { Route } from './route.js';
 import {
@@ -14,6 +15,7 @@ import {
   StopAdjacency,
   Transfer,
   TransferType,
+  TripBoarding,
 } from './timetable.js';
 
 export type SerializedRoute = {
@@ -125,14 +127,19 @@ export const serializeStopsAdjacency = (
 ): 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(),
-        }),
-      })),
+      transfers: value.transfers
+        ? value.transfers.map((transfer) => ({
+            destination: transfer.destination,
+            type: serializeTransferType(transfer.type),
+            ...(transfer.minTransferTime !== undefined && {
+              minTransferTime: transfer.minTransferTime.toSeconds(),
+            }),
+          }))
+        : [],
       routes: value.routes,
+      tripContinuations: value.tripContinuations
+        ? serializeTripContinuations(value.tripContinuations)
+        : [],
     };
   });
 };
@@ -190,10 +197,22 @@ export const deserializeStopsAdjacency = (
       transfers.push(newTransfer);
     }
 
-    result.push({
-      transfers: transfers,
+    const stopAdjacency: StopAdjacency = {
       routes: value.routes,
-    });
+    };
+
+    if (transfers.length > 0) {
+      stopAdjacency.transfers = transfers;
+    }
+
+    const deserializedTripContinuations = deserializeTripContinuations(
+      value.tripContinuations,
+    );
+    if (deserializedTripContinuations.size > 0) {
+      stopAdjacency.tripContinuations = deserializedTripContinuations;
+    }
+
+    result.push(stopAdjacency);
   }
 
   return result;
@@ -210,6 +229,7 @@ export const deserializeRoutesAdjacency = (
     const stops = bytesToUint32Array(value.stops);
     routesAdjacency.push(
       new Route(
+        i,
         bytesToUint16Array(value.stopTimes),
         value.pickUpDropOffTypes,
         stops,
@@ -319,3 +339,44 @@ const serializeRouteType = (type: RouteType): ProtoRouteType => {
       return ProtoRouteType.MONORAIL;
   }
 };
+
+export const serializeTripContinuations = (
+  tripContinuations: Map<number, TripBoarding[]>,
+): ProtoTripContinuationEntry[] => {
+  const result: ProtoTripContinuationEntry[] = [];
+
+  for (const [key, value] of tripContinuations.entries()) {
+    result.push({
+      key: key,
+      value: value.map((tripBoarding) => ({
+        hopOnStop: tripBoarding.hopOnStop,
+        routeId: tripBoarding.routeId,
+        tripIndex: tripBoarding.tripIndex,
+      })),
+    });
+  }
+
+  return result;
+};
+
+export const deserializeTripContinuations = (
+  protoTripContinuations: ProtoTripContinuationEntry[],
+): Map<number, TripBoarding[]> => {
+  const result = new Map<number, TripBoarding[]>();
+
+  for (let i = 0; i < protoTripContinuations.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const entry = protoTripContinuations[i]!;
+    const tripBoardings: TripBoarding[] = entry.value.map(
+      (protoTripBoarding) => ({
+        hopOnStop: protoTripBoarding.hopOnStop,
+        routeId: protoTripBoarding.routeId,
+        tripIndex: protoTripBoarding.tripIndex,
+      }),
+    );
+
+    result.set(entry.key, tripBoardings);
+  }
+
+  return result;
+};

package/src/timetable/proto/timetable.proto

@@ -40,9 +40,21 @@ message Transfer {
   optional uint32 minTransferTime = 3;
 }
 
+message TripBoarding {
+  uint32 hopOnStop = 1;
+  uint32 routeId = 2;
+  uint32 tripIndex = 3;
+}
+
+message TripContinuationEntry {
+  uint32 key = 1;
+  repeated TripBoarding value = 2;
+}
+
 message StopAdjacency {
-  repeated Transfer transfers = 1;
-  repeated uint32 routes = 2;
+  repeated uint32 routes = 1;
+  repeated Transfer transfers = 2;
+  repeated TripContinuationEntry tripContinuations = 3;
 }
 
 enum RouteType {