minotor 11.2.2 → 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 (79) hide show
  1. package/CHANGELOG.md +3 -3
  2. package/README.md +28 -0
  3. package/dist/cli.mjs +378 -127
  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 +5 -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/query.d.ts +20 -0
  21. package/dist/routing/rangeState.d.ts +1 -0
  22. package/dist/routing/raptor.d.ts +2 -0
  23. package/dist/routing/result.d.ts +1 -4
  24. package/dist/routing/route.d.ts +9 -5
  25. package/dist/routing/state.d.ts +11 -1
  26. package/dist/timetable/route.d.ts +9 -5
  27. package/dist/timetable/timetable.d.ts +24 -2
  28. package/dist/transfers/__tests__/straightLineTransferGenerator.test.d.ts +1 -0
  29. package/dist/transfers/generator.d.ts +40 -0
  30. package/dist/transfers/straightLineTransferGenerator.d.ts +58 -0
  31. package/dist/utils/map.d.ts +10 -0
  32. package/package.json +1 -1
  33. package/src/__e2e__/router.test.ts +6 -2
  34. package/src/cli/minotor.ts +21 -1
  35. package/src/cli/perf.ts +4 -2
  36. package/src/cli/repl.ts +55 -35
  37. package/src/gtfs/__tests__/parser.test.ts +29 -1
  38. package/src/gtfs/__tests__/routes.test.ts +4 -3
  39. package/src/gtfs/__tests__/transfers.test.ts +8 -8
  40. package/src/gtfs/__tests__/trips.test.ts +60 -24
  41. package/src/gtfs/parser.ts +50 -1
  42. package/src/gtfs/profiles/__tests__/extended.test.ts +2 -1
  43. package/src/gtfs/profiles/extended.ts +14 -14
  44. package/src/gtfs/profiles/standard.ts +11 -10
  45. package/src/gtfs/routes.ts +5 -2
  46. package/src/gtfs/transfers.ts +6 -5
  47. package/src/gtfs/trips.ts +7 -14
  48. package/src/parser.ts +20 -2
  49. package/src/router.ts +15 -6
  50. package/src/routing/__tests__/access.test.ts +14 -6
  51. package/src/routing/__tests__/plainRouter.test.ts +47 -23
  52. package/src/routing/__tests__/plotter.test.ts +8 -3
  53. package/src/routing/__tests__/rangeResult.test.ts +6 -2
  54. package/src/routing/__tests__/rangeRouter.test.ts +32 -6
  55. package/src/routing/__tests__/raptor.test.ts +157 -9
  56. package/src/routing/__tests__/result.test.ts +9 -4
  57. package/src/routing/__tests__/route.test.ts +3 -4
  58. package/src/routing/__tests__/router.test.ts +2 -1
  59. package/src/routing/access.ts +7 -4
  60. package/src/routing/plainRouter.ts +1 -0
  61. package/src/routing/plotter.ts +8 -3
  62. package/src/routing/query.ts +18 -0
  63. package/src/routing/rangeRouter.ts +2 -0
  64. package/src/routing/rangeState.ts +4 -0
  65. package/src/routing/raptor.ts +19 -9
  66. package/src/routing/result.ts +32 -14
  67. package/src/routing/route.ts +13 -10
  68. package/src/routing/state.ts +30 -0
  69. package/src/timetable/__tests__/io.test.ts +22 -10
  70. package/src/timetable/__tests__/route.test.ts +18 -24
  71. package/src/timetable/__tests__/timetable.test.ts +17 -11
  72. package/src/timetable/io.ts +30 -28
  73. package/src/timetable/route.ts +14 -7
  74. package/src/timetable/timetable.ts +77 -31
  75. package/src/transfers/README.md +97 -0
  76. package/src/transfers/__tests__/straightLineTransferGenerator.test.ts +204 -0
  77. package/src/transfers/generator.ts +45 -0
  78. package/src/transfers/straightLineTransferGenerator.ts +143 -0
  79. package/src/utils/map.ts +22 -0
