chore: enable noUncheckedIndexedAccess tsconfig setting

- aggregate.ts: extract times[i] in loop with undefined guard, fix leadHoursAt signature, guard used[id] in for-in renorm loops
- aggregate.test.ts: use optional chaining (out[N]?.prop) for index accesses; use toBeDefined() + narrowing guard in wind test
- chartHelpers.ts: guard times[i], times[0], sunrise[0], sunset[i] with explicit undefined checks
- useForecast.ts: guard times[0] with early return null in both hourly and daily computed properties
- useUnits.ts: add ?? fallback on COMPASS[idx]
- HourlyChart.vue: guard times[idx] and precP in tooltip formatter

Assisted-by: Zed:claude-sonnet-4-6

Author: Flowm

src/components/HourlyChart.vue

@@ -76,13 +76,14 @@ const option = computed<EChartsOption>(() => {
         const idx = labels.indexOf(t);
         const tempP = temps[idx];
         const precP = precips[idx];
-        if (!tempP) return "";
-        const date = new Date(times[idx]);
+        const timeStr = times[idx];
+        if (!tempP || timeStr === undefined) return "";
+        const date = new Date(timeStr);
         const header = date.toLocaleString([], { weekday: "short", hour: "2-digit", minute: "2-digit" });
         const tempStr =
           `<span style="color:#fda4af">${formatTemp.value(tempP.value, 1)}</span>` +
           ` <span style="color:#94a3b8">± ${formatTemp.value(tempP.stdDev, 1).replace(/°[CF]/, "")} ${tempUnit.value}</span>`;
-        const precStr = precP.value > 0.05 ? `<br/><span style="color:#7dd3fc">${formatPrecip.value(precP.value, 1)}</span>` : "";
+        const precStr = precP != null && precP.value > 0.05 ? `<br/><span style="color:#7dd3fc">${formatPrecip.value(precP.value, 1)}</span>` : "";
         return `<div style="font-weight:600;margin-bottom:4px">${header}</div>${tempStr}${precStr}`;
       },
     },

src/components/chartHelpers.ts

@@ -6,7 +6,8 @@
 /** First index in `times` whose timestamp is at or after `nowStr`. */
 export function findNowIndex(times: string[], nowStr: string): number {
   for (let i = 0; i < times.length; i++) {
-    if (times[i] >= nowStr) return i;
+    const t = times[i];
+    if (t !== undefined && t >= nowStr) return i;
   }
   return -1;
 }
