minotor 1.0.7 → 2.0.1

package/src/gtfs/__tests__/stops.test.ts

@@ -2,12 +2,12 @@ import assert from 'node:assert';
 import { Readable } from 'node:stream';
 import { describe, it } from 'node:test';
 
-import { StopsMap } from '../../stops/stops.js';
+import { StopId } from '../../stops/stops.js';
 import { chGtfsProfile } from '../profiles/ch.js';
-import { parseStops } from '../stops.js';
+import { indexStops, ParsedStopsMap, parseStops } from '../stops.js';
 
 describe('GTFS stops parser', () => {
-  describe('parsing a well formed stream', () => {
+  describe('parseStops', () => {
     it('should parse valid stops present in the source', async () => {
       const mockedStream = new Readable();
       mockedStream.push(
@@ -21,37 +21,34 @@ describe('GTFS stops parser', () => {
       );
 
       mockedStream.push(null);
-      const stops = await parseStops(
+      const parsedStops = await parseStops(
         mockedStream,
         chGtfsProfile.platformParser,
       );
-      const expectedStops: StopsMap = new Map([
-        [
-          'Parent8587255',
-          {
-            id: 'Parent8587255',
-            lat: 46.8061375857565,
-            locationType: 'STATION',
-            lon: 7.16145029437328,
-            name: 'Fribourg, Tilleul/Cathédrale',
-            children: [],
-          },
-        ],
-        [
-          'Parent8504100',
-          {
-            id: 'Parent8504100',
-            lat: 46.8031492395272,
-            locationType: 'STATION',
-            lon: 7.15104780338173,
-            name: 'Fribourg/Freiburg',
-            children: [],
-          },
-        ],
-      ]);
-
-      assert.deepEqual(stops, expectedStops);
+
+      assert.equal(parsedStops.size, 2);
+
+      const stop1 = parsedStops.get('Parent8587255');
+      assert.ok(stop1);
+      assert.equal(stop1.id, 0);
+      assert.equal(stop1.sourceStopId, 'Parent8587255');
+      assert.equal(stop1.name, 'Fribourg, Tilleul/Cathédrale');
+      assert.equal(stop1.lat, 46.8061375857565);
+      assert.equal(stop1.lon, 7.16145029437328);
+      assert.equal(stop1.locationType, 'STATION');
+      assert.deepEqual(stop1.children, []);
+
+      const stop2 = parsedStops.get('Parent8504100');
+      assert.ok(stop2);
+      assert.equal(stop2.id, 1);
+      assert.equal(stop2.sourceStopId, 'Parent8504100');
+      assert.equal(stop2.name, 'Fribourg/Freiburg');
+      assert.equal(stop2.lat, 46.8031492395272);
+      assert.equal(stop2.lon, 7.15104780338173);
+      assert.equal(stop2.locationType, 'STATION');
+      assert.deepEqual(stop2.children, []);
     });
+
     it('should parse nested stops', async () => {
       const mockedStream = new Readable();
       mockedStream.push(
@@ -69,47 +66,30 @@ describe('GTFS stops parser', () => {
 
       mockedStream.push(null);
 
-      const stops = await parseStops(mockedStream);
-      const expectedStops: StopsMap = new Map([
-        [
-          '8504100:0:1',
-          {
-            id: '8504100:0:1',
-            lat: 46.8018210323626,
-            lon: 7.14993389242926,
-            name: 'Fribourg/Freiburg',
-            parent: 'Parent8504100',
-            locationType: 'SIMPLE_STOP_OR_PLATFORM',
-            children: [],
-          },
-        ],
-        [
-          '8504100:0:2',
-          {
-            id: '8504100:0:2',
-            lat: 46.8010031847878,
-            lon: 7.14920625704902,
-            name: 'Fribourg/Freiburg',
-            parent: 'Parent8504100',
-            locationType: 'SIMPLE_STOP_OR_PLATFORM',
-            children: [],
-          },
-        ],
-        [
-          'Parent8504100',
-          {
-            id: 'Parent8504100',
-            children: ['8504100:0:1', '8504100:0:2'],
-            lat: 46.8031492395272,
-            locationType: 'STATION',
-            lon: 7.15104780338173,
-            name: 'Fribourg/Freiburg',
-          },
-        ],
-      ]);
-
-      assert.deepEqual(stops, expectedStops);
+      const parsedStops = await parseStops(mockedStream);
+
+      assert.equal(parsedStops.size, 3);
+
+      const parentStop = parsedStops.get('Parent8504100');
+      assert.ok(parentStop);
+      assert.equal(parentStop.id, 2);
+      assert.equal(parentStop.sourceStopId, 'Parent8504100');
+      assert.equal(parentStop.locationType, 'STATION');
+      assert.deepEqual(parentStop.children, [0, 1]);
+
+      const childStop1 = parsedStops.get('8504100:0:1');
+      assert.ok(childStop1);
+      assert.equal(childStop1.id, 0);
+      assert.equal(childStop1.parent, 2);
+      assert.equal(childStop1.locationType, 'SIMPLE_STOP_OR_PLATFORM');
+
+      const childStop2 = parsedStops.get('8504100:0:2');
+      assert.ok(childStop2);
+      assert.equal(childStop2.id, 1);
+      assert.equal(childStop2.parent, 2);
+      assert.equal(childStop2.locationType, 'SIMPLE_STOP_OR_PLATFORM');
     });
+
     it('should parse the platform', async () => {
       const mockedStream = new Readable();
       mockedStream.push(
@@ -127,51 +107,140 @@ describe('GTFS stops parser', () => {
 
       mockedStream.push(null);
 
-      const stops = await parseStops(
+      const parsedStops = await parseStops(
         mockedStream,
         chGtfsProfile.platformParser,
       );
-      const expectedStops: StopsMap = new Map([
-        [
-          '8504100:0:1',
-          {
-            id: '8504100:0:1',
-            lat: 46.8018210323626,
-            lon: 7.14993389242926,
-            name: 'Fribourg/Freiburg',
-            parent: 'Parent8504100',
-            platform: '1',
-            locationType: 'SIMPLE_STOP_OR_PLATFORM',
-            children: [],
-          },
-        ],
-        [
-          '8504100:0:2',
-          {
-            id: '8504100:0:2',
-            lat: 46.8010031847878,
-            lon: 7.14920625704902,
-            name: 'Fribourg/Freiburg',
-            parent: 'Parent8504100',
-            platform: '2',
-            locationType: 'SIMPLE_STOP_OR_PLATFORM',
-            children: [],
-          },
-        ],
-        [
-          'Parent8504100',
-          {
-            id: 'Parent8504100',
-            children: ['8504100:0:1', '8504100:0:2'],
-            lat: 46.8031492395272,
-            locationType: 'STATION',
-            lon: 7.15104780338173,
-            name: 'Fribourg/Freiburg',
-          },
-        ],
-      ]);
-
-      assert.deepEqual(stops, expectedStops);
+
+      const childStop1 = parsedStops.get('8504100:0:1');
+      assert.ok(childStop1);
+      assert.equal(childStop1.platform, '1');
+
+      const childStop2 = parsedStops.get('8504100:0:2');
+      assert.ok(childStop2);
+      assert.equal(childStop2.platform, '2');
+    });
+  });
+
+  describe('indexStops', () => {
+    it('should correctly index parsed stops', () => {
+      const parsedStopsMap: ParsedStopsMap = new Map();
+
+      parsedStopsMap.set('Parent8504100', {
+        id: 0,
+        sourceStopId: 'Parent8504100',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8031492395272,
+        lon: 7.15104780338173,
+        locationType: 'STATION',
+        children: [1, 2],
+      });
+
+      parsedStopsMap.set('8504100:0:1', {
+        id: 1,
+        sourceStopId: '8504100:0:1',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8018210323626,
+        lon: 7.14993389242926,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        children: [],
+        parent: 0,
+        platform: '1',
+        parentSourceId: 'Parent8504100',
+      });
+
+      parsedStopsMap.set('8504100:0:2', {
+        id: 2,
+        sourceStopId: '8504100:0:2',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8010031847878,
+        lon: 7.14920625704902,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        children: [],
+        parent: 0,
+        platform: '2',
+        parentSourceId: 'Parent8504100',
+      });
+
+      const indexedStops = indexStops(parsedStopsMap);
+
+      assert.equal(indexedStops.size, 3);
+
+      const station = indexedStops.get(0);
+      assert.ok(station);
+      assert.equal(station.sourceStopId, 'Parent8504100');
+      assert.deepEqual(station.children, [1, 2]);
+
+      const platform1 = indexedStops.get(1);
+      assert.ok(platform1);
+      assert.equal(platform1.sourceStopId, '8504100:0:1');
+      assert.equal(platform1.platform, '1');
+      assert.equal(platform1.parent, 0);
+
+      const platform2 = indexedStops.get(2);
+      assert.ok(platform2);
+      assert.equal(platform2.sourceStopId, '8504100:0:2');
+      assert.equal(platform2.platform, '2');
+      assert.equal(platform2.parent, 0);
+    });
+
+    it('should filter stops based on validStops set', () => {
+      const parsedStopsMap: ParsedStopsMap = new Map();
+
+      parsedStopsMap.set('Parent8504100', {
+        id: 0,
+        sourceStopId: 'Parent8504100',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8031492395272,
+        lon: 7.15104780338173,
+        locationType: 'STATION',
+        children: [1, 2, 3],
+      });
+
+      parsedStopsMap.set('8504100:0:1', {
+        id: 1,
+        sourceStopId: '8504100:0:1',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8018210323626,
+        lon: 7.14993389242926,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        children: [],
+        parent: 0,
+        parentSourceId: 'Parent8504100',
+      });
+
+      parsedStopsMap.set('8504100:0:2', {
+        id: 2,
+        sourceStopId: '8504100:0:2',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8010031847878,
+        lon: 7.14920625704902,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        children: [],
+        parent: 0,
+        parentSourceId: 'Parent8504100',
+      });
+
+      parsedStopsMap.set('8504100:0:3', {
+        id: 3,
+        sourceStopId: '8504100:0:3',
+        name: 'Fribourg/Freiburg',
+        lat: 46.8,
+        lon: 7.14,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        children: [],
+        parent: 0,
+        parentSourceId: 'Parent8504100',
+      });
+      const validStops = new Set<StopId>([1, 2]);
+
+      const indexedStops = indexStops(parsedStopsMap, validStops);
+
+      assert.equal(indexedStops.size, 3);
+      assert.ok(indexedStops.has(0));
+      assert.ok(indexedStops.has(1));
+      assert.ok(indexedStops.has(2));
+      assert.ok(!indexedStops.has(3));
     });
   });
 });

package/src/gtfs/__tests__/transfers.test.ts

@@ -3,6 +3,7 @@ import { Readable } from 'node:stream';
 import { describe, it } from 'node:test';
 
 import { Duration } from '../../timetable/duration.js';
+import { ParsedStopsMap } from '../stops.js';
 import { parseTransfers } from '../transfers.js';
 
 describe('GTFS transfers parser', () => {
@@ -15,23 +16,66 @@ describe('GTFS transfers parser', () => {
     mockedStream.push('"1100097","8014447","2","240"\n');
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
-    const expectedTransfers = new Map([
+    const stopsMap: ParsedStopsMap = new Map([
       [
         '1100084',
+        {
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014440:0:1',
+        {
+          id: 1,
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '1100097',
+        {
+          id: 2,
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014447',
+        {
+          id: 3,
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+
+    const transfers = await parseTransfers(mockedStream, stopsMap);
+    const expectedTransfers = new Map([
+      [
+        0, // Internal ID for stop '1100084'
         [
           {
-            destination: '8014440:0:1',
+            destination: 1, // Internal ID for stop '8014440:0:1'
             type: 'REQUIRES_MINIMAL_TIME',
             minTransferTime: Duration.fromSeconds(180),
           },
         ],
       ],
       [
-        '1100097',
+        2, // Internal ID for stop '1100097'
         [
           {
-            destination: '8014447',
+            destination: 3, // Internal ID for stop '8014447'
             type: 'REQUIRES_MINIMAL_TIME',
             minTransferTime: Duration.fromSeconds(240),
           },
@@ -51,7 +95,50 @@ describe('GTFS transfers parser', () => {
     mockedStream.push('"1100097","8014447","5","240"\n');
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
+    const stopsMap: ParsedStopsMap = new Map([
+      [
+        '1100084',
+        {
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014440:0:1',
+        {
+          id: 1,
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '1100097',
+        {
+          id: 2,
+          sourceStopId: '1100097',
+          name: 'Test Stop 3',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014447',
+        {
+          id: 3,
+          sourceStopId: '8014447',
+          name: 'Test Stop 4',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+
+    const transfers = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(transfers, new Map());
   });
 
@@ -63,7 +150,30 @@ describe('GTFS transfers parser', () => {
     mockedStream.push('"1100084","8014440","2","180"\n');
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
+    const stopsMap: ParsedStopsMap = new Map([
+      [
+        '1100084',
+        {
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014440',
+        {
+          id: 1,
+          sourceStopId: '8014440',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+
+    const transfers = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(transfers, new Map());
   });
 
@@ -75,7 +185,30 @@ describe('GTFS transfers parser', () => {
     mockedStream.push('"1100084","8014440","2","180"\n');
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
+    const stopsMap: ParsedStopsMap = new Map([
+      [
+        '1100084',
+        {
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014440',
+        {
+          id: 1,
+          sourceStopId: '8014440',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+
+    const transfers = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(transfers, new Map());
   });
 
@@ -87,15 +220,38 @@ describe('GTFS transfers parser', () => {
     mockedStream.push('"1100084","8014440:0:1","2"\n');
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
+    const stopsMap: ParsedStopsMap = new Map([
+      [
+        '1100084',
+        {
+          id: 0,
+          sourceStopId: '1100084',
+          name: 'Test Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        '8014440:0:1',
+        {
+          id: 1,
+          sourceStopId: '8014440:0:1',
+          name: 'Test Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+    console.log(JSON.stringify(stopsMap));
+    const transfers = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(
       transfers,
       new Map([
         [
-          '1100084',
+          0, // Internal ID for stop '1100084'
           [
             {
-              destination: '8014440:0:1',
+              destination: 1, // Internal ID for stop '8014440:0:1'
               type: 'REQUIRES_MINIMAL_TIME',
             },
           ],
@@ -111,7 +267,9 @@ describe('GTFS transfers parser', () => {
     );
     mockedStream.push(null);
 
-    const transfers = await parseTransfers(mockedStream);
+    const stopsMap: ParsedStopsMap = new Map();
+
+    const transfers = await parseTransfers(mockedStream, stopsMap);
     assert.deepEqual(transfers, new Map());
   });
 });