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.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "minotor",
3
- "version": "11.4.0",
3
+ "version": "11.5.0",
4
4
  "description": "A lightweight client-side transit routing library.",
5
5
  "keywords": [
6
6
  "minotor",
@@ -8,9 +8,13 @@ import { Timetable, TransferTypes } from '../../timetable/timetable.js';
8
8
  import { encode } from '../../timetable/tripStopId.js';
9
9
  import { GtfsStopsMap } from '../stops.js';
10
10
  import {
11
+ addGeneratedTransfers,
12
+ addMissingSiblingTransfers,
11
13
  buildTripTransfers,
14
+ ForbiddenTransfersMap,
12
15
  GtfsTripTransfer,
13
16
  parseTransfers,
17
+ TransfersMap,
14
18
  } from '../transfers.js';
15
19
  import { TripsMapping } from '../trips.js';
16
20
 
@@ -96,13 +100,15 @@ describe('GTFS transfers parser', () => {
96
100
  assert.deepEqual(result.tripContinuations, []);
97
101
  });
98
102
 
99
- it('should ignore impossible transfer types (3 and 5)', async () => {
103
+ it('should only retain unscoped impossible transfers as forbidden', async () => {
100
104
  const mockedStream = new Readable();
101
105
  mockedStream.push(
102
- 'from_stop_id,to_stop_id,transfer_type,min_transfer_time\n',
106
+ 'from_stop_id,to_stop_id,from_trip_id,to_trip_id,from_route_id,to_route_id,transfer_type,min_transfer_time\n',
103
107
  );
104
- mockedStream.push('"1100084","8014440:0:1","3","180"\n');
105
- mockedStream.push('"1100097","8014447","5","240"\n');
108
+ mockedStream.push('"1100084","8014440:0:1","","","","","3","180"\n');
109
+ mockedStream.push('"8014440:0:1","1100084","trip-a","","","","3","180"\n');
110
+ mockedStream.push('"1100097","8014447","","","","route-b","3","240"\n');
111
+ mockedStream.push('"1100097","8014447","","","","","5","240"\n');
106
112
  mockedStream.push(null);
107
113
 
108
114
  const stopsMap: GtfsStopsMap = new Map([
@@ -151,6 +157,7 @@ describe('GTFS transfers parser', () => {
151
157
  const result = await parseTransfers(mockedStream, stopsMap, new Set());
152
158
 
153
159
  assert.deepEqual(result.transfers, new Map());
160
+ assert.deepEqual(result.forbiddenTransfers, new Map([[0, new Set([1])]]));
154
161
  assert.deepEqual(result.tripContinuations, []);
155
162
  });
156
163
 
@@ -881,6 +888,159 @@ describe('GTFS transfers parser', () => {
881
888
  });
882
889
  });
883
890
 
891
+ describe('generated transfers', () => {
892
+ const stopsMap: GtfsStopsMap = new Map([
893
+ [
894
+ 'station',
895
+ {
896
+ id: 0,
897
+ sourceStopId: 'station',
898
+ name: 'Interchange',
899
+ children: [1, 2],
900
+ locationType: 'STATION',
901
+ },
902
+ ],
903
+ [
904
+ 'platform-a',
905
+ {
906
+ id: 1,
907
+ sourceStopId: 'platform-a',
908
+ name: 'Interchange',
909
+ parent: 0,
910
+ children: [],
911
+ locationType: 'SIMPLE_STOP_OR_PLATFORM',
912
+ },
913
+ ],
914
+ [
915
+ 'platform-b',
916
+ {
917
+ id: 2,
918
+ sourceStopId: 'platform-b',
919
+ name: 'Interchange',
920
+ parent: 0,
921
+ children: [],
922
+ locationType: 'SIMPLE_STOP_OR_PLATFORM',
923
+ },
924
+ ],
925
+ ]);
926
+
927
+ it('adds directed fallback transfers between active sibling platforms', () => {
928
+ const transfers: TransfersMap = new Map();
929
+
930
+ const added = addMissingSiblingTransfers(
931
+ stopsMap,
932
+ new Set([1, 2]),
933
+ transfers,
934
+ );
935
+
936
+ assert.strictEqual(added, 2);
937
+ assert.deepStrictEqual(
938
+ transfers,
939
+ new Map([
940
+ [
941
+ 1,
942
+ [
943
+ {
944
+ destination: 2,
945
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
946
+ },
947
+ ],
948
+ ],
949
+ [
950
+ 2,
951
+ [
952
+ {
953
+ destination: 1,
954
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
955
+ },
956
+ ],
957
+ ],
958
+ ]),
959
+ );
960
+ });
961
+
962
+ it('preserves explicit transfers and excludes forbidden sibling directions', () => {
963
+ const transfers: TransfersMap = new Map([
964
+ [
965
+ 1,
966
+ [
967
+ {
968
+ destination: 2,
969
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
970
+ minTransferTime: 7,
971
+ },
972
+ ],
973
+ ],
974
+ ]);
975
+ const forbiddenTransfers: ForbiddenTransfersMap = new Map([
976
+ [2, new Set([1])],
977
+ ]);
978
+
979
+ const added = addMissingSiblingTransfers(
980
+ stopsMap,
981
+ new Set([1, 2]),
982
+ transfers,
983
+ forbiddenTransfers,
984
+ );
985
+
986
+ assert.strictEqual(added, 0);
987
+ assert.deepStrictEqual(transfers.get(1), [
988
+ {
989
+ destination: 2,
990
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
991
+ minTransferTime: 7,
992
+ },
993
+ ]);
994
+ assert.strictEqual(transfers.has(2), false);
995
+ });
996
+
997
+ it('excludes forbidden directions from generated transfers', () => {
998
+ const transfers: TransfersMap = new Map();
999
+ const generatedTransfers: TransfersMap = new Map([
1000
+ [
1001
+ 1,
1002
+ [
1003
+ {
1004
+ destination: 2,
1005
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
1006
+ minTransferTime: 3,
1007
+ },
1008
+ ],
1009
+ ],
1010
+ [
1011
+ 2,
1012
+ [
1013
+ {
1014
+ destination: 1,
1015
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
1016
+ minTransferTime: 3,
1017
+ },
1018
+ ],
1019
+ ],
1020
+ ]);
1021
+ const forbiddenTransfers: ForbiddenTransfersMap = new Map([
1022
+ [1, new Set([2])],
1023
+ ]);
1024
+
1025
+ const added = addGeneratedTransfers(
1026
+ generatedTransfers,
1027
+ new Set([1, 2]),
1028
+ transfers,
1029
+ forbiddenTransfers,
1030
+ );
1031
+
1032
+ assert.strictEqual(added, 1);
1033
+ assert.strictEqual(transfers.has(1), false);
1034
+ assert.deepStrictEqual(transfers.get(2), [
1035
+ {
1036
+ destination: 1,
1037
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
1038
+ minTransferTime: 3,
1039
+ },
1040
+ ]);
1041
+ });
1042
+ });
1043
+
884
1044
  describe('buildTripTransfers', () => {
885
1045
  it('should build trip transfers for valid data', () => {
886
1046
  const tripsMapping: TripsMapping = new Map([
@@ -6,14 +6,16 @@ import { StopId } from '../stops/stops.js';
6
6
  import { StopsIndex } from '../stops/stopsIndex.js';
7
7
  import { RouteType, Timetable } from '../timetable/timetable.js';
8
8
  import { TransferGenerator } from '../transfers/generator.js';
9
- import { getOrInsert } from '../utils/map.js';
10
9
  import { FrequenciesMap, parseFrequencies } from './frequencies.js';
11
10
  import { standardGtfsProfile } from './profiles/standard.js';
12
11
  import { indexRoutes, parseRoutes } from './routes.js';
13
12
  import { parseCalendar, parseCalendarDates, ServiceIds } from './services.js';
14
13
  import { parseStops } from './stops.js';
15
14
  import {
15
+ addGeneratedTransfers,
16
+ addMissingSiblingTransfers,
16
17
  buildTripTransfers,
18
+ ForbiddenTransfersMap,
17
19
  GtfsTripTransfer,
18
20
  parseTransfers,
19
21
  TransfersMap,
@@ -36,6 +38,12 @@ const TRANSFERS_FILE = 'transfers.txt';
36
38
 
37
39
  export type GtfsProfile = {
38
40
  routeTypeParser: (routeType: number) => Maybe<RouteType>;
41
+ /**
42
+ * Derive fallback transfers between active stops that share a parent station.
43
+ *
44
+ * @default true
45
+ */
46
+ deriveSiblingTransfers?: boolean;
39
47
  };
40
48
 
41
49
  export class GtfsParser {
@@ -123,6 +131,7 @@ export class GtfsParser {
123
131
  );
124
132
 
125
133
  let transfers: TransfersMap = new Map();
134
+ let forbiddenTransfers: ForbiddenTransfersMap = new Map();
126
135
  let tripContinuationsList: GtfsTripTransfer[] = [];
127
136
  let guaranteedTripTransfersList: GtfsTripTransfer[] = [];
128
137
  if (entries[TRANSFERS_FILE]) {
@@ -131,10 +140,12 @@ export class GtfsParser {
131
140
  const transfersStream = await zip.stream(TRANSFERS_FILE);
132
141
  const {
133
142
  transfers: parsedTransfers,
143
+ forbiddenTransfers: parsedForbiddenTransfers,
134
144
  tripContinuations: parsedTripContinuations,
135
145
  guaranteedTripTransfers: parsedGuaranteedTripTransfers,
136
146
  } = await parseTransfers(transfersStream, parsedStops, activeServiceIds);
137
147
  transfers = parsedTransfers;
148
+ forbiddenTransfers = parsedForbiddenTransfers;
138
149
  tripContinuationsList = parsedTripContinuations;
139
150
  guaranteedTripTransfersList = parsedGuaranteedTripTransfers;
140
151
  const transfersEnd = performance.now();
@@ -174,6 +185,20 @@ export class GtfsParser {
174
185
  `${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`,
175
186
  );
176
187
 
188
+ if (this.profile.deriveSiblingTransfers !== false) {
189
+ const siblingTransfersStart = performance.now();
190
+ const siblingTransfersAdded = addMissingSiblingTransfers(
191
+ parsedStops,
192
+ activeStopIds,
193
+ transfers,
194
+ forbiddenTransfers,
195
+ );
196
+ const siblingTransfersEnd = performance.now();
197
+ log.info(
198
+ `${siblingTransfersAdded} sibling transfers added. (${(siblingTransfersEnd - siblingTransfersStart).toFixed(2)}ms)`,
199
+ );
200
+ }
201
+
177
202
  if (this.transferGenerator) {
178
203
  log.info('Generating virtual transfers');
179
204
  const virtualTransfersStart = performance.now();
@@ -190,24 +215,12 @@ export class GtfsParser {
190
215
  originStops,
191
216
  stopsIndex,
192
217
  );
193
- let addedTransfers = 0;
194
- for (const [fromStop, newTransfers] of generatedTransfers) {
195
- const existing = getOrInsert(transfers, fromStop, []);
196
- // Deduplicate per directed pair against existing (feed) transfers, and
197
- // only keep transfers into stops a route actually calls at.
198
- const connected = new Set(existing.map((t) => t.destination));
199
- for (const transfer of newTransfers) {
200
- if (
201
- !activeStopIds.has(transfer.destination) ||
202
- connected.has(transfer.destination)
203
- ) {
204
- continue;
205
- }
206
- connected.add(transfer.destination);
207
- existing.push(transfer);
208
- addedTransfers += 1;
209
- }
210
- }
218
+ const addedTransfers = addGeneratedTransfers(
219
+ generatedTransfers,
220
+ activeStopIds,
221
+ transfers,
222
+ forbiddenTransfers,
223
+ );
211
224
  const virtualTransfersEnd = performance.now();
212
225
  log.info(
213
226
  `${addedTransfers} virtual transfers added. (${(virtualTransfersEnd - virtualTransfersStart).toFixed(2)}ms)`,
@@ -5,6 +5,10 @@ import { RouteTypes } from '../../../timetable/timetable.js';
5
5
  import { extendedGtfsProfile } from '../extended.js';
6
6
 
7
7
  describe('The extended GTFS feed parser', () => {
8
+ it('derives sibling transfers by default', () => {
9
+ assert.strictEqual(extendedGtfsProfile.deriveSiblingTransfers, true);
10
+ });
11
+
8
12
  it('should convert the extended route type to GTFS route type', () => {
9
13
  assert.ok(extendedGtfsProfile.routeTypeParser);
10
14
  assert.equal(extendedGtfsProfile.routeTypeParser(106), RouteTypes.RAIL);
@@ -0,0 +1,10 @@
1
+ import assert from 'node:assert';
2
+ import { describe, it } from 'node:test';
3
+
4
+ import { standardGtfsProfile } from '../standard.js';
5
+
6
+ describe('The standard GTFS feed parser', () => {
7
+ it('derives sibling transfers by default', () => {
8
+ assert.strictEqual(standardGtfsProfile.deriveSiblingTransfers, true);
9
+ });
10
+ });
@@ -142,5 +142,6 @@ const routeTypeParser = (routeType: number): Maybe<RouteType> => {
142
142
  };
143
143
 
144
144
  export const extendedGtfsProfile: GtfsProfile = {
145
+ deriveSiblingTransfers: true,
145
146
  routeTypeParser,
146
147
  };
@@ -2,6 +2,7 @@ import { RouteTypes } from '../../timetable/timetable.js';
2
2
  import { GtfsProfile } from '../parser.js';
3
3
 
4
4
  export const standardGtfsProfile: GtfsProfile = {
5
+ deriveSiblingTransfers: true,
5
6
  routeTypeParser: (routeType: number) => {
6
7
  switch (routeType) {
7
8
  case 0:
@@ -28,6 +28,15 @@ export type GtfsTransferType =
28
28
 
29
29
  export type TransfersMap = Map<StopId, Transfer[]>;
30
30
 
31
+ /**
32
+ * Directed stop pairs for which the feed explicitly disallows transfers.
33
+ *
34
+ * These constraints are retained during parsing so generated transfers do not
35
+ * accidentally re-enable a connection declared with GTFS transfer_type=3.
36
+ * They are not serialized into the routing timetable.
37
+ */
38
+ export type ForbiddenTransfersMap = Map<StopId, Set<StopId>>;
39
+
31
40
  export type GtfsTripTransfer = {
32
41
  fromStop: StopId;
33
42
  fromTrip: GtfsTripId;
@@ -193,10 +202,12 @@ export const parseTransfers = async (
193
202
  activeServiceIds: ServiceIds,
194
203
  ): Promise<{
195
204
  transfers: TransfersMap;
205
+ forbiddenTransfers: ForbiddenTransfersMap;
196
206
  tripContinuations: GtfsTripTransfer[];
197
207
  guaranteedTripTransfers: GtfsTripTransfer[];
198
208
  }> => {
199
209
  const transfers: TransfersMap = new Map();
210
+ const forbiddenTransfers: ForbiddenTransfersMap = new Map();
200
211
  const tripContinuations: GtfsTripTransfer[] = [];
201
212
  const guaranteedTripTransfers: GtfsTripTransfer[] = [];
202
213
 
@@ -213,10 +224,9 @@ export const parseTransfers = async (
213
224
  continue;
214
225
  }
215
226
 
216
- if (
217
- transferEntry.transfer_type === 3 ||
218
- transferEntry.transfer_type === 5
219
- ) {
227
+ // Type 5 only prevents remaining seated between two specific trips. It
228
+ // does not prohibit an ordinary stop-to-stop transfer.
229
+ if (transferEntry.transfer_type === 5) {
220
230
  continue;
221
231
  }
222
232
 
@@ -267,6 +277,24 @@ export const parseTransfers = async (
267
277
  );
268
278
  }
269
279
  break;
280
+ case 3: {
281
+ if (
282
+ transferEntry.from_trip_id ||
283
+ transferEntry.to_trip_id ||
284
+ transferEntry.from_route_id ||
285
+ transferEntry.to_route_id
286
+ ) {
287
+ log.warn(
288
+ `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}.`,
289
+ );
290
+ break;
291
+ }
292
+ const forbiddenDestinations =
293
+ forbiddenTransfers.get(fromStop.id) ?? new Set<StopId>();
294
+ forbiddenDestinations.add(toStop.id);
295
+ forbiddenTransfers.set(fromStop.id, forbiddenDestinations);
296
+ break;
297
+ }
270
298
  case 0: // Recommended transfer
271
299
  case 2: // Requires minimal time
272
300
  default:
@@ -282,11 +310,113 @@ export const parseTransfers = async (
282
310
 
283
311
  return {
284
312
  transfers,
313
+ forbiddenTransfers,
285
314
  tripContinuations,
286
315
  guaranteedTripTransfers,
287
316
  };
288
317
  };
289
318
 
319
+ /**
320
+ * Adds missing directed transfers between route-served child stops belonging
321
+ * to the same parent station.
322
+ *
323
+ * GTFS feeds commonly use parent_station to group platforms while omitting the
324
+ * corresponding transfers.txt rows. The generated transfers intentionally do
325
+ * not carry a fixed duration: routing applies the query's fallback minimum
326
+ * transfer time. Explicit and forbidden feed entries always take precedence.
327
+ *
328
+ * @returns The number of directed sibling transfers added.
329
+ */
330
+ export const addMissingSiblingTransfers = (
331
+ stopsMap: GtfsStopsMap,
332
+ activeStops: ReadonlySet<StopId>,
333
+ transfers: TransfersMap,
334
+ forbiddenTransfers: ForbiddenTransfersMap = new Map(),
335
+ ): number => {
336
+ let addedTransfers = 0;
337
+
338
+ for (const parent of stopsMap.values()) {
339
+ const activeChildren = parent.children.filter((child) =>
340
+ activeStops.has(child),
341
+ );
342
+ if (activeChildren.length < 2) continue;
343
+
344
+ for (const fromStop of activeChildren) {
345
+ const existing = transfers.get(fromStop) ?? [];
346
+ const connected = new Set(
347
+ existing.map((transfer) => transfer.destination),
348
+ );
349
+ const forbidden = forbiddenTransfers.get(fromStop);
350
+
351
+ for (const toStop of activeChildren) {
352
+ if (
353
+ toStop === fromStop ||
354
+ connected.has(toStop) ||
355
+ forbidden?.has(toStop)
356
+ ) {
357
+ continue;
358
+ }
359
+ existing.push({
360
+ destination: toStop,
361
+ type: TransferTypes.REQUIRES_MINIMAL_TIME,
362
+ });
363
+ connected.add(toStop);
364
+ addedTransfers += 1;
365
+ }
366
+
367
+ if (existing.length > 0) {
368
+ transfers.set(fromStop, existing);
369
+ }
370
+ }
371
+ }
372
+
373
+ return addedTransfers;
374
+ };
375
+
376
+ /**
377
+ * Merges generated transfers into parsed feed transfers.
378
+ *
379
+ * Only transfers between active stops are kept. Explicit feed transfers and
380
+ * forbidden directed pairs take precedence over generated candidates.
381
+ *
382
+ * @returns The number of generated transfers added.
383
+ */
384
+ export const addGeneratedTransfers = (
385
+ generatedTransfers: ReadonlyMap<StopId, readonly Transfer[]>,
386
+ activeStops: ReadonlySet<StopId>,
387
+ transfers: TransfersMap,
388
+ forbiddenTransfers: ForbiddenTransfersMap = new Map(),
389
+ ): number => {
390
+ let addedTransfers = 0;
391
+
392
+ for (const [fromStop, candidates] of generatedTransfers) {
393
+ if (!activeStops.has(fromStop)) continue;
394
+
395
+ const existing = transfers.get(fromStop) ?? [];
396
+ const connected = new Set(existing.map((transfer) => transfer.destination));
397
+ const forbidden = forbiddenTransfers.get(fromStop);
398
+
399
+ for (const transfer of candidates) {
400
+ if (
401
+ !activeStops.has(transfer.destination) ||
402
+ connected.has(transfer.destination) ||
403
+ forbidden?.has(transfer.destination)
404
+ ) {
405
+ continue;
406
+ }
407
+ connected.add(transfer.destination);
408
+ existing.push(transfer);
409
+ addedTransfers += 1;
410
+ }
411
+
412
+ if (existing.length > 0) {
413
+ transfers.set(fromStop, existing);
414
+ }
415
+ }
416
+
417
+ return addedTransfers;
418
+ };
419
+
290
420
  /**
291
421
  * Disambiguates stops involved in a transfer.
292
422
  *