minotor 3.0.2 → 4.0.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
-## [3.0.2](https://github.com/aubryio/minotor/compare/v3.0.1...v3.0.2) (2025-09-05)
+# [4.0.0](https://github.com/aubryio/minotor/compare/v3.0.2...v4.0.0) (2025-09-13)
 
 
-### Bug Fixes
+### Performance Improvements
 
-* make csv-parser cast sequence numbers as numbers ([#21](https://github.com/aubryio/minotor/issues/21)) ([8bf70c2](https://github.com/aubryio/minotor/commit/8bf70c26a4ccec6e32b849b608bd399fe53382db))
+* encode boarding flags on 2 bits only ([b373d0c](https://github.com/aubryio/minotor/commit/b373d0c606ca6ead53e9138d5ca31d2928e2415b))
+
+
+### BREAKING CHANGES
+
+* Timetable format 0.0.4 introduced to use 2 bits instead of 8 for boarding flags.

package/README.md

@@ -183,6 +183,7 @@ The project is under active development. Here are some of the features that are
 Contact [the author](https://aubry.io/) for feature requests.
 
 - Route/Trip-based transfer support
+- Favor shorter trips with less transfers in case of tie
 - Arrive-by support
 - Range queries
 - Transfer preferences

package/dist/cli.mjs

@@ -10,7 +10,7 @@ import require$$2$1 from 'path';
 import require$$3$1 from 'events';
 import require$$4$1 from 'zlib';
 import require$$5, { Transform } from 'stream';
-import { performance } from 'perf_hooks';
+import { performance as performance$1 } from 'perf_hooks';
 import repl from 'node:repl';
 
 /******************************************************************************
@@ -17754,11 +17754,16 @@ let Route$1 = class Route {
      * @returns The pick-up type at the specified stop and trip.
      */
     pickUpTypeFrom(stopId, tripIndex) {
-        const pickUpIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2;
-        const pickUpValue = this.pickUpDropOffTypes[pickUpIndex];
-        if (pickUpValue === undefined) {
+        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const byteIndex = Math.floor(globalIndex / 2);
+        const isSecondPair = globalIndex % 2 === 1;
+        const byte = this.pickUpDropOffTypes[byteIndex];
+        if (byte === undefined) {
             throw new Error(`Pick up type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
+        const pickUpValue = isSecondPair
+            ? (byte >> 6) & 0x03 // Upper 2 bits for second pair
+            : (byte >> 2) & 0x03; // Bits 2-3 for first pair
         return toPickupDropOffType(pickUpValue);
     }
     /**
@@ -17769,11 +17774,16 @@ let Route$1 = class Route {
      * @returns The drop-off type at the specified stop and trip.
      */
     dropOffTypeAt(stopId, tripIndex) {
-        const dropOffIndex = (tripIndex * this.stops.length + this.stopIndex(stopId)) * 2 + 1;
-        const dropOffValue = this.pickUpDropOffTypes[dropOffIndex];
-        if (dropOffValue === undefined) {
+        const globalIndex = tripIndex * this.stops.length + this.stopIndex(stopId);
+        const byteIndex = Math.floor(globalIndex / 2);
+        const isSecondPair = globalIndex % 2 === 1;
+        const byte = this.pickUpDropOffTypes[byteIndex];
+        if (byte === undefined) {
             throw new Error(`Drop off type not found for stop ${stopId} at trip index ${tripIndex} in route ${this.serviceRouteId}`);
         }
+        const dropOffValue = isSecondPair
+            ? (byte >> 4) & 0x03 // Bits 4-5 for second pair
+            : byte & 0x03; // Lower 2 bits for first pair
         return toPickupDropOffType(dropOffValue);
     }
     /**
@@ -18075,7 +18085,7 @@ const ALL_TRANSPORT_MODES = new Set([
     'TROLLEYBUS',
     'MONORAIL',
 ]);
-const CURRENT_VERSION = '0.0.3';
+const CURRENT_VERSION = '0.0.4';
 /**
  * The internal transit timetable format.
  */
@@ -20506,6 +20516,86 @@ const parseGtfsTransferType = (gtfsTransferType) => {
     }
 };
 
+/**
+ * Encodes pickup/drop-off types into a Uint8Array using 2 bits per value.
+ * Layout per byte: [drop_off_1][pickup_1][drop_off_0][pickup_0] for stops 0 and 1
+ */
+const encodePickUpDropOffTypes = (pickUpTypes, dropOffTypes) => {
+    const stopsCount = pickUpTypes.length;
+    // Each byte stores 2 pickup/drop-off pairs (4 bits each)
+    const arraySize = Math.ceil(stopsCount / 2);
+    const encoded = new Uint8Array(arraySize);
+    for (let i = 0; i < stopsCount; i++) {
+        const byteIndex = Math.floor(i / 2);
+        const isSecondPair = i % 2 === 1;
+        const dropOffType = dropOffTypes[i];
+        const pickUpType = pickUpTypes[i];
+        if (dropOffType !== undefined &&
+            pickUpType !== undefined &&
+            byteIndex < encoded.length) {
+            if (isSecondPair) {
+                // Second pair: upper 4 bits
+                const currentByte = encoded[byteIndex];
+                if (currentByte !== undefined) {
+                    encoded[byteIndex] =
+                        currentByte | (dropOffType << 4) | (pickUpType << 6);
+                }
+            }
+            else {
+                // First pair: lower 4 bits
+                const currentByte = encoded[byteIndex];
+                if (currentByte !== undefined) {
+                    encoded[byteIndex] = currentByte | dropOffType | (pickUpType << 2);
+                }
+            }
+        }
+    }
+    return encoded;
+};
+/**
+ * Sorts trips by departure time and creates optimized typed arrays
+ */
+const finalizeRouteFromBuilder = (builder) => {
+    builder.trips.sort((a, b) => a.firstDeparture - b.firstDeparture);
+    const stopsCount = builder.stops.length;
+    const tripsCount = builder.trips.length;
+    const stopsArray = new Uint32Array(builder.stops);
+    const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
+    const allPickUpTypes = [];
+    const allDropOffTypes = [];
+    for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
+        const trip = builder.trips[tripIndex];
+        if (!trip) {
+            throw new Error(`Missing trip data at index ${tripIndex}`);
+        }
+        const baseIndex = tripIndex * stopsCount * 2;
+        for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
+            const timeIndex = baseIndex + stopIndex * 2;
+            const arrivalTime = trip.arrivalTimes[stopIndex];
+            const departureTime = trip.departureTimes[stopIndex];
+            const pickUpType = trip.pickUpTypes[stopIndex];
+            const dropOffType = trip.dropOffTypes[stopIndex];
+            if (arrivalTime === undefined ||
+                departureTime === undefined ||
+                pickUpType === undefined ||
+                dropOffType === undefined) {
+                throw new Error(`Missing trip data for trip ${tripIndex} at stop ${stopIndex}`);
+            }
+            stopTimesArray[timeIndex] = arrivalTime;
+            stopTimesArray[timeIndex + 1] = departureTime;
+            allDropOffTypes.push(dropOffType);
+            allPickUpTypes.push(pickUpType);
+        }
+    }
+    // Use 2-bit encoding for pickup/drop-off types
+    const pickUpDropOffTypesArray = encodePickUpDropOffTypes(allPickUpTypes, allDropOffTypes);
+    return {
+        serviceRouteId: builder.serviceRouteId,
+        stops: stopsArray,
+        stopTimes: stopTimesArray,
+        pickUpDropOffTypes: pickUpDropOffTypesArray,
+    };
+};
 /**
  * Parses the trips.txt file from a GTFS feed
  *
@@ -20583,11 +20673,11 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
     var _a, e_2, _b, _c;
     var _d, _e;
     /**
-     * Inserts a trip at the right place in the routes adjacency structure.
+     * Adds a trip to the appropriate route builder
      */
     const addTrip = (currentTripId) => {
         const gtfsRouteId = validTripIds.get(currentTripId);
-        if (!gtfsRouteId) {
+        if (!gtfsRouteId || stops.length === 0) {
             stops = [];
             arrivalTimes = [];
             departureTimes = [];
@@ -20596,83 +20686,42 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             return;
         }
         const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
-        let route = routes.get(routeId);
-        if (!route) {
-            const stopsCount = stops.length;
-            const stopsArray = new Uint32Array(stops);
-            const stopTimesArray = new Uint16Array(stopsCount * 2);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopTimesArray[i * 2] = arrivalTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                stopTimesArray[i * 2 + 1] = departureTimes[i];
-            }
-            const pickUpDropOffTypesArray = new Uint8Array(stopsCount * 2);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                pickUpDropOffTypesArray[i * 2] = pickUpTypes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                pickUpDropOffTypesArray[i * 2 + 1] = dropOffTypes[i];
-            }
-            route = {
+        const firstDeparture = departureTimes[0];
+        if (firstDeparture === undefined) {
+            console.warn(`Empty trip ${currentTripId}`);
+            stops = [];
+            arrivalTimes = [];
+            departureTimes = [];
+            pickUpTypes = [];
+            dropOffTypes = [];
+            return;
+        }
+        let routeBuilder = routeBuilders.get(routeId);
+        if (!routeBuilder) {
+            routeBuilder = {
                 serviceRouteId: gtfsRouteId,
-                stops: stopsArray,
-                stopTimes: stopTimesArray,
-                pickUpDropOffTypes: pickUpDropOffTypesArray,
+                stops: [...stops],
+                trips: [],
             };
-            routes.set(routeId, route);
+            routeBuilders.set(routeId, routeBuilder);
             for (const stop of stops) {
                 validStopIds.add(stop);
             }
         }
-        else {
-            const tripFirstStopDeparture = departureTimes[0];
-            if (tripFirstStopDeparture === undefined) {
-                throw new Error(`Empty trip ${currentTripId}`);
-            }
-            // Find the correct position to insert the new trip
-            const stopsCount = stops.length;
-            let insertPosition = 0;
-            const existingTripsCount = route.stopTimes.length / (stopsCount * 2);
-            for (let tripIndex = 0; tripIndex < existingTripsCount; tripIndex++) {
-                const currentDeparture = route.stopTimes[tripIndex * stopsCount * 2 + 1];
-                if (currentDeparture && tripFirstStopDeparture > currentDeparture) {
-                    insertPosition = (tripIndex + 1) * stopsCount;
-                }
-                else {
-                    break;
-                }
-            }
-            // insert data for the new trip at the right place
-            const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
-            const newStopTimes = new Uint16Array(newStopTimesLength);
-            const newPickUpDropOffTypes = new Uint8Array(newStopTimesLength);
-            newStopTimes.set(route.stopTimes.slice(0, insertPosition * 2), 0);
-            newPickUpDropOffTypes.set(route.pickUpDropOffTypes.slice(0, insertPosition * 2), 0);
-            for (let i = 0; i < stopsCount; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newStopTimes[(insertPosition + i) * 2] = arrivalTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newStopTimes[(insertPosition + i) * 2 + 1] = departureTimes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newPickUpDropOffTypes[(insertPosition + i) * 2] = pickUpTypes[i];
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                newPickUpDropOffTypes[(insertPosition + i) * 2 + 1] = dropOffTypes[i];
-            }
-            const afterInsertionSlice = route.stopTimes.slice(insertPosition * 2);
-            newStopTimes.set(afterInsertionSlice, (insertPosition + stopsCount) * 2);
-            const afterInsertionTypesSlice = route.pickUpDropOffTypes.slice(insertPosition * 2);
-            newPickUpDropOffTypes.set(afterInsertionTypesSlice, (insertPosition + stopsCount) * 2);
-            route.stopTimes = newStopTimes;
-            route.pickUpDropOffTypes = newPickUpDropOffTypes;
-        }
+        routeBuilder.trips.push({
+            firstDeparture,
+            arrivalTimes: [...arrivalTimes],
+            departureTimes: [...departureTimes],
+            pickUpTypes: [...pickUpTypes],
+            dropOffTypes: [...dropOffTypes],
+        });
         stops = [];
         arrivalTimes = [];
         departureTimes = [];
         pickUpTypes = [];
         dropOffTypes = [];
     };
-    const routes = new Map();
+    const routeBuilders = new Map();
     let previousSeq = 0;
     let stops = [];
     let arrivalTimes = [];
@@ -20687,27 +20736,33 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
             const rawLine = _c;
             const line = rawLine;
             if (line.trip_id === currentTripId && line.stop_sequence <= previousSeq) {
-                console.warn(`Stop sequences not increasing for trip ${line.trip_id}.`);
+                console.warn(`Stop sequences not increasing for trip ${line.trip_id}: ${line.stop_sequence} > ${previousSeq}.`);
                 continue;
             }
             if (!line.arrival_time && !line.departure_time) {
                 console.warn(`Missing arrival or departure time for ${line.trip_id} at stop ${line.stop_id}.`);
                 continue;
             }
-            if (line.pickup_type === 1 && line.drop_off_type === 1) {
+            if (line.pickup_type === '1' && line.drop_off_type === '1') {
                 continue;
             }
             if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
                 addTrip(currentTripId);
             }
             currentTripId = line.trip_id;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            stops.push(stopsMap.get(line.stop_id).id);
+            const stopData = stopsMap.get(line.stop_id);
+            if (!stopData) {
+                console.warn(`Unknown stop ID: ${line.stop_id}`);
+                continue;
+            }
+            stops.push(stopData.id);
             const departure = (_d = line.departure_time) !== null && _d !== void 0 ? _d : line.arrival_time;
             const arrival = (_e = line.arrival_time) !== null && _e !== void 0 ? _e : line.departure_time;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            if (!arrival || !departure) {
+                console.warn(`Missing time data for ${line.trip_id} at stop ${line.stop_id}`);
+                continue;
+            }
             arrivalTimes.push(toTime(arrival).toMinutes());
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             departureTimes.push(toTime(departure).toMinutes());
             pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
             dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
@@ -20725,7 +20780,8 @@ const parseStopTimes = (stopTimesStream, stopsMap, validTripIds, validStopIds) =
         addTrip(currentTripId);
     }
     const routesAdjacency = new Map();
-    for (const [routeId, routeData] of routes) {
+    for (const [routeId, routeBuilder] of routeBuilders) {
+        const routeData = finalizeRouteFromBuilder(routeBuilder);
         routesAdjacency.set(routeId, new Route$1(routeData.stopTimes, routeData.pickUpDropOffTypes, routeData.stops, routeData.serviceRouteId));
     }
     return routesAdjacency;
@@ -20734,13 +20790,13 @@ const parsePickupDropOffType = (gtfsType) => {
     switch (gtfsType) {
         default:
             return REGULAR;
-        case 0:
+        case '0':
             return REGULAR;
-        case 1:
+        case '1':
             return NOT_AVAILABLE;
-        case 2:
+        case '2':
             return MUST_PHONE_AGENCY;
-        case 3:
+        case '3':
             return MUST_COORDINATE_WITH_DRIVER;
     }
 };
@@ -20768,54 +20824,74 @@ class GtfsParser {
      */
     parse(date) {
         return __awaiter(this, void 0, void 0, function* () {
+            log.setLevel('INFO');
             const zip = new StreamZip.async({ file: this.path });
             const entries = yield zip.entries();
             const datetime = DateTime.fromJSDate(date);
             const validServiceIds = new Set();
             const validStopIds = new Set();
             log.info(`Parsing ${STOPS_FILE}`);
+            const stopsStart = performance.now();
             const stopsStream = yield zip.stream(STOPS_FILE);
             const parsedStops = yield parseStops(stopsStream, this.profile.platformParser);
-            log.info(`${parsedStops.size} parsed stops.`);
+            const stopsEnd = performance.now();
+            log.info(`${parsedStops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
             if (entries[CALENDAR_FILE]) {
                 log.info(`Parsing ${CALENDAR_FILE}`);
+                const calendarStart = performance.now();
                 const calendarStream = yield zip.stream(CALENDAR_FILE);
                 yield parseCalendar(calendarStream, validServiceIds, datetime);
-                log.info(`${validServiceIds.size} valid services.`);
+                const calendarEnd = performance.now();
+                log.info(`${validServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`);
             }
             if (entries[CALENDAR_DATES_FILE]) {
                 log.info(`Parsing ${CALENDAR_DATES_FILE}`);
+                const calendarDatesStart = performance.now();
                 const calendarDatesStream = yield zip.stream(CALENDAR_DATES_FILE);
                 yield parseCalendarDates(calendarDatesStream, validServiceIds, datetime);
-                log.info(`${validServiceIds.size} valid services.`);
+                const calendarDatesEnd = performance.now();
+                log.info(`${validServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`);
             }
             log.info(`Parsing ${ROUTES_FILE}`);
+            const routesStart = performance.now();
             const routesStream = yield zip.stream(ROUTES_FILE);
             const validGtfsRoutes = yield parseRoutes(routesStream, this.profile);
-            log.info(`${validGtfsRoutes.size} valid GTFS routes.`);
+            const routesEnd = performance.now();
+            log.info(`${validGtfsRoutes.size} valid GTFS routes. (${(routesEnd - routesStart).toFixed(2)}ms)`);
             log.info(`Parsing ${TRIPS_FILE}`);
+            const tripsStart = performance.now();
             const tripsStream = yield zip.stream(TRIPS_FILE);
             const trips = yield parseTrips(tripsStream, validServiceIds, validGtfsRoutes);
-            log.info(`${trips.size} valid trips.`);
+            const tripsEnd = performance.now();
+            log.info(`${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`);
             let transfers = new Map();
             if (entries[TRANSFERS_FILE]) {
                 log.info(`Parsing ${TRANSFERS_FILE}`);
+                const transfersStart = performance.now();
                 const transfersStream = yield zip.stream(TRANSFERS_FILE);
                 transfers = yield parseTransfers(transfersStream, parsedStops);
-                log.info(`${transfers.size} valid transfers.`);
+                const transfersEnd = performance.now();
+                log.info(`${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`);
             }
             log.info(`Parsing ${STOP_TIMES_FILE}`);
+            const stopTimesStart = performance.now();
             const stopTimesStream = yield zip.stream(STOP_TIMES_FILE);
             const routesAdjacency = yield parseStopTimes(stopTimesStream, parsedStops, trips, validStopIds);
             const stopsAdjacency = buildStopsAdjacencyStructure(validStopIds, routesAdjacency, transfers);
-            log.info(`${routesAdjacency.size} valid unique routes.`);
+            const stopTimesEnd = performance.now();
+            log.info(`${routesAdjacency.size} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`);
             log.info(`Removing unused stops.`);
+            const indexStopsStart = performance.now();
             const stops = indexStops(parsedStops, validStopIds);
-            log.info(`${stops.size} used stop stops, ${parsedStops.size - stops.size} unused.`);
+            const indexStopsEnd = performance.now();
+            log.info(`${stops.size} used stop stops, ${parsedStops.size - stops.size} unused. (${(indexStopsEnd - indexStopsStart).toFixed(2)}ms)`);
             yield zip.close();
             const timetable = new Timetable(stopsAdjacency, routesAdjacency, validGtfsRoutes);
             log.info(`Building stops index.`);
+            const stopsIndexStart = performance.now();
             const stopsIndex = new StopsIndex(stops);
+            const stopsIndexEnd = performance.now();
+            log.info(`Stops index built. (${(stopsIndexEnd - stopsIndexStart).toFixed(2)}ms)`);
             log.info('Parsing complete.');
             return { timetable, stopsIndex };
         });
@@ -20831,9 +20907,11 @@ class GtfsParser {
         return __awaiter(this, void 0, void 0, function* () {
             const zip = new StreamZip.async({ file: this.path });
             log.info(`Parsing ${STOPS_FILE}`);
+            const stopsStart = performance.now();
             const stopsStream = yield zip.stream(STOPS_FILE);
             const stops = indexStops(yield parseStops(stopsStream, this.profile.platformParser));
-            log.info(`${stops.size} parsed stops.`);
+            const stopsEnd = performance.now();
+            log.info(`${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`);
             yield zip.close();
             return new StopsIndex(stops);
         });
@@ -21456,9 +21534,9 @@ const testRouterPerformance = (router, stopsIndex, tasks, iterations) => {
                 global.gc();
             }
             const startMemory = process.memoryUsage().heapUsed;
-            const startTime = performance.now();
+            const startTime = performance$1.now();
             router.route(task);
-            const endTime = performance.now();
+            const endTime = performance$1.now();
             const endMemory = process.memoryUsage().heapUsed;
             totalTime += endTime - startTime;
             if (endMemory >= startMemory) {
@@ -21610,7 +21688,6 @@ const startRepl = (stopsPath, timetablePath) => {
                 if (bestRoute) {
                     console.log(`Found route from ${fromStop.name} to ${toStop.name}:`);
                     console.log(bestRoute.toString());
-                    console.log(JSON.stringify(bestRoute.asJson(), null, 2));
                 }
                 else {
                     console.log('No route found');