minotor 11.5.2 → 12.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/CHANGELOG.md +3 -3
  2. package/README.md +1 -1
  3. package/dist/cli/perf.d.ts +15 -5
  4. package/dist/cli.mjs +139 -151
  5. package/dist/cli.mjs.map +1 -1
  6. package/dist/parser.cjs.js +37 -19
  7. package/dist/parser.cjs.js.map +1 -1
  8. package/dist/parser.esm.js +37 -19
  9. package/dist/parser.esm.js.map +1 -1
  10. package/dist/router.cjs.js +1 -1
  11. package/dist/router.cjs.js.map +1 -1
  12. package/dist/router.d.ts +6 -5
  13. package/dist/router.esm.js +1 -1
  14. package/dist/router.esm.js.map +1 -1
  15. package/dist/router.umd.js +1 -1
  16. package/dist/router.umd.js.map +1 -1
  17. package/dist/routing/route.d.ts +6 -9
  18. package/dist/routing/state.d.ts +2 -2
  19. package/dist/stops/stopsIndex.d.ts +1 -1
  20. package/dist/timetable/route.d.ts +7 -4
  21. package/package.json +2 -2
  22. package/src/__e2e__/router.test.ts +55 -56
  23. package/src/cli/minotor.ts +19 -2
  24. package/src/cli/perf.ts +94 -107
  25. package/src/cli/repl.ts +9 -5
  26. package/src/router.ts +21 -8
  27. package/src/routing/__tests__/plainRouter.test.ts +2 -2
  28. package/src/routing/__tests__/result.test.ts +1 -1
  29. package/src/routing/__tests__/route.test.ts +8 -7
  30. package/src/routing/__tests__/router.test.ts +21 -1
  31. package/src/routing/__tests__/state.test.ts +29 -0
  32. package/src/routing/result.ts +11 -45
  33. package/src/routing/route.ts +11 -13
  34. package/src/routing/state.ts +11 -3
  35. package/src/stops/__tests__/stopFinder.test.ts +13 -0
  36. package/src/stops/stopsIndex.ts +13 -19
  37. package/src/timetable/__tests__/io.test.ts +27 -0
  38. package/src/timetable/__tests__/route.test.ts +30 -0
  39. package/src/timetable/io.ts +15 -1
  40. package/src/timetable/route.ts +40 -12
  41. package/src/timetable/timetable.ts +1 -1
package/src/cli/perf.ts CHANGED
@@ -13,7 +13,68 @@ import { timeFromString, timeToString } from '../timetable/time.js';
13
13
  type PerformanceResult = {
14
14
  label: string;
15
15
  meanTimeUs: number;
16
- meanMemoryMb: number;
16
+ meanHeapMiB: number;
17
+ meanArrayBuffersMiB: number;
18
+ };
19
+
20
+ // Keep operation results reachable until the ending memory sample has been taken.
21
+ const retainedResults: unknown[] = [];
22
+
23
+ /** Observed deltas, not peak memory or total allocations; GC can make them negative. */
24
+ export const measurePerformance = (
25
+ operation: () => unknown,
26
+ iterations: number,
27
+ ): Omit<PerformanceResult, 'label'> => {
28
+ let totalTime = 0;
29
+ let totalHeap = 0;
30
+ let totalArrayBuffers = 0;
31
+ for (let i = 0; i < iterations; i++) {
32
+ global.gc?.();
33
+ const before = process.memoryUsage();
34
+ const start = performance.now();
35
+ const result = operation();
36
+ const end = performance.now();
37
+ retainedResults.push(result);
38
+ const after = process.memoryUsage();
39
+ retainedResults.pop();
40
+ totalTime += (end - start) * 1_000;
41
+ totalHeap += after.heapUsed - before.heapUsed;
42
+ totalArrayBuffers += after.arrayBuffers - before.arrayBuffers;
43
+ }
44
+ return {
45
+ meanTimeUs: totalTime / iterations,
46
+ meanHeapMiB: totalHeap / iterations / (1024 * 1024),
47
+ meanArrayBuffersMiB: totalArrayBuffers / iterations / (1024 * 1024),
48
+ };
49
+ };
50
+
51
+ /** Measure retained storage after collection, keeping only the returned value alive. */
52
+ export const measureRetainedMemory = <T>(
53
+ operation: () => T,
54
+ ): {
55
+ value: T;
56
+ loadTimeMs: number;
57
+ retainedHeapMiB?: number;
58
+ retainedArrayBuffersMiB?: number;
59
+ } => {
60
+ const gc = global.gc;
61
+ gc?.();
62
+ const before = gc ? process.memoryUsage() : undefined;
63
+ const start = performance.now();
64
+ const value = operation();
65
+ const loadTimeMs = performance.now() - start;
66
+ if (!gc || !before) return { value, loadTimeMs };
67
+ // A second collection lets backing storage released by finalization settle.
68
+ gc();
69
+ gc();
70
+ const after = process.memoryUsage();
71
+ return {
72
+ value,
73
+ loadTimeMs,
74
+ retainedHeapMiB: (after.heapUsed - before.heapUsed) / (1024 * 1024),
75
+ retainedArrayBuffersMiB:
76
+ (after.arrayBuffers - before.arrayBuffers) / (1024 * 1024),
77
+ };
17
78
  };