@@ -20,17 +21,22 @@ function isoToHourIndex(iso: string, baseMs: number, count: number): number {
 /** Build [startIdx, endIdx] pairs covering night hours within the visible window. */
 export function buildNightRanges(times: string[], sunrise: string[] | undefined, sunset: string[] | undefined): Array<[number, number]> {
   if (!times.length || !sunrise?.length || !sunset?.length) return [];
-  const baseMs = new Date(times[0]).getTime();
+  const firstTime = times[0];
+  const firstSunrise = sunrise[0];
+  if (firstTime === undefined || firstSunrise === undefined) return [];
+  const baseMs = new Date(firstTime).getTime();
   const count = times.length;
   const ranges: Array<[number, number]> = [];
 
   // Pre-dawn on the first day.
-  const firstRise = isoToHourIndex(sunrise[0], baseMs, count);
+  const firstRise = isoToHourIndex(firstSunrise, baseMs, count);
   if (firstRise > 0) ranges.push([0, firstRise]);
 
   // Sunset of day i → sunrise of day i+1.
   for (let i = 0; i < sunset.length; i++) {
-    const setIdx = isoToHourIndex(sunset[i], baseMs, count);
+    const sunsetTime = sunset[i];
+    if (sunsetTime === undefined) continue;
+    const setIdx = isoToHourIndex(sunsetTime, baseMs, count);
     const nextRiseIso = sunrise[i + 1];
     const endIdx = nextRiseIso ? isoToHourIndex(nextRiseIso, baseMs, count) : count - 1;
     if (endIdx > setIdx) ranges.push([setIdx, endIdx]);

src/composables/useForecast.ts

@@ -101,7 +101,9 @@ export function useForecast(location: Ref<Location>): UseForecastReturn {
     const data = raw.value;
     if (!data) return null;
     const times = data.hourly.time;
-    const baseTime = new Date(times[0]);
+    const firstHourlyTime = times[0];
+    if (firstHourlyTime === undefined) return null;
+    const baseTime = new Date(firstHourlyTime);
     const series: Record<HourlyVar, AggregatePoint[]> = {} as never;
     const confidence: Record<HourlyVar, number[]> = {} as never;
     const perModel: Record<HourlyVar, Record<string, (number | null)[]>> = {} as never;
@@ -125,7 +127,9 @@ export function useForecast(location: Ref<Location>): UseForecastReturn {
     const data = raw.value;
     if (!data) return null;
     const times = data.daily.time;
-    const baseTime = new Date(times[0]);
+    const firstDailyTime = times[0];
+    if (firstDailyTime === undefined) return null;
+    const baseTime = new Date(firstDailyTime);
     const series: Record<DailyVar, AggregatePoint[]> = {} as never;
     const confidence: Record<DailyVar, number[]> = {} as never;
     const perModel: Record<DailyVar, Record<string, (number | null)[]>> = {} as never;

src/composables/useUnits.ts

@@ -17,7 +17,7 @@ export function formatPercent(v: number | null | undefined): string {
 export function compassPoint(deg: number | null | undefined): string {
   if (deg == null || Number.isNaN(deg)) return "–";
   const idx = Math.round((((deg % 360) + 360) % 360) / 45) % 8;
-  return COMPASS[idx];
+  return COMPASS[idx] ?? "–";
 }
 
 export function useUnits() {

src/domain/aggregate.test.ts

@@ -29,8 +29,8 @@ describe("aggregateSeries (temperature)", () => {
       baseTime,
     });
     expect(out).toHaveLength(4);
-    expect(out[0].value).toBeCloseTo(10, 5);
-    expect(out[3].value).toBeCloseTo(13, 5);
+    expect(out[0]?.value).toBeCloseTo(10, 5);
+    expect(out[3]?.value).toBeCloseTo(13, 5);
     for (const p of out) expect(p.stdDev).toBeCloseTo(0, 5);
   });
 
@@ -50,9 +50,9 @@ describe("aggregateSeries (temperature)", () => {
       lon: PARIS.lon,
       baseTime,
     });
-    expect(out[0].stdDev).toBeGreaterThan(0);
-    expect(out[0].value).toBeGreaterThan(10);
-    expect(out[0].value).toBeLessThan(14);
+    expect(out[0]?.stdDev).toBeGreaterThan(0);
+    expect(out[0]?.value).toBeGreaterThan(10);
+    expect(out[0]?.value).toBeLessThan(14);
   });
 
   it("handles null per-model values without crashing", () => {
@@ -71,7 +71,7 @@ describe("aggregateSeries (temperature)", () => {
       lon: PARIS.lon,
       baseTime,
     });
-    expect(out[0].value).toBeCloseTo(10, 5);
+    expect(out[0]?.value).toBeCloseTo(10, 5);
   });
 });
 
@@ -98,7 +98,10 @@ describe("aggregateSeries (wind_direction_10m)", () => {
       },
     );
     // Allow either side of the wrap.
-    const v = out[0].value;
+    const p0 = out[0];
+    expect(p0).toBeDefined();
+    if (!p0) return;
+    const v = p0.value;
     const distFromNorth = Math.min(v, 360 - v);
     expect(distFromNorth).toBeLessThan(2);
   });
@@ -120,8 +123,8 @@ describe("aggregateSeries (wind_direction_10m)", () => {
         baseTime,
       },
     );
-    expect(out[0].value).toBeCloseTo(180, 0);
-    expect(out[0].stdDev).toBeLessThan(10);
+    expect(out[0]?.value).toBeCloseTo(180, 0);
+    expect(out[0]?.stdDev).toBeLessThan(10);
   });
 
   it("reports a large angular stddev when models are opposite", () => {
@@ -142,7 +145,7 @@ describe("aggregateSeries (wind_direction_10m)", () => {
       },
     );
     // Mean resultant length → 0, so circular stddev should be huge.
-    expect(out[0].stdDev).toBeGreaterThan(90);
+    expect(out[0]?.stdDev).toBeGreaterThan(90);
   });
 });
 
@@ -165,6 +168,6 @@ describe("aggregateSeries (weather_code)", () => {
       baseTime,
     });
     // Should land somewhere in the rain group.
-    expect([61, 63, 80]).toContain(out[0].value);
+    expect([61, 63, 80]).toContain(out[0]?.value);
   });
 });

src/domain/aggregate.ts

