minotor 11.2.1 → 11.2.2

package/dist/routing/rangeState.d.ts

@@ -69,7 +69,7 @@ export declare class RangeRaptorState implements IRaptorState {
      */
     get destinationBest(): Time;
     isDestination(stop: StopId): boolean;
-    /** Updates both the per-run state and the cross-run shared labels. */
+    /** Updates the per-run aggregate best when improved, and always considers the cross-run shared label. */
     updateArrival(stop: StopId, time: Time, round: number): void;
     /**
      * initialized round `k` from round `k-1`: τk(p) ← min(τk(p), τk-1(p)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minotor",
-  "version": "11.2.1",
+  "version": "11.2.2",
   "description": "A lightweight client-side transit routing library.",
   "keywords": [
     "minotor",

package/src/routing/__tests__/rangeState.test.ts

@@ -229,6 +229,94 @@ describe('RangeRaptorState', () => {
     });
   });
 
+  describe('updateArrival aggregate overwrite behavior', () => {
+    it('does not overwrite the current run aggregate with a later arrival from a higher round', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 1]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 45), 2);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 1,
+      });
+      assert.strictEqual(state.roundLabels[2]![2], timeFromHM(8, 45));
+    });
+
+    it('does not overwrite the current run aggregate with an equal-time arrival using more legs', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 2]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 3);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 2,
+      });
+      assert.strictEqual(state.roundLabels[3]![2], timeFromHM(8, 30));
+    });
+
+    it('prefers fewer legs for the current run aggregate when arrival time is equal', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 30), 3]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 2);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 2,
+      });
+    });
+
+    it('still updates the current run aggregate when the new arrival is earlier', () => {
+      const state = new RangeRaptorState(
+        MAX_ROUNDS,
+        NB_STOPS,
+        timeFromHM(12, 0),
+      );
+      const run = RoutingState.fromTestData({
+        nbStops: NB_STOPS,
+        destinations: [2],
+        arrivals: [[2, timeFromHM(8, 45), 1]],
+      });
+      state.setCurrentRun(run);
+
+      state.updateArrival(2, timeFromHM(8, 30), 3);
+
+      assert.deepStrictEqual(run.getArrival(2), {
+        arrival: timeFromHM(8, 30),
+        legNumber: 3,
+      });
+    });
+  });
+
   describe('isDestination', () => {
     it('delegates to the current run', () => {
       const state = new RangeRaptorState(

package/src/routing/rangeState.ts

@@ -113,9 +113,19 @@ export class RangeRaptorState implements IRaptorState {
     return this.currentRun.isDestination(stop);
   }
 
-  /** Updates both the per-run state and the cross-run shared labels. */
+  /** Updates the per-run aggregate best when improved, and always considers the cross-run shared label. */
   updateArrival(stop: StopId, time: Time, round: number): void {
-    this.currentRun.updateArrival(stop, time, round);
+    const currentRunArrival = this.currentRun.getArrival(stop);
+    const improvesCurrentRunAggregate =
+      currentRunArrival === undefined ||
+      time < currentRunArrival.arrival ||
+      (time === currentRunArrival.arrival &&
+        round < currentRunArrival.legNumber);
+
+    if (improvesCurrentRunAggregate) {
+      this.currentRun.updateArrival(stop, time, round);
+    }
+
     if (time < this.roundLabels[round]![stop]!) {
       this.roundLabels[round]![stop] = time;
       this.changedInRound[round]!.push(stop);