18
79
 
19
80
  type SerializedQuery = {
@@ -204,7 +265,7 @@ export const loadRangeQueriesFromJson = (
204
265
  * yield a more stable mean at the cost of longer wall-clock time.
205
266
  * @param stopsIndex - Used to resolve stop names for result labels.
206
267
  * @returns An array of {@link PerformanceResult} objects, one per query, each
207
- * containing the mean wall-clock time (µs) and mean heap delta (MB).
268
+ * containing the mean wall-clock time (µs) and mean heap and ArrayBuffer deltas (MiB).
208
269
  */
209
270
  export const testRouterPerformance = (
210
271
  router: Router,
@@ -215,32 +276,9 @@ export const testRouterPerformance = (
215
276
  const results: PerformanceResult[] = [];
216
277
 
217
278
  for (const task of tasks) {
218
- let totalTime = 0;
219
- let totalMemory = 0;
220
-
221
- for (let i = 0; i < iterations; i++) {
222
- if (global.gc) {
223
- global.gc();
224
- }
225
-
226
- const startMemory = process.memoryUsage().heapUsed;
227
- const startTime = performance.now();
228
-
229
- router.route(task);
230
-
231
- const endTime = performance.now();
232
- const endMemory = process.memoryUsage().heapUsed;
233
-
234
- totalTime += (endTime - startTime) * 1_000;
235
- if (endMemory >= startMemory) {
236
- totalMemory += endMemory - startMemory;
237
- }
238
- }
239
-
240
279
  results.push({
241
280
  label: buildQueryLabel(task, stopsIndex),
242
- meanTimeUs: totalTime / iterations,
243
- meanMemoryMb: totalMemory / iterations / (1024 * 1024),
281
+ ...measurePerformance(() => router.route(task), iterations),
244
282
  });
245
283
  }
246
284
 
@@ -258,7 +296,7 @@ export const testRouterPerformance = (
258
296
  * @param iterations - Number of times `bestRoute` is called per query.
259
297
  * @param stopsIndex - Used to resolve stop names for result labels.
260
298
  * @returns An array of {@link PerformanceResult} objects, one per query, each
261
- * containing the mean wall-clock time (µs) and mean heap delta (MB) for the
299
+ * containing the mean wall-clock time (µs) and mean heap and ArrayBuffer deltas (MiB) for the
262
300
  * `bestRoute` call alone.
263
301
  */
264
302
  export const testBestRoutePerformance = (
@@ -272,32 +310,9 @@ export const testBestRoutePerformance = (
272
310
  for (const task of tasks) {
273
311
  const result = router.route(task);
274
312
 
275
- let totalTime = 0;
276
- let totalMemory = 0;
277
-
278
- for (let i = 0; i < iterations; i++) {
279
- if (global.gc) {
280
- global.gc();
281
- }
282
-
283
- const startMemory = process.memoryUsage().heapUsed;
284
- const startTime = performance.now();
285
-
286
- result.bestRoute();
287
-
288
- const endTime = performance.now();
289
- const endMemory = process.memoryUsage().heapUsed;
290
-
291
- totalTime += (endTime - startTime) * 1_000;
292
- if (endMemory >= startMemory) {
293
- totalMemory += endMemory - startMemory;
294
- }
295
- }
296
-
297
313
  results.push({
298
314
  label: buildQueryLabel(task, stopsIndex),
299
- meanTimeUs: totalTime / iterations,
300
- meanMemoryMb: totalMemory / iterations / (1024 * 1024),
315
+ ...measurePerformance(() => result.bestRoute(), iterations),
301
316
  });
302
317
  }
303
318
 
@@ -313,7 +328,7 @@ export const testBestRoutePerformance = (
313
328
  * @param iterations - Number of times each query is repeated.
314
329
  * @param stopsIndex - Used to resolve stop names for result labels.
315
330
  * @returns An array of {@link PerformanceResult} objects, one per query, each
316
- * containing the mean wall-clock time (µs) and mean heap delta (MB).
331
+ * containing the mean wall-clock time (µs) and mean heap and ArrayBuffer deltas (MiB).
317
332
  */
318
333
  export const testRangeRouterPerformance = (
319
334
  router: Router,
@@ -324,32 +339,9 @@ export const testRangeRouterPerformance = (
324
339
  const results: PerformanceResult[] = [];
325
340
 
326
341
  for (const task of tasks) {
327
- let totalTime = 0;
328
- let totalMemory = 0;
329
-
330
- for (let i = 0; i < iterations; i++) {
331
- if (global.gc) {
332
- global.gc();
333
- }
334
-
335
- const startMemory = process.memoryUsage().heapUsed;
336
- const startTime = performance.now();
337
-
338
- router.rangeRoute(task);
339
-
340
- const endTime = performance.now();
341
- const endMemory = process.memoryUsage().heapUsed;
342
-
343
- totalTime += (endTime - startTime) * 1_000;
344
- if (endMemory >= startMemory) {
345
- totalMemory += endMemory - startMemory;
346
- }
347
- }
348
-
349
342
  results.push({
350
343
  label: buildQueryLabel(task, stopsIndex),
351
- meanTimeUs: totalTime / iterations,
352
- meanMemoryMb: totalMemory / iterations / (1024 * 1024),
344
+ ...measurePerformance(() => router.rangeRoute(task), iterations),
353
345
  });
354
346
  }
355
347
 
@@ -367,7 +359,7 @@ export const testRangeRouterPerformance = (
367
359
  * @param iterations - Number of times `getRoutes` is called per query.
368
360
  * @param stopsIndex - Used to resolve stop names for result labels.
369
361
  * @returns An array of {@link PerformanceResult} objects, one per query, each
370
- * containing the mean wall-clock time (µs) and mean heap delta (MB) for the
362
+ * containing the mean wall-clock time (µs) and mean heap and ArrayBuffer deltas (MiB) for the
371
363
  * `getRoutes` call alone.
372
364
  */
373
365
  export const testRangeResultPerformance = (
@@ -381,40 +373,15 @@ export const testRangeResultPerformance = (
381
373
  for (const task of tasks) {
382
374
  const rangeResult: RangeResult = router.rangeRoute(task);
383
375
 
384
- let totalTime = 0;
385
- let totalMemory = 0;
386
-
387
- for (let i = 0; i < iterations; i++) {
388
- if (global.gc) {
389
- global.gc();
390
- }
391
-
392
- const startMemory = process.memoryUsage().heapUsed;
393
- const startTime = performance.now();
394
-
395
- rangeResult.getRoutes();
396
-
397
- const endTime = performance.now();
398
- const endMemory = process.memoryUsage().heapUsed;
399
-
400
- totalTime += (endTime - startTime) * 1_000;
401
- if (endMemory >= startMemory) {
402
- totalMemory += endMemory - startMemory;
403
- }
404
- }
405
-
406
376
  results.push({
407
377
  label: buildQueryLabel(task, stopsIndex),
408
- meanTimeUs: totalTime / iterations,
409
- meanMemoryMb: totalMemory / iterations / (1024 * 1024),
378
+ ...measurePerformance(() => rangeResult.getRoutes(), iterations),
410
379
  });
411
380
  }
412
381
 
413
382
  return results;
414
383
  };
415
384
 
416
- // ─── Output ───────────────────────────────────────────────────────────────────
417
-
418
385
  /**
419
386
  * Prints a table summary of performance results to stdout.
420
387
  *
@@ -442,14 +409,19 @@ export const prettyPrintPerformanceResults = (
442
409
  const meanTime =
443
410
  results.reduce((s, r) => s + r.meanTimeUs, 0) / results.length;
444
411
  const meanMem =
445
- results.reduce((s, r) => s + r.meanMemoryMb, 0) / results.length;
412
+ results.reduce((s, r) => s + r.meanHeapMiB, 0) / results.length;
413
+ const meanBuffers =
414
+ results.reduce((s, r) => s + r.meanArrayBuffersMiB, 0) / results.length;
446
415
 
447
416
  const queryHeader = 'Query';
448
417
  const timeHeader = 'Time (µs)';
449
- const memHeader = 'Mem (MB)';
418
+ const memHeader = 'Heap Δ (MiB)';
419
+ const buffersHeader = 'ArrayBuffers Δ (MiB)';
450
420
 
451
421
  const timeVals = results.map((r) => fmtTime(r.meanTimeUs));
452
- const memVals = results.map((r) => fmtMem(r.meanMemoryMb));
422
+ const memVals = results.map((r) => fmtMem(r.meanHeapMiB));
423
+ const bufferVals = results.map((r) => fmtMem(r.meanArrayBuffersMiB));
424
+ const meanBuffersStr = fmtMem(meanBuffers);
453
425
  const meanTimeStr = fmtTime(meanTime);
454
426
  const meanMemStr = fmtMem(meanMem);
455
427
 
@@ -473,14 +445,29 @@ export const prettyPrintPerformanceResults = (
473
445
  { header: queryHeader, width: queryWidth, align: 'left' },
474
446
  { header: timeHeader, width: timeWidth, align: 'right' },
475
447
  { header: memHeader, width: memWidth, align: 'right' },
448
+ {
449
+ header: buffersHeader,
450
+ width: Math.max(
451
+ buffersHeader.length,
452
+ meanBuffersStr.length,
453
+ ...bufferVals.map((v) => v.length),
454
+ ),
455
+ align: 'right',
456
+ },
476
457
  ];
477
458
 
478
459
  const rows = results.map((r, i) => [
479
460
  r.label,
480
461
  timeVals[i] ?? '',
481
462
  memVals[i] ?? '',
463
+ bufferVals[i] ?? '',
482
464
  ]);
483
- const footer = ['mean', meanTimeStr, meanMemStr];
465
+ const footer = ['mean', meanTimeStr, meanMemStr, meanBuffersStr];
484
466
 
485
467
  console.log(renderTable(columns, rows, footer));
468
+ if (!global.gc) {
469
+ console.log(
470
+ 'Explicit GC unavailable; use node --expose-gc for more consistent samples.',
471
+ );
472
+ }
486
473
  };
package/src/cli/repl.ts CHANGED
@@ -4,9 +4,13 @@ import fs from 'fs';
4
4
 
5
5
  import { Query, RangeQuery, Router, StopsIndex, Timetable } from '../router.js';
6
6
  import type { Stop } from '../stops/stops.js';
7
- import type { RawPickUpDropOffType } from '../timetable/route.js';
7
+ import type { PickUpDropOffType } from '../timetable/route.js';
8
8
  import { PickUpDropOffTypes, Route } from '../timetable/route.js';
9
9
  import { timeFromString, timeToString } from '../timetable/time.js';
10
+ import {
11
+ routeTypeToString,
12
+ transferTypeToString,
13
+ } from '../timetable/timetable.js';
10
14
  import { plotGraphToDotFile } from './utils.js';
11
15
 
12
16
  export const startRepl = (stopsPath: string, timetablePath: string) => {
@@ -298,7 +302,7 @@ export const startRepl = (stopsPath: string, timetablePath: string) => {
298
302
  },
299
303
  });
300
304
 
301
- const formatPickupDropoffType = (type: RawPickUpDropOffType): string => {
305
+ const formatPickupDropoffType = (type: PickUpDropOffType): string => {
302
306
  switch (type) {
303
307
  case PickUpDropOffTypes.REGULAR:
304
308
  return 'R';
@@ -351,7 +355,7 @@ export const startRepl = (stopsPath: string, timetablePath: string) => {
351
355
 
352
356
  const serviceRouteInfo = timetable.getServiceRouteInfo(route);
353
357
  const routeName = serviceRouteInfo.name;
354
- const routeType = serviceRouteInfo.type;
358
+ const routeType = routeTypeToString(serviceRouteInfo.type);
355
359
 
356
360
  console.log(`\n=== Route ${routeId} ===`);
357
361
  console.log(`Service Route: ${routeName}`);
@@ -450,7 +454,7 @@ export const startRepl = (stopsPath: string, timetablePath: string) => {
450
454
  routes.forEach((route, index) => {
451
455
  const serviceRouteInfo = timetable.getServiceRouteInfo(route);
452
456
  console.log(
453
- `${index + 1}. Route ${route.id}: ${serviceRouteInfo.name} (${serviceRouteInfo.type})`,
457
+ `${index + 1}. Route ${route.id}: ${serviceRouteInfo.name} (${routeTypeToString(serviceRouteInfo.type)})`,
454
458
  );
455
459
  });
456
460
  }
@@ -469,7 +473,7 @@ export const startRepl = (stopsPath: string, timetablePath: string) => {
469
473
  ? ` (min: ${transfer.minTransferTime}min)`
470
474
  : '';
471
475
  console.log(
472
- `${index + 1}. ${transfer.type} to ${destStop?.name ?? 'Unknown'}${platform} (${transfer.destination}, ${destStop?.sourceStopId ?? 'N/A'})${minTime}`,
476
+ `${index + 1}. ${transferTypeToString(transfer.type)} to ${destStop?.name ?? 'Unknown'}${platform} (${transfer.destination}, ${destStop?.sourceStopId ?? 'N/A'})${minTime}`,
473
477
  );
474
478
  });
475
479
  }
package/src/router.ts CHANGED
@@ -18,16 +18,25 @@ import { RangeResult, Router } from './routing/router.js';
18
18
  import type { LocationType, SourceStopId, StopId } from './stops/stops.js';
19
19
  import type { Stop } from './stops/stops.js';
20
20
  import { StopsIndex } from './stops/stopsIndex.js';
21
- import type { PickUpDropOffTypeString } from './timetable/route.js';
21
+ import type { PickUpDropOffType } from './timetable/route.js';
22
+ import {
23
+ PickUpDropOffTypes,
24
+ pickUpDropOffTypeToString,
25
+ } from './timetable/route.js';
22
26
  import type { Duration, Time } from './timetable/time.js';
23
- import type {
24
- RouteTypeString,
25
- TransferTypeString,
27
+ import type { RouteType, TransferType } from './timetable/timetable.js';
28
+ import {
29
+ RouteTypes,
30
+ routeTypeToString,
31
+ Timetable,
32
+ TransferTypes,
33
+ transferTypeToString,
26
34
  } from './timetable/timetable.js';
27
- import { Timetable } from './timetable/timetable.js';
28
35
 
29
36
  export {
30
37
  Duration,
38
+ PickUpDropOffTypes,
39
+ pickUpDropOffTypeToString,
31
40
  Plotter,
32
41
  Query,
33
42
  RangeQuery,
@@ -35,9 +44,13 @@ export {
35
44
  Result,
36
45
  Route,
37
46
  Router,
47
+ RouteTypes,
48
+ routeTypeToString,
38
49
  StopsIndex,
39
50
  Time,
40
51
  Timetable,
52
+ TransferTypes,
53
+ transferTypeToString,
41
54
  };
42
55
 
43
56
  export type {
@@ -46,15 +59,15 @@ export type {
46
59
  Leg,
47
60
  LocationType,
48
61
  ParetoRun,
49
- PickUpDropOffTypeString as PickUpDropOffType,
62
+ PickUpDropOffType,
50
63
  QueryOptions,
51
64
  RangeQueryOptions,
52
- RouteTypeString as RouteType,
65
+ RouteType,
53
66
  ServiceRouteInfo,
54
67
  SourceStopId,
55
68
  Stop,
56
69
  StopId,
57
70
  Transfer,
58
- TransferTypeString as TransferType,
71
+ TransferType,
59
72
  VehicleLeg,
60
73
  };
@@ -1029,7 +1029,7 @@ describe('PlainRouter', () => {
1029
1029
 
1030
1030
  // Should find a route with 3 legs:
1031
1031
  // 1. Vehicle leg (route 0)
1032
- // 2. Guaranteed transfer leg (shown as type: 'GUARANTEED')
1032
+ // 2. Guaranteed transfer leg (shown as type: TransferTypes.GUARANTEED)
1033
1033
  // 3. Vehicle leg (route 1)
1034
1034
  assert.ok(bestRoute);
1035
1035
  assert.strictEqual(bestRoute.legs.length, 3);
@@ -1037,7 +1037,7 @@ describe('PlainRouter', () => {
1037
1037
  // The middle leg should be the guaranteed transfer
1038
1038
  const transferLeg = bestRoute.legs[1];
1039
1039
  assert.ok(transferLeg && 'type' in transferLeg);
1040
- assert.strictEqual(transferLeg.type, 'GUARANTEED');
1040
+ assert.strictEqual(transferLeg.type, TransferTypes.GUARANTEED);
1041
1041
 
1042
1042
  // Should arrive at 08:40 because the guaranteed transfer allows catching
1043
1043
  // the 08:21 departure despite only having 1 minute of transfer time
@@ -635,7 +635,7 @@ describe('Result', () => {
635
635
  assert.strictEqual(transferLeg.to.id, 2);
636
636
  assert('type' in transferLeg);
637
637
  assert('minTransferTime' in transferLeg);
638
- assert.strictEqual(transferLeg.type, 'RECOMMENDED');
638
+ assert.strictEqual(transferLeg.type, TransferTypes.RECOMMENDED);
639
639
 
640
640
  assert.strictEqual(thirdLeg.from.id, 2);
641
641
  assert.strictEqual(thirdLeg.to.id, 3);
@@ -1,6 +1,7 @@
1
1
  import assert from 'node:assert';
2
2
  import { describe, it } from 'node:test';
3
3
 
4
+ import { PickUpDropOffTypes, RouteTypes, TransferTypes } from '../../router.js';
4
5
  import { Stop } from '../../stops/stops.js';
5
6
  import { timeFromHMS } from '../../timetable/time.js';
6
7
  import { Route, ServiceRouteInfo, Transfer, VehicleLeg } from '../route.js';
@@ -39,12 +40,12 @@ describe('Route', () => {
39
40
  };
40
41
 
41
42
  const serviceRoute: ServiceRouteInfo = {
42
- type: 'BUS',
43
+ type: RouteTypes.BUS,
43
44
  name: 'Route 1',
44
45
  };
45
46
 
46
47
  const serviceRoute2: ServiceRouteInfo = {
47
- type: 'RAIL',
48
+ type: RouteTypes.RAIL,
48
49
  name: 'Route 2',
49
50
  };
50
51
 
@@ -54,14 +55,14 @@ describe('Route', () => {
54
55
  route: serviceRoute,
55
56
  departureTime: timeFromHMS(8, 0, 0),
56
57
  arrivalTime: timeFromHMS(8, 30, 0),
57
- pickUpType: 'REGULAR',
58
- dropOffType: 'REGULAR',
58
+ pickUpType: PickUpDropOffTypes.REGULAR,
59
+ dropOffType: PickUpDropOffTypes.REGULAR,
59
60
  };
60
61
 
61
62
  const transferLeg: Transfer = {
62
63
  from: stopB,
63
64
  to: stopC,
64
- type: 'RECOMMENDED',
65
+ type: TransferTypes.RECOMMENDED,
65
66
  minTransferTime: 5,
66
67
  };
67
68
 
@@ -71,8 +72,8 @@ describe('Route', () => {
71
72
  route: serviceRoute2,
72
73
  departureTime: timeFromHMS(8, 40, 0),
73
74
  arrivalTime: timeFromHMS(9, 0, 0),
74
- pickUpType: 'REGULAR',
75
- dropOffType: 'REGULAR',
75
+ pickUpType: PickUpDropOffTypes.REGULAR,
76
+ dropOffType: PickUpDropOffTypes.REGULAR,
76
77
  };
77
78
 
78
79
  it('should calculate the correct departure time', () => {
@@ -1,12 +1,12 @@
1
1
  import assert from 'node:assert';
2
2
  import { describe, it } from 'node:test';
3
3
 
4
+ import { PickUpDropOffTypes, RouteType, RouteTypes } from '../../router.js';
4
5
  import { Stop } from '../../stops/stops.js';
5
6
  import { StopsIndex } from '../../stops/stopsIndex.js';
6
7
  import { Route } from '../../timetable/route.js';
7
8
  import { timeFromHM } from '../../timetable/time.js';
8
9
  import {
9
- RouteTypes,
10
10
  ServiceRoute,
11
11
  StopAdjacency,
12
12
  Timetable,
@@ -27,11 +27,13 @@ const routesAdjacency = [
27
27
  stops: [
28
28
  {
29
29
  id: 0,
30
+ pickUpType: PickUpDropOffTypes.MUST_PHONE_AGENCY,
30
31
  arrivalTime: timeFromHM(8, 0),
31
32
  departureTime: timeFromHM(8, 10),
32
33
  },
33
34
  {
34
35
  id: 1,
36
+ dropOffType: PickUpDropOffTypes.MUST_COORDINATE_WITH_DRIVER,
35
37
  arrivalTime: timeFromHM(8, 30),
36
38
  departureTime: timeFromHM(8, 30),
37
39
  },
@@ -72,10 +74,19 @@ describe('Router', () => {
72
74
  const query = new Query.Builder()
73
75
  .from(0)
74
76
  .to(1)
77
+ .transportModes(new Set<RouteType>([RouteTypes.BUS]))
75
78
  .departureTime(timeFromHM(8, 0))
76
79
  .build();
77
80
  const result = router.route(query);
78
81
  assert(result instanceof Result);
82
+ const leg = result.bestRoute()?.legs[0];
83
+ assert(leg && 'route' in leg);
84
+ assert.strictEqual(leg.route.type, RouteTypes.BUS);
85
+ assert.strictEqual(leg.pickUpType, PickUpDropOffTypes.MUST_PHONE_AGENCY);
86
+ assert.strictEqual(
87
+ leg.dropOffType,
88
+ PickUpDropOffTypes.MUST_COORDINATE_WITH_DRIVER,
89
+ );
79
90
  assert.strictEqual(result.arrivalAt(1)?.arrival, timeFromHM(8, 30));
80
91
  });
81
92
 
@@ -83,11 +94,20 @@ describe('Router', () => {
83
94
  const query = new RangeQuery.Builder()
84
95
  .from(0)
85
96
  .to(1)
97
+ .transportModes(new Set<RouteType>([RouteTypes.BUS]))
86
98
  .departureTime(timeFromHM(8, 0))
87
99
  .lastDepartureTime(timeFromHM(9, 0))
88
100
  .build();
89
101
  const result = router.rangeRoute(query);
90
102
  assert(result instanceof RangeResult);
103
+ const leg = result.bestRoute()?.legs[0];
104
+ assert(leg && 'route' in leg);
105
+ assert.strictEqual(leg.route.type, RouteTypes.BUS);
106
+ assert.strictEqual(leg.pickUpType, PickUpDropOffTypes.MUST_PHONE_AGENCY);
107
+ assert.strictEqual(
108
+ leg.dropOffType,
109
+ PickUpDropOffTypes.MUST_COORDINATE_WITH_DRIVER,
110
+ );
91
111
  assert.strictEqual(result.size, 1);
92
112
  assert.strictEqual(result.bestRoute()?.arrivalTime(), timeFromHM(8, 30));
93
113
  });
@@ -76,3 +76,32 @@ describe('RoutingState', () => {
76
76
  });
77
77
  });
78
78
  });
79
+
80
+ describe('RoutingState reuse', () => {
81
+ it('resets repeated improvements and all rounds like a fresh state', () => {
82
+ const access = [{ fromStopId: 0, toStopId: 0, duration: 0 }];
83
+ const state = new RoutingState(100, [2], access, 4, 3, 60);
84
+ state.updateArrival(0, 99, 1);
85
+ state.updateArrival(1, 120, 1);
86
+ state.graph[1]![1] = { stopId: 1, arrival: 120 };
87
+ state.updateArrival(1, 110, 2);
88
+ state.graph[2]![1] = { stopId: 1, arrival: 110 };
89
+ state.updateArrival(2, 130, 3);
90
+ state.graph[3]![2] = { stopId: 2, arrival: 130 };
91
+ for (const departure of [90, 80]) {
92
+ state.resetFor(departure, access);
93
+ const fresh = new RoutingState(departure, [2], access, 4, 3, 60);
94
+ assert.deepStrictEqual([...state.arrivals()], [...fresh.arrivals()]);
95
+ assert.strictEqual(state.destinationBest, fresh.destinationBest);
96
+ assert.strictEqual(state.maxArrivalTime, fresh.maxArrivalTime);
97
+ for (let round = 0; round < state.graph.length; round++) {
98
+ assert.deepStrictEqual(
99
+ Array.from(state.graph[round]!),
100
+ Array.from(fresh.graph[round]!),
101
+ );
102
+ }
103
+ state.updateArrival(1, departure + 10, 1);
104
+ state.graph[1]![1] = { stopId: 1, arrival: departure + 10 };
105
+ }
106
+ });
107
+ });