@@ -27,11 +27,11 @@ export interface AggregateOptions {
   baseTime: Date;
 }
 
-function leadHoursAt(times: string[], i: number, baseTime: Date): number {
+function leadHoursAt(time: string, baseTime: Date): number {
   // open-meteo returns timezone-shifted ISO strings without a TZ marker.
   // Both the times array and our cursor are in the same local frame, so a
   // direct millisecond diff is correct.
-  const t = new Date(times[i]).getTime();
+  const t = new Date(time).getTime();
   return Math.max(0, (t - baseTime.getTime()) / 3_600_000);
 }
 
@@ -53,11 +53,15 @@ function weightedMean(perModel: ModelSamples, weights: Map<string, number>): { m
   let varSum = 0;
   for (const id in used) {
     const v = perModel[id];
-    if (v == null) continue;
-    varSum += (used[id] / totalW) * (v - mean) ** 2;
+    const w = used[id];
+    if (v == null || w === undefined) continue;
+    varSum += (w / totalW) * (v - mean) ** 2;
   }
   // Renormalize so the exposed weights sum to 1 even after dropping nulls.
-  for (const id in used) used[id] = used[id] / totalW;
+  for (const id in used) {
+    const w = used[id];
+    if (w !== undefined) used[id] = w / totalW;
+  }
   return { mean, stdDev: Math.sqrt(varSum), effectiveWeights: used };
 }
 
@@ -88,7 +92,10 @@ function weightedCircularMean(perModel: ModelSamples, weights: Map<string, numbe
   const R = Math.min(1, Math.sqrt(mx * mx + my * my));
   // Circular standard deviation in radians: sqrt(-2 * ln(R)). Convert to degrees.
   const stdDev = R > 0 ? (Math.sqrt(-2 * Math.log(R)) * 180) / Math.PI : 180;
-  for (const id in used) used[id] = used[id] / totalW;
+  for (const id in used) {
+    const w = used[id];
+    if (w !== undefined) used[id] = w / totalW;
+  }
   return { mean, stdDev, effectiveWeights: used };
 }
 
@@ -125,7 +132,10 @@ function severityWeightedMode(perModel: ModelSamples, weights: Map<string, numbe
       bestCodeW = w;
     }
   }
-  for (const id in used) used[id] = used[id] / totalW;
+  for (const id in used) {
+    const w = used[id];
+    if (w !== undefined) used[id] = w / totalW;
+  }
   return { code: bestCode, effectiveWeights: used };
 }
 
@@ -135,7 +145,9 @@ export function aggregateSeries(times: string[], series: Record<string, (number
   const { variable, models, lat, lon, baseTime } = opts;
   const result: AggregatePoint[] = [];
   for (let i = 0; i < times.length; i++) {
-    const leadH = leadHoursAt(times, i, baseTime);
+    const timeStr = times[i];
+    if (timeStr === undefined) continue;
+    const leadH = leadHoursAt(timeStr, baseTime);
     const weights = normalizedWeights(models, leadH, lat, lon, variable);
     const perModel: ModelSamples = {};
     for (const m of models) {
@@ -150,7 +162,7 @@ export function aggregateSeries(times: string[], series: Record<string, (number
       }
       const { code, effectiveWeights } = severityWeightedMode(perModel, weights);
       result.push({
-        time: times[i],
+        time: timeStr,
         value: code,
         stdDev: 0,
         weights: effectiveWeights,
@@ -159,7 +171,7 @@ export function aggregateSeries(times: string[], series: Record<string, (number
     } else if (variable === "wind_direction_10m") {
       const { mean, stdDev, effectiveWeights } = weightedCircularMean(perModel, weights);
       result.push({
-        time: times[i],
+        time: timeStr,
         value: mean,
         stdDev,
         weights: effectiveWeights,
@@ -168,7 +180,7 @@ export function aggregateSeries(times: string[], series: Record<string, (number
     } else {
       const { mean, stdDev, effectiveWeights } = weightedMean(perModel, weights);
       result.push({
-        time: times[i],
+        time: timeStr,
         value: mean,
         stdDev,
         weights: effectiveWeights,

tsconfig.json

@@ -5,6 +5,7 @@
     "noFallthroughCasesInSwitch": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
+    "noUncheckedIndexedAccess": true,
     "types": ["vite/client", "vite-plugin-pwa/client"],
     "paths": {
       "@/*": ["./src/*"]