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.
@@ -13664,25 +13664,6 @@ class Timetable {
13664
13664
  }
13665
13665
  }
13666
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
-
13686
13667
  const toGtfsDate = (date) => {
13687
13668
  return parseInt(date.toFormat('yyyyLLdd'));
13688
13669
  };
@@ -15691,6 +15672,7 @@ const parseFrequencies = (stream, activeTripIds) => __awaiter(void 0, void 0, vo
15691
15672
  });
15692
15673
 
15693
15674
  const standardGtfsProfile = {
15675
+ deriveSiblingTransfers: true,
15694
15676
  routeTypeParser: (routeType) => {
15695
15677
  switch (routeType) {
15696
15678
  case 0:
@@ -16019,25 +16001,34 @@ const processStopToStopTransfer = (transferEntry, fromStop, toStop, transfers) =
16019
16001
  /**
16020
16002
  * Parses the transfers.txt file from a GTFS feed.
16021
16003
  *
16022
- * @param stopsStream The readable stream containing the stops data.
16023
- * @return A mapping of stop IDs to corresponding stop details.
16004
+ * @param transfersStream The readable stream containing the transfers data.
16005
+ * @param stopsMap The parsed GTFS stops indexed by their source IDs.
16006
+ * @param activeServiceIds The service IDs active for the requested date.
16007
+ * @returns Parsed stop transfers, trip continuations, and guaranteed trip transfers.
16024
16008
  */
16025
- const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0, void 0, function* () {
16009
+ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaiter(void 0, void 0, void 0, function* () {
16026
16010
  var _a, e_1, _b, _c;
16011
+ var _d;
16027
16012
  const transfers = new Map();
16013
+ const forbiddenTransfers = new Map();
16028
16014
  const tripContinuations = [];
16029
16015
  const guaranteedTripTransfers = [];
16030
16016
  try {
16031
- for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
16017
+ for (var _e = true, _f = __asyncValues(parseCsv(transfersStream, [
16032
16018
  'transfer_type',
16033
16019
  'min_transfer_time',
16034
- ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
16035
- _c = _f.value;
16036
- _d = false;
16020
+ ])), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
16021
+ _c = _g.value;
16022
+ _e = false;
16037
16023
  const rawLine = _c;
16038
16024
  const transferEntry = rawLine;
16039
- if (transferEntry.transfer_type === 3 ||
16040
- transferEntry.transfer_type === 5) {
16025
+ if (transferEntry.service_id &&
16026
+ !activeServiceIds.has(transferEntry.service_id)) {
16027
+ continue;
16028
+ }
16029
+ // Type 5 only prevents remaining seated between two specific trips. It
16030
+ // does not prohibit an ordinary stop-to-stop transfer.
16031
+ if (transferEntry.transfer_type === 5) {
16041
16032
  continue;
16042
16033
  }
16043
16034
  if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
@@ -16067,6 +16058,19 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
16067
16058
  processGuaranteedStopTransfer(transferEntry, fromStop.id, toStop.id, transfers);
16068
16059
  }
16069
16060
  break;
16061
+ case 3: {
16062
+ if (transferEntry.from_trip_id ||
16063
+ transferEntry.to_trip_id ||
16064
+ transferEntry.from_route_id ||
16065
+ transferEntry.to_route_id) {
16066
+ 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}.`);
16067
+ break;
16068
+ }
16069
+ const forbiddenDestinations = (_d = forbiddenTransfers.get(fromStop.id)) !== null && _d !== void 0 ? _d : new Set();
16070
+ forbiddenDestinations.add(toStop.id);
16071
+ forbiddenTransfers.set(fromStop.id, forbiddenDestinations);
16072
+ break;
16073
+ }
16070
16074
  case 0: // Recommended transfer
16071
16075
  case 2: // Requires minimal time
16072
16076
  default:
@@ -16078,16 +16082,92 @@ const parseTransfers = (transfersStream, stopsMap) => __awaiter(void 0, void 0,
16078
16082
  catch (e_1_1) { e_1 = { error: e_1_1 }; }
16079
16083
  finally {
16080
16084
  try {
16081
- if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
16085
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
16082
16086
  }
16083
16087
  finally { if (e_1) throw e_1.error; }
16084
16088
  }
16085
16089
  return {
16086
16090
  transfers,
16091
+ forbiddenTransfers,
16087
16092
  tripContinuations,
16088
16093
  guaranteedTripTransfers,
16089
16094
  };
16090
16095
  });
16096
+ /**
16097
+ * Adds missing directed transfers between route-served child stops belonging
16098
+ * to the same parent station.
16099
+ *
16100
+ * GTFS feeds commonly use parent_station to group platforms while omitting the
16101
+ * corresponding transfers.txt rows. The generated transfers intentionally do
16102
+ * not carry a fixed duration: routing applies the query's fallback minimum
16103
+ * transfer time. Explicit and forbidden feed entries always take precedence.
16104
+ *
16105
+ * @returns The number of directed sibling transfers added.
16106
+ */
16107
+ const addMissingSiblingTransfers = (stopsMap, activeStops, transfers, forbiddenTransfers = new Map()) => {
16108
+ var _a;
16109
+ let addedTransfers = 0;
16110
+ for (const parent of stopsMap.values()) {
16111
+ const activeChildren = parent.children.filter((child) => activeStops.has(child));
16112
+ if (activeChildren.length < 2)
16113
+ continue;
16114
+ for (const fromStop of activeChildren) {
16115
+ const existing = (_a = transfers.get(fromStop)) !== null && _a !== void 0 ? _a : [];
16116
+ const connected = new Set(existing.map((transfer) => transfer.destination));
16117
+ const forbidden = forbiddenTransfers.get(fromStop);
16118
+ for (const toStop of activeChildren) {
16119
+ if (toStop === fromStop ||
16120
+ connected.has(toStop) ||
16121
+ (forbidden === null || forbidden === void 0 ? void 0 : forbidden.has(toStop))) {
16122
+ continue;
16123
+ }
16124
+ existing.push({
16125
+ destination: toStop,
16126
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
16127
+ });
16128
+ connected.add(toStop);
16129
+ addedTransfers += 1;
16130
+ }
16131
+ if (existing.length > 0) {
16132
+ transfers.set(fromStop, existing);
16133
+ }
16134
+ }
16135
+ }
16136
+ return addedTransfers;
16137
+ };
16138
+ /**
16139
+ * Merges generated transfers into parsed feed transfers.
16140
+ *
16141
+ * Only transfers between active stops are kept. Explicit feed transfers and
16142
+ * forbidden directed pairs take precedence over generated candidates.
16143
+ *
16144
+ * @returns The number of generated transfers added.
16145
+ */
16146
+ const addGeneratedTransfers = (generatedTransfers, activeStops, transfers, forbiddenTransfers = new Map()) => {
16147
+ var _a;
16148
+ let addedTransfers = 0;
16149
+ for (const [fromStop, candidates] of generatedTransfers) {
16150
+ if (!activeStops.has(fromStop))
16151
+ continue;
16152
+ const existing = (_a = transfers.get(fromStop)) !== null && _a !== void 0 ? _a : [];
16153
+ const connected = new Set(existing.map((transfer) => transfer.destination));
16154
+ const forbidden = forbiddenTransfers.get(fromStop);
16155
+ for (const transfer of candidates) {
16156
+ if (!activeStops.has(transfer.destination) ||
16157
+ connected.has(transfer.destination) ||
16158
+ (forbidden === null || forbidden === void 0 ? void 0 : forbidden.has(transfer.destination))) {
16159
+ continue;
16160
+ }
16161
+ connected.add(transfer.destination);
16162
+ existing.push(transfer);
16163
+ addedTransfers += 1;
16164
+ }
16165
+ if (existing.length > 0) {
16166
+ transfers.set(fromStop, existing);
16167
+ }
16168
+ }
16169
+ return addedTransfers;
16170
+ };
16091
16171
  /**
16092
16172
  * Disambiguates stops involved in a transfer.
16093
16173
  *
@@ -16607,14 +16687,16 @@ class GtfsParser {
16607
16687
  const tripsEnd = performance.now();
16608
16688
  log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
16609
16689
  let transfers = new Map();
16690
+ let forbiddenTransfers = new Map();
16610
16691
  let tripContinuationsList = [];
16611
16692
  let guaranteedTripTransfersList = [];
16612
16693
  if (entries[TRANSFERS_FILE]) {
16613
16694
  log.info(`Parsing ${TRANSFERS_FILE}`);
16614
16695
  const transfersStart = performance.now();
16615
16696
  const transfersStream = yield zip.stream(TRANSFERS_FILE);
16616
- const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops);
16697
+ const { transfers: parsedTransfers, forbiddenTransfers: parsedForbiddenTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16617
16698
  transfers = parsedTransfers;
16699
+ forbiddenTransfers = parsedForbiddenTransfers;
16618
16700
  tripContinuationsList = parsedTripContinuations;
16619
16701
  guaranteedTripTransfersList = parsedGuaranteedTripTransfers;
16620
16702
  const transfersEnd = performance.now();
@@ -16636,6 +16718,12 @@ class GtfsParser {
16636
16718
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16637
16719
  const stopTimesEnd = performance.now();
16638
16720
  log.info(`${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
16721
+ if (this.profile.deriveSiblingTransfers !== false) {
16722
+ const siblingTransfersStart = performance.now();
16723
+ const siblingTransfersAdded = addMissingSiblingTransfers(parsedStops, activeStopIds, transfers, forbiddenTransfers);
16724
+ const siblingTransfersEnd = performance.now();
16725
+ log.info(`${siblingTransfersAdded} sibling transfers added. (${(siblingTransfersEnd - siblingTransfersStart).toFixed(2)}ms)`);
16726
+ }
16639
16727
  if (this.transferGenerator) {
16640
16728
  log.info('Generating virtual transfers');
16641
16729
  const virtualTransfersStart = performance.now();
@@ -16646,22 +16734,7 @@ class GtfsParser {
16646
16734
  stop.lon !== undefined);
16647
16735
  const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16648
16736
  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
- }
16737
+ const addedTransfers = addGeneratedTransfers(generatedTransfers, activeStopIds, transfers, forbiddenTransfers);
16665
16738
  const virtualTransfersEnd = performance.now();
16666
16739
  log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16667
16740
  }
@@ -16832,9 +16905,29 @@ const routeTypeParser = (routeType) => {
16832
16905
  }
16833
16906
  };
16834
16907
  const extendedGtfsProfile = {
16908
+ deriveSiblingTransfers: true,
16835
16909
  routeTypeParser,
16836
16910
  };
16837
16911
 
16912
+ /**
16913
+ * Returns the value stored under `key`, inserting and returning `defaultValue`
16914
+ * when the key is absent. Mirrors the TC39 `Map.prototype.getOrInsert`
16915
+ * proposal.
16916
+ *
16917
+ * TODO: remove this helper and call `map.getOrInsert(key, defaultValue)`
16918
+ * directly once we only target Node 26+ (where the method is built in).
16919
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/getOrInsert
16920
+ */
16921
+ const getOrInsert = (map, key, defaultValue) => {
16922
+ if (map.has(key)) {
16923
+ // Key is present, so `get` returns the stored value (which may itself be a
16924
+ // legitimately-stored `undefined`).
16925
+ return map.get(key);
16926
+ }
16927
+ map.set(key, defaultValue);
16928
+ return defaultValue;
16929
+ };
16930
+
16838
16931
  const DEFAULT_MAX_DISTANCE_METERS = 500;
16839
16932
  const DEFAULT_WALKING_SPEED_KMH = 4;
16840
16933
  const DEFAULT_DETOUR_FACTOR = 1.3;