@@ -1,13 +1,15 @@
1
1
  import assert from 'node:assert';
2
2
  import { describe, it } from 'node:test';
3
3
 
4
- import { NOT_AVAILABLE, Route } from '../route.js';
4
+ import { PickUpDropOffTypes, Route } from '../route.js';
5
5
  import { timeFromHMS } from '../time.js';
6
6
  import {
7
7
  RouteType,
8
+ RouteTypes,
8
9
  ServiceRoute,
9
10
  StopAdjacency,
10
11
  Timetable,
12
+ TransferTypes,
11
13
  TripStop,
12
14
  TripTransfers,
13
15
  } from '../timetable.js';
@@ -17,14 +19,14 @@ describe('Timetable', () => {
17
19
  const stopsAdjacency: StopAdjacency[] = [
18
20
  { routes: [] },
19
21
  {
20
- transfers: [{ destination: 2, type: 'RECOMMENDED' }],
22
+ transfers: [{ destination: 2, type: TransferTypes.RECOMMENDED }],
21
23
  routes: [0, 1],
22
24
  },
23
25
  {
24
26
  transfers: [
25
27
  {
26
28
  destination: 1,
27
- type: 'GUARANTEED',
29
+ type: TransferTypes.GUARANTEED,
28
30
  minTransferTime: 3,
29
31
  },
30
32
  ],
@@ -50,7 +52,7 @@ describe('Timetable', () => {
50
52
  id: 2,
51
53
  arrivalTime: timeFromHMS(17, 20, 0),
52
54
  departureTime: timeFromHMS(17, 30, 0),
53
- pickUpType: NOT_AVAILABLE,
55
+ pickUpType: PickUpDropOffTypes.NOT_AVAILABLE,
54
56
  },
55
57
  ],
56
58
  },
@@ -92,8 +94,8 @@ describe('Timetable', () => {
92
94
  });
93
95
  const routesAdjacency = [route1, route2];
94
96
  const routes: ServiceRoute[] = [
95
- { type: 'RAIL', name: 'Route 1', routes: [0] },
96
- { type: 'RAIL', name: 'Route 2', routes: [1] },
97
+ { type: RouteTypes.RAIL, name: 'Route 1', routes: [0] },
98
+ { type: RouteTypes.RAIL, name: 'Route 2', routes: [1] },
97
99
  ];
98
100
 
99
101
  const sampleTimetable: Timetable = new Timetable(
@@ -191,7 +193,7 @@ describe('Timetable', () => {
191
193
 
192
194
  const railRoutes = sampleTimetable.findReachableRoutes(
193
195
  fromStops,
194
- new Set<RouteType>(['RAIL']),
196
+ new Set<RouteType>([RouteTypes.RAIL]),
195
197
  );
196
198
  assert.strictEqual(railRoutes.size, 2);
197
199
  assert.deepStrictEqual(
@@ -204,14 +206,18 @@ describe('Timetable', () => {
204
206
 
205
207
  const busRoutes = sampleTimetable.findReachableRoutes(
206
208
  fromStops,
207
- new Set<RouteType>(['BUS']),
209
+ new Set<RouteType>([RouteTypes.BUS]),
208
210
  );
209
211
  assert.strictEqual(busRoutes.size, 0);
210
212
  assert.deepStrictEqual(busRoutes, new Map());
211
213
 
212
214
  const multiModeRoutes = sampleTimetable.findReachableRoutes(
213
215
  fromStops,
214
- new Set<RouteType>(['RAIL', 'BUS', 'SUBWAY']),
216
+ new Set<RouteType>([
217
+ RouteTypes.RAIL,
218
+ RouteTypes.BUS,
219
+ RouteTypes.SUBWAY,
220
+ ]),
215
221
  );
216
222
  assert.strictEqual(multiModeRoutes.size, 2);
217
223
  });
@@ -685,7 +691,7 @@ describe('Timetable', () => {
685
691
  id: 0,
686
692
  arrivalTime: timeFromHMS(9, 0, 0),
687
693
  departureTime: timeFromHMS(9, 0, 0),
688
- pickUpType: NOT_AVAILABLE,
694
+ pickUpType: PickUpDropOffTypes.NOT_AVAILABLE,
689
695
  },
690
696
  {
691
697
  id: 1,
@@ -731,7 +737,7 @@ describe('Timetable', () => {
731
737
  ];
732
738
 
733
739
  const ffbtServiceRoutes = [
734
- { type: 'BUS' as const, name: 'Route 2', routes: [FFBT_ROUTE_ID] },
740
+ { type: RouteTypes.BUS, name: 'Route 2', routes: [FFBT_ROUTE_ID] },
735
741
  ];
736
742
 
737
743
  const ffbtTimetable = new Timetable(
@@ -9,11 +9,13 @@ import {
9
9
  import { Route } from './route.js';
10
10
  import {
11
11
  RouteType,
12
+ RouteTypes,
12
13
  ServiceRoute,
13
14
  ServiceRouteId,
14
15
  StopAdjacency,
15
16
  Transfer,
16
17
  TransferType,
18
+ TransferTypes,
17
19
  TripStop,
18
20
  TripTransfers,
19
21
  } from './timetable.js';
@@ -255,13 +257,13 @@ const parseTransferType = (type: ProtoTransferType): TransferType => {
255
257
  case ProtoTransferType.TRANSFER_TYPE_UNSPECIFIED:
256
258
  throw new Error('Unspecified protobuf transfer type.');
257
259
  case ProtoTransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT:
258
- return 'RECOMMENDED';
260
+ return TransferTypes.RECOMMENDED;
259
261
  case ProtoTransferType.TRANSFER_TYPE_TIMED_TRANSFER:
260
- return 'GUARANTEED';
262
+ return TransferTypes.GUARANTEED;
261
263
  case ProtoTransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME:
262
- return 'REQUIRES_MINIMAL_TIME';
264
+ return TransferTypes.REQUIRES_MINIMAL_TIME;
263
265
  case ProtoTransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER:
264
- return 'IN_SEAT';
266
+ return TransferTypes.IN_SEAT;
265
267
  case ProtoTransferType.UNRECOGNIZED:
266
268
  throw new Error('Unrecognized protobuf transfer type.');
267
269
  }
@@ -269,13 +271,13 @@ const parseTransferType = (type: ProtoTransferType): TransferType => {
269
271
 
270
272
  const serializeTransferType = (type: TransferType): ProtoTransferType => {
271
273
  switch (type) {
272
- case 'RECOMMENDED':
274
+ case TransferTypes.RECOMMENDED:
273
275
  return ProtoTransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT;
274
- case 'GUARANTEED':
276
+ case TransferTypes.GUARANTEED:
275
277
  return ProtoTransferType.TRANSFER_TYPE_TIMED_TRANSFER;
276
- case 'REQUIRES_MINIMAL_TIME':
278
+ case TransferTypes.REQUIRES_MINIMAL_TIME:
277
279
  return ProtoTransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME;
278
- case 'IN_SEAT':
280
+ case TransferTypes.IN_SEAT:
279
281
  return ProtoTransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER;
280
282
  }
281
283
  };
@@ -285,25 +287,25 @@ const parseRouteType = (type: ProtoRouteType): RouteType => {
285
287
  case ProtoRouteType.ROUTE_TYPE_UNSPECIFIED:
286
288
  throw new Error('Unspecified protobuf route type.');
287
289
  case ProtoRouteType.ROUTE_TYPE_TRAM:
288
- return 'TRAM';
290
+ return RouteTypes.TRAM;
289
291
  case ProtoRouteType.ROUTE_TYPE_SUBWAY:
290
- return 'SUBWAY';
292
+ return RouteTypes.SUBWAY;
291
293
  case ProtoRouteType.ROUTE_TYPE_RAIL:
292
- return 'RAIL';
294
+ return RouteTypes.RAIL;
293
295
  case ProtoRouteType.ROUTE_TYPE_BUS:
294
- return 'BUS';
296
+ return RouteTypes.BUS;
295
297
  case ProtoRouteType.ROUTE_TYPE_FERRY:
296
- return 'FERRY';
298
+ return RouteTypes.FERRY;
297
299
  case ProtoRouteType.ROUTE_TYPE_CABLE_TRAM:
298
- return 'CABLE_TRAM';
300
+ return RouteTypes.CABLE_TRAM;
299
301
  case ProtoRouteType.ROUTE_TYPE_AERIAL_LIFT:
300
- return 'AERIAL_LIFT';
302
+ return RouteTypes.AERIAL_LIFT;
301
303
  case ProtoRouteType.ROUTE_TYPE_FUNICULAR:
302
- return 'FUNICULAR';
304
+ return RouteTypes.FUNICULAR;
303
305
  case ProtoRouteType.ROUTE_TYPE_TROLLEYBUS:
304
- return 'TROLLEYBUS';
306
+ return RouteTypes.TROLLEYBUS;
305
307
  case ProtoRouteType.ROUTE_TYPE_MONORAIL:
306
- return 'MONORAIL';
308
+ return RouteTypes.MONORAIL;
307
309
  case ProtoRouteType.UNRECOGNIZED:
308
310
  default:
309
311
  throw new Error('Unrecognized protobuf route type.');
@@ -312,25 +314,25 @@ const parseRouteType = (type: ProtoRouteType): RouteType => {
312
314
 
313
315
  const serializeRouteType = (type: RouteType): ProtoRouteType => {
314
316
  switch (type) {
315
- case 'TRAM':
317
+ case RouteTypes.TRAM:
316
318
  return ProtoRouteType.ROUTE_TYPE_TRAM;
317
- case 'SUBWAY':
319
+ case RouteTypes.SUBWAY:
318
320
  return ProtoRouteType.ROUTE_TYPE_SUBWAY;
319
- case 'RAIL':
321
+ case RouteTypes.RAIL:
320
322
  return ProtoRouteType.ROUTE_TYPE_RAIL;
321
- case 'BUS':
323
+ case RouteTypes.BUS:
322
324
  return ProtoRouteType.ROUTE_TYPE_BUS;
323
- case 'FERRY':
325
+ case RouteTypes.FERRY:
324
326
  return ProtoRouteType.ROUTE_TYPE_FERRY;
325
- case 'CABLE_TRAM':
327
+ case RouteTypes.CABLE_TRAM:
326
328
  return ProtoRouteType.ROUTE_TYPE_CABLE_TRAM;
327
- case 'AERIAL_LIFT':
329
+ case RouteTypes.AERIAL_LIFT:
328
330
  return ProtoRouteType.ROUTE_TYPE_AERIAL_LIFT;
329
- case 'FUNICULAR':
331
+ case RouteTypes.FUNICULAR:
330
332
  return ProtoRouteType.ROUTE_TYPE_FUNICULAR;
331
- case 'TROLLEYBUS':
333
+ case RouteTypes.TROLLEYBUS:
332
334
  return ProtoRouteType.ROUTE_TYPE_TROLLEYBUS;
333
- case 'MONORAIL':
335
+ case RouteTypes.MONORAIL:
334
336
  return ProtoRouteType.ROUTE_TYPE_MONORAIL;
335
337
  }
336
338
  };
@@ -11,12 +11,19 @@ import { ServiceRouteId } from './timetable.js';
11
11
  */
12
12
  export type RouteId = number;
13
13
 
14
- export type RawPickUpDropOffType = 0 | 1 | 2 | 3;
14
+ export const PickUpDropOffTypes = {
15
+ REGULAR: 0,
16
+ NOT_AVAILABLE: 1,
17
+ MUST_PHONE_AGENCY: 2,
18
+ MUST_COORDINATE_WITH_DRIVER: 3,
19
+ } as const;
15
20
 
16
- export const REGULAR = 0;
17
- export const NOT_AVAILABLE = 1;
18
- export const MUST_PHONE_AGENCY = 2;
19
- export const MUST_COORDINATE_WITH_DRIVER = 3;
21
+ export type PickUpDropOffType =
22
+ (typeof PickUpDropOffTypes)[keyof typeof PickUpDropOffTypes];
23
+
24
+ export type PickUpDropOffTypeString = keyof typeof PickUpDropOffTypes;
25
+
26
+ export type RawPickUpDropOffType = PickUpDropOffType;
20
27
 
21
28
  /*
22
29
  * A trip route index corresponds to the index of a given trip in a route.
@@ -182,8 +189,8 @@ export class Route {
182
189
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
183
190
  const stop = trip.stops[stopIndex]!;
184
191
  const globalIndex = tripIndex * numStops + stopIndex;
185
- const pickUp = stop.pickUpType ?? REGULAR;
186
- const dropOff = stop.dropOffType ?? REGULAR;
192
+ const pickUp = stop.pickUpType ?? PickUpDropOffTypes.REGULAR;
193
+ const dropOff = stop.dropOffType ?? PickUpDropOffTypes.REGULAR;
187
194
  const byteIndex = Math.floor(globalIndex / 2);
188
195
  const isSecondPair = globalIndex % 2 === 1;
189
196
 
@@ -13,16 +13,26 @@ import {
13
13
  serializeTripTransfers,
14
14
  } from './io.js';
15
15
  import { Timetable as ProtoTimetable } from './proto/v1/timetable.js';
16
- import { NOT_AVAILABLE } from './route.js';
17
- import { Route, RouteId, StopRouteIndex, TripRouteIndex } from './route.js';
16
+ import {
17
+ PickUpDropOffTypes,
18
+ Route,
19
+ RouteId,
20
+ StopRouteIndex,
21
+ TripRouteIndex,
22
+ } from './route.js';
18
23
  import { Duration, DURATION_ZERO, Time, TIME_ORIGIN } from './time.js';
19
24
  import { encode, TripStopId } from './tripStopId.js';
20
25
 
21
- export type TransferType =
22
- | 'RECOMMENDED'
23
- | 'GUARANTEED'
24
- | 'REQUIRES_MINIMAL_TIME'
25
- | 'IN_SEAT';
26
+ export const TransferTypes = {
27
+ RECOMMENDED: 1,
28
+ GUARANTEED: 2,
29
+ REQUIRES_MINIMAL_TIME: 3,
30
+ IN_SEAT: 4,
31
+ } as const;
32
+
33
+ export type TransferType = (typeof TransferTypes)[keyof typeof TransferTypes];
34
+
35
+ export type TransferTypeString = keyof typeof TransferTypes;
26
36
 
27
37
  export type Transfer = {
28
38
  destination: StopId;
@@ -45,17 +55,22 @@ export type TripTransfers = Map<TripStopId, TripStop[]>;
45
55
 
46
56
  export type ServiceRouteId = number;
47
57
 
48
- export type RouteType =
49
- | 'TRAM'
50
- | 'SUBWAY'
51
- | 'RAIL'
52
- | 'BUS'
53
- | 'FERRY'
54
- | 'CABLE_TRAM'
55
- | 'AERIAL_LIFT'
56
- | 'FUNICULAR'
57
- | 'TROLLEYBUS'
58
- | 'MONORAIL';
58
+ export const RouteTypes = {
59
+ TRAM: 1,
60
+ SUBWAY: 2,
61
+ RAIL: 3,
62
+ BUS: 4,
63
+ FERRY: 5,
64
+ CABLE_TRAM: 6,
65
+ AERIAL_LIFT: 7,
66
+ FUNICULAR: 8,
67
+ TROLLEYBUS: 9,
68
+ MONORAIL: 10,
69
+ } as const;
70
+
71
+ export type RouteType = (typeof RouteTypes)[keyof typeof RouteTypes];
72
+
73
+ export type RouteTypeString = keyof typeof RouteTypes;
59
74
 
60
75
  // A service refers to a collection of trips that are displayed to riders as a single service.
61
76
  // As opposed to a route which consists of the subset of trips from a service which shares the same list of stops.
@@ -67,18 +82,9 @@ export type ServiceRoute = {
67
82
  };
68
83
  export type ServiceRouteInfo = Omit<ServiceRoute, 'routes'>;
69
84
 
70
- export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set([
71
- 'TRAM',
72
- 'SUBWAY',
73
- 'RAIL',
74
- 'BUS',
75
- 'FERRY',
76
- 'CABLE_TRAM',
77
- 'AERIAL_LIFT',
78
- 'FUNICULAR',
79
- 'TROLLEYBUS',
80
- 'MONORAIL',
81
- ]);
85
+ export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set(
86
+ Object.values(RouteTypes),
87
+ );
82
88
 
83
89
  const EMPTY_TRIP_BOARDINGS: TripStop[] = [];
84
90
 
@@ -370,7 +376,7 @@ export class Timetable {
370
376
 
371
377
  for (let t = earliestTrip; t < (beforeTrip ?? nbTrips); t++) {
372
378
  const pickup = route.pickUpTypeFrom(stopIndex, t);
373
- if (pickup === NOT_AVAILABLE) {
379
+ if (pickup === PickUpDropOffTypes.NOT_AVAILABLE) {
374
380
  continue;
375
381
  }
376
382
  if (fromTripStop === undefined) {
@@ -416,3 +422,43 @@ export class Timetable {
416
422
  return guaranteedTripTransfers;
417
423
  }
418
424
  }
425
+
426
+ export const routeTypeToString = (type: RouteType): RouteTypeString => {
427
+ switch (type) {
428
+ case RouteTypes.TRAM:
429
+ return 'TRAM';
430
+ case RouteTypes.SUBWAY:
431
+ return 'SUBWAY';
432
+ case RouteTypes.RAIL:
433
+ return 'RAIL';
434
+ case RouteTypes.BUS:
435
+ return 'BUS';
436
+ case RouteTypes.FERRY:
437
+ return 'FERRY';
438
+ case RouteTypes.CABLE_TRAM:
439
+ return 'CABLE_TRAM';
440
+ case RouteTypes.AERIAL_LIFT:
441
+ return 'AERIAL_LIFT';
442
+ case RouteTypes.FUNICULAR:
443
+ return 'FUNICULAR';
444
+ case RouteTypes.TROLLEYBUS:
445
+ return 'TROLLEYBUS';
446
+ case RouteTypes.MONORAIL:
447
+ return 'MONORAIL';
448
+ }
449
+ };
450
+
451
+ export const transferTypeToString = (
452
+ type: TransferType,
453
+ ): TransferTypeString => {
454
+ switch (type) {
455
+ case TransferTypes.RECOMMENDED:
456
+ return 'RECOMMENDED';
457
+ case TransferTypes.GUARANTEED:
458
+ return 'GUARANTEED';
459
+ case TransferTypes.REQUIRES_MINIMAL_TIME:
460
+ return 'REQUIRES_MINIMAL_TIME';
461
+ case TransferTypes.IN_SEAT:
462
+ return 'IN_SEAT';
463
+ }
464
+ };
@@ -0,0 +1,97 @@
1
+ # Virtual transfers
2
+
3
+ Many GTFS feeds only partially populate `transfers.txt`, so nearby stops that belong to different stations (e.g. a subway platform and an adjacent tram or bus terminal) end up with no walking connection and cannot be used as an interchange. A `TransferGenerator` can be passed to the parser to synthesize the missing walking transfers as a pre-processing step, before the timetable is serialized.
4
+
5
+ ## Built-in implementation
6
+
7
+ `StraightLineTransferGenerator` connects nearby stops that aren't already linked in the feed — for every stop it adds walking transfers to the other stops within a radius, estimating the walking time from the straight-line distance:
8
+
9
+ ```ts
10
+ import {
11
+ GtfsParser,
12
+ StraightLineTransferGenerator,
13
+ extendedGtfsProfile,
14
+ } from 'minotor/parser';
15
+
16
+ const parser = new GtfsParser(
17
+ 'gtfs-feed.zip',
18
+ extendedGtfsProfile,
19
+ new StraightLineTransferGenerator({ maxDistanceMeters: 500 }),
20
+ );
21
+
22
+ const timetable = await parser.parseTimetable(new Date());
23
+ ```
24
+
25
+ On top of the walking time, some adjustments make the estimate more realistic:
26
+
27
+ - a **detour factor** as no path in the real world is a straight line
28
+ - a flat **change penalty** added to every transfer, for the general overhead of changing
29
+
30
+ The change penalty is symmetric, so the two directions of a transfer share the same minimum time. Existing transfers from the feed are always preserved:
31
+
32
+ | Option | Default | Description |
33
+ | ---------------------- | ------- | ----------------------------------------------------------------------- |
34
+ | `maxDistanceMeters` | `500` | Radius within which two stops are connected |
35
+ | `walkingSpeedKmh` | `4` | Assumed walking speed |
36
+ | `detourFactor` | `1.3` | Multiplier from straight-line to real walking distance (`1` to disable) |
37
+ | `changePenaltyMinutes` | `3` | Flat penalty added to every generated transfer (`0` to disable) |
38
+
39
+ ## Custom implementation
40
+
41
+ The straight-line estimate is relatively basic but works without external dependencies. For realistic walking times, you can implement the `TransferGenerator` interface yourself by e.g. delegating to an external pedestrian routing engine.
42
+
43
+ The parser passes the candidate origin stops (route-served stops with coordinates) and deduplicates the result against the transfers already in the feed, keeping only links between stops a route actually calls at — so you can emit a transfer for every nearby pair without tracking what already exists. Return the directed transfers to add, using `TransferTypes.REQUIRES_MINIMAL_TIME` so the router treats them as walking connections (for both transfers and access/egress). `minTransferTime` is expressed in minutes.
44
+
45
+ ```ts
46
+ import { GtfsParser, TransferTypes, extendedGtfsProfile } from 'minotor/parser';
47
+ import type { GeneratedTransfers, TransferGenerator } from 'minotor/parser';
48
+ import type { Stop, StopsIndex } from 'minotor';
49
+
50
+ // Delegates to a hypothetical external walking-router HTTP API.
51
+ class WalkingApiTransferGenerator implements TransferGenerator {
52
+ async generate(
53
+ originStops: Stop[],
54
+ stops: StopsIndex,
55
+ ): Promise<GeneratedTransfers> {
56
+ const generated: GeneratedTransfers = new Map();
57
+
58
+ for (const origin of originStops) {
59
+ // Reuse minotor's geo index to find nearby candidate stops.
60
+ const neighbors = stops.findStopsByLocation(
61
+ origin.lat,
62
+ origin.lon,
63
+ Infinity,
64
+ this.maxDistanceKm,
65
+ );
66
+
67
+ for (const neighbor of neighbors) {
68
+ // Ask the external engine for a real door-to-door walking time.
69
+ const walkTimeInMinutes = await callExternalRoutingEngine(
70
+ origin.lat,
71
+ origin.lon,
72
+ neighbor.lat,
73
+ neighbor.lon,
74
+ );
75
+
76
+ const transfers = generated.get(origin.id) ?? [];
77
+ transfers.push({
78
+ destination: neighbor.id,
79
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
80
+ minTransferTime: walkTimeInMinutes,
81
+ });
82
+ generated.set(origin.id, transfers);
83
+ }
84
+ }
85
+
86
+ return generated;
87
+ }
88
+ }
89
+
90
+ const parser = new GtfsParser(
91
+ 'gtfs-feed.zip',
92
+ extendedGtfsProfile,
93
+ new WalkingApiTransferGenerator('https://walk.example.com'),
94
+ );
95
+ ```
96
+
97
+ Transfers are directed. The example above emits one edge per `origin -> neighbor`; the reverse edge is produced when the neighbor is itself visited as an origin (every candidate stop is passed as an origin), so a symmetric walking time yields a usable connection both ways.