minotor 7.0.2 → 9.0.0

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

@@ -0,0 +1,57 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { RouteId, StopRouteIndex, TripRouteIndex } from '../route.js';
+import {
+  decode,
+  encode,
+  getRouteId,
+  getStopIndex,
+  getTripIndex,
+} from '../tripBoardingId.js';
+
+describe('tripBoardingId', () => {
+  it('should maintain identity for encode/decode round-trip', () => {
+    const testCases: [StopRouteIndex, RouteId, TripRouteIndex][] = [
+      [0, 0, 0],
+      [1, 1, 1],
+      [500, 1000, 500],
+      [100000, 200000, 300000],
+      [0, 1048575, 0],
+      [1048575, 0, 1048575],
+      [1048575, 1048575, 1048575], // Maximum values (2^20 - 1)
+    ];
+
+    testCases.forEach(([stopIndex, routeId, tripIndex]) => {
+      const tripBoardingId = encode(stopIndex, routeId, tripIndex);
+      const [decodedStopIndex, decodedRouteId, decodedTripIndex] =
+        decode(tripBoardingId);
+
+      assert.strictEqual(decodedStopIndex, stopIndex);
+      assert.strictEqual(decodedRouteId, routeId);
+      assert.strictEqual(decodedTripIndex, tripIndex);
+    });
+  });
+
+  it('should extract stop index correctly', () => {
+    const tripBoardingId = encode(42, 100, 200);
+    assert.strictEqual(getStopIndex(tripBoardingId), 42);
+  });
+
+  it('should extract route ID correctly', () => {
+    const tripBoardingId = encode(42, 100, 200);
+    assert.strictEqual(getRouteId(tripBoardingId), 100);
+  });
+
+  it('should extract trip index correctly', () => {
+    const tripBoardingId = encode(42, 100, 200);
+    assert.strictEqual(getTripIndex(tripBoardingId), 200);
+  });
+
+  it('should throw error for values exceeding 20-bit limit', () => {
+    const maxValue = 1048575; // 2^20 - 1
+    assert.throws(() => encode(maxValue + 1, 0, 0));
+    assert.throws(() => encode(0, maxValue + 1, 0));
+    assert.throws(() => encode(0, 0, maxValue + 1));
+  });
+});

package/src/timetable/io.ts

