minotor 5.0.1 → 7.0.0

package/src/timetable/route.ts

@@ -81,7 +81,7 @@ export class Route {
    * A binary array of stopIds in the route.
    * [stop1, stop2, stop3,...]
    */
-  private readonly stops: Uint32Array;
+  public readonly stops: Uint32Array;
   /**
    * A reverse mapping of each stop with their index in the route:
    * {
@@ -269,36 +269,6 @@ export class Route {
     return toPickupDropOffType(dropOffValue);
   }
 
-  /**
-   * Iterates over the stops in the route, starting from an optional specified stop.
-   * If no start stop is provided, the iteration begins from the first stop in the route.
-   *
-   * @param [startStopId] - (Optional) The StopId of the stop to start the iteration from.
-   * @returns An IterableIterator of StopIds, starting from the specified stop or the first stop.
-   * @throws An error if the specified start stop is not found in the route.
-   */
-  stopsIterator(startStopId?: StopId): IterableIterator<StopId> {
-    const startIndex =
-      startStopId !== undefined ? this.stopIndices.get(startStopId) : 0;
-    if (startIndex === undefined) {
-      throw new Error(
-        `Start stop ${startStopId} not found in route ${this.serviceRouteId}`,
-      );
-    }
-
-    function* generator(
-      stops: Uint32Array,
-      startIndex: number,
-    ): IterableIterator<StopId> {
-      for (let i = startIndex; i < stops.length; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        yield stops[i]!;
-      }
-    }
-
-    return generator(this.stops, startIndex);
-  }
-
   /**
    * Finds the earliest trip that can be taken from a specific stop on a given route,
    * optionally constrained by a latest trip index and a time before which the trip
@@ -349,7 +319,7 @@ export class Route {
    * @param stopId The StopId of the stop to locate in the route.
    * @returns The index of the stop in the route.
    */
-  private stopIndex(stopId: StopId): number {
+  public stopIndex(stopId: StopId): number {
     const stopIndex = this.stopIndices.get(stopId);
     if (stopIndex === undefined) {
       throw new Error(

package/src/timetable/timetable.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
 
 import { StopId } from '../stops/stops.js';
@@ -25,15 +26,12 @@ export type Transfer = {
   minTransferTime?: Duration;
 };
 
-export type StopsAdjacency = Map<
-  StopId,
-  {
-    transfers: Transfer[];
-    routes: RouteId[];
-  }
->;
+export type StopAdjacency = {
+  transfers: Transfer[];
+  routes: RouteId[];
+};
 
-export type ServiceRouteId = string;
+export type ServiceRouteId = number;
 
 export type RouteType =
   | 'TRAM'
@@ -47,18 +45,16 @@ export type RouteType =
   | 'TROLLEYBUS'
   | 'MONORAIL';
 
-type ServiceRoute = {
+// A service refers to a collection of trips that are displayed to riders as a single service.
+// As opposed to a route which consists of the subset of trips from a service which shares the same list of stops.
+// Service is here a synonym for route in the GTFS sense.
+export type ServiceRoute = {
   type: RouteType;
   name: string;
   routes: RouteId[];
 };
 export type ServiceRouteInfo = Omit<ServiceRoute, 'routes'>;
 
-// A service refers to a collection of trips that are displayed to riders as a single service.
-// As opposed to a route which consists of the subset of trips from a service which shares the same list of stops.
-// Service is here a synonym for route in the GTFS sense.
-export type ServiceRoutesMap = Map<ServiceRouteId, ServiceRoute>;
-
 export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set([
   'TRAM',
   'SUBWAY',
@@ -72,24 +68,33 @@ export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set([
   'MONORAIL',
 ]);
 
-export const CURRENT_VERSION = '0.0.5';
+export const CURRENT_VERSION = '0.0.7';
 
 /**
  * The internal transit timetable format.
  */
 export class Timetable {
-  private readonly stopsAdjacency: StopsAdjacency;
+  private readonly stopsAdjacency: StopAdjacency[];
   private readonly routesAdjacency: Route[];
-  private readonly routes: ServiceRoutesMap;
+  private readonly serviceRoutes: ServiceRoute[];
+  private readonly activeStops: Set<StopId>;
 
   constructor(
-    stopsAdjacency: StopsAdjacency,
+    stopsAdjacency: StopAdjacency[],
     routesAdjacency: Route[],
-    routes: ServiceRoutesMap,
+    routes: ServiceRoute[],
   ) {
     this.stopsAdjacency = stopsAdjacency;
     this.routesAdjacency = routesAdjacency;
-    this.routes = routes;
+    this.serviceRoutes = routes;
+    this.activeStops = new Set<StopId>();
+    for (let i = 0; i < stopsAdjacency.length; i++) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const stop = stopsAdjacency[i]!;
+      if (stop.routes.length > 0 || stop.transfers.length > 0) {
+        this.activeStops.add(i);
+      }
+    }
   }
 
   /**
@@ -102,7 +107,7 @@ export class Timetable {
       version: CURRENT_VERSION,
       stopsAdjacency: serializeStopsAdjacency(this.stopsAdjacency),
       routesAdjacency: serializeRoutesAdjacency(this.routesAdjacency),
-      routes: serializeServiceRoutesMap(this.routes),
+      serviceRoutes: serializeServiceRoutesMap(this.serviceRoutes),
     };
     const writer = new BinaryWriter();
     ProtoTimetable.encode(protoTimetable, writer);
@@ -124,14 +129,25 @@ export class Timetable {
       );
     }
     return new Timetable(
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      deserializeStopsAdjacency(protoTimetable.stopsAdjacency!),
+      deserializeStopsAdjacency(protoTimetable.stopsAdjacency),
       deserializeRoutesAdjacency(protoTimetable.routesAdjacency),
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      deserializeServiceRoutesMap(protoTimetable.routes!),
+
+      deserializeServiceRoutesMap(protoTimetable.serviceRoutes),
     );
   }
 
+  /**
+   * Checks if the given stop is active on the timetable.
+   * An active stop is a stop reached by a route that is active on the timetable
+   * or by a transfer reachable from an active route.
+   *
+   * @param stopId - The ID of the stop to check.
+   * @returns True if the stop is active, false otherwise.
+   */
+  isActive(stopId: StopId): boolean {
+    return this.activeStops.has(stopId);
+  }
+
   /**
    * Retrieves the route associated with the given route ID.
    *
@@ -150,7 +166,7 @@ export class Timetable {
    * @returns An array of transfer options available at the stop.
    */
   getTransfers(stopId: StopId): Transfer[] {
-    return this.stopsAdjacency.get(stopId)?.transfers ?? [];
+    return this.stopsAdjacency[stopId]?.transfers ?? [];
   }
 
   /**
@@ -162,7 +178,7 @@ export class Timetable {
    * @returns The service route corresponding to the provided route.
    */
   getServiceRouteInfo(route: Route): ServiceRouteInfo {
-    const serviceRoute = this.routes.get(route.serviceRoute());
+    const serviceRoute = this.serviceRoutes[route.serviceRoute()];
     if (!serviceRoute) {
       throw new Error(
         `Service route not found for route ID: ${route.serviceRoute()}`,
@@ -180,12 +196,13 @@ export class Timetable {
    * @returns An array of routes passing through the specified stop.
    */
   routesPassingThrough(stopId: StopId): Route[] {
-    const stopData = this.stopsAdjacency.get(stopId);
+    const stopData = this.stopsAdjacency[stopId];
     if (!stopData) {
       return [];
     }
     const routes: Route[] = [];
-    for (const routeId of stopData.routes) {
+    for (let i = 0; i < stopData.routes.length; i++) {
+      const routeId = stopData.routes[i]!;
       const route = this.routesAdjacency[routeId];
       if (route) {
         routes.push(route);
@@ -208,14 +225,17 @@ export class Timetable {
     transportModes: Set<RouteType> = ALL_TRANSPORT_MODES,
   ): Map<Route, StopId> {
     const reachableRoutes = new Map<Route, StopId>();
-    for (const originStop of fromStops) {
+    const fromStopsArray = Array.from(fromStops);
+    for (let i = 0; i < fromStopsArray.length; i++) {
+      const originStop = fromStopsArray[i]!;
       const validRoutes = this.routesPassingThrough(originStop).filter(
         (route) => {
           const serviceRoute = this.getServiceRouteInfo(route);
           return transportModes.has(serviceRoute.type);
         },
       );
-      for (const route of validRoutes) {
+      for (let j = 0; j < validRoutes.length; j++) {
+        const route = validRoutes[j]!;
         const hopOnStop = reachableRoutes.get(route);
         if (hopOnStop) {
           if (route.isBefore(originStop, hopOnStop)) {