minotor 11.4.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:
@@ -16026,24 +16008,27 @@ const processStopToStopTransfer = (transferEntry, fromStop, toStop, transfers) =
16026
16008
  */
16027
16009
  const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaiter(void 0, void 0, void 0, function* () {
16028
16010
  var _a, e_1, _b, _c;
16011
+ var _d;
16029
16012
  const transfers = new Map();
16013
+ const forbiddenTransfers = new Map();
16030
16014
  const tripContinuations = [];
16031
16015
  const guaranteedTripTransfers = [];
16032
16016
  try {
16033
- for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
16017
+ for (var _e = true, _f = __asyncValues(parseCsv(transfersStream, [
16034
16018
  'transfer_type',
16035
16019
  'min_transfer_time',
16036
- ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
16037
- _c = _f.value;
16038
- _d = false;
16020
+ ])), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
16021
+ _c = _g.value;
16022
+ _e = false;
16039
16023
  const rawLine = _c;
16040
16024
  const transferEntry = rawLine;
16041
16025
  if (transferEntry.service_id &&
16042
16026
  !activeServiceIds.has(transferEntry.service_id)) {
16043
16027
  continue;
16044
16028
  }
16045
- if (transferEntry.transfer_type === 3 ||
16046
- transferEntry.transfer_type === 5) {
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) {
16047
16032
  continue;
16048
16033
  }
16049
16034
  if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
@@ -16073,6 +16058,19 @@ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaite
16073
16058
  processGuaranteedStopTransfer(transferEntry, fromStop.id, toStop.id, transfers);
16074
16059
  }
16075
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
+ }
16076
16074
  case 0: // Recommended transfer
16077
16075
  case 2: // Requires minimal time
16078
16076
  default:
@@ -16084,16 +16082,92 @@ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaite
16084
16082
  catch (e_1_1) { e_1 = { error: e_1_1 }; }
16085
16083
  finally {
16086
16084
  try {
16087
- if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
16085
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
16088
16086
  }
16089
16087
  finally { if (e_1) throw e_1.error; }
16090
16088
  }
16091
16089
  return {
16092
16090
  transfers,
16091
+ forbiddenTransfers,
16093
16092
  tripContinuations,
16094
16093
  guaranteedTripTransfers,
16095
16094
  };
16096
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
+ };
16097
16171
  /**
16098
16172
  * Disambiguates stops involved in a transfer.
16099
16173
  *
@@ -16613,14 +16687,16 @@ class GtfsParser {
16613
16687
  const tripsEnd = performance.now();
16614
16688
  log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
16615
16689
  let transfers = new Map();
16690
+ let forbiddenTransfers = new Map();
16616
16691
  let tripContinuationsList = [];
16617
16692
  let guaranteedTripTransfersList = [];
16618
16693
  if (entries[TRANSFERS_FILE]) {
16619
16694
  log.info(`Parsing ${TRANSFERS_FILE}`);
16620
16695
  const transfersStart = performance.now();
16621
16696
  const transfersStream = yield zip.stream(TRANSFERS_FILE);
16622
- const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16697
+ const { transfers: parsedTransfers, forbiddenTransfers: parsedForbiddenTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16623
16698
  transfers = parsedTransfers;
16699
+ forbiddenTransfers = parsedForbiddenTransfers;
16624
16700
  tripContinuationsList = parsedTripContinuations;
16625
16701
  guaranteedTripTransfersList = parsedGuaranteedTripTransfers;
16626
16702
  const transfersEnd = performance.now();
@@ -16642,6 +16718,12 @@ class GtfsParser {
16642
16718
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16643
16719
  const stopTimesEnd = performance.now();
16644
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
+ }
16645
16727
  if (this.transferGenerator) {
16646
16728
  log.info('Generating virtual transfers');
16647
16729
  const virtualTransfersStart = performance.now();
@@ -16652,22 +16734,7 @@ class GtfsParser {
16652
16734
  stop.lon !== undefined);
16653
16735
  const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16654
16736
  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
- }
16737
+ const addedTransfers = addGeneratedTransfers(generatedTransfers, activeStopIds, transfers, forbiddenTransfers);
16671
16738
  const virtualTransfersEnd = performance.now();
16672
16739
  log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16673
16740
  }
@@ -16838,9 +16905,29 @@ const routeTypeParser = (routeType) => {
16838
16905
  }
16839
16906
  };
16840
16907
  const extendedGtfsProfile = {
16908
+ deriveSiblingTransfers: true,
16841
16909
  routeTypeParser,
16842
16910
  };
16843
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
+
16844
16931
  const DEFAULT_MAX_DISTANCE_METERS = 500;
16845
16932
  const DEFAULT_WALKING_SPEED_KMH = 4;
16846
16933
  const DEFAULT_DETOUR_FACTOR = 1.3;