minotor 7.0.2 → 8.0.0

package/dist/routing/__tests__/plotter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/plotter.d.ts

@@ -1,11 +1,50 @@
 import { Result } from './result.js';
 export declare class Plotter {
     private result;
+    private readonly ROUND_COLORS;
     constructor(result: Result);
     /**
-     * Plots the path three as a DOT for debugging purposes.
-     *
-     * @returns A string representing the DOT graph of the path tree.
+     * Gets the color for a round based on the specified palette.
+     */
+    private getRoundColor;
+    /**
+     * Escapes special characters in DOT strings to prevent syntax errors.
+     */
+    private escapeDotString;
+    /**
+     * Determines station type (origin/destination) information.
+     */
+    private getStationInfo;
+    /**
+     * Formats a stop name for display, including platform information.
+     */
+    private formatStopName;
+    /**
+     * Gets the appropriate fill color for a station based on its type.
+     */
+    private getStationFillColor;
+    /**
+     * Creates a DOT node for a station.
+     */
+    private createStationNode;
+    /**
+     * Creates a vehicle edge with route information oval in the middle.
+     */
+    private createVehicleEdge;
+    /**
+     * Creates a transfer edge with transfer information oval in the middle.
+     */
+    private createTransferEdge;
+    /**
+     * Creates a continuation edge to visually link trip continuations.
+     */
+    private createContinuationEdge;
+    /**
+     * Collects all stations and edges for the graph.
+     */
+    private collectGraphData;
+    /**
+     * Plots the routing graph as a DOT graph for visualization.
      */
     plotDotGraph(): string;
 }

package/dist/routing/result.d.ts

