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