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
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) || [];
@@ -16143,13 +16176,13 @@ const parseGtfsTransferType = (gtfsTransferType) => {
16143
16176
  switch (gtfsTransferType) {
16144
16177
  case 0:
16145
16178
  default:
16146
- return 'RECOMMENDED';
16179
+ return TransferTypes.RECOMMENDED;
16147
16180
  case 1:
16148
- return 'GUARANTEED';
16181
+ return TransferTypes.GUARANTEED;
16149
16182
  case 2:
16150
- return 'REQUIRES_MINIMAL_TIME';
16183
+ return TransferTypes.REQUIRES_MINIMAL_TIME;
16151
16184
  case 4:
16152
- return 'IN_SEAT';
16185
+ return TransferTypes.IN_SEAT;
16153
16186
  }
16154
16187
  };
16155
16188
 
@@ -16498,15 +16531,15 @@ const parseStopTimes = (stopTimesStream, stopsMap, activeTripIds, activeStopIds,
16498
16531
  const parsePickupDropOffType = (gtfsType) => {
16499
16532
  switch (gtfsType) {
16500
16533
  default:
16501
- return REGULAR;
16534
+ return PickUpDropOffTypes.REGULAR;
16502
16535
  case '0':
16503
- return REGULAR;
16536
+ return PickUpDropOffTypes.REGULAR;
16504
16537
  case '1':
16505
- return NOT_AVAILABLE;
16538
+ return PickUpDropOffTypes.NOT_AVAILABLE;
16506
16539
  case '2':
16507
- return MUST_PHONE_AGENCY;
16540
+ return PickUpDropOffTypes.MUST_PHONE_AGENCY;
16508
16541
  case '3':
16509
- return MUST_COORDINATE_WITH_DRIVER;
16542
+ return PickUpDropOffTypes.MUST_COORDINATE_WITH_DRIVER;
16510
16543
  }
16511
16544
  };
16512
16545
 
@@ -16519,10 +16552,11 @@ const STOP_TIMES_FILE = 'stop_times.txt';
16519
16552
  const STOPS_FILE = 'stops.txt';
16520
16553
  const TRANSFERS_FILE = 'transfers.txt';
16521
16554
  class GtfsParser {
16522
- constructor(path, profile = standardGtfsProfile) {
16555
+ constructor(path, profile = standardGtfsProfile, transferGenerator) {
16523
16556
  // TODO: support input from multiple sources
16524
16557
  this.path = path;
16525
16558
  this.profile = profile;
16559
+ this.transferGenerator = transferGenerator;
16526
16560
  }
16527
16561
  /**
16528
16562
  * Parses a GTFS feed to extract all the data relevant to a given day in a transit-planner friendly format.
@@ -16602,6 +16636,35 @@ class GtfsParser {
16602
16636
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16603
16637
  const stopTimesEnd = performance.now();
16604
16638
  log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
16639
+ if (this.transferGenerator) {
16640
+ log.info('Generating virtual transfers');
16641
+ const virtualTransfersStart = performance.now();
16642
+ // Only route-served stops with coordinates are worth connecting: a
16643
+ // transfer to a stop no route calls at is a dead end for the router.
16644
+ const originStops = Array.from(parsedStops.values()).filter((stop) => activeStopIds.has(stop.id) &&
16645
+ stop.lat !== undefined &&
16646
+ stop.lon !== undefined);
16647
+ const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16648
+ const generatedTransfers = yield this.transferGenerator.generate(originStops, stopsIndex);
16649
+ let addedTransfers = 0;
16650
+ for (const [fromStop, newTransfers] of generatedTransfers) {
16651
+ const existing = getOrInsert(transfers, fromStop, []);
16652
+ // Deduplicate per directed pair against existing (feed) transfers, and
16653
+ // only keep transfers into stops a route actually calls at.
16654
+ const connected = new Set(existing.map((t) => t.destination));
16655
+ for (const transfer of newTransfers) {
16656
+ if (!activeStopIds.has(transfer.destination) ||
16657
+ connected.has(transfer.destination)) {
16658
+ continue;
16659
+ }
16660
+ connected.add(transfer.destination);
16661
+ existing.push(transfer);
16662
+ addedTransfers += 1;
16663
+ }
16664
+ }
16665
+ const virtualTransfersEnd = performance.now();
16666
+ log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16667
+ }
16605
16668
  log.info('Building stops adjacency structure');
16606
16669
  const stopsAdjacencyStart = performance.now();
16607
16670
  const stopsAdjacency = buildStopsAdjacencyStructure(serviceRoutes, routes, transfers, parsedStops.size, activeStopIds);
@@ -16674,7 +16737,7 @@ const routeTypeParser = (routeType) => {
16674
16737
  case 115: // Vehicle Transport Rail Service
16675
16738
  case 116: // Rack and Pinion Railway (Rochers de Naye, Dolderbahn)
16676
16739
  case 117: // Additional Rail Service
16677
- return 'RAIL';
16740
+ return RouteTypes.RAIL;
16678
16741
  // Coach Service (200-299)
16679
16742
  case 200: // Coach Service
16680
16743
  case 201: // International Coach Service (EuroLine, Touring)
@@ -16686,16 +16749,16 @@ const routeTypeParser = (routeType) => {
16686
16749
  case 207: // Tourist Coach Service
16687
16750
  case 208: // Commuter Coach Service
16688
16751
  case 209: // All Coach Services
16689
- return 'BUS';
16752
+ return RouteTypes.BUS;
16690
16753
  // Urban Railway Service (400-499)
16691
16754
  case 400: // Urban Railway Service
16692
16755
  case 401: // Metro Service (Métro de Paris)
16693
16756
  case 402: // Underground Service (London Underground, U-Bahn)
16694
16757
  case 403: // Urban Railway Service
16695
16758
  case 404: // All Urban Railway Services
16696
- return 'SUBWAY';
16759
+ return RouteTypes.SUBWAY;
16697
16760
  case 405: // Monorail
16698
- return 'MONORAIL';
16761
+ return RouteTypes.MONORAIL;
16699
16762
  // Bus Service (700-799)
16700
16763
  case 700: // Bus Service
16701
16764
  case 701: // Regional Bus Service (Eastbourne-Maidstone)
@@ -16714,10 +16777,10 @@ const routeTypeParser = (routeType) => {
16714
16777
  case 714: // Rail Replacement Bus Service
16715
16778
  case 715: // Demand and Response Bus Service
16716
16779
  case 716: // All Bus Services
16717
- return 'BUS';
16780
+ return RouteTypes.BUS;
16718
16781
  // Trolleybus Service (800-899)
16719
16782
  case 800: // Trolleybus Service
16720
- return 'TROLLEYBUS';
16783
+ return RouteTypes.TROLLEYBUS;
16721
16784
  // Tram Service (900-999)
16722
16785
  case 900: // Tram Service
16723
16786
  case 901: // City Tram Service
@@ -16726,16 +16789,16 @@ const routeTypeParser = (routeType) => {
16726
16789
  case 904: // Sightseeing Tram Service (Blackpool Seafront)
16727
16790
  case 905: // Shuttle Tram Service
16728
16791
  case 906: // All Tram Services
16729
- return 'TRAM';
16792
+ return RouteTypes.TRAM;
16730
16793
  // Water Transport Service (1000-1099)
16731
16794
  case 1000: // Water Transport Service
16732
- return 'FERRY';
16795
+ return RouteTypes.FERRY;
16733
16796
  // Air Service (1100-1199)
16734
16797
  case 1100: // Air Service
16735
16798
  return undefined;
16736
16799
  // Ferry Service (1200-1299)
16737
16800
  case 1200: // Ferry Service
16738
- return 'FERRY';
16801
+ return RouteTypes.FERRY;
16739
16802
  // Aerial Lift Service (1300-1399)
16740
16803
  case 1300: // Aerial Lift Service (Telefèric de Montjuïc, Roosevelt Island Tramway)
16741
16804
  case 1301: // Telecabin Service
@@ -16744,10 +16807,10 @@ const routeTypeParser = (routeType) => {
16744
16807
  case 1305: // Drag Lift Service
16745
16808
  case 1306: // Small Telecabin Service
16746
16809
  case 1307: // All Telecabin Services
16747
- return 'AERIAL_LIFT';
16810
+ return RouteTypes.AERIAL_LIFT;
16748
16811
  case 1303: // Elevator Service (Ascenseur, Aufzug)
16749
16812
  case 1400: // Funicular Service (Rigiblick)
16750
- return 'FUNICULAR';
16813
+ return RouteTypes.FUNICULAR;
16751
16814
  // Taxi Service (1500-1599)
16752
16815
  case 1500: // Taxi Service
16753
16816
  case 1502: // Water Taxi Service
@@ -16758,12 +16821,12 @@ const routeTypeParser = (routeType) => {
16758
16821
  case 1507: // All Taxi Services
16759
16822
  return undefined;
16760
16823
  case 1501: // Communal Taxi Service (Marshrutka, dolmuş)
16761
- return 'BUS';
16824
+ return RouteTypes.BUS;
16762
16825
  // Miscellaneous Service (1700-1799)
16763
16826
  case 1700: // Miscellaneous Service / Unknown mode
16764
16827
  return undefined;
16765
16828
  case 1702: // Horse-drawn Carriage
16766
- return 'BUS';
16829
+ return RouteTypes.BUS;
16767
16830
  default:
16768
16831
  return undefined;
16769
16832
  }
@@ -16772,5 +16835,84 @@ const extendedGtfsProfile = {
16772
16835
  routeTypeParser,
16773
16836
  };
16774
16837
 
16775
- export { GtfsParser, extendedGtfsProfile, standardGtfsProfile };
16838
+ const DEFAULT_MAX_DISTANCE_METERS = 500;
16839
+ const DEFAULT_WALKING_SPEED_KMH = 4;
16840
+ const DEFAULT_DETOUR_FACTOR = 1.3;
16841
+ const DEFAULT_CHANGE_PENALTY_MINUTES = 3;
16842
+ /**
16843
+ * A {@link TransferGenerator} that connects geographically close stops with
16844
+ * virtual walking transfers.
16845
+ *
16846
+ * The transfer time is derived from the straight-line (great-circle / haversine)
16847
+ * distance between two stops, scaled up by a detour factor to approximate the
16848
+ * real walking path and divided by an assumed walking speed. This is a
16849
+ * deliberately crude heuristic meant to fill in footpaths for feeds that
16850
+ * under-specify `transfers.txt` (e.g. large interchanges where subway, tram and
16851
+ * bus stops sit close together but are left unconnected).
16852
+ *
16853
+ * Generated transfers use {@link TransferTypes.REQUIRES_MINIMAL_TIME} so they
16854
+ * are treated as walking connections by both the router's transfer step and
16855
+ * its access/egress computation. Each origin is connected to its nearby stops
16856
+ * with a single directed edge; the reverse edge is produced when the neighbor
16857
+ * is itself visited as an origin.
16858
+ *
16859
+ * On top of the walking time, a flat `changePenaltyMinutes` is added for the
16860
+ * general overhead of any change. It is symmetric, so the two directions of a
16861
+ * transfer share the same minimum time.
16862
+ */
16863
+ class StraightLineTransferGenerator {
16864
+ constructor(options = {}) {
16865
+ var _a, _b, _c, _d;
16866
+ this.maxDistanceMeters =
16867
+ (_a = options.maxDistanceMeters) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DISTANCE_METERS;
16868
+ this.walkingSpeedKmh = (_b = options.walkingSpeedKmh) !== null && _b !== void 0 ? _b : DEFAULT_WALKING_SPEED_KMH;
16869
+ this.detourFactor = (_c = options.detourFactor) !== null && _c !== void 0 ? _c : DEFAULT_DETOUR_FACTOR;
16870
+ this.changePenaltyMinutes =
16871
+ (_d = options.changePenaltyMinutes) !== null && _d !== void 0 ? _d : DEFAULT_CHANGE_PENALTY_MINUTES;
16872
+ }
16873
+ generate(originStops, stops) {
16874
+ const generated = new Map();
16875
+ const maxDistanceKm = this.maxDistanceMeters / 1000;
16876
+ for (const origin of originStops) {
16877
+ const { id, lat, lon } = origin;
16878
+ if (lat === undefined || lon === undefined) {
16879
+ continue;
16880
+ }
16881
+ const neighbors = stops.findStopsByLocation(lat, lon, Infinity, maxDistanceKm);
16882
+ for (const neighbor of neighbors) {
16883
+ const { id: neighborId, lat: neighborLat, lon: neighborLon } = neighbor;
16884
+ if (neighborId === id ||
16885
+ neighborLat === undefined ||
16886
+ neighborLon === undefined) {
16887
+ continue;
16888
+ }
16889
+ const walkingTime = this.walkingDuration(lon, lat, neighborLon, neighborLat);
16890
+ // Emit a single directed edge; the reverse edge is emitted when the
16891
+ // neighbor is itself visited as an origin. The penalty is symmetric, so
16892
+ // both directions end up with the same minimum time.
16893
+ const minTransferTime = walkingTime + this.changePenaltyMinutes;
16894
+ this.addTransfer(generated, id, neighborId, minTransferTime);
16895
+ }
16896
+ }
16897
+ return generated;
16898
+ }
16899
+ addTransfer(transfers, from, to, minTransferTime) {
16900
+ const transfer = {
16901
+ destination: to,
16902
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
16903
+ minTransferTime,
16904
+ };
16905
+ getOrInsert(transfers, from, []).push(transfer);
16906
+ }
16907
+ /**
16908
+ * Estimates the walking time between two coordinates, in whole minutes.
16909
+ */
16910
+ walkingDuration(lon1, lat1, lon2, lat2) {
16911
+ const straightLineKm = distance(lon1, lat1, lon2, lat2);
16912
+ const walkingKm = straightLineKm * this.detourFactor;
16913
+ return Math.round((walkingKm / this.walkingSpeedKmh) * 60);
16914
+ }
16915
+ }
16916
+
16917
+ export { GtfsParser, StraightLineTransferGenerator, TransferTypes, extendedGtfsProfile, standardGtfsProfile };
16776
16918
  //# sourceMappingURL=parser.esm.js.map