minotor 7.0.2 → 9.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([]),
@@ -88,34 +95,6 @@ describe('Route', () => {
     });
   });
 
-  describe('isBefore', () => {
-    it('should return true when stopA is before stopB', () => {
-      assert.strictEqual(route.isBefore(1001, 1002), true);
-    });
-
-    it('should return false when stopA is after stopB', () => {
-      assert.strictEqual(route.isBefore(1002, 1001), false);
-    });
-
-    it('should return false when stopA equals stopB', () => {
-      assert.strictEqual(route.isBefore(1001, 1001), false);
-    });
-
-    it('should throw error when stopA is not found', () => {
-      assert.throws(
-        () => route.isBefore(9999, 1002),
-        /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 0/,
-      );
-    });
-  });
-
   describe('getNbStops', () => {
     it('should return correct number of stops', () => {
       assert.strictEqual(route.getNbStops(), 2);
@@ -129,178 +108,192 @@ describe('Route', () => {
   });
 
   describe('arrivalAt', () => {
-    it('should return correct arrival time for trip 0 at stop 1001', () => {
-      const arrival = route.arrivalAt(1001, 0);
+    it('should return correct arrival time for trip 0 at stop index 0', () => {
+      const arrival = route.arrivalAt(0, 0);
       assert.strictEqual(
         arrival.toMinutes(),
         Time.fromHMS(8, 0, 0).toMinutes(),
       );
     });
 
-    it('should return correct arrival time for trip 1 at stop 1002', () => {
-      const arrival = route.arrivalAt(1002, 1);
+    it('should return correct arrival time for trip 1 at stop index 1', () => {
+      const arrival = route.arrivalAt(1, 1);
       assert.strictEqual(
         arrival.toMinutes(),
         Time.fromHMS(9, 30, 0).toMinutes(),
       );
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.arrivalAt(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.arrivalAt(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
-      assert.throws(
-        () => route.arrivalAt(1001, 999),
-        /Arrival time not found for stop 1001 at trip index 999/,
-      );
+      assert.throws(() => route.arrivalAt(0, 999), /Arrival time not found/);
     });
   });
 
   describe('departureFrom', () => {
-    it('should return correct departure time for trip 0 at stop 1001', () => {
-      const departure = route.departureFrom(1001, 0);
+    it('should return correct departure time for trip 0 at stop index 0', () => {
+      const departure = route.departureFrom(0, 0);
       assert.strictEqual(
         departure.toMinutes(),
         Time.fromHMS(8, 1, 0).toMinutes(),
       );
     });
 
-    it('should return correct departure time for trip 2 at stop 1002', () => {
-      const departure = route.departureFrom(1002, 2);
+    it('should return correct departure time for trip 2 at stop index 1', () => {
+      const departure = route.departureFrom(1, 2);
       assert.strictEqual(
         departure.toMinutes(),
         Time.fromHMS(10, 31, 0).toMinutes(),
       );
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.departureFrom(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.departureFrom(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.departureFrom(1001, 999),
-        /Departure time not found for stop 1001 at trip index 999/,
+        () => route.departureFrom(0, 999),
+        /Departure time not found/,
       );
     });
   });
 
   describe('pickUpTypeFrom', () => {
-    it('should return REGULAR pickup type for trip 0 at stop 1001', () => {
-      const pickUpType = route.pickUpTypeFrom(1001, 0);
+    it('should return REGULAR pickup type for trip 0 at stop index 0', () => {
+      const pickUpType = route.pickUpTypeFrom(0, 0);
       assert.strictEqual(pickUpType, 'REGULAR');
     });
 
-    it('should return NOT_AVAILABLE pickup type for trip 0 at stop 1002', () => {
-      const pickUpType = route.pickUpTypeFrom(1002, 0);
+    it('should return NOT_AVAILABLE pickup type for trip 0 at stop index 1', () => {
+      const pickUpType = route.pickUpTypeFrom(1, 0);
       assert.strictEqual(pickUpType, 'NOT_AVAILABLE');
     });
 
-    it('should return MUST_PHONE_AGENCY pickup type for trip 2 at stop 1001', () => {
-      const pickUpType = route.pickUpTypeFrom(1001, 2);
+    it('should return MUST_PHONE_AGENCY pickup type for trip 2 at stop index 0', () => {
+      const pickUpType = route.pickUpTypeFrom(0, 2);
       assert.strictEqual(pickUpType, 'MUST_PHONE_AGENCY');
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.pickUpTypeFrom(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.pickUpTypeFrom(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.pickUpTypeFrom(1001, 999),
-        /Pick up type not found for stop 1001 at trip index 999/,
+        () => route.pickUpTypeFrom(0, 999),
+        /Pick up type not found/,
       );
     });
   });
 
   describe('dropOffTypeAt', () => {
-    it('should return REGULAR drop off type for trip 0 at stop 1001', () => {
-      const dropOffType = route.dropOffTypeAt(1001, 0);
+    it('should return REGULAR drop off type for trip 0 at stop index 0', () => {
+      const dropOffType = route.dropOffTypeAt(0, 0);
       assert.strictEqual(dropOffType, 'REGULAR');
     });
 
-    it('should return REGULAR drop off type for trip 1 at stop 1002', () => {
-      const dropOffType = route.dropOffTypeAt(1002, 1);
+    it('should return REGULAR drop off type for trip 1 at stop index 1', () => {
+      const dropOffType = route.dropOffTypeAt(1, 1);
       assert.strictEqual(dropOffType, 'REGULAR');
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.dropOffTypeAt(9999, 0),
-        /Stop index for 9999 not found in route 0/,
+        () => route.dropOffTypeAt(999, 0),
+        /StopId for stop at index 999 not found/,
       );
     });
 
     it('should throw error for invalid trip index', () => {
       assert.throws(
-        () => route.dropOffTypeAt(1001, 999),
-        /Drop off type not found for stop 1001 at trip index 999/,
+        () => route.dropOffTypeAt(0, 999),
+        /Drop off type not found/,
       );
     });
   });
 
   describe('findEarliestTrip', () => {
     it('should find earliest trip without time constraint', () => {
-      const tripIndex = route.findEarliestTrip(1001);
+      const tripIndex = route.findEarliestTrip(0);
       assert.strictEqual(tripIndex, 0);
     });
 
     it('should find earliest trip after specified time', () => {
       const afterTime = Time.fromHMS(8, 30, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should find earliest trip with exact match time', () => {
       const afterTime = Time.fromHMS(9, 1, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should return undefined when no trip is available after specified time', () => {
       const afterTime = Time.fromHMS(23, 0, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should skip trips where pickup is not available', () => {
-      const tripIndex = route.findEarliestTrip(1002);
-      // Trip 0 has NOT_AVAILABLE pickup at stop 1002, so should return trip 1
+      const tripIndex = route.findEarliestTrip(1);
+      // Trip 0 has NOT_AVAILABLE pickup at stop index 1, so should return trip 1
       assert.strictEqual(tripIndex, 1);
     });
 
     it('should respect beforeTrip constraint', () => {
-      const tripIndex = route.findEarliestTrip(1001, Time.fromHMS(8, 2, 0), 1);
+      const tripIndex = route.findEarliestTrip(0, Time.fromHMS(8, 2, 0), 1);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should return undefined when beforeTrip is 0', () => {
-      const tripIndex = route.findEarliestTrip(1001, Time.origin(), 0);
+      const tripIndex = route.findEarliestTrip(0, Time.origin(), 0);
       assert.strictEqual(tripIndex, undefined);
     });
 
     it('should handle MUST_PHONE_AGENCY pickup type', () => {
       const afterTime = Time.fromHMS(9, 30, 0);
-      const tripIndex = route.findEarliestTrip(1001, afterTime);
+      const tripIndex = route.findEarliestTrip(0, afterTime);
       // Should find trip 2 even though it requires phone agency
       assert.strictEqual(tripIndex, 2);
     });
 
-    it('should throw error for invalid stop ID', () => {
+    it('should throw error for invalid stop index', () => {
       assert.throws(
-        () => route.findEarliestTrip(9999),
-        /Stop index for 9999 not found in route 0/,
+        () => route.findEarliestTrip(999),
+        /StopId for stop at index 999 not found/,
       );
     });
   });
+
+  describe('stopRouteIndices', () => {
+    it('should return correct stop route indices for existing stop', () => {
+      const indices = route.stopRouteIndices(1001);
+      assert.deepStrictEqual(indices, [0]);
+    });
+
+    it('should return correct stop route indices for second stop', () => {
+      const indices = route.stopRouteIndices(1002);
+      assert.deepStrictEqual(indices, [1]);
+    });
+
+    it('should return empty array for non-existent stop', () => {
+      const indices = route.stopRouteIndices(9999);
+      assert.deepStrictEqual(indices, []);
+    });
+  });
 });

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 '../tripBoardingId.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] },
@@ -74,6 +100,7 @@ describe('Timetable', () => {
     stopsAdjacency,
     routesAdjacency,
     routes,
+    new Map(),
   );
 
   it('should serialize a timetable to a Uint8Array', () => {
@@ -90,7 +117,7 @@ describe('Timetable', () => {
   it('should find the earliest trip for stop1 on route1', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
-    const tripIndex = route.findEarliestTrip(1);
+    const tripIndex = route.findEarliestTrip(0);
     assert.strictEqual(tripIndex, 0);
   });
 
@@ -98,7 +125,7 @@ describe('Timetable', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
     const afterTime = Time.fromHMS(17, 0, 0);
-    const tripIndex = route.findEarliestTrip(1, afterTime);
+    const tripIndex = route.findEarliestTrip(0, afterTime);
     assert.strictEqual(tripIndex, 1);
   });
 
@@ -106,40 +133,184 @@ describe('Timetable', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute(0)!;
     const afterTime = Time.fromHMS(23, 40, 0);
-    const tripIndex = route.findEarliestTrip(1, afterTime);
+    const tripIndex = route.findEarliestTrip(0, afterTime);
     assert.strictEqual(tripIndex, undefined);
   });
   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(0)!;
-    const tripIndex = route.findEarliestTrip(2);
+    const tripIndex = route.findEarliestTrip(1);
     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, 0],
+          [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, 0],
+          [route2, 0],
+        ]),
+      );
+    });
+
+    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, 0],
+          [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 index 0 (stop 1 comes before stop 2 on route1)
+      // route2 should use stop index 0 (stop 2 comes before stop 1 on route2)
+      assert.strictEqual(reachableRoutes.size, 2);
+      assert.deepStrictEqual(
+        reachableRoutes,
+        new Map([
+          [route1, 0], // Stop index 0 (stop 1) comes before stop index 1 (stop 2) on route1
+          [route2, 0], // Stop index 0 (stop 2) comes before stop index 1 (stop 1) on route2
+        ]),
+      );
+    });
+
+    describe('getContinuousTrips', () => {
+      it('should return empty array when stop has no trip continuations', () => {
+        const continuousTrips = sampleTimetable.getContinuousTrips(0, 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 tripContinuationsMap = new Map([
+          [encode(0, 0, 1), [{ hopOnStopIndex: 0, routeId: 1, tripIndex: 0 }]], // Different trip index
+        ]);
+
+        const stopsWithContinuations: StopAdjacency[] = [
+          { routes: [] },
+          {
+            routes: [0, 1],
+          },
+          { routes: [1] },
+        ];
+
+        const timetableWithContinuations = new Timetable(
+          stopsWithContinuations,
+          routesAdjacency,
+          routes,
+          tripContinuationsMap,
+        );
+
+        const continuousTrips = timetableWithContinuations.getContinuousTrips(
+          0,
+          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[] = [
+          { hopOnStopIndex: 0, routeId: 1, tripIndex: 0 },
+          { hopOnStopIndex: 0, routeId: 1, tripIndex: 1 },
+        ];
+
+        const tripContinuationsMap = new Map([
+          [encode(0, 0, 0), expectedContinuations],
+        ]);
+
+        const stopsWithContinuations: StopAdjacency[] = [
+          { routes: [] },
+          {
+            routes: [0, 1],
+          },
+          { routes: [1] },
+        ];
+
+        const timetableWithContinuations = new Timetable(
+          stopsWithContinuations,
+          routesAdjacency,
+          routes,
+          tripContinuationsMap,
+        );
+
+        const continuousTrips = timetableWithContinuations.getContinuousTrips(
+          0,
+          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 return empty array when querying with non-matching parameters', () => {
+        const continuousTrips = sampleTimetable.getContinuousTrips(999, 0, 0);
+        assert.deepStrictEqual(continuousTrips, []);
+      });
+    });
   });
 });