@@ -5,6 +5,7 @@ import {
   ServiceRoute as ProtoServiceRoute,
   StopAdjacency as ProtoStopAdjacency,
   TransferType as ProtoTransferType,
+  TripContinuationEntry as ProtoTripContinuationEntry,
 } from './proto/timetable.js';
 import { Route } from './route.js';
 import {
@@ -14,7 +15,10 @@ import {
   StopAdjacency,
   Transfer,
   TransferType,
+  TripBoarding,
+  TripContinuations,
 } from './timetable.js';
+import { decode, encode, TripBoardingId } from './tripBoardingId.js';
 
 export type SerializedRoute = {
   stopTimes: Uint16Array;
@@ -125,13 +129,15 @@ export const serializeStopsAdjacency = (
 ): ProtoStopAdjacency[] => {
   return stopsAdjacency.map((value) => {
     return {
-      transfers: value.transfers.map((transfer) => ({
-        destination: transfer.destination,
-        type: serializeTransferType(transfer.type),
-        ...(transfer.minTransferTime !== undefined && {
-          minTransferTime: transfer.minTransferTime.toSeconds(),
-        }),
-      })),
+      transfers: value.transfers
+        ? value.transfers.map((transfer) => ({
+            destination: transfer.destination,
+            type: serializeTransferType(transfer.type),
+            ...(transfer.minTransferTime !== undefined && {
+              minTransferTime: transfer.minTransferTime.toSeconds(),
+            }),
+          }))
+        : [],
       routes: value.routes,
     };
   });
@@ -190,10 +196,15 @@ export const deserializeStopsAdjacency = (
       transfers.push(newTransfer);
     }
 
-    result.push({
-      transfers: transfers,
+    const stopAdjacency: StopAdjacency = {
       routes: value.routes,
-    });
+    };
+
+    if (transfers.length > 0) {
+      stopAdjacency.transfers = transfers;
+    }
+
+    result.push(stopAdjacency);
   }
 
   return result;
@@ -210,6 +221,7 @@ export const deserializeRoutesAdjacency = (
     const stops = bytesToUint32Array(value.stops);
     routesAdjacency.push(
       new Route(
+        i,
         bytesToUint16Array(value.stopTimes),
         value.pickUpDropOffTypes,
         stops,
@@ -319,3 +331,53 @@ const serializeRouteType = (type: RouteType): ProtoRouteType => {
       return ProtoRouteType.MONORAIL;
   }
 };
+
+export const serializeTripContinuations = (
+  tripContinuations: TripContinuations,
+): ProtoTripContinuationEntry[] => {
+  const result: ProtoTripContinuationEntry[] = [];
+  for (const [tripBoardingId, boardings] of tripContinuations.entries()) {
+    const [originStopIndex, originRouteId, originTripIndex] =
+      decode(tripBoardingId);
+
+    result.push({
+      originStopIndex,
+      originRouteId,
+      originTripIndex,
+      continuations: boardings.map((tripBoarding) => ({
+        hopOnStopIndex: tripBoarding.hopOnStopIndex,
+        routeId: tripBoarding.routeId,
+        tripIndex: tripBoarding.tripIndex,
+      })),
+    });
+  }
+
+  return result;
+};
+
+export const deserializeTripContinuations = (
+  protoTripContinuations: ProtoTripContinuationEntry[],
+): TripContinuations => {
+  const result = new Map<TripBoardingId, TripBoarding[]>();
+
+  for (let i = 0; i < protoTripContinuations.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const entry = protoTripContinuations[i]!;
+    const tripBoardingId = encode(
+      entry.originStopIndex,
+      entry.originRouteId,
+      entry.originTripIndex,
+    );
+    const tripBoardings: TripBoarding[] = entry.continuations.map(
+      (protoTripBoarding) => ({
+        hopOnStopIndex: protoTripBoarding.hopOnStopIndex,
+        routeId: protoTripBoarding.routeId,
+        tripIndex: protoTripBoarding.tripIndex,
+      }),
+    );
+
+    result.set(tripBoardingId, tripBoardings);
+  }
+
+  return result;
+};

package/src/timetable/proto/timetable.proto

@@ -40,9 +40,22 @@ message Transfer {
   optional uint32 minTransferTime = 3;
 }
 
+message TripBoarding {
+  uint32 hopOnStopIndex = 1;
+  uint32 routeId = 2;
+  uint32 tripIndex = 3;
+}
+
+message TripContinuationEntry {
+  uint32 originStopIndex = 1;
+  uint32 originRouteId = 2;
+  uint32 originTripIndex = 3;
+  repeated TripBoarding continuations = 4;
+}
+
 message StopAdjacency {
-  repeated Transfer transfers = 1;
-  repeated uint32 routes = 2;
+  repeated uint32 routes = 1;
+  repeated Transfer transfers = 2;
 }
 
 enum RouteType {
@@ -69,4 +82,5 @@ message Timetable {
   repeated StopAdjacency stopsAdjacency = 2;
   repeated Route routesAdjacency = 3;
   repeated ServiceRoute serviceRoutes = 4;
+  repeated TripContinuationEntry tripContinuations = 5;
 }

package/src/timetable/proto/timetable.ts

@@ -166,9 +166,22 @@ export interface Transfer {
   minTransferTime?: number | undefined;
 }
 
+export interface TripBoarding {
+  hopOnStopIndex: number;
+  routeId: number;
+  tripIndex: number;
+}
+
+export interface TripContinuationEntry {
+  originStopIndex: number;
+  originRouteId: number;
+  originTripIndex: number;
+  continuations: TripBoarding[];
+}
+
 export interface StopAdjacency {
-  transfers: Transfer[];
   routes: number[];
+  transfers: Transfer[];
 }
 
 export interface ServiceRoute {
@@ -182,6 +195,7 @@ export interface Timetable {
   stopsAdjacency: StopAdjacency[];
   routesAdjacency: Route[];
   serviceRoutes: ServiceRoute[];
+  tripContinuations: TripContinuationEntry[];
 }
 
 function createBaseRoute(): Route {
@@ -391,20 +405,222 @@ export const Transfer: MessageFns<Transfer> = {
   },
 };
 
+function createBaseTripBoarding(): TripBoarding {
+  return { hopOnStopIndex: 0, routeId: 0, tripIndex: 0 };
+}
+
+export const TripBoarding: MessageFns<TripBoarding> = {
+  encode(message: TripBoarding, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.hopOnStopIndex !== 0) {
+      writer.uint32(8).uint32(message.hopOnStopIndex);
+    }
+    if (message.routeId !== 0) {
+      writer.uint32(16).uint32(message.routeId);
+    }
+    if (message.tripIndex !== 0) {
+      writer.uint32(24).uint32(message.tripIndex);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TripBoarding {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTripBoarding();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.hopOnStopIndex = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.routeId = reader.uint32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.tripIndex = reader.uint32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TripBoarding {
+    return {
+      hopOnStopIndex: isSet(object.hopOnStopIndex) ? globalThis.Number(object.hopOnStopIndex) : 0,
+      routeId: isSet(object.routeId) ? globalThis.Number(object.routeId) : 0,
+      tripIndex: isSet(object.tripIndex) ? globalThis.Number(object.tripIndex) : 0,
+    };
+  },
+
+  toJSON(message: TripBoarding): unknown {
+    const obj: any = {};
+    if (message.hopOnStopIndex !== 0) {
+      obj.hopOnStopIndex = Math.round(message.hopOnStopIndex);
+    }
+    if (message.routeId !== 0) {
+      obj.routeId = Math.round(message.routeId);
+    }
+    if (message.tripIndex !== 0) {
+      obj.tripIndex = Math.round(message.tripIndex);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TripBoarding>, I>>(base?: I): TripBoarding {
+    return TripBoarding.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TripBoarding>, I>>(object: I): TripBoarding {
+    const message = createBaseTripBoarding();
+    message.hopOnStopIndex = object.hopOnStopIndex ?? 0;
+    message.routeId = object.routeId ?? 0;
+    message.tripIndex = object.tripIndex ?? 0;
+    return message;
+  },
+};
+
+function createBaseTripContinuationEntry(): TripContinuationEntry {
+  return { originStopIndex: 0, originRouteId: 0, originTripIndex: 0, continuations: [] };
+}
+
+export const TripContinuationEntry: MessageFns<TripContinuationEntry> = {
+  encode(message: TripContinuationEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.originStopIndex !== 0) {
+      writer.uint32(8).uint32(message.originStopIndex);
+    }
+    if (message.originRouteId !== 0) {
+      writer.uint32(16).uint32(message.originRouteId);
+    }
+    if (message.originTripIndex !== 0) {
+      writer.uint32(24).uint32(message.originTripIndex);
+    }
+    for (const v of message.continuations) {
+      TripBoarding.encode(v!, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TripContinuationEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTripContinuationEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.originStopIndex = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.originRouteId = reader.uint32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.originTripIndex = reader.uint32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.continuations.push(TripBoarding.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TripContinuationEntry {
+    return {
+      originStopIndex: isSet(object.originStopIndex) ? globalThis.Number(object.originStopIndex) : 0,
+      originRouteId: isSet(object.originRouteId) ? globalThis.Number(object.originRouteId) : 0,
+      originTripIndex: isSet(object.originTripIndex) ? globalThis.Number(object.originTripIndex) : 0,
+      continuations: globalThis.Array.isArray(object?.continuations)
+        ? object.continuations.map((e: any) => TripBoarding.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: TripContinuationEntry): unknown {
+    const obj: any = {};
+    if (message.originStopIndex !== 0) {
+      obj.originStopIndex = Math.round(message.originStopIndex);
+    }
+    if (message.originRouteId !== 0) {
+      obj.originRouteId = Math.round(message.originRouteId);
+    }
+    if (message.originTripIndex !== 0) {
+      obj.originTripIndex = Math.round(message.originTripIndex);
+    }
+    if (message.continuations?.length) {
+      obj.continuations = message.continuations.map((e) => TripBoarding.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TripContinuationEntry>, I>>(base?: I): TripContinuationEntry {
+    return TripContinuationEntry.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TripContinuationEntry>, I>>(object: I): TripContinuationEntry {
+    const message = createBaseTripContinuationEntry();
+    message.originStopIndex = object.originStopIndex ?? 0;
+    message.originRouteId = object.originRouteId ?? 0;
+    message.originTripIndex = object.originTripIndex ?? 0;
+    message.continuations = object.continuations?.map((e) => TripBoarding.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseStopAdjacency(): StopAdjacency {
-  return { transfers: [], routes: [] };
+  return { routes: [], transfers: [] };
 }
 
 export const StopAdjacency: MessageFns<StopAdjacency> = {
   encode(message: StopAdjacency, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.transfers) {
-      Transfer.encode(v!, writer.uint32(10).fork()).join();
-    }
-    writer.uint32(18).fork();
+    writer.uint32(10).fork();
     for (const v of message.routes) {
       writer.uint32(v);
     }
     writer.join();
+    for (const v of message.transfers) {
+      Transfer.encode(v!, writer.uint32(18).fork()).join();
+    }
     return writer;
   },
 
@@ -416,21 +632,13 @@ export const StopAdjacency: MessageFns<StopAdjacency> = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1: {
-          if (tag !== 10) {
-            break;
-          }
-
-          message.transfers.push(Transfer.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 2: {
-          if (tag === 16) {
+          if (tag === 8) {
             message.routes.push(reader.uint32());
 
             continue;
           }
 
-          if (tag === 18) {
+          if (tag === 10) {
             const end2 = reader.uint32() + reader.pos;
             while (reader.pos < end2) {
               message.routes.push(reader.uint32());
@@ -441,6 +649,14 @@ export const StopAdjacency: MessageFns<StopAdjacency> = {
 
           break;
         }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.transfers.push(Transfer.decode(reader, reader.uint32()));
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -452,21 +668,21 @@ export const StopAdjacency: MessageFns<StopAdjacency> = {
 
   fromJSON(object: any): StopAdjacency {
     return {
+      routes: globalThis.Array.isArray(object?.routes) ? object.routes.map((e: any) => globalThis.Number(e)) : [],
       transfers: globalThis.Array.isArray(object?.transfers)
         ? object.transfers.map((e: any) => Transfer.fromJSON(e))
         : [],
-      routes: globalThis.Array.isArray(object?.routes) ? object.routes.map((e: any) => globalThis.Number(e)) : [],
     };
   },
 
   toJSON(message: StopAdjacency): unknown {
     const obj: any = {};
-    if (message.transfers?.length) {
-      obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
-    }
     if (message.routes?.length) {
       obj.routes = message.routes.map((e) => Math.round(e));
     }
+    if (message.transfers?.length) {
+      obj.transfers = message.transfers.map((e) => Transfer.toJSON(e));
+    }
     return obj;
   },
 
@@ -475,8 +691,8 @@ export const StopAdjacency: MessageFns<StopAdjacency> = {
   },
   fromPartial<I extends Exact<DeepPartial<StopAdjacency>, I>>(object: I): StopAdjacency {
     const message = createBaseStopAdjacency();
-    message.transfers = object.transfers?.map((e) => Transfer.fromPartial(e)) || [];
     message.routes = object.routes?.map((e) => e) || [];
+    message.transfers = object.transfers?.map((e) => Transfer.fromPartial(e)) || [];
     return message;
   },
 };
@@ -586,7 +802,7 @@ export const ServiceRoute: MessageFns<ServiceRoute> = {
 };
 
 function createBaseTimetable(): Timetable {
-  return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [] };
+  return { version: "", stopsAdjacency: [], routesAdjacency: [], serviceRoutes: [], tripContinuations: [] };
 }
 
 export const Timetable: MessageFns<Timetable> = {
@@ -603,6 +819,9 @@ export const Timetable: MessageFns<Timetable> = {
     for (const v of message.serviceRoutes) {
       ServiceRoute.encode(v!, writer.uint32(34).fork()).join();
     }
+    for (const v of message.tripContinuations) {
+      TripContinuationEntry.encode(v!, writer.uint32(42).fork()).join();
+    }
     return writer;
   },
 
@@ -645,6 +864,14 @@ export const Timetable: MessageFns<Timetable> = {
           message.serviceRoutes.push(ServiceRoute.decode(reader, reader.uint32()));
           continue;
         }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.tripContinuations.push(TripContinuationEntry.decode(reader, reader.uint32()));
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -666,6 +893,9 @@ export const Timetable: MessageFns<Timetable> = {
       serviceRoutes: globalThis.Array.isArray(object?.serviceRoutes)
         ? object.serviceRoutes.map((e: any) => ServiceRoute.fromJSON(e))
         : [],
+      tripContinuations: globalThis.Array.isArray(object?.tripContinuations)
+        ? object.tripContinuations.map((e: any) => TripContinuationEntry.fromJSON(e))
+        : [],
     };
   },
 
@@ -683,6 +913,9 @@ export const Timetable: MessageFns<Timetable> = {
     if (message.serviceRoutes?.length) {
       obj.serviceRoutes = message.serviceRoutes.map((e) => ServiceRoute.toJSON(e));
     }
+    if (message.tripContinuations?.length) {
+      obj.tripContinuations = message.tripContinuations.map((e) => TripContinuationEntry.toJSON(e));
+    }
     return obj;
   },
 
@@ -695,6 +928,7 @@ export const Timetable: MessageFns<Timetable> = {
     message.stopsAdjacency = object.stopsAdjacency?.map((e) => StopAdjacency.fromPartial(e)) || [];
     message.routesAdjacency = object.routesAdjacency?.map((e) => Route.fromPartial(e)) || [];
     message.serviceRoutes = object.serviceRoutes?.map((e) => ServiceRoute.fromPartial(e)) || [];
+    message.tripContinuations = object.tripContinuations?.map((e) => TripContinuationEntry.fromPartial(e)) || [];
     return message;
   },
 };