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.
@@ -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 {};
@@ -5,6 +5,14 @@ import { GtfsStopsMap } from './stops.js';
5
5
  import { GtfsTripId, TripsMapping } from './trips.js';
6
6
  export type GtfsTransferType = 0 | 1 | 2 | 3 | 4 | 5;
7
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>>;
8
16
  export type GtfsTripTransfer = {
9
17
  fromStop: StopId;
10
18
  fromTrip: GtfsTripId;
@@ -32,9 +40,31 @@ export type TransferEntry = {
32
40
  */
33
41
  export declare const parseTransfers: (transfersStream: NodeJS.ReadableStream, stopsMap: GtfsStopsMap, activeServiceIds: ServiceIds) => Promise<{
34
42
  transfers: TransfersMap;
43
+ forbiddenTransfers: ForbiddenTransfersMap;
35
44
  tripContinuations: GtfsTripTransfer[];
36
45
  guaranteedTripTransfers: GtfsTripTransfer[];
37
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;
38
68
  /**
39
69
  * Builds trip continuations map from GTFS trip continuation data.
40
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:
@@ -16028,24 +16010,27 @@ const processStopToStopTransfer = (transferEntry, fromStop, toStop, transfers) =
16028
16010
  */
16029
16011
  const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaiter(void 0, void 0, void 0, function* () {
16030
16012
  var _a, e_1, _b, _c;
16013
+ var _d;
16031
16014
  const transfers = new Map();
16015
+ const forbiddenTransfers = new Map();
16032
16016
  const tripContinuations = [];
16033
16017
  const guaranteedTripTransfers = [];
16034
16018
  try {
16035
- for (var _d = true, _e = __asyncValues(parseCsv(transfersStream, [
16019
+ for (var _e = true, _f = __asyncValues(parseCsv(transfersStream, [
16036
16020
  'transfer_type',
16037
16021
  'min_transfer_time',
16038
- ])), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
16039
- _c = _f.value;
16040
- _d = false;
16022
+ ])), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
16023
+ _c = _g.value;
16024
+ _e = false;
16041
16025
  const rawLine = _c;
16042
16026
  const transferEntry = rawLine;
16043
16027
  if (transferEntry.service_id &&
16044
16028
  !activeServiceIds.has(transferEntry.service_id)) {
16045
16029
  continue;
16046
16030
  }
16047
- if (transferEntry.transfer_type === 3 ||
16048
- transferEntry.transfer_type === 5) {
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) {
16049
16034
  continue;
16050
16035
  }
16051
16036
  if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
@@ -16075,6 +16060,19 @@ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaite
16075
16060
  processGuaranteedStopTransfer(transferEntry, fromStop.id, toStop.id, transfers);
16076
16061
  }
16077
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
+ }
16078
16076
  case 0: // Recommended transfer
16079
16077
  case 2: // Requires minimal time
16080
16078
  default:
@@ -16086,16 +16084,92 @@ const parseTransfers = (transfersStream, stopsMap, activeServiceIds) => __awaite
16086
16084
  catch (e_1_1) { e_1 = { error: e_1_1 }; }
16087
16085
  finally {
16088
16086
  try {
16089
- if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
16087
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
16090
16088
  }
16091
16089
  finally { if (e_1) throw e_1.error; }
16092
16090
  }
16093
16091
  return {
16094
16092
  transfers,
16093
+ forbiddenTransfers,
16095
16094
  tripContinuations,
16096
16095
  guaranteedTripTransfers,
16097
16096
  };
16098
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
+ };
16099
16173
  /**
16100
16174
  * Disambiguates stops involved in a transfer.
16101
16175
  *
@@ -16615,14 +16689,16 @@ class GtfsParser {
16615
16689
  const tripsEnd = performance.now();
16616
16690
  log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
16617
16691
  let transfers = new Map();
16692
+ let forbiddenTransfers = new Map();
16618
16693
  let tripContinuationsList = [];
16619
16694
  let guaranteedTripTransfersList = [];
16620
16695
  if (entries[TRANSFERS_FILE]) {
16621
16696
  log.info(`Parsing ${TRANSFERS_FILE}`);
16622
16697
  const transfersStart = performance.now();
16623
16698
  const transfersStream = yield zip.stream(TRANSFERS_FILE);
16624
- const { transfers: parsedTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16699
+ const { transfers: parsedTransfers, forbiddenTransfers: parsedForbiddenTransfers, tripContinuations: parsedTripContinuations, guaranteedTripTransfers: parsedGuaranteedTripTransfers, } = yield parseTransfers(transfersStream, parsedStops, activeServiceIds);
16625
16700
  transfers = parsedTransfers;
16701
+ forbiddenTransfers = parsedForbiddenTransfers;
16626
16702
  tripContinuationsList = parsedTripContinuations;
16627
16703
  guaranteedTripTransfersList = parsedGuaranteedTripTransfers;
16628
16704
  const transfersEnd = performance.now();
@@ -16644,6 +16720,12 @@ class GtfsParser {
16644
16720
  const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
16645
16721
  const stopTimesEnd = performance.now();
16646
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
+ }
16647
16729
  if (this.transferGenerator) {
16648
16730
  log.info('Generating virtual transfers');
16649
16731
  const virtualTransfersStart = performance.now();
@@ -16654,22 +16736,7 @@ class GtfsParser {
16654
16736
  stop.lon !== undefined);
16655
16737
  const stopsIndex = new StopsIndex(Array.from(parsedStops.values()));
16656
16738
  const generatedTransfers = yield this.transferGenerator.generate(originStops, stopsIndex);
16657
- let addedTransfers = 0;
16658
- for (const [fromStop, newTransfers] of generatedTransfers) {
16659
- const existing = getOrInsert(transfers, fromStop, []);
16660
- // Deduplicate per directed pair against existing (feed) transfers, and
16661
- // only keep transfers into stops a route actually calls at.
16662
- const connected = new Set(existing.map((t) => t.destination));
16663
- for (const transfer of newTransfers) {
16664
- if (!activeStopIds.has(transfer.destination) ||
16665
- connected.has(transfer.destination)) {
16666
- continue;
16667
- }
16668
- connected.add(transfer.destination);
16669
- existing.push(transfer);
16670
- addedTransfers += 1;
16671
- }
16672
- }
16739
+ const addedTransfers = addGeneratedTransfers(generatedTransfers, activeStopIds, transfers, forbiddenTransfers);
16673
16740
  const virtualTransfersEnd = performance.now();
16674
16741
  log.info(`${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`);
16675
16742
  }
@@ -16840,9 +16907,29 @@ const routeTypeParser = (routeType) => {
16840
16907
  }
16841
16908
  };
16842
16909
  const extendedGtfsProfile = {
16910
+ deriveSiblingTransfers: true,
16843
16911
  routeTypeParser,
16844
16912
  };
16845
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
+
16846
16933
  const DEFAULT_MAX_DISTANCE_METERS = 500;
16847
16934
  const DEFAULT_WALKING_SPEED_KMH = 4;
16848
16935
  const DEFAULT_DETOUR_FACTOR = 1.3;