minotor 11.3.0 → 11.5.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.
@@ -4,6 +4,12 @@ import { TransferGenerator } from '../transfers/generator.js';
4
4
  import { Maybe } from './utils.js';
5
5
  export type GtfsProfile = {
6
6
  routeTypeParser: (routeType: number) => Maybe<RouteType>;
7
+ /**
8
+ * Derive fallback transfers between active stops that share a parent station.
9
+ *
10
+ * @default true
11
+ */
12
+ deriveSiblingTransfers?: boolean;
7
13
  };
8
14
  export declare class GtfsParser {
9
15
  private path;
@@ -0,0 +1 @@
1
+ export {};
@@ -1,9 +1,18 @@
1
1
  import { SourceStopId, StopId } from '../stops/stops.js';
2
2
  import { ServiceRouteId, Timetable, Transfer, TripTransfers as TripTransfers } from '../timetable/timetable.js';
3
+ import { ServiceId, ServiceIds } from './services.js';
3
4
  import { GtfsStopsMap } from './stops.js';
4
5
  import { GtfsTripId, TripsMapping } from './trips.js';
5
6
  export type GtfsTransferType = 0 | 1 | 2 | 3 | 4 | 5;
6
7
  export type TransfersMap = Map<StopId, Transfer[]>;
8
+ /**
9
+ * Directed stop pairs for which the feed explicitly disallows transfers.
10
+ *
11
+ * These constraints are retained during parsing so generated transfers do not
12
+ * accidentally re-enable a connection declared with GTFS transfer_type=3.
13
+ * They are not serialized into the routing timetable.
14
+ */
15
+ export type ForbiddenTransfersMap = Map<StopId, Set<StopId>>;
7
16
  export type GtfsTripTransfer = {
8
17
  fromStop: StopId;
9
18
  fromTrip: GtfsTripId;
@@ -17,20 +26,45 @@ export type TransferEntry = {
17
26
  to_trip_id?: GtfsTripId;
18
27
  from_route_id?: ServiceRouteId;
19
28
  to_route_id?: ServiceRouteId;
29
+ service_id?: ServiceId;
20
30
  transfer_type: GtfsTransferType;
21
31
  min_transfer_time?: number;
22
32
  };
23
33
  /**
24
34
  * Parses the transfers.txt file from a GTFS feed.
25
35
  *
26
- * @param stopsStream The readable stream containing the stops data.
27
- * @return A mapping of stop IDs to corresponding stop details.
36
+ * @param transfersStream The readable stream containing the transfers data.
37
+ * @param stopsMap The parsed GTFS stops indexed by their source IDs.
38
+ * @param activeServiceIds The service IDs active for the requested date.
39
+ * @returns Parsed stop transfers, trip continuations, and guaranteed trip transfers.
28
40
  */
29
- export declare const parseTransfers: (transfersStream: NodeJS.ReadableStream, stopsMap: GtfsStopsMap) => Promise<{
41
+ export declare const parseTransfers: (transfersStream: NodeJS.ReadableStream, stopsMap: GtfsStopsMap, activeServiceIds: ServiceIds) => Promise<{
30
42
  transfers: TransfersMap;
43
+ forbiddenTransfers: ForbiddenTransfersMap;
31
44
  tripContinuations: GtfsTripTransfer[];
32
45
  guaranteedTripTransfers: GtfsTripTransfer[];
33
46
  }>;
47
+ /**
48
+ * Adds missing directed transfers between route-served child stops belonging
49
+ * to the same parent station.
50
+ *
51
+ * GTFS feeds commonly use parent_station to group platforms while omitting the
52
+ * corresponding transfers.txt rows. The generated transfers intentionally do
53
+ * not carry a fixed duration: routing applies the query's fallback minimum
54
+ * transfer time. Explicit and forbidden feed entries always take precedence.
55
+ *
56
+ * @returns The number of directed sibling transfers added.
57
+ */
58
+ export declare const addMissingSiblingTransfers: (stopsMap: GtfsStopsMap, activeStops: ReadonlySet<StopId>, transfers: TransfersMap, forbiddenTransfers?: ForbiddenTransfersMap) => number;
59
+ /**
60
+ * Merges generated transfers into parsed feed transfers.
61
+ *
62
+ * Only transfers between active stops are kept. Explicit feed transfers and
63
+ * forbidden directed pairs take precedence over generated candidates.
64
+ *
65
+ * @returns The number of generated transfers added.
66
+ */
67
+ export declare const addGeneratedTransfers: (generatedTransfers: ReadonlyMap<StopId, readonly Transfer[]>, activeStops: ReadonlySet<StopId>, transfers: TransfersMap, forbiddenTransfers?: ForbiddenTransfersMap) => number;
34
68
  /**
35
69
  * Builds trip continuations map from GTFS trip continuation data.
36
70
  *
@@ -13666,25 +13666,6 @@ class Timetable {
13666
13666
  }
13667
13667
  }
13668
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
-
13688
13669
  const toGtfsDate = (date) => {
13689
13670
  return parseInt(date.toFormat('yyyyLLdd'));
13690
13671
  };
@@ -15693,6 +15674,7 @@ const parseFrequencies = (stream, activeTripIds) => __awaiter(void 0, void 0, vo
15693
15674
  });
15694
15675
 
15695
15676
  const standardGtfsProfile = {
15677
+ deriveSiblingTransfers: true,
15696
15678
  routeTypeParser: (routeType) => {
15697
15679
  switch (routeType) {
15698
15680
  case 0:
@@ -16021,25 +16003,34 @@ const processStopToStopTransfer = (transferEntry, fromStop, toStop, transfers) =
16021
16003
  /**
16022
16004
  * Parses the transfers.txt file from a GTFS feed.
16023
16005
  *
16024
- * @param stopsStream The readable stream containing the stops data.
16025
- * @return A mapping of stop IDs to corresponding stop details.
16006
+ * @param transfersStream The readable stream containing the transfers data.
16007
+ * @param stopsMap The parsed GTFS stops indexed by their source IDs.
16008
+ * @param activeServiceIds The service IDs active for the requested date.
16009
+ * @returns Parsed stop transfers, trip continuations, and guaranteed trip transfers.
16026
16010
  */
16027
- const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
16011
+ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaiter(void 0, void 0, void 0, function* () {
16028
16012
  var _a, e_1, _b, _c;
16013
+ var _d;
16029
16014
  const transfers = new Map();
16015
+ const forbiddenTransfers = new Map();
16030
16016
  const tripContinuations = [];
16031
16017
  const guaranteedTripTransfers = [];
16032
16018
  try {
16033
- for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
16019
+ for (var _e = true, _f = __asyncValues(parseCsv(transfersStream, [
16034
16020
  'transfer_type',
16035
16021
  'min_transfer_time',
16036
- ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
16037
- _c = _f.value;
16038
- _d = false;
16022
+ ])), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
16023
+ _c = _g.value;
16024
+ _e = false;
16039
16025
  const rawLine = _c;
16040
16026
  const transferEntry = rawLine;
16041
- if (transferEntry.transfer_type === 3 ||
16042
- transferEntry.transfer_type === 5) {
16027
+ if (transferEntry.service_id &&
16028
+ !activeServiceIds.has(transferEntry.service_id)) {
16029
+ continue;
16030
+ }
16031
+ // Type 5 only prevents remaining seated between two specific trips. It
16032
+ // does not prohibit an ordinary stop-to-stop transfer.
16033
+ if (transferEntry.transfer_type === 5) {
16043
16034
  continue;
16044
16035
  }
16045
16036
  if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
@@ -16069,6 +16060,19 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
16069
16060
  processGuaranteedStopTransfer(transferEntry, fromStop.id, toStop.id, transfers);
16070
16061
  }
16071
16062
  break;
16063
+ case 3: {
16064
+ if (transferEntry.from_trip_id ||
16065
+ transferEntry.to_trip_id ||
16066
+ transferEntry.from_route_id ||
16067
+ transferEntry.to_route_id) {
16068
+ log.warn(`Unsupported transfer of type 3 with trip or route constraints: from_trip_id=${transferEntry.from_trip_id}, to_trip_id=${transferEntry.to_trip_id}, from_route_id=${transferEntry.from_route_id}, to_route_id=${transferEntry.to_route_id}.`);
16069
+ break;
16070
+ }
16071
+ const forbiddenDestinations = (_d = forbiddenTransfers.get(fromStop.id)) !== null && _d !== void 0 ? _d : new Set();
16072
+ forbiddenDestinations.add(toStop.id);
16073
+ forbiddenTransfers.set(fromStop.id, forbiddenDestinations);
16074
+ break;
16075
+ }
16072
16076
  case 0: // Recommended transfer
16073
16077
  case 2: // Requires minimal time
16074
16078
  default:
@@ -16080,16 +16084,92 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
16080
16084
  catch (e_1_1) { e_1 = { error: e_1_1 }; }
16081
16085
  finally {
16082
16086
  try {
16083
- if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
16087
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
16084
16088
  }
16085
16089
  finally { if (e_1) throw e_1.error; }
16086
16090
  }
16087
16091
  return {
16088
16092
  transfers,
16093
+ forbiddenTransfers,
16089
16094
  tripContinuations,
16090
16095
  guaranteedTripTransfers,
16091
16096
  };
16092
16097
  });
16098
+ /**
16099
+ * Adds missing directed transfers between route-served child stops belonging
16100
+ * to the same parent station.
16101
+ *
16102
+ * GTFS feeds commonly use parent_station to group platforms while omitting the
16103
+ * corresponding transfers.txt rows. The generated transfers intentionally do
16104
+ * not carry a fixed duration: routing applies the query's fallback minimum
16105
+ * transfer time. Explicit and forbidden feed entries always take precedence.
16106
+ *
16107
+ * @returns The number of directed sibling transfers added.
16108
+ */
16109
+ const addMissingSiblingTransfers = (stopsMap, activeStops, transfers, forbiddenTransfers = new Map()) => {
16110
+ var _a;
16111
+ let addedTransfers = 0;
16112
+ for (const parent of stopsMap.values()) {
16113
+ const activeChildren = parent.children.filter((child) => activeStops.has(child));
16114
+ if (activeChildren.length < 2)
16115
+ continue;
16116
+ for (const fromStop of activeChildren) {
16117
+ const existing = (_a = transfers.get(fromStop)) !== null && _a !== void 0 ? _a : [];
16118
+ const connected = new Set(existing.map((transfer) => transfer.destination));
16119
+ const forbidden = forbiddenTransfers.get(fromStop);
16120
+ for (const toStop of activeChildren) {
16121
+ if (toStop === fromStop ||
16122
+ connected.has(toStop) ||
16123
+ (forbidden === null || forbidden === void 0 ? void 0 : forbidden.has(toStop))) {
16124
+ continue;
16125
+ }
16126
+ existing.push({
16127
+ destination: toStop,
16128
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
16129
+ });
16130
+ connected.add(toStop);
16131
+ addedTransfers += 1;
16132
+ }
16133
+ if (existing.length > 0) {
16134
+ transfers.set(fromStop, existing);
16135
+ }
16136
+ }
16137
+ }
16138
+ return addedTransfers;
16139
+ };
16140
+ /**
16141
+ * Merges generated transfers into parsed feed transfers.
16142
+ *
16143
+ * Only transfers between active stops are kept. Explicit feed transfers and
16144
+ * forbidden directed pairs take precedence over generated candidates.
16145
+ *
16146
+ * @returns The number of generated transfers added.
16147
+ */
16148
+ const addGeneratedTransfers = (generatedTransfers, activeStops, transfers, forbiddenTransfers = new Map()) => {
16149
+ var _a;
16150
+ let addedTransfers = 0;
16151
+ for (const [fromStop, candidates] of generatedTransfers) {
16152
+ if (!activeStops.has(fromStop))
16153
+ continue;
16154
+ const existing = (_a = transfers.get(fromStop)) !== null && _a !== void 0 ? _a : [];
16155
+ const connected = new Set(existing.map((transfer) => transfer.destination));
16156
+ const forbidden = forbiddenTransfers.get(fromStop);
16157
+ for (const transfer of candidates) {
16158
+ if (!activeStops.has(transfer.destination) ||
16159
+ connected.has(transfer.destination) ||
16160
+ (forbidden === null || forbidden === void 0 ? void 0 : forbidden.has(transfer.destination))) {
16161
+ continue;
16162
+ }
16163
+ connected.add(transfer.destination);
16164
+ existing.push(transfer);
16165
+ addedTransfers += 1;
16166
+ }
16167
+ if (existing.length > 0) {
16168
+ transfers.set(fromStop, existing);
16169
+ }
16170
+ }
16171
+ return addedTransfers;
16172
+ };
16093
16173
  /**
16094
16174
  * Disambiguates stops involved in a transfer.
16095
16175
  *
@@ -16609,14 +16689,16 @@ class GtfsParser {
16609
16689
  const tripsEnd = performance.now();
16610
16690
  log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
16611
16691
  let transfers = new Map();
16692
+ let forbiddenTransfers = new Map();
16612
16693
  let tripContinuationsList = [];
16613
16694
  let guaranteedTripTransfersList = [];
16614
16695
  if (entries[TRANSFERS_FILE]) {
16615
16696
  log.info(`Parsing ${TRANSFERS_FILE}`);
16616
16697
  const transfersStart = performance.now();
16617
16698
  const transfersStream = yield zip.stream(TRANSFERS_FILE);
16618
- const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops);
16699
+ const { transfers: parsedTransfers, forbiddenTransfers: parsedForbiddenTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16619
16700
  transfers = parsedTransfers;
16701
+ forbiddenTransfers = parsedForbiddenTransfers;
16620
16702
  tripContinuationsList = parsedTripContinuations;
16621
16703
  guaranteedTripTransfersList = parsedGuaranteedTripTransfers;
16622
16704
  const transfersEnd = performance.now();
@@ -16638,6 +16720,12 @@ class GtfsParser {
16638
16720
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16639
16721
  const stopTimesEnd = performance.now();
16640
16722
  log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
16723
+ if (this.profile.deriveSiblingTransfers !== false) {
16724
+ const siblingTransfersStart = performance.now();
16725
+ const siblingTransfersAdded = addMissingSiblingTransfers(parsedStops, activeStopIds, transfers, forbiddenTransfers);
16726
+ const siblingTransfersEnd = performance.now();
16727
+ log.info(`${siblingTransfersAdded} sibling transfers added. (${(siblingTransfersEnd - siblingTransfersStart).toFixed(2)}ms)`);
16728
+ }
16641
16729
  if (this.transferGenerator) {
16642
16730
  log.info('Generating virtual transfers');
16643
16731
  const virtualTransfersStart = performance.now();
@@ -16648,22 +16736,7 @@ class GtfsParser {
16648
16736
  stop.lon !== undefined);
16649
16737
  const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16650
16738
  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
- }
16739
+ const addedTransfers = addGeneratedTransfers(generatedTransfers, activeStopIds, transfers, forbiddenTransfers);
16667
16740
  const virtualTransfersEnd = performance.now();
16668
16741
  log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16669
16742
  }
@@ -16834,9 +16907,29 @@ const routeTypeParser = (routeType) => {
16834
16907
  }
16835
16908
  };
16836
16909
  const extendedGtfsProfile = {
16910
+ deriveSiblingTransfers: true,
16837
16911
  routeTypeParser,
16838
16912
  };
16839
16913
 
16914
+ /**
16915
+ * Returns the value stored under `key`, inserting and returning `defaultValue`
16916
+ * when the key is absent. Mirrors the TC39 `Map.prototype.getOrInsert`
16917
+ * proposal.
16918
+ *
16919
+ * TODO: remove this helper and call `map.getOrInsert(key, defaultValue)`
16920
+ * directly once we only target Node 26+ (where the method is built in).
16921
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/getOrInsert
16922
+ */
16923
+ const getOrInsert = (map, key, defaultValue) => {
16924
+ if (map.has(key)) {
16925
+ // Key is present, so `get` returns the stored value (which may itself be a
16926
+ // legitimately-stored `undefined`).
16927
+ return map.get(key);
16928
+ }
16929
+ map.set(key, defaultValue);
16930
+ return defaultValue;
16931
+ };
16932
+
16840
16933
  const DEFAULT_MAX_DISTANCE_METERS = 500;
16841
16934
  const DEFAULT_WALKING_SPEED_KMH = 4;
16842
16935
  const DEFAULT_DETOUR_FACTOR = 1.3;