minotor 11.2.3 → 11.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (70) hide show
  1. package/CHANGELOG.md +3 -3
  2. package/README.md +27 -0
  3. package/dist/cli.mjs +300 -98
  4. package/dist/cli.mjs.map +1 -1
  5. package/dist/gtfs/parser.d.ts +3 -1
  6. package/dist/gtfs/routes.d.ts +1 -2
  7. package/dist/gtfs/trips.d.ts +2 -1
  8. package/dist/parser.cjs.js +225 -81
  9. package/dist/parser.cjs.js.map +1 -1
  10. package/dist/parser.d.ts +6 -2
  11. package/dist/parser.esm.js +224 -82
  12. package/dist/parser.esm.js.map +1 -1
  13. package/dist/router.cjs.js +1 -1
  14. package/dist/router.cjs.js.map +1 -1
  15. package/dist/router.d.ts +4 -3
  16. package/dist/router.esm.js +1 -1
  17. package/dist/router.esm.js.map +1 -1
  18. package/dist/router.umd.js +1 -1
  19. package/dist/router.umd.js.map +1 -1
  20. package/dist/routing/result.d.ts +1 -4
  21. package/dist/routing/route.d.ts +9 -5
  22. package/dist/timetable/route.d.ts +9 -5
  23. package/dist/timetable/timetable.d.ts +24 -3
  24. package/dist/transfers/__tests__/straightLineTransferGenerator.test.d.ts +1 -0
  25. package/dist/transfers/generator.d.ts +40 -0
  26. package/dist/transfers/straightLineTransferGenerator.d.ts +58 -0
  27. package/dist/utils/map.d.ts +10 -0
  28. package/package.json +1 -1
  29. package/src/__e2e__/router.test.ts +6 -2
  30. package/src/cli/minotor.ts +21 -1
  31. package/src/cli/repl.ts +6 -12
  32. package/src/gtfs/__tests__/parser.test.ts +29 -1
  33. package/src/gtfs/__tests__/routes.test.ts +4 -3
  34. package/src/gtfs/__tests__/transfers.test.ts +8 -8
  35. package/src/gtfs/__tests__/trips.test.ts +60 -24
  36. package/src/gtfs/parser.ts +50 -1
  37. package/src/gtfs/profiles/__tests__/extended.test.ts +2 -1
  38. package/src/gtfs/profiles/extended.ts +14 -14
  39. package/src/gtfs/profiles/standard.ts +11 -10
  40. package/src/gtfs/routes.ts +5 -2
  41. package/src/gtfs/transfers.ts +6 -5
  42. package/src/gtfs/trips.ts +7 -14
  43. package/src/parser.ts +20 -2
  44. package/src/router.ts +12 -6
  45. package/src/routing/__tests__/access.test.ts +14 -6
  46. package/src/routing/__tests__/plainRouter.test.ts +25 -23
  47. package/src/routing/__tests__/plotter.test.ts +8 -3
  48. package/src/routing/__tests__/rangeResult.test.ts +6 -2
  49. package/src/routing/__tests__/rangeRouter.test.ts +10 -6
  50. package/src/routing/__tests__/raptor.test.ts +15 -9
  51. package/src/routing/__tests__/result.test.ts +9 -4
  52. package/src/routing/__tests__/route.test.ts +3 -4
  53. package/src/routing/__tests__/router.test.ts +2 -1
  54. package/src/routing/access.ts +7 -4
  55. package/src/routing/plotter.ts +8 -3
  56. package/src/routing/raptor.ts +5 -5
  57. package/src/routing/result.ts +32 -14
  58. package/src/routing/route.ts +13 -10
  59. package/src/routing/state.ts +1 -1
  60. package/src/timetable/__tests__/io.test.ts +22 -10
  61. package/src/timetable/__tests__/route.test.ts +18 -24
  62. package/src/timetable/__tests__/timetable.test.ts +17 -11
  63. package/src/timetable/io.ts +30 -28
  64. package/src/timetable/route.ts +14 -7
  65. package/src/timetable/timetable.ts +77 -28
  66. package/src/transfers/README.md +97 -0
  67. package/src/transfers/__tests__/straightLineTransferGenerator.test.ts +204 -0
  68. package/src/transfers/generator.ts +45 -0
  69. package/src/transfers/straightLineTransferGenerator.ts +143 -0
  70. package/src/utils/map.ts +22 -0