@@ -1,14 +1,15 @@
-import { SourceStopId, StopId } from '../stops/stops.js';
+import { Timetable } from '../router.js';
+import { SourceStopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
 import { Query } from './query.js';
 import { Route } from './route.js';
-import { ReachingTime, TripLeg } from './router.js';
+import { Arrival, RoutingState } from './router.js';
 export declare class Result {
     private readonly query;
-    readonly earliestArrivals: Map<StopId, ReachingTime>;
-    readonly earliestArrivalsPerRound: Map<StopId, TripLeg>[];
-    private readonly stopsIndex;
-    constructor(query: Query, earliestArrivals: Map<StopId, ReachingTime>, earliestArrivalsPerRound: Map<StopId, TripLeg>[], stopsIndex: StopsIndex);
+    readonly routingState: RoutingState;
+    readonly stopsIndex: StopsIndex;
+    readonly timetable: Timetable;
+    constructor(query: Query, routingState: RoutingState, stopsIndex: StopsIndex, timetable: Timetable);
     /**
      * Reconstructs the best route to a stop.
      * (to any stop reachable in less time / transfers than the destination(s) of the query)
@@ -17,6 +18,21 @@ export declare class Result {
      * @returns a route to the destination stop if it exists.
      */
     bestRoute(to?: SourceStopId | Set<SourceStopId>): Route | undefined;
+    /**
+     * Builds a vehicle leg from a chain of vehicle edges.
+     *
+     * @param edges Array of vehicle edges representing continuous trips on transit vehicles
+     * @returns A vehicle leg with departure/arrival information and route details
+     * @throws Error if the edges array is empty
+     */
+    private buildVehicleLeg;
+    /**
+     * Builds a transfer leg from a transfer edge.
+     *
+     * @param edge Transfer edge representing a walking connection between stops
+     * @returns A transfer leg with from/to stops and transfer details
+     */
+    private buildTransferLeg;
     /**
      * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
      *
@@ -24,5 +40,5 @@ export declare class Result {
      * @param maxTransfers The optional maximum number of transfers allowed.
      * @returns The arrival time if the target stop is reachable, otherwise undefined.
      */
-    arrivalAt(stop: SourceStopId, maxTransfers?: number): ReachingTime | undefined;
+    arrivalAt(stop: SourceStopId, maxTransfers?: number): Arrival | undefined;
 }

package/dist/routing/route.d.ts

@@ -26,6 +26,8 @@ export type VehicleLeg = BaseLeg & {
     route: ServiceRouteInfo;
     departureTime: Time;
     arrivalTime: Time;
+    pickUpType: PickUpDropOffType;
+    dropOffType: PickUpDropOffType;
 };
 export type Leg = Transfer | VehicleLeg;
 /**

package/dist/routing/router.d.ts

@@ -1,22 +1,43 @@
 import { StopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
+import { Duration } from '../timetable/duration.js';
+import { RouteId, TripRouteIndex } from '../timetable/route.js';
 import { Time } from '../timetable/time.js';
-import { Timetable } from '../timetable/timetable.js';
+import { Timetable, TransferType } from '../timetable/timetable.js';
 import { Query } from './query.js';
 import { Result } from './result.js';
-import { Leg } from './route.js';
-export type TripLeg = ReachingTime & {
-    leg?: Leg;
+export type OriginNode = {
+    arrival: Time;
+};
+export type VehicleEdge = {
+    arrival: Time;
+    from: StopId;
+    to: StopId;
+    routeId: RouteId;
+    tripIndex: TripRouteIndex;
+    continuationOf?: VehicleEdge;
+};
+export type TransferEdge = {
+    arrival: Time;
+    from: StopId;
+    to: StopId;
+    type: TransferType;
+    minTransferTime?: Duration;
 };
-export type ReachingTime = {
+export type RoutingEdge = OriginNode | VehicleEdge | TransferEdge;
+export type Arrival = {
     arrival: Time;
     legNumber: number;
-    origin: StopId;
+};
+export type RoutingState = {
+    earliestArrivals: Map<StopId, Arrival>;
+    graph: Map<StopId, RoutingEdge>[];
+    destinations: StopId[];
 };
 /**
- * A public transportation network router implementing the RAPTOR algorithm for
- * efficient journey planning and routing. For more information on the RAPTOR
- * algorithm, refer to its detailed explanation in the research paper:
+ * A public transportation router implementing the RAPTOR algorithm.
+ * For more information on the RAPTOR algorithm,
+ * refer to its detailed explanation in the research paper:
  * https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
  */
 export declare class Router {
@@ -24,9 +45,54 @@ export declare class Router {
     private readonly stopsIndex;
     constructor(timetable: Timetable, stopsIndex: StopsIndex);
     /**
-     * Evaluates possible transfers for a given query on a transport
-     * network, updating the earliest arrivals at various stops and marking new
-     * stops that can be reached through these transfers.
+     * The main Raptor algorithm implementation.
+     *
+     * @param query The query containing the main parameters for the routing.
+     * @returns A result object containing data structures allowing to reconstruct routes and .
+     */
+    route(query: Query): Result;
+    /**
+     * Finds trip continuations for the given marked stops and edges at the current round.
+     * @param markedStops The set of marked stops.
+     * @param edgesAtCurrentRound The map of edges at the current round.
+     * @returns An array of trip continuations.
+     */
+    private findTripContinuations;
+    /**
+     * Initializes the routing state for the RAPTOR algorithm.
+     *
+     * This method sets up the initial data structures needed for route planning,
+     * including origin and destination stops (considering equivalent stops),
+     * earliest arrival times, and marked stops for processing.
+     *
+     * @param query The routing query containing origin, destination, and departure time
+     * @returns The initialized routing state with all necessary data structures
+     */
+    private initRoutingState;
+    /**
+     * Scans a route to find the earliest possible trips (if not provided) and updates arrival times.
+     *
+     * This method implements the core route scanning logic of the RAPTOR algorithm.
+     * It iterates through all stops on a given route starting from the hop-on stop,
+     * maintaining the current best trip and updating arrival times when improvements
+     * are found. The method also handles boarding new trips when earlier departures
+     * are available if no given trip is provided as a parameter.
+     *
+     * @param route The route to scan for possible trips
+     * @param hopOnStop The stop ID where passengers can board the route
+     * @param round The current round number in the RAPTOR algorithm
+     * @param routingState The current routing state containing arrival times and marked stops
+     */
+    private scanRoute;
+    /**
+     * Processes all currently marked stops to find available transfers
+     * and determines if using these transfers would result in earlier arrival times
+     * at destination stops. It handles different transfer types including in-seat
+     * transfers and walking transfers with appropriate minimum transfer times.
+     *
+     * @param query The routing query containing transfer options and constraints
+     * @param round The current round number in the RAPTOR algorithm
+     * @param routingState The current routing state containing arrival times and marked stops
      */
     private considerTransfers;
     /**
@@ -37,11 +103,4 @@ export declare class Router {
      * @returns The earliest arrival time among the provided destinations.
      */
     private earliestArrivalAtAnyStop;
-    /**
-     * The main Raptor algorithm implementation.
-     *
-     * @param query The query containing the main parameters for the routing.
-     * @returns A result object containing data structures allowing to reconstruct routes and .
-     */
-    route(query: Query): Result;
 }

package/dist/timetable/__tests__/tripId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/timetable/io.d.ts

@@ -1,6 +1,6 @@
-import { Route as ProtoRoute, ServiceRoute as ProtoServiceRoute, StopAdjacency as ProtoStopAdjacency } from './proto/timetable.js';
+import { Route as ProtoRoute, ServiceRoute as ProtoServiceRoute, StopAdjacency as ProtoStopAdjacency, TripContinuationEntry as ProtoTripContinuationEntry } from './proto/timetable.js';
 import { Route } from './route.js';
-import { ServiceRoute, ServiceRouteId, StopAdjacency } from './timetable.js';
+import { ServiceRoute, ServiceRouteId, StopAdjacency, TripBoarding } from './timetable.js';
 export type SerializedRoute = {
     stopTimes: Uint16Array;
     pickUpDropOffTypes: Uint8Array;
@@ -13,3 +13,5 @@ export declare const serializeServiceRoutesMap: (serviceRoutes: ServiceRoute[])
 export declare const deserializeStopsAdjacency: (protoStopsAdjacency: ProtoStopAdjacency[]) => StopAdjacency[];
 export declare const deserializeRoutesAdjacency: (protoRoutesAdjacency: ProtoRoute[]) => Route[];
 export declare const deserializeServiceRoutesMap: (protoServiceRoutes: ProtoServiceRoute[]) => ServiceRoute[];
+export declare const serializeTripContinuations: (tripContinuations: Map<number, TripBoarding[]>) => ProtoTripContinuationEntry[];
+export declare const deserializeTripContinuations: (protoTripContinuations: ProtoTripContinuationEntry[]) => Map<number, TripBoarding[]>;

package/dist/timetable/proto/timetable.d.ts

@@ -53,9 +53,19 @@ export interface Transfer {
     type: TransferType;
     minTransferTime?: number | undefined;
 }
+export interface TripBoarding {
+    hopOnStop: number;
+    routeId: number;
+    tripIndex: number;
+}
+export interface TripContinuationEntry {
+    key: number;
+    value: TripBoarding[];
+}
 export interface StopAdjacency {
-    transfers: Transfer[];
     routes: number[];
+    transfers: Transfer[];
+    tripContinuations: TripContinuationEntry[];
 }
 export interface ServiceRoute {
     type: RouteType;
@@ -70,6 +80,8 @@ export interface Timetable {
 }
 export declare const Route: MessageFns<Route>;
 export declare const Transfer: MessageFns<Transfer>;
+export declare const TripBoarding: MessageFns<TripBoarding>;
+export declare const TripContinuationEntry: MessageFns<TripContinuationEntry>;
 export declare const StopAdjacency: MessageFns<StopAdjacency>;
 export declare const ServiceRoute: MessageFns<ServiceRoute>;
 export declare const Timetable: MessageFns<Timetable>;

package/dist/timetable/route.d.ts

@@ -17,11 +17,13 @@ export declare const REGULAR = 0;
 export declare const NOT_AVAILABLE = 1;
 export declare const MUST_PHONE_AGENCY = 2;
 export declare const MUST_COORDINATE_WITH_DRIVER = 3;
-export type TripIndex = number;
+export type TripRouteIndex = number;
+export type StopRouteIndex = number;
 /**
  * A route identifies all trips of a given service route sharing the same list of stops.
  */
 export declare class Route {
+    readonly id: RouteId;
     /**
      * Arrivals and departures encoded as minutes from midnight.
      * Format: [arrival1, departure1, arrival2, departure2, etc.]
@@ -66,7 +68,26 @@ export declare class Route {
      * The total number of trips in the route.
      */
     private readonly nbTrips;
-    constructor(stopTimes: Uint16Array, pickUpDropOffTypes: Uint8Array, stops: Uint32Array, serviceRouteId: ServiceRouteId);
+    constructor(id: RouteId, stopTimes: Uint16Array, pickUpDropOffTypes: Uint8Array, stops: Uint32Array, serviceRouteId: ServiceRouteId);
+    /**
+     * Creates a new route from multiple trips with their stops.
+     *
+     * @param params The route parameters including ID, service route ID, and trips.
+     * @returns The new route.
+     */
+    static of(params: {
+        id: RouteId;
+        serviceRouteId: ServiceRouteId;
+        trips: Array<{
+            stops: Array<{
+                id: StopId;
+                arrivalTime: Time;
+                departureTime: Time;
+                dropOffType?: number;
+                pickUpType?: number;
+            }>;
+        }>;
+    }): Route;
     /**
      * Serializes the Route into binary arrays.
      *
@@ -87,6 +108,12 @@ export declare class Route {
      * @returns The total number of stops in the route.
      */
     getNbStops(): number;
+    /**
+     * Retrieves the number of trips in the route.
+     *
+     * @returns The total number of trips in the route.
+     */
+    getNbTrips(): number;
     /**
      * Finds the ServiceRouteId of the route. It corresponds the identifier
      * of the service shown to the end user as a route.
@@ -101,7 +128,7 @@ export declare class Route {
      * @param tripIndex - The index of the trip.
      * @returns The arrival time at the specified stop and trip as a Time object.
      */
-    arrivalAt(stopId: StopId, tripIndex: TripIndex): Time;
+    arrivalAt(stopId: StopId, tripIndex: TripRouteIndex): Time;
     /**
      * Retrieves the departure time at a specific stop for a given trip.
      *
@@ -109,7 +136,7 @@ export declare class Route {
      * @param tripIndex - The index of the trip.
      * @returns The departure time at the specified stop and trip as a Time object.
      */
-    departureFrom(stopId: StopId, tripIndex: TripIndex): Time;
+    departureFrom(stopId: StopId, tripIndex: TripRouteIndex): Time;
     /**
      * Retrieves the pick-up type for a specific stop and trip.
      *
@@ -117,7 +144,7 @@ export declare class Route {
      * @param tripIndex - The index of the trip.
      * @returns The pick-up type at the specified stop and trip.
      */
-    pickUpTypeFrom(stopId: StopId, tripIndex: TripIndex): PickUpDropOffType;
+    pickUpTypeFrom(stopId: StopId, tripIndex: TripRouteIndex): PickUpDropOffType;
     /**
      * Retrieves the drop-off type for a specific stop and trip.
      *
@@ -125,7 +152,7 @@ export declare class Route {
      * @param tripIndex - The index of the trip.
      * @returns The drop-off type at the specified stop and trip.
      */
-    dropOffTypeAt(stopId: StopId, tripIndex: TripIndex): PickUpDropOffType;
+    dropOffTypeAt(stopId: StopId, tripIndex: TripRouteIndex): PickUpDropOffType;
     /**
      * 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
@@ -138,11 +165,17 @@ export declare class Route {
      *                                   If not provided, searches all available trips.
      * @returns The index of the earliest trip meeting the criteria, or undefined if no such trip is found.
      */
-    findEarliestTrip(stopId: StopId, after?: Time, beforeTrip?: TripIndex): TripIndex | undefined;
+    findEarliestTrip(stopId: StopId, after?: Time, beforeTrip?: TripRouteIndex): TripRouteIndex | undefined;
     /**
      * Retrieves the index of a stop within the route.
      * @param stopId The StopId of the stop to locate in the route.
      * @returns The index of the stop in the route.
      */
-    stopIndex(stopId: StopId): number;
+    stopRouteIndex(stopId: StopId): StopRouteIndex;
+    /**
+     * Retrieves the id of a stop at a given index in a route.
+     * @param stopRouteIndex The route index of the stop.
+     * @returns The id of the stop at the given index in the route.
+     */
+    stopId(stopRouteIndex: StopRouteIndex): StopId;
 }

package/dist/timetable/timetable.d.ts

@@ -1,14 +1,21 @@
 import { StopId } from '../stops/stops.js';
 import { Duration } from './duration.js';
-import { Route, RouteId } from './route.js';
+import { Route, RouteId, TripRouteIndex } from './route.js';
+import { TripId } from './tripId.js';
 export type TransferType = 'RECOMMENDED' | 'GUARANTEED' | 'REQUIRES_MINIMAL_TIME' | 'IN_SEAT';
 export type Transfer = {
     destination: StopId;
     type: TransferType;
     minTransferTime?: Duration;
 };
+export type TripBoarding = {
+    hopOnStop: StopId;
+    routeId: RouteId;
+    tripIndex: TripRouteIndex;
+};
 export type StopAdjacency = {
-    transfers: Transfer[];
+    transfers?: Transfer[];
+    tripContinuations?: Map<TripId, TripBoarding[]>;
     routes: RouteId[];
 };
 export type ServiceRouteId = number;
@@ -20,7 +27,7 @@ export type ServiceRoute = {
 };
 export type ServiceRouteInfo = Omit<ServiceRoute, 'routes'>;
 export declare const ALL_TRANSPORT_MODES: Set<RouteType>;
-export declare const CURRENT_VERSION = "0.0.7";
+export declare const CURRENT_VERSION = "0.0.8";
 /**
  * The internal transit timetable format.
  */
@@ -67,6 +74,14 @@ export declare class Timetable {
      * @returns An array of transfer options available at the stop.
      */
     getTransfers(stopId: StopId): Transfer[];
+    /**
+     * Retrieves all trip continuation options available at the specified stop for a given trip.
+     *
+     * @param stopId - The ID of the stop to get trip continuations for.
+     * @param tripIndex - The index of the trip to get continuations for.
+     * @returns An array of trip continuation options available at the stop for the specified trip.
+     */
+    getContinuousTrips(stopId: StopId, routeId: RouteId, tripIndex: TripRouteIndex): TripBoarding[];
     /**
      * Retrieves the service route associated with the given route.
      * A service route refers to a collection of trips that are displayed

package/dist/timetable/tripId.d.ts

@@ -0,0 +1,15 @@
+import { RouteId, TripRouteIndex } from './route.js';
+export type TripId = number;
+/**
+ * Encodes a route ID and trip index into a single trip ID.
+ * @param routeId - The route identifier, needs to fit on 17 bits
+ * @param tripIndex - The index of the trip within the route, needs to fit on 15 bits
+ * @returns The encoded trip ID
+ */
+export declare const encode: (routeId: RouteId, tripIndex: TripRouteIndex) => TripId;
+/**
+ * Decodes a trip ID back into its constituent route ID and trip index.
+ * @param tripId - The encoded trip ID
+ * @returns A tuple containing the route ID and trip index
+ */
+export declare const decode: (tripId: TripId) => [RouteId, TripRouteIndex];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minotor",
-  "version": "7.0.2",
+  "version": "8.0.0",
   "description": "A lightweight client-side transit routing library.",
   "keywords": [
     "minotor",