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/CHANGELOG.md +2 -2
- package/dist/cli.mjs +130 -43
- package/dist/cli.mjs.map +1 -1
- package/dist/gtfs/parser.d.ts +6 -0
- package/dist/gtfs/profiles/__tests__/standard.test.d.ts +1 -0
- package/dist/gtfs/transfers.d.ts +30 -0
- package/dist/parser.cjs.js +130 -43
- package/dist/parser.cjs.js.map +1 -1
- package/dist/parser.esm.js +130 -43
- package/dist/parser.esm.js.map +1 -1
- package/package.json +1 -1
- package/src/gtfs/__tests__/transfers.test.ts +164 -4
- package/src/gtfs/parser.ts +32 -19
- package/src/gtfs/profiles/__tests__/extended.test.ts +4 -0
- package/src/gtfs/profiles/__tests__/standard.test.ts +10 -0
- package/src/gtfs/profiles/extended.ts +1 -0
- package/src/gtfs/profiles/standard.ts +1 -0
- package/src/gtfs/transfers.ts +134 -4
package/package.json
CHANGED
|
@@ -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
|
|
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('"
|
|
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([
|
package/src/gtfs/parser.ts
CHANGED
|
@@ -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
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
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
|
+
});
|
package/src/gtfs/transfers.ts
CHANGED
|
@@ -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
|
-
|
|
217
|
-
|
|
218
|
-
|
|
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
|
*
|