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.
- package/CHANGELOG.md +2 -2
- package/dist/cli.mjs +139 -46
- 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 +37 -3
- package/dist/parser.cjs.js +139 -46
- package/dist/parser.cjs.js.map +1 -1
- package/dist/parser.esm.js +139 -46
- package/dist/parser.esm.js.map +1 -1
- package/package.json +1 -1
- package/src/gtfs/__tests__/transfers.test.ts +264 -17
- package/src/gtfs/parser.ts +33 -20
- 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 +146 -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
|
|
|
@@ -67,7 +71,7 @@ describe('GTFS transfers parser', () => {
|
|
|
67
71
|
],
|
|
68
72
|
]);
|
|
69
73
|
|
|
70
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
74
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
71
75
|
|
|
72
76
|
const expectedTransfers = new Map([
|
|
73
77
|
[
|
|
@@ -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([
|
|
@@ -148,9 +154,10 @@ describe('GTFS transfers parser', () => {
|
|
|
148
154
|
],
|
|
149
155
|
]);
|
|
150
156
|
|
|
151
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
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
|
|
|
@@ -186,7 +193,7 @@ describe('GTFS transfers parser', () => {
|
|
|
186
193
|
],
|
|
187
194
|
]);
|
|
188
195
|
|
|
189
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
196
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
190
197
|
|
|
191
198
|
assert.deepEqual(result.transfers, new Map());
|
|
192
199
|
assert.deepEqual(result.tripContinuations, []);
|
|
@@ -244,7 +251,7 @@ describe('GTFS transfers parser', () => {
|
|
|
244
251
|
],
|
|
245
252
|
]);
|
|
246
253
|
|
|
247
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
254
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
248
255
|
|
|
249
256
|
const expectedTripContinuations = [
|
|
250
257
|
{
|
|
@@ -318,7 +325,7 @@ describe('GTFS transfers parser', () => {
|
|
|
318
325
|
],
|
|
319
326
|
]);
|
|
320
327
|
|
|
321
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
328
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
322
329
|
|
|
323
330
|
const expectedGuaranteedTripTransfers = [
|
|
324
331
|
{
|
|
@@ -398,7 +405,7 @@ describe('GTFS transfers parser', () => {
|
|
|
398
405
|
],
|
|
399
406
|
]);
|
|
400
407
|
|
|
401
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
408
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
402
409
|
|
|
403
410
|
// Type 1 with trip IDs -> guaranteedTripTransfers
|
|
404
411
|
const expectedGuaranteedTripTransfers = [
|
|
@@ -486,7 +493,7 @@ describe('GTFS transfers parser', () => {
|
|
|
486
493
|
],
|
|
487
494
|
]);
|
|
488
495
|
|
|
489
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
496
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
490
497
|
|
|
491
498
|
assert.deepEqual(result.transfers, new Map());
|
|
492
499
|
assert.deepEqual(result.tripContinuations, []);
|
|
@@ -523,7 +530,7 @@ describe('GTFS transfers parser', () => {
|
|
|
523
530
|
],
|
|
524
531
|
]);
|
|
525
532
|
|
|
526
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
533
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
527
534
|
|
|
528
535
|
assert.deepEqual(result.transfers, new Map());
|
|
529
536
|
assert.deepEqual(result.tripContinuations, []);
|
|
@@ -560,7 +567,7 @@ describe('GTFS transfers parser', () => {
|
|
|
560
567
|
],
|
|
561
568
|
]);
|
|
562
569
|
|
|
563
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
570
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
564
571
|
|
|
565
572
|
assert.deepEqual(result.transfers, new Map());
|
|
566
573
|
assert.deepEqual(result.tripContinuations, []);
|
|
@@ -618,7 +625,7 @@ describe('GTFS transfers parser', () => {
|
|
|
618
625
|
],
|
|
619
626
|
]);
|
|
620
627
|
|
|
621
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
628
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
622
629
|
|
|
623
630
|
const expectedTransfers = new Map([
|
|
624
631
|
[
|
|
@@ -698,7 +705,7 @@ describe('GTFS transfers parser', () => {
|
|
|
698
705
|
],
|
|
699
706
|
]);
|
|
700
707
|
|
|
701
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
708
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
702
709
|
|
|
703
710
|
const expectedTransfers = new Map([
|
|
704
711
|
[
|
|
@@ -726,6 +733,93 @@ describe('GTFS transfers parser', () => {
|
|
|
726
733
|
assert.deepEqual(result.tripContinuations, expectedTripContinuations);
|
|
727
734
|
});
|
|
728
735
|
|
|
736
|
+
it('should filter service-scoped transfers by active service regardless of type', async () => {
|
|
737
|
+
const mockedStream = new Readable();
|
|
738
|
+
mockedStream.push(
|
|
739
|
+
'from_stop_id,to_stop_id,from_trip_id,to_trip_id,service_id,transfer_type,min_transfer_time\n',
|
|
740
|
+
);
|
|
741
|
+
mockedStream.push('"from","to","","","","0",""\n');
|
|
742
|
+
mockedStream.push('"from","to","","","","2","120"\n');
|
|
743
|
+
mockedStream.push('"from","to","","","active","1",""\n');
|
|
744
|
+
mockedStream.push('"from","to","","","inactive","2","180"\n');
|
|
745
|
+
mockedStream.push('"from","to","tripA","tripB","active","1",""\n');
|
|
746
|
+
mockedStream.push('"from","to","tripC","tripD","inactive","1",""\n');
|
|
747
|
+
mockedStream.push('"from","to","tripE","tripF","active","4",""\n');
|
|
748
|
+
mockedStream.push('"from","to","tripG","tripH","inactive","4",""\n');
|
|
749
|
+
mockedStream.push(null);
|
|
750
|
+
|
|
751
|
+
const stopsMap: GtfsStopsMap = new Map([
|
|
752
|
+
[
|
|
753
|
+
'from',
|
|
754
|
+
{
|
|
755
|
+
id: 0,
|
|
756
|
+
sourceStopId: 'from',
|
|
757
|
+
name: 'From',
|
|
758
|
+
children: [],
|
|
759
|
+
locationType: 'SIMPLE_STOP_OR_PLATFORM',
|
|
760
|
+
},
|
|
761
|
+
],
|
|
762
|
+
[
|
|
763
|
+
'to',
|
|
764
|
+
{
|
|
765
|
+
id: 1,
|
|
766
|
+
sourceStopId: 'to',
|
|
767
|
+
name: 'To',
|
|
768
|
+
children: [],
|
|
769
|
+
locationType: 'SIMPLE_STOP_OR_PLATFORM',
|
|
770
|
+
},
|
|
771
|
+
],
|
|
772
|
+
]);
|
|
773
|
+
|
|
774
|
+
const result = await parseTransfers(
|
|
775
|
+
mockedStream,
|
|
776
|
+
stopsMap,
|
|
777
|
+
new Set(['active']),
|
|
778
|
+
);
|
|
779
|
+
|
|
780
|
+
assert.deepEqual(
|
|
781
|
+
result.transfers,
|
|
782
|
+
new Map([
|
|
783
|
+
[
|
|
784
|
+
0,
|
|
785
|
+
[
|
|
786
|
+
{
|
|
787
|
+
destination: 1,
|
|
788
|
+
type: TransferTypes.RECOMMENDED,
|
|
789
|
+
minTransferTime: durationFromSeconds(0),
|
|
790
|
+
},
|
|
791
|
+
{
|
|
792
|
+
destination: 1,
|
|
793
|
+
type: TransferTypes.REQUIRES_MINIMAL_TIME,
|
|
794
|
+
minTransferTime: durationFromSeconds(120),
|
|
795
|
+
},
|
|
796
|
+
{
|
|
797
|
+
destination: 1,
|
|
798
|
+
type: TransferTypes.GUARANTEED,
|
|
799
|
+
minTransferTime: durationFromSeconds(0),
|
|
800
|
+
},
|
|
801
|
+
],
|
|
802
|
+
],
|
|
803
|
+
]),
|
|
804
|
+
);
|
|
805
|
+
assert.deepEqual(result.guaranteedTripTransfers, [
|
|
806
|
+
{
|
|
807
|
+
fromStop: 0,
|
|
808
|
+
fromTrip: 'tripA',
|
|
809
|
+
toStop: 1,
|
|
810
|
+
toTrip: 'tripB',
|
|
811
|
+
},
|
|
812
|
+
]);
|
|
813
|
+
assert.deepEqual(result.tripContinuations, [
|
|
814
|
+
{
|
|
815
|
+
fromStop: 0,
|
|
816
|
+
fromTrip: 'tripE',
|
|
817
|
+
toStop: 1,
|
|
818
|
+
toTrip: 'tripF',
|
|
819
|
+
},
|
|
820
|
+
]);
|
|
821
|
+
});
|
|
822
|
+
|
|
729
823
|
it('should handle empty transfers file', async () => {
|
|
730
824
|
const mockedStream = new Readable();
|
|
731
825
|
mockedStream.push(
|
|
@@ -735,7 +829,7 @@ describe('GTFS transfers parser', () => {
|
|
|
735
829
|
|
|
736
830
|
const stopsMap: GtfsStopsMap = new Map();
|
|
737
831
|
|
|
738
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
832
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
739
833
|
|
|
740
834
|
assert.deepEqual(result.transfers, new Map());
|
|
741
835
|
assert.deepEqual(result.tripContinuations, []);
|
|
@@ -774,7 +868,7 @@ describe('GTFS transfers parser', () => {
|
|
|
774
868
|
],
|
|
775
869
|
]);
|
|
776
870
|
|
|
777
|
-
const result = await parseTransfers(mockedStream, stopsMap);
|
|
871
|
+
const result = await parseTransfers(mockedStream, stopsMap, new Set());
|
|
778
872
|
|
|
779
873
|
const expectedTransfers = new Map([
|
|
780
874
|
[
|
|
@@ -794,6 +888,159 @@ describe('GTFS transfers parser', () => {
|
|
|
794
888
|
});
|
|
795
889
|
});
|
|
796
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
|
+
|
|
797
1044
|
describe('buildTripTransfers', () => {
|
|
798
1045
|
it('should build trip transfers for valid data', () => {
|
|
799
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
|
-
} = await parseTransfers(transfersStream, parsedStops);
|
|
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
|
+
});
|