minotor 2.0.1 → 3.0.0

package/src/timetable/__tests__/timetable.test.ts

@@ -37,15 +37,15 @@ describe('timetable io', () => {
     [
       'route1',
       {
-        stopTimes: new Uint32Array([
-          Time.fromHMS(0, 16, 40).toSeconds(),
-          Time.fromHMS(0, 16, 50).toSeconds(),
-          Time.fromHMS(0, 33, 20).toSeconds(),
-          Time.fromHMS(0, 33, 30).toSeconds(),
-          Time.fromHMS(0, 50, 0).toSeconds(),
-          Time.fromHMS(0, 50, 10).toSeconds(),
-          Time.fromHMS(1, 10, 0).toSeconds(),
-          Time.fromHMS(1, 10, 10).toSeconds(),
+        stopTimes: new Uint16Array([
+          Time.fromHMS(16, 40, 0).toMinutes(),
+          Time.fromHMS(16, 50, 0).toMinutes(),
+          Time.fromHMS(17, 20, 0).toMinutes(),
+          Time.fromHMS(17, 30, 0).toMinutes(),
+          Time.fromHMS(18, 0, 0).toMinutes(),
+          Time.fromHMS(18, 10, 0).toMinutes(),
+          Time.fromHMS(19, 0, 0).toMinutes(),
+          Time.fromHMS(19, 10, 0).toMinutes(),
         ]),
         pickUpDropOffTypes: new Uint8Array([
           0,
@@ -68,11 +68,11 @@ describe('timetable io', () => {
     [
       'route2',
       {
-        stopTimes: new Uint32Array([
-          Time.fromHMS(1, 6, 40).toSeconds(),
-          Time.fromHMS(1, 6, 50).toSeconds(),
-          Time.fromHMS(1, 23, 20).toSeconds(),
-          Time.fromHMS(1, 23, 30).toSeconds(),
+        stopTimes: new Uint16Array([
+          Time.fromHMS(18, 20, 0).toMinutes(),
+          Time.fromHMS(18, 30, 0).toMinutes(),
+          Time.fromHMS(23, 20, 0).toMinutes(),
+          Time.fromHMS(23, 30, 0).toMinutes(),
         ]),
         pickUpDropOffTypes: new Uint8Array([
           0,
@@ -121,7 +121,7 @@ describe('timetable io', () => {
   it('should find the earliest trip for stop1 on route1 after a specific time', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute('route1')!;
-    const afterTime = Time.fromHMS(0, 25, 0);
+    const afterTime = Time.fromHMS(17, 0, 0);
     const tripIndex = sampleTimetable.findEarliestTrip(
       route,
       1,
@@ -134,7 +134,7 @@ describe('timetable io', () => {
   it('should return undefined if no valid trip exists after a specific time', () => {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const route = sampleTimetable.getRoute('route1')!;
-    const afterTime = Time.fromHMS(0, 58, 20);
+    const afterTime = Time.fromHMS(23, 40, 0);
     const tripIndex = sampleTimetable.findEarliestTrip(
       route,
       1,

package/src/timetable/io.ts

@@ -70,6 +70,50 @@ function bytesToUint32Array(bytes: Uint8Array): Uint32Array {
   return result;
 }
 
+function uint16ArrayToBytes(array: Uint16Array): Uint8Array {
+  if (isLittleEndian === STANDARD_ENDIANNESS) {
+    return new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+  }
+
+  // If endianness doesn't match, we need to swap byte order
+  const result = new Uint8Array(array.length * 2);
+  const view = new DataView(result.buffer);
+
+  for (let i = 0; i < array.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    view.setUint16(i * 2, array[i]!, STANDARD_ENDIANNESS);
+  }
+
+  return result;
+}
+
+function bytesToUint16Array(bytes: Uint8Array): Uint16Array {
+  if (bytes.byteLength % 2 !== 0) {
+    throw new Error(
+      'Byte array length must be a multiple of 2 to convert to Uint16Array',
+    );
+  }
+
+  // If system endianness matches our standard, we can create a view directly
+  if (isLittleEndian === STANDARD_ENDIANNESS) {
+    return new Uint16Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength / 2,
+    );
+  }
+
+  // If endianness doesn't match, we need to swap byte order
+  const result = new Uint16Array(bytes.byteLength / 2);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  for (let i = 0; i < result.length; i++) {
+    result[i] = view.getUint16(i * 2, STANDARD_ENDIANNESS);
+  }
+
+  return result;
+}
+
 export const serializeStopsAdjacency = (
   stopsAdjacency: StopsAdjacency,
 ): ProtoStopsAdjacency => {
@@ -104,7 +148,7 @@ export const serializeRoutesAdjacency = (
 
   routesAdjacency.forEach((value: Route, key: string) => {
     protoRoutesAdjacency.routes[key] = {
-      stopTimes: uint32ArrayToBytes(value.stopTimes),
+      stopTimes: uint16ArrayToBytes(value.stopTimes),
       pickUpDropOffTypes: value.pickUpDropOffTypes,
       stops: uint32ArrayToBytes(value.stops),
       serviceRouteId: value.serviceRouteId,
@@ -170,7 +214,7 @@ export const deserializeRoutesAdjacency = (
       indices.set(stops[i]!, i);
     }
     routesAdjacency.set(key, {
-      stopTimes: bytesToUint32Array(value.stopTimes),
+      stopTimes: bytesToUint16Array(value.stopTimes),
       pickUpDropOffTypes: value.pickUpDropOffTypes,
       stops: stops,
       stopIndices: indices,

package/src/timetable/time.ts

@@ -1,10 +1,14 @@
 import { Duration } from './duration.js';
 
 /**
- * A class representing a time in hours, minutes, and seconds.
+ * A class representing a time as minutes since midnight.
  */
 export class Time {
-  private secondsSinceMidnight: number;
+  /*
+   * Number of minutes since midnight.
+   Note that this value can go beyond 3600 to model services overlapping with the next day.
+   */
+  private minutesSinceMidnight: number;
   /**
    * Gets the infinity time as a Time instance.
    * This represents a time that is conceptually beyond any real possible time.
@@ -17,28 +21,29 @@ export class Time {
   /**
    * Gets the midnight time as a Time instance.
    *
-   * @returns A Time instance representing midnight (00:00:00).
+   * @returns A Time instance representing midnight.
    */
   static origin(): Time {
     return new Time(0);
   }
 
-  private constructor(seconds: number) {
-    this.secondsSinceMidnight = seconds;
+  private constructor(minutes: number) {
+    this.minutesSinceMidnight = minutes;
   }
 
   /**
-   * Creates a Time instance from the number of seconds since midnight.
+   * Creates a Time instance from the number of minutes since midnight.
    *
-   * @param seconds - The number of seconds since midnight.
+   * @param minutes - The number of minutes since midnight.
    * @returns A Time instance representing the specified time.
    */
-  static fromSeconds(seconds: number): Time {
-    return new Time(seconds);
+  static fromMinutes(minutes: number): Time {
+    return new Time(minutes);
   }
 
   /**
    * Creates a Time instance from hours, minutes, and seconds.
+   * Rounds to the closest minute as times are represented in minutes from midnight.
    *
    * @param hours - The hours component of the time.
    * @param minutes - The minutes component of the time.
@@ -57,7 +62,25 @@ export class Time {
         'Invalid time. Ensure hours, minutes, and seconds are valid values.',
       );
     }
-    return new Time(seconds + 60 * minutes + 3600 * hours);
+    const totalSeconds = seconds + 60 * minutes + 3600 * hours;
+    const roundedMinutes = Math.round(totalSeconds / 60);
+    return new Time(roundedMinutes);
+  }
+
+  /**
+   * Creates a Time instance from hours, minutes.
+   *
+   * @param hours - The hours component of the time.
+   * @param minutes - The minutes component of the time.
+   * @returns A Time instance representing the specified time.
+   */
+  static fromHM(hours: number, minutes: number): Time {
+    if (hours < 0 || minutes < 0 || minutes >= 60) {
+      throw new Error(
+        'Invalid time. Ensure hours and minutes are valid values.',
+      );
+    }
+    return new Time(minutes + hours * 60);
   }
 
   /**
@@ -70,7 +93,7 @@ export class Time {
     const hours = date.getHours();
     const minutes = date.getMinutes();
     const seconds = date.getSeconds();
-    return new Time(seconds + 60 * minutes + 3600 * hours);
+    return Time.fromHMS(hours, minutes, seconds);
   }
 
   /**
@@ -95,7 +118,7 @@ export class Time {
     const hours = parseInt(hoursStr, 10);
     const minutes = parseInt(minutesStr, 10);
     const seconds = secondsStr !== undefined ? parseInt(secondsStr, 10) : 0;
-    return new Time(seconds + 60 * minutes + 3600 * hours);
+    return Time.fromHMS(hours, minutes, seconds);
   }
 
   /**
@@ -104,22 +127,20 @@ export class Time {
    * @returns A string representing the time.
    */
   toString(): string {
-    const hours = Math.floor(this.secondsSinceMidnight / 3600);
-    const minutes = Math.floor((this.secondsSinceMidnight % 3600) / 60);
-    const seconds = this.secondsSinceMidnight % 60;
-    return `${hours.toString().padStart(2, '0')}:${minutes
-      .toString()
-      .padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+    const hours = Math.floor(this.minutesSinceMidnight / 60);
+    const minutes = Math.floor(this.minutesSinceMidnight % 60);
+    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
   }
 
   /**
-   * Gets the time as the number of seconds since midnight.
+   * Converts the Time instance to the total number of minutes since midnight, rounded to the closest minute.
    *
-   * @returns The time in seconds since midnight.
+   * @returns The time in minutes since midnight.
    */
-  toSeconds(): number {
-    return this.secondsSinceMidnight;
+  toMinutes(): number {
+    return this.minutesSinceMidnight;
   }
+
   /**
    * Adds a Duration to the current Time instance and returns a new Time instance.
    *
@@ -127,8 +148,8 @@ export class Time {
    * @returns A new Time instance with the added duration.
    */
   plus(duration: Duration): Time {
-    const totalSeconds = this.secondsSinceMidnight + duration.toSeconds();
-    return new Time(totalSeconds);
+    const totalSeconds = this.minutesSinceMidnight * 60 + duration.toSeconds();
+    return new Time(Math.round(totalSeconds / 60));
   }
 
   /**
@@ -138,11 +159,11 @@ export class Time {
    * @returns A new Time instance with the subtracted duration.
    */
   minus(duration: Duration): Time {
-    let totalSeconds = this.secondsSinceMidnight - duration.toSeconds();
+    let totalSeconds = this.minutesSinceMidnight * 60 - duration.toSeconds();
     if (totalSeconds < 0) {
       totalSeconds += 24 * 3600; // Adjust for negative time to loop back to previous day
     }
-    return new Time(totalSeconds);
+    return new Time(Math.round(totalSeconds / 60));
   }
 
   /**
@@ -152,8 +173,8 @@ export class Time {
    * @returns A Duration instance representing the time difference.
    */
   diff(otherTime: Time): Duration {
-    const totalSeconds = this.secondsSinceMidnight - otherTime.toSeconds();
-    return Duration.fromSeconds(Math.abs(totalSeconds));
+    const totalMinutes = this.minutesSinceMidnight - otherTime.toMinutes();
+    return Duration.fromSeconds(Math.abs(totalMinutes * 60));
   }
 
   /**
@@ -167,7 +188,7 @@ export class Time {
       throw new Error('At least one Time instance is required.');
     }
     return times.reduce((maxTime, currentTime) => {
-      return currentTime.toSeconds() > maxTime.toSeconds()
+      return currentTime.toMinutes() > maxTime.toMinutes()
         ? currentTime
         : maxTime;
     });
@@ -184,7 +205,7 @@ export class Time {
       throw new Error('At least one Time instance is required.');
     }
     return times.reduce((minTime, currentTime) => {
-      return currentTime.toSeconds() < minTime.toSeconds()
+      return currentTime.toMinutes() < minTime.toMinutes()
         ? currentTime
         : minTime;
     });

package/src/timetable/timetable.ts

@@ -29,10 +29,10 @@ export type PickUpDropOffType =
 
 export type Route = {
   /**
-   * Arrivals and departures encoded as a binary array.
+   * Arrivals and departures encoded as minutes from midnight.
    * Format: [arrival1, departure1, arrival2, departure2, etc.]
    */
-  stopTimes: Uint32Array;
+  stopTimes: Uint16Array;
   /**
    * PickUp and DropOff types represented as a binary Uint8Array.
    * Values:
@@ -127,7 +127,7 @@ export const ALL_TRANSPORT_MODES: RouteType[] = [
   'MONORAIL',
 ];
 
-export const CURRENT_VERSION = '0.0.2';
+export const CURRENT_VERSION = '0.0.3';
 
 /**
  * The internal transit timetable format
@@ -285,7 +285,7 @@ export class Timetable {
         const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
         const departure = route.stopTimes[stopTimeIndex * 2 + 1]!;
         const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2]!;
-        if (departure >= after.toSeconds() && pickUpType !== NOT_AVAILABLE) {
+        if (departure >= after.toMinutes() && pickUpType !== NOT_AVAILABLE) {
           return tripIndex;
         }
       }
@@ -301,16 +301,16 @@ export class Timetable {
         const stopTimeIndex = tripIndex * stopsNumber + stopIndex;
         const departure = route.stopTimes[stopTimeIndex * 2 + 1]!;
         const pickUpType = route.pickUpDropOffTypes[stopTimeIndex * 2]!;
-        if (departure < after.toSeconds()) {
+        if (departure < after.toMinutes()) {
           break;
         }
         if (
           pickUpType !== NOT_AVAILABLE &&
           (earliestDeparture === undefined ||
-            departure < earliestDeparture.toSeconds())
+            departure < earliestDeparture.toMinutes())
         ) {
           earliestTripIndex = tripIndex;
-          earliestDeparture = Time.fromSeconds(departure);
+          earliestDeparture = Time.fromMinutes(departure);
         }
       }
       return earliestTripIndex;