@@ -1,5 +1,6 @@
1
1
  import { StopsIndex } from '../stops/stopsIndex.js';
2
2
  import { RouteType, Timetable } from '../timetable/timetable.js';
3
+ import { TransferGenerator } from '../transfers/generator.js';
3
4
  import { Maybe } from './utils.js';
4
5
  export type GtfsProfile = {
5
6
  routeTypeParser: (routeType: number) => Maybe<RouteType>;
@@ -7,7 +8,8 @@ export type GtfsProfile = {
7
8
  export declare class GtfsParser {
8
9
  private path;
9
10
  private profile;
10
- constructor(path: string, profile?: GtfsProfile);
11
+ private transferGenerator?;
12
+ constructor(path: string, profile?: GtfsProfile, transferGenerator?: TransferGenerator);
11
13
  /**
12
14
  * Parses a GTFS feed to extract all the data relevant to a given day in a transit-planner friendly format.
13
15
  *
@@ -1,5 +1,4 @@
1
- import { RouteType } from '../router.js';
2
- import { ServiceRoute, ServiceRouteId } from '../timetable/timetable.js';
1
+ import { RouteType, ServiceRoute, ServiceRouteId } from '../timetable/timetable.js';
3
2
  import { GtfsProfile } from './parser.js';
4
3
  export type GtfsRouteType = number;
5
4
  export type GtfsRouteId = string;
@@ -1,5 +1,6 @@
1
1
  import { StopId } from '../stops/stops.js';
2
- import { Route, RouteId, TripRouteIndex } from '../timetable/route.js';
2
+ import type { RouteId, TripRouteIndex } from '../timetable/route.js';
3
+ import { Route } from '../timetable/route.js';
3
4
  import { ServiceRoute, ServiceRouteId, StopAdjacency } from '../timetable/timetable.js';
4
5
  import { FrequenciesMap } from './frequencies.js';
5
6
  import { GtfsRouteId, GtfsRoutesMap } from './routes.js';
@@ -10999,6 +10999,11 @@ function haverSinDist(lng1, lat1, lng2, lat2, cosLat1) {
10999
10999
  return haverSinDistPartial(haverSinDLng, cosLat1, lat1, lat2);
11000
11000
  }
11001
11001
 
11002
+ function distance(lng1, lat1, lng2, lat2) {
11003
+ const h = haverSinDist(lng1, lat1, lng2, lat2, Math.cos(lat1 * rad));
11004
+ return 2 * earthRadius * Math.asin(Math.sqrt(h));
11005
+ }
11006
+
11002
11007
  function vertexLat(lat, haverSinDLng) {
11003
11008
  const cosDLng = 1 - 2 * haverSinDLng;
11004
11009
  if (cosDLng <= 0) return lat > 0 ? 90 : -90;
@@ -12744,10 +12749,12 @@ const timeFromHMS = (hours, minutes, seconds) => {
12744
12749
  */
12745
12750
  const durationFromSeconds = (seconds) => Math.round(seconds / 60);
12746
12751
 
12747
- const REGULAR = 0;
12748
- const NOT_AVAILABLE = 1;
12749
- const MUST_PHONE_AGENCY = 2;
12750
- const MUST_COORDINATE_WITH_DRIVER = 3;
12752
+ const PickUpDropOffTypes = {
12753
+ REGULAR: 0,
12754
+ NOT_AVAILABLE: 1,
12755
+ MUST_PHONE_AGENCY: 2,
12756
+ MUST_COORDINATE_WITH_DRIVER: 3,
12757
+ };
12751
12758
  /**
12752
12759
  * A route identifies all trips of a given service route sharing the same list of stops.
12753
12760
  */
@@ -12827,8 +12834,8 @@ class Route {
12827
12834
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
12828
12835
  const stop = trip.stops[stopIndex];
12829
12836
  const globalIndex = tripIndex * numStops + stopIndex;
12830
- const pickUp = (_a = stop.pickUpType) !== null && _a !== void 0 ? _a : REGULAR;
12831
- const dropOff = (_b = stop.dropOffType) !== null && _b !== void 0 ? _b : REGULAR;
12837
+ const pickUp = (_a = stop.pickUpType) !== null && _a !== void 0 ? _a : PickUpDropOffTypes.REGULAR;
12838
+ const dropOff = (_b = stop.dropOffType) !== null && _b !== void 0 ? _b : PickUpDropOffTypes.REGULAR;
12832
12839
  const byteIndex = Math.floor(globalIndex / 2);
12833
12840
  const isSecondPair = globalIndex % 2 === 1;
12834
12841
  if (isSecondPair) {
@@ -13262,26 +13269,26 @@ const parseTransferType = (type) => {
13262
13269
  case TransferType.TRANSFER_TYPE_UNSPECIFIED:
13263
13270
  throw new Error('Unspecified protobuf transfer type.');
13264
13271
  case TransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT:
13265
- return 'RECOMMENDED';
13272
+ return TransferTypes.RECOMMENDED;
13266
13273
  case TransferType.TRANSFER_TYPE_TIMED_TRANSFER:
13267
- return 'GUARANTEED';
13274
+ return TransferTypes.GUARANTEED;
13268
13275
  case TransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME:
13269
- return 'REQUIRES_MINIMAL_TIME';
13276
+ return TransferTypes.REQUIRES_MINIMAL_TIME;
13270
13277
  case TransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER:
13271
- return 'IN_SEAT';
13278
+ return TransferTypes.IN_SEAT;
13272
13279
  case TransferType.UNRECOGNIZED:
13273
13280
  throw new Error('Unrecognized protobuf transfer type.');
13274
13281
  }
13275
13282
  };
13276
13283
  const serializeTransferType = (type) => {
13277
13284
  switch (type) {
13278
- case 'RECOMMENDED':
13285
+ case TransferTypes.RECOMMENDED:
13279
13286
  return TransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT;
13280
- case 'GUARANTEED':
13287
+ case TransferTypes.GUARANTEED:
13281
13288
  return TransferType.TRANSFER_TYPE_TIMED_TRANSFER;
13282
- case 'REQUIRES_MINIMAL_TIME':
13289
+ case TransferTypes.REQUIRES_MINIMAL_TIME:
13283
13290
  return TransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME;
13284
- case 'IN_SEAT':
13291
+ case TransferTypes.IN_SEAT:
13285
13292
  return TransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER;
13286
13293
  }
13287
13294
  };
@@ -13290,25 +13297,25 @@ const parseRouteType = (type) => {
13290
13297
  case RouteType.ROUTE_TYPE_UNSPECIFIED:
13291
13298
  throw new Error('Unspecified protobuf route type.');
13292
13299
  case RouteType.ROUTE_TYPE_TRAM:
13293
- return 'TRAM';
13300
+ return RouteTypes.TRAM;
13294
13301
  case RouteType.ROUTE_TYPE_SUBWAY:
13295
- return 'SUBWAY';
13302
+ return RouteTypes.SUBWAY;
13296
13303
  case RouteType.ROUTE_TYPE_RAIL:
13297
- return 'RAIL';
13304
+ return RouteTypes.RAIL;
13298
13305
  case RouteType.ROUTE_TYPE_BUS:
13299
- return 'BUS';
13306
+ return RouteTypes.BUS;
13300
13307
  case RouteType.ROUTE_TYPE_FERRY:
13301
- return 'FERRY';
13308
+ return RouteTypes.FERRY;
13302
13309
  case RouteType.ROUTE_TYPE_CABLE_TRAM:
13303
- return 'CABLE_TRAM';
13310
+ return RouteTypes.CABLE_TRAM;
13304
13311
  case RouteType.ROUTE_TYPE_AERIAL_LIFT:
13305
- return 'AERIAL_LIFT';
13312
+ return RouteTypes.AERIAL_LIFT;
13306
13313
  case RouteType.ROUTE_TYPE_FUNICULAR:
13307
- return 'FUNICULAR';
13314
+ return RouteTypes.FUNICULAR;
13308
13315
  case RouteType.ROUTE_TYPE_TROLLEYBUS:
13309
- return 'TROLLEYBUS';
13316
+ return RouteTypes.TROLLEYBUS;
13310
13317
  case RouteType.ROUTE_TYPE_MONORAIL:
13311
- return 'MONORAIL';
13318
+ return RouteTypes.MONORAIL;
13312
13319
  case RouteType.UNRECOGNIZED:
13313
13320
  default:
13314
13321
  throw new Error('Unrecognized protobuf route type.');
@@ -13316,25 +13323,25 @@ const parseRouteType = (type) => {
13316
13323
  };
13317
13324
  const serializeRouteType = (type) => {
13318
13325
  switch (type) {
13319
- case 'TRAM':
13326
+ case RouteTypes.TRAM:
13320
13327
  return RouteType.ROUTE_TYPE_TRAM;
13321
- case 'SUBWAY':
13328
+ case RouteTypes.SUBWAY:
13322
13329
  return RouteType.ROUTE_TYPE_SUBWAY;
13323
- case 'RAIL':
13330
+ case RouteTypes.RAIL:
13324
13331
  return RouteType.ROUTE_TYPE_RAIL;
13325
- case 'BUS':
13332
+ case RouteTypes.BUS:
13326
13333
  return RouteType.ROUTE_TYPE_BUS;
13327
- case 'FERRY':
13334
+ case RouteTypes.FERRY:
13328
13335
  return RouteType.ROUTE_TYPE_FERRY;
13329
- case 'CABLE_TRAM':
13336
+ case RouteTypes.CABLE_TRAM:
13330
13337
  return RouteType.ROUTE_TYPE_CABLE_TRAM;
13331
- case 'AERIAL_LIFT':
13338
+ case RouteTypes.AERIAL_LIFT:
13332
13339
  return RouteType.ROUTE_TYPE_AERIAL_LIFT;
13333
- case 'FUNICULAR':
13340
+ case RouteTypes.FUNICULAR:
13334
13341
  return RouteType.ROUTE_TYPE_FUNICULAR;
13335
- case 'TROLLEYBUS':
13342
+ case RouteTypes.TROLLEYBUS:
13336
13343
  return RouteType.ROUTE_TYPE_TROLLEYBUS;
13337
- case 'MONORAIL':
13344
+ case RouteTypes.MONORAIL:
13338
13345
  return RouteType.ROUTE_TYPE_MONORAIL;
13339
13346
  }
13340
13347
  };
@@ -13376,18 +13383,25 @@ const deserializeTripTransfers = (protoTripTransfer) => {
13376
13383
  };
13377
13384
 
13378
13385
  /* eslint-disable @typescript-eslint/no-non-null-assertion */
13379
- const ALL_TRANSPORT_MODES = new Set([
13380
- 'TRAM',
13381
- 'SUBWAY',
13382
- 'RAIL',
13383
- 'BUS',
13384
- 'FERRY',
13385
- 'CABLE_TRAM',
13386
- 'AERIAL_LIFT',
13387
- 'FUNICULAR',
13388
- 'TROLLEYBUS',
13389
- 'MONORAIL',
13390
- ]);
13386
+ const TransferTypes = {
13387
+ RECOMMENDED: 1,
13388
+ GUARANTEED: 2,
13389
+ REQUIRES_MINIMAL_TIME: 3,
13390
+ IN_SEAT: 4,
13391
+ };
13392
+ const RouteTypes = {
13393
+ TRAM: 1,
13394
+ SUBWAY: 2,
13395
+ RAIL: 3,
13396
+ BUS: 4,
13397
+ FERRY: 5,
13398
+ CABLE_TRAM: 6,
13399
+ AERIAL_LIFT: 7,
13400
+ FUNICULAR: 8,
13401
+ TROLLEYBUS: 9,
13402
+ MONORAIL: 10,
13403
+ };
13404
+ const ALL_TRANSPORT_MODES = new Set(Object.values(RouteTypes));
13391
13405
  const EMPTY_TRIP_BOARDINGS = [];
13392
13406
  /**
13393
13407
  * The internal transit timetable format.
@@ -13612,7 +13626,7 @@ class Timetable {
13612
13626
  const nbTrips = route.getNbTrips();
13613
13627
  for (let t = earliestTrip; t < (beforeTrip !== null && beforeTrip !== void 0 ? beforeTrip : nbTrips); t++) {
13614
13628
  const pickup = route.pickUpTypeFrom(stopIndex, t);
13615
- if (pickup === NOT_AVAILABLE) {
13629
+ if (pickup === PickUpDropOffTypes.NOT_AVAILABLE) {
13616
13630
  continue;
13617
13631
  }
13618
13632
  if (fromTripStop === undefined) {
@@ -13652,6 +13666,25 @@ class Timetable {
13652
13666
  }
13653
13667
  }
13654
13668
 
13669
+ /**
13670
+ * Returns the value stored under `key`, inserting and returning `defaultValue`
13671
+ * when the key is absent. Mirrors the TC39 `Map.prototype.getOrInsert`
13672
+ * proposal.
13673
+ *
13674
+ * TODO: remove this helper and call `map.getOrInsert(key, defaultValue)`
13675
+ * directly once we only target Node 26+ (where the method is built in).
13676
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/getOrInsert
13677
+ */
13678
+ const getOrInsert = (map, key, defaultValue) => {
13679
+ if (map.has(key)) {
13680
+ // Key is present, so `get` returns the stored value (which may itself be a
13681
+ // legitimately-stored `undefined`).
13682
+ return map.get(key);
13683
+ }
13684
+ map.set(key, defaultValue);
13685
+ return defaultValue;
13686
+ };
13687
+
13655
13688
  const toGtfsDate = (date) => {
13656
13689
  return parseInt(date.toFormat('yyyyLLdd'));
13657
13690
  };
@@ -15663,25 +15696,25 @@ const standardGtfsProfile = {
15663
15696
  routeTypeParser: (routeType) => {
15664
15697
  switch (routeType) {
15665
15698
  case 0:
15666
- return 'TRAM';
15699
+ return RouteTypes.TRAM;
15667
15700
  case 1:
15668
- return 'SUBWAY';
15701
+ return RouteTypes.SUBWAY;
15669
15702
  case 2:
15670
- return 'RAIL';
15703
+ return RouteTypes.RAIL;
15671
15704
  case 3:
15672
- return 'BUS';
15705
+ return RouteTypes.BUS;
15673
15706
  case 4:
15674
- return 'FERRY';
15707
+ return RouteTypes.FERRY;
15675
15708
  case 5:
15676
- return 'CABLE_TRAM';
15709
+ return RouteTypes.CABLE_TRAM;
15677
15710
  case 6:
15678
- return 'AERIAL_LIFT';
15711
+ return RouteTypes.AERIAL_LIFT;
15679
15712
  case 7:
15680
- return 'FUNICULAR';
15713
+ return RouteTypes.FUNICULAR;
15681
15714
  case 11:
15682
- return 'TROLLEYBUS';
15715
+ return RouteTypes.TROLLEYBUS;
15683
15716
  case 12:
15684
- return 'MONORAIL';
15717
+ return RouteTypes.MONORAIL;
15685
15718
  default:
15686
15719
  return undefined;
15687
15720
  }
@@ -15955,7 +15988,7 @@ const processGuaranteedStopTransfer = (transferEntry, fromStop, toStop, transfer
15955
15988
  log.warn(`Unsupported transfer of type ${transferEntry.transfer_type} between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`);
15956
15989
  return;
15957
15990
  }
15958
- const transfer = Object.assign({ destination: toStop, type: 'GUARANTEED' }, (transferEntry.min_transfer_time !== undefined && {
15991
+ const transfer = Object.assign({ destination: toStop, type: TransferTypes.GUARANTEED }, (transferEntry.min_transfer_time !== undefined && {
15959
15992
  minTransferTime: durationFromSeconds(transferEntry.min_transfer_time),
15960
15993
  }));
15961
15994
  const fromStopTransfers = transfers.get(fromStop) || [];
@@ -16145,13 +16178,13 @@ const parseGtfsTransferType = (gtfsTransferType) => {
16145
16178
  switch (gtfsTransferType) {
16146
16179
  case 0:
16147
16180
  default:
16148
- return 'RECOMMENDED';
16181
+ return TransferTypes.RECOMMENDED;
16149
16182
  case 1:
16150
- return 'GUARANTEED';
16183
+ return TransferTypes.GUARANTEED;
16151
16184
  case 2:
16152
- return 'REQUIRES_MINIMAL_TIME';
16185
+ return TransferTypes.REQUIRES_MINIMAL_TIME;
16153
16186
  case 4:
16154
- return 'IN_SEAT';
16187
+ return TransferTypes.IN_SEAT;
16155
16188
  }
16156
16189
  };
16157
16190
 
@@ -16500,15 +16533,15 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds,
16500
16533
  const parsePickupDropOffType = (gtfsType) => {
16501
16534
  switch (gtfsType) {
16502
16535
  default:
16503
- return REGULAR;
16536
+ return PickUpDropOffTypes.REGULAR;
16504
16537
  case '0':
16505
- return REGULAR;
16538
+ return PickUpDropOffTypes.REGULAR;
16506
16539
  case '1':
16507
- return NOT_AVAILABLE;
16540
+ return PickUpDropOffTypes.NOT_AVAILABLE;
16508
16541
  case '2':
16509
- return MUST_PHONE_AGENCY;
16542
+ return PickUpDropOffTypes.MUST_PHONE_AGENCY;
16510
16543
  case '3':
16511
- return MUST_COORDINATE_WITH_DRIVER;
16544
+ return PickUpDropOffTypes.MUST_COORDINATE_WITH_DRIVER;
16512
16545
  }
16513
16546
  };
16514
16547
 
@@ -16521,10 +16554,11 @@ const STOP_TIMES_FILE = 'stop_times.txt';
16521
16554
  const STOPS_FILE = 'stops.txt';
16522
16555
  const TRANSFERS_FILE = 'transfers.txt';
16523
16556
  class GtfsParser {
16524
- constructor(path, profile = standardGtfsProfile) {
16557
+ constructor(path, profile = standardGtfsProfile, transferGenerator) {
16525
16558
  // TODO: support input from multiple sources
16526
16559
  this.path = path;
16527
16560
  this.profile = profile;
16561
+ this.transferGenerator = transferGenerator;
16528
16562
  }
16529
16563
  /**
16530
16564
  * Parses a GTFS feed to extract all the data relevant to a given day in a transit-planner friendly format.
@@ -16604,6 +16638,35 @@ class GtfsParser {
16604
16638
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16605
16639
  const stopTimesEnd = performance.now();
16606
16640
  log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
16641
+ if (this.transferGenerator) {
16642
+ log.info('Generating virtual transfers');
16643
+ const virtualTransfersStart = performance.now();
16644
+ // Only route-served stops with coordinates are worth connecting: a
16645
+ // transfer to a stop no route calls at is a dead end for the router.
16646
+ const originStops = Array.from(parsedStops.values()).filter((stop) => activeStopIds.has(stop.id) &&
16647
+ stop.lat !== undefined &&
16648
+ stop.lon !== undefined);
16649
+ const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16650
+ const generatedTransfers = yield this.transferGenerator.generate(originStops, stopsIndex);
16651
+ let addedTransfers = 0;
16652
+ for (const [fromStop, newTransfers] of generatedTransfers) {
16653
+ const existing = getOrInsert(transfers, fromStop, []);
16654
+ // Deduplicate per directed pair against existing (feed) transfers, and
16655
+ // only keep transfers into stops a route actually calls at.
16656
+ const connected = new Set(existing.map((t) => t.destination));
16657
+ for (const transfer of newTransfers) {
16658
+ if (!activeStopIds.has(transfer.destination) ||
16659
+ connected.has(transfer.destination)) {
16660
+ continue;
16661
+ }
16662
+ connected.add(transfer.destination);
16663
+ existing.push(transfer);
16664
+ addedTransfers += 1;
16665
+ }
16666
+ }
16667
+ const virtualTransfersEnd = performance.now();
16668
+ log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16669
+ }
16607
16670
  log.info('Building stops adjacency structure');
16608
16671
  const stopsAdjacencyStart = performance.now();
16609
16672
  const stopsAdjacency = buildStopsAdjacencyStructure(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
@@ -16676,7 +16739,7 @@ const routeTypeParser = (routeType) => {
16676
16739
  case 115: // Vehicle Transport Rail Service
16677
16740
  case 116: // Rack and Pinion Railway (Rochers de Naye, Dolderbahn)
16678
16741
  case 117: // Additional Rail Service
16679
- return 'RAIL';
16742
+ return RouteTypes.RAIL;
16680
16743
  // Coach Service (200-299)
16681
16744
  case 200: // Coach Service
16682
16745
  case 201: // International Coach Service (EuroLine, Touring)
@@ -16688,16 +16751,16 @@ const routeTypeParser = (routeType) => {
16688
16751
  case 207: // Tourist Coach Service
16689
16752
  case 208: // Commuter Coach Service
16690
16753
  case 209: // All Coach Services
16691
- return 'BUS';
16754
+ return RouteTypes.BUS;
16692
16755
  // Urban Railway Service (400-499)
16693
16756
  case 400: // Urban Railway Service
16694
16757
  case 401: // Metro Service (Métro de Paris)
16695
16758
  case 402: // Underground Service (London Underground, U-Bahn)
16696
16759
  case 403: // Urban Railway Service
16697
16760
  case 404: // All Urban Railway Services
16698
- return 'SUBWAY';
16761
+ return RouteTypes.SUBWAY;
16699
16762
  case 405: // Monorail
16700
- return 'MONORAIL';
16763
+ return RouteTypes.MONORAIL;
16701
16764
  // Bus Service (700-799)
16702
16765
  case 700: // Bus Service
16703
16766
  case 701: // Regional Bus Service (Eastbourne-Maidstone)
@@ -16716,10 +16779,10 @@ const routeTypeParser = (routeType) => {
16716
16779
  case 714: // Rail Replacement Bus Service
16717
16780
  case 715: // Demand and Response Bus Service
16718
16781
  case 716: // All Bus Services
16719
- return 'BUS';
16782
+ return RouteTypes.BUS;
16720
16783
  // Trolleybus Service (800-899)
16721
16784
  case 800: // Trolleybus Service
16722
- return 'TROLLEYBUS';
16785
+ return RouteTypes.TROLLEYBUS;
16723
16786
  // Tram Service (900-999)
16724
16787
  case 900: // Tram Service
16725
16788
  case 901: // City Tram Service
@@ -16728,16 +16791,16 @@ const routeTypeParser = (routeType) => {
16728
16791
  case 904: // Sightseeing Tram Service (Blackpool Seafront)
16729
16792
  case 905: // Shuttle Tram Service
16730
16793
  case 906: // All Tram Services
16731
- return 'TRAM';
16794
+ return RouteTypes.TRAM;
16732
16795
  // Water Transport Service (1000-1099)
16733
16796
  case 1000: // Water Transport Service
16734
- return 'FERRY';
16797
+ return RouteTypes.FERRY;
16735
16798
  // Air Service (1100-1199)
16736
16799
  case 1100: // Air Service
16737
16800
  return undefined;
16738
16801
  // Ferry Service (1200-1299)
16739
16802
  case 1200: // Ferry Service
16740
- return 'FERRY';
16803
+ return RouteTypes.FERRY;
16741
16804
  // Aerial Lift Service (1300-1399)
16742
16805
  case 1300: // Aerial Lift Service (Telefèric de Montjuïc, Roosevelt Island Tramway)
16743
16806
  case 1301: // Telecabin Service
@@ -16746,10 +16809,10 @@ const routeTypeParser = (routeType) => {
16746
16809
  case 1305: // Drag Lift Service
16747
16810
  case 1306: // Small Telecabin Service
16748
16811
  case 1307: // All Telecabin Services
16749
- return 'AERIAL_LIFT';
16812
+ return RouteTypes.AERIAL_LIFT;
16750
16813
  case 1303: // Elevator Service (Ascenseur, Aufzug)
16751
16814
  case 1400: // Funicular Service (Rigiblick)
16752
- return 'FUNICULAR';
16815
+ return RouteTypes.FUNICULAR;
16753
16816
  // Taxi Service (1500-1599)
16754
16817
  case 1500: // Taxi Service
16755
16818
  case 1502: // Water Taxi Service
@@ -16760,12 +16823,12 @@ const routeTypeParser = (routeType) => {
16760
16823
  case 1507: // All Taxi Services
16761
16824
  return undefined;
16762
16825
  case 1501: // Communal Taxi Service (Marshrutka, dolmuş)
16763
- return 'BUS';
16826
+ return RouteTypes.BUS;
16764
16827
  // Miscellaneous Service (1700-1799)
16765
16828
  case 1700: // Miscellaneous Service / Unknown mode
16766
16829
  return undefined;
16767
16830
  case 1702: // Horse-drawn Carriage
16768
- return 'BUS';
16831
+ return RouteTypes.BUS;
16769
16832
  default:
16770
16833
  return undefined;
16771
16834
  }
@@ -16774,7 +16837,88 @@ const extendedGtfsProfile = {
16774
16837
  routeTypeParser,
16775
16838
  };
16776
16839
 
16840
+ const DEFAULT_MAX_DISTANCE_METERS = 500;
16841
+ const DEFAULT_WALKING_SPEED_KMH = 4;
16842
+ const DEFAULT_DETOUR_FACTOR = 1.3;
16843
+ const DEFAULT_CHANGE_PENALTY_MINUTES = 3;
16844
+ /**
16845
+ * A {@link TransferGenerator} that connects geographically close stops with
16846
+ * virtual walking transfers.
16847
+ *
16848
+ * The transfer time is derived from the straight-line (great-circle / haversine)
16849
+ * distance between two stops, scaled up by a detour factor to approximate the
16850
+ * real walking path and divided by an assumed walking speed. This is a
16851
+ * deliberately crude heuristic meant to fill in footpaths for feeds that
16852
+ * under-specify `transfers.txt` (e.g. large interchanges where subway, tram and
16853
+ * bus stops sit close together but are left unconnected).
16854
+ *
16855
+ * Generated transfers use {@link TransferTypes.REQUIRES_MINIMAL_TIME} so they
16856
+ * are treated as walking connections by both the router's transfer step and
16857
+ * its access/egress computation. Each origin is connected to its nearby stops
16858
+ * with a single directed edge; the reverse edge is produced when the neighbor
16859
+ * is itself visited as an origin.
16860
+ *
16861
+ * On top of the walking time, a flat `changePenaltyMinutes` is added for the
16862
+ * general overhead of any change. It is symmetric, so the two directions of a
16863
+ * transfer share the same minimum time.
16864
+ */
16865
+ class StraightLineTransferGenerator {
16866
+ constructor(options = {}) {
16867
+ var _a, _b, _c, _d;
16868
+ this.maxDistanceMeters =
16869
+ (_a = options.maxDistanceMeters) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DISTANCE_METERS;
16870
+ this.walkingSpeedKmh = (_b = options.walkingSpeedKmh) !== null && _b !== void 0 ? _b : DEFAULT_WALKING_SPEED_KMH;
16871
+ this.detourFactor = (_c = options.detourFactor) !== null && _c !== void 0 ? _c : DEFAULT_DETOUR_FACTOR;
16872
+ this.changePenaltyMinutes =
16873
+ (_d = options.changePenaltyMinutes) !== null && _d !== void 0 ? _d : DEFAULT_CHANGE_PENALTY_MINUTES;
16874
+ }
16875
+ generate(originStops, stops) {
16876
+ const generated = new Map();
16877
+ const maxDistanceKm = this.maxDistanceMeters / 1000;
16878
+ for (const origin of originStops) {
16879
+ const { id, lat, lon } = origin;
16880
+ if (lat === undefined || lon === undefined) {
16881
+ continue;
16882
+ }
16883
+ const neighbors = stops.findStopsByLocation(lat, lon, Infinity, maxDistanceKm);
16884
+ for (const neighbor of neighbors) {
16885
+ const { id: neighborId, lat: neighborLat, lon: neighborLon } = neighbor;
16886
+ if (neighborId === id ||
16887
+ neighborLat === undefined ||
16888
+ neighborLon === undefined) {
16889
+ continue;
16890
+ }
16891
+ const walkingTime = this.walkingDuration(lon, lat, neighborLon, neighborLat);
16892
+ // Emit a single directed edge; the reverse edge is emitted when the
16893
+ // neighbor is itself visited as an origin. The penalty is symmetric, so
16894
+ // both directions end up with the same minimum time.
16895
+ const minTransferTime = walkingTime + this.changePenaltyMinutes;
16896
+ this.addTransfer(generated, id, neighborId, minTransferTime);
16897
+ }
16898
+ }
16899
+ return generated;
16900
+ }
16901
+ addTransfer(transfers, from, to, minTransferTime) {
16902
+ const transfer = {
16903
+ destination: to,
16904
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
16905
+ minTransferTime,
16906
+ };
16907
+ getOrInsert(transfers, from, []).push(transfer);
16908
+ }
16909
+ /**
16910
+ * Estimates the walking time between two coordinates, in whole minutes.
16911
+ */
16912
+ walkingDuration(lon1, lat1, lon2, lat2) {
16913
+ const straightLineKm = distance(lon1, lat1, lon2, lat2);
16914
+ const walkingKm = straightLineKm * this.detourFactor;
16915
+ return Math.round((walkingKm / this.walkingSpeedKmh) * 60);
16916
+ }
16917
+ }
16918
+
16777
16919
  exports.GtfsParser = GtfsParser;
16920
+ exports.StraightLineTransferGenerator = StraightLineTransferGenerator;
16921
+ exports.TransferTypes = TransferTypes;
16778
16922
  exports.extendedGtfsProfile = extendedGtfsProfile;
16779
16923
  exports.standardGtfsProfile = standardGtfsProfile;
16780
16924
  //# sourceMappingURL=parser.cjs.js.map