From ba9df708f906d005fa2b6b054ef222336185fe01 Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 08:01:59 +0100
Subject: [PATCH 1/6] from end

---
 app/components/Package/TrendsChart.vue       |  14 +-
 app/composables/useCharts.ts                 | 151 ++++++++++++++-----
 test/unit/app/composables/use-charts.spec.ts | 112 ++++++++++++--
 3 files changed, 229 insertions(+), 48 deletions(-)

diff --git a/app/components/Package/TrendsChart.vue b/app/components/Package/TrendsChart.vue
index 7d08014719..05f7762616 100644
--- a/app/components/Package/TrendsChart.vue
+++ b/app/components/Package/TrendsChart.vue
@@ -402,7 +402,9 @@ const isEndDateOnPeriodEnd = computed(() => {
 })
 
 const supportsEstimation = computed(
-  () => displayedGranularity.value !== 'daily' && selectedMetric.value !== 'contributors',
+  () =>
+    !['daily', 'weekly'].includes(displayedGranularity.value) &&
+    selectedMetric.value !== 'contributors',
 )
 
 const hasDownloadAnomalies = computed(() =>
@@ -1081,7 +1083,10 @@ const normalisedDataset = computed(() => {
       {
         averageWindow: settings.value.chartFilter.averageWindow,
         smoothingTau: settings.value.chartFilter.smoothingTau,
-        predictionPoints: settings.value.chartFilter.predictionPoints ?? DEFAULT_PREDICTION_POINTS,
+        predictionPoints:
+          granularity === 'weekly'
+            ? 0 // weekly buckets are end-aligned → always complete, no prediction needed
+            : (settings.value.chartFilter.predictionPoints ?? DEFAULT_PREDICTION_POINTS),
       },
       { granularity, lastDateMs, referenceMs, isAbsoluteMetric },
     )
@@ -1771,15 +1776,14 @@ watch(selectedMetric, value => {
             </span>
             <label
               class="flex items-center gap-1.5 text-2xs font-mono text-fg-subtle cursor-pointer h-4"
-              :class="{ 'opacity-50 pointer-events-none': !hasAnomalies }"
+              :class="{ 'opacity-50': !hasAnomalies }"
             >
               <input
-                :checked="settings.chartFilter.anomaliesFixed && hasAnomalies"
+                :checked="settings.chartFilter.anomaliesFixed"
                 @change="
                   settings.chartFilter.anomaliesFixed = ($event.target as HTMLInputElement).checked
                 "
                 type="checkbox"
-                :disabled="!hasAnomalies"
                 class="accent-[var(--accent-color,var(--fg-subtle))]"
               />
               {{ $t('package.trends.apply_correction') }}
diff --git a/app/composables/useCharts.ts b/app/composables/useCharts.ts
index 339d760e2d..55c13cbb6c 100644
--- a/app/composables/useCharts.ts
+++ b/app/composables/useCharts.ts
@@ -32,6 +32,25 @@ function startOfUtcMonth(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1))
 }
 
+function daysInMonth(year: number, month: number): number {
+  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
+}
+
+function daysInYear(year: number): number {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
+}
+
+/**
+ * Scale up a partial bucket value proportionally.
+ * @param value - the raw sum for the partial bucket
+ * @param actualDays - number of days with data in the bucket
+ * @param totalDays - expected full bucket size in days
+ */
+export function fillPartialBucket(value: number, actualDays: number, totalDays: number): number {
+  if (actualDays <= 0 || actualDays >= totalDays) return value
+  return Math.round((value * totalDays) / actualDays)
+}
+
 function startOfUtcYear(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), 0, 1))
 }
@@ -107,35 +126,48 @@ export function buildRollingWeeklyEvolutionFromDaily(
   rangeEndIso: string,
 ): WeeklyDataPoint[] {
   const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const rangeStartDate = parseIsoDateOnly(rangeStartIso)
-  const rangeEndDate = parseIsoDateOnly(rangeEndIso)
+  if (sorted.length === 0) return []
 
+  const rangeStartDate = parseIsoDateOnly(rangeStartIso)
+  // Align from last day with actual data (npm has 1-2 day delay, today is incomplete)
+  const lastNonZero = sorted.findLast(d => d.value > 0)
+  const effectiveEnd = lastNonZero
+    ? parseIsoDateOnly(lastNonZero.day)
+    : parseIsoDateOnly(rangeEndIso)
+  const pickerEnd = parseIsoDateOnly(rangeEndIso)
+  const rangeEndDate = effectiveEnd.getTime() < pickerEnd.getTime() ? effectiveEnd : pickerEnd
+
+  // Build 7-day buckets from END backwards
   const groupedByIndex = new Map<number, number>()
 
   for (const item of sorted) {
     const itemDate = parseIsoDateOnly(item.day)
-    const dayOffset = Math.floor((itemDate.getTime() - rangeStartDate.getTime()) / 86400000)
-    if (dayOffset < 0) continue
+    const dayOffsetFromEnd = Math.floor((rangeEndDate.getTime() - itemDate.getTime()) / 86400000)
+    if (dayOffsetFromEnd < 0) continue
 
-    const weekIndex = Math.floor(dayOffset / 7)
+    const weekIndex = Math.floor(dayOffsetFromEnd / 7)
     groupedByIndex.set(weekIndex, (groupedByIndex.get(weekIndex) ?? 0) + item.value)
   }
 
   return Array.from(groupedByIndex.entries())
-    .sort(([a], [b]) => a - b)
+    .sort(([a], [b]) => b - a) // reverse: highest index = oldest week
     .map(([weekIndex, value]) => {
-      const weekStartDate = addDays(rangeStartDate, weekIndex * 7)
-      const weekEndDate = addDays(weekStartDate, 6)
-
-      // Clamp weekEnd to the actual data range end date
-      const clampedWeekEndDate =
-        weekEndDate.getTime() > rangeEndDate.getTime() ? rangeEndDate : weekEndDate
+      const weekEndDate = addDays(rangeEndDate, -(weekIndex * 7))
+      let weekStartDate = addDays(weekEndDate, -6)
+
+      // First bucket may be partial — scale up proportionally
+      if (weekStartDate.getTime() < rangeStartDate.getTime()) {
+        weekStartDate = rangeStartDate
+        const actualDays =
+          Math.floor((weekEndDate.getTime() - rangeStartDate.getTime()) / 86400000) + 1
+        value = fillPartialBucket(value, actualDays, 7)
+      }
 
       const weekStartIso = toIsoDateString(weekStartDate)
-      const weekEndIso = toIsoDateString(clampedWeekEndDate)
+      const weekEndIso = toIsoDateString(weekEndDate)
 
       const timestampStart = weekStartDate.getTime()
-      const timestampEnd = clampedWeekEndDate.getTime()
+      const timestampEnd = weekEndDate.getTime()
 
       return {
         value,
@@ -148,7 +180,11 @@ export function buildRollingWeeklyEvolutionFromDaily(
     })
 }
 
-export function buildMonthlyEvolutionFromDaily(daily: DailyRawPoint[]): MonthlyDataPoint[] {
+export function buildMonthlyEvolutionFromDaily(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): MonthlyDataPoint[] {
   const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
   const valuesByMonth = new Map<string, number>()
 
@@ -157,16 +193,39 @@ export function buildMonthlyEvolutionFromDaily(daily: DailyRawPoint[]): MonthlyD
     valuesByMonth.set(month, (valuesByMonth.get(month) ?? 0) + item.value)
   }
 
-  return Array.from(valuesByMonth.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([month, value]) => {
-      const monthStartDate = parseIsoDateOnly(`${month}-01`)
-      const timestamp = monthStartDate.getTime()
-      return { month, value, timestamp }
-    })
+  const entries = Array.from(valuesByMonth.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([month, value], index) => {
+    const monthStartDate = parseIsoDateOnly(`${month}-01`)
+    const [y, m] = month.split('-').map(Number) as [number, number]
+    const totalDays = daysInMonth(y, m - 1)
+
+    // Scale up partial first bucket
+    if (index === 0 && rangeStartIso) {
+      const rangeStartDay = Number(rangeStartIso.split('-')[2])
+      if (rangeStartDay > 1) {
+        value = fillPartialBucket(value, totalDays - rangeStartDay + 1, totalDays)
+      }
+    }
+
+    // Scale up partial last bucket
+    if (index === entries.length - 1 && rangeEndIso) {
+      const rangeEndDay = Number(rangeEndIso.split('-')[2])
+      if (rangeEndDay < totalDays) {
+        value = fillPartialBucket(value, rangeEndDay, totalDays)
+      }
+    }
+
+    const timestamp = monthStartDate.getTime()
+    return { month, value, timestamp }
+  })
 }
 
-export function buildYearlyEvolutionFromDaily(daily: DailyRawPoint[]): YearlyDataPoint[] {
+export function buildYearlyEvolutionFromDaily(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): YearlyDataPoint[] {
   const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
   const valuesByYear = new Map<string, number>()
 
@@ -175,13 +234,36 @@ export function buildYearlyEvolutionFromDaily(daily: DailyRawPoint[]): YearlyDat
     valuesByYear.set(year, (valuesByYear.get(year) ?? 0) + item.value)
   }
 
-  return Array.from(valuesByYear.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([year, value]) => {
-      const yearStartDate = parseIsoDateOnly(`${year}-01-01`)
-      const timestamp = yearStartDate.getTime()
-      return { year, value, timestamp }
-    })
+  const entries = Array.from(valuesByYear.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([year, value], index) => {
+    const y = Number(year)
+    const totalDays = daysInYear(y)
+
+    // Scale up partial first bucket
+    if (index === 0 && rangeStartIso) {
+      const rangeStart = parseIsoDateOnly(rangeStartIso)
+      const yearStart = parseIsoDateOnly(`${year}-01-01`)
+      const dayOfYear = Math.floor((rangeStart.getTime() - yearStart.getTime()) / 86400000)
+      if (dayOfYear > 0) {
+        value = fillPartialBucket(value, totalDays - dayOfYear, totalDays)
+      }
+    }
+
+    // Scale up partial last bucket
+    if (index === entries.length - 1 && rangeEndIso) {
+      const rangeEnd = parseIsoDateOnly(rangeEndIso)
+      const yearStart = parseIsoDateOnly(`${year}-01-01`)
+      const actualDays = Math.floor((rangeEnd.getTime() - yearStart.getTime()) / 86400000) + 1
+      if (actualDays < totalDays) {
+        value = fillPartialBucket(value, actualDays, totalDays)
+      }
+    }
+
+    const yearStartDate = parseIsoDateOnly(`${year}-01-01`)
+    const timestamp = yearStartDate.getTime()
+    return { year, value, timestamp }
+  })
 }
 
 const npmDailyRangeCache = import.meta.client ? new Map<string, Promise<DailyRawPoint[]>>() : null
@@ -473,8 +555,9 @@ export function useCharts() {
     if (resolvedOptions.granularity === 'day') return buildDailyEvolutionFromDaily(sortedDaily)
     if (resolvedOptions.granularity === 'week')
       return buildRollingWeeklyEvolutionFromDaily(sortedDaily, startIso, endIso)
-    if (resolvedOptions.granularity === 'month') return buildMonthlyEvolutionFromDaily(sortedDaily)
-    return buildYearlyEvolutionFromDaily(sortedDaily)
+    if (resolvedOptions.granularity === 'month')
+      return buildMonthlyEvolutionFromDaily(sortedDaily, startIso, endIso)
+    return buildYearlyEvolutionFromDaily(sortedDaily, startIso, endIso)
   }
 
   async function fetchPackageLikesEvolution(
@@ -517,8 +600,8 @@ export function useCharts() {
     if (resolvedOptions.granularity === 'week')
       return buildRollingWeeklyEvolutionFromDaily(filteredDaily, startIso, endIso)
     if (resolvedOptions.granularity === 'month')
-      return buildMonthlyEvolutionFromDaily(filteredDaily)
-    return buildYearlyEvolutionFromDaily(filteredDaily)
+      return buildMonthlyEvolutionFromDaily(filteredDaily, startIso, endIso)
+    return buildYearlyEvolutionFromDaily(filteredDaily, startIso, endIso)
   }
 
   async function fetchRepoContributorsEvolution(
diff --git a/test/unit/app/composables/use-charts.spec.ts b/test/unit/app/composables/use-charts.spec.ts
index 1a66f85224..1c702f7949 100644
--- a/test/unit/app/composables/use-charts.spec.ts
+++ b/test/unit/app/composables/use-charts.spec.ts
@@ -10,6 +10,7 @@ import {
   buildMonthlyEvolutionFromDaily,
   buildYearlyEvolutionFromDaily,
   getNpmPackageCreationDate,
+  fillPartialBucket,
 } from '../../../../app/composables/useCharts'
 
 describe('buildDailyEvolutionFromDaily', () => {
@@ -41,7 +42,7 @@ describe('buildDailyEvolutionFromDaily', () => {
 })
 
 describe('buildRollingWeeklyEvolutionFromDaily', () => {
-  it('groups daily data into rolling 7-day buckets', () => {
+  it('groups daily data into 7-day buckets aligned from end', () => {
     const daily = Array.from({ length: 14 }, (_, i) => ({
       day: `2025-03-${String(i + 1).padStart(2, '0')}`,
       value: 10,
@@ -50,26 +51,55 @@ describe('buildRollingWeeklyEvolutionFromDaily', () => {
     const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-14')
 
     expect(result).toHaveLength(2)
+    // Buckets built from end (Mar 14) backwards: [Mar 1–7, Mar 8–14]
     expect(result[0]!.value).toBe(70)
     expect(result[0]!.weekStart).toBe('2025-03-01')
     expect(result[0]!.weekEnd).toBe('2025-03-07')
     expect(result[1]!.value).toBe(70)
     expect(result[1]!.weekStart).toBe('2025-03-08')
-    expect(result[1]!.weekEnd).toBe('2025-03-14')
+    expect(result[1]!.weekEnd).toBe('2025-03-14') // last bucket is always complete
   })
 
-  it('clamps last week to range end date', () => {
+  it('scales up partial first bucket proportionally', () => {
+    // 10 days = 1 full week (Mar 4-10) + 3 partial days (Mar 1-3) at start
+    const daily = Array.from({ length: 10 }, (_, i) => ({
+      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-10')
+
+    expect(result).toHaveLength(2)
+    // First bucket: 3 days (Mar 1-3) with value 30, scaled up to 7 days → 70
+    expect(result[0]!.value).toBe(Math.round((30 * 7) / 3))
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-03')
+    // Second bucket: full 7 days
+    expect(result[1]!.value).toBe(70)
+    expect(result[1]!.weekStart).toBe('2025-03-04')
+    expect(result[1]!.weekEnd).toBe('2025-03-10')
+  })
+
+  it('aligns from last non-zero data day, ignoring trailing zeros', () => {
     const daily = [
-      { day: '2025-03-01', value: 5 },
-      { day: '2025-03-02', value: 5 },
-      { day: '2025-03-08', value: 10 },
+      { day: '2025-03-01', value: 10 },
+      { day: '2025-03-02', value: 10 },
+      { day: '2025-03-03', value: 10 },
+      { day: '2025-03-04', value: 10 },
+      { day: '2025-03-05', value: 10 },
+      { day: '2025-03-06', value: 10 },
+      { day: '2025-03-07', value: 10 },
+      { day: '2025-03-08', value: 0 },
+      { day: '2025-03-09', value: 0 },
     ]
 
+    // End date is Mar 09 but last real data is Mar 07
     const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-09')
 
-    // Last week bucket should be clamped to end date
-    const lastWeek = result[result.length - 1]!
-    expect(lastWeek.weekEnd).toBe('2025-03-09')
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(70)
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-07')
   })
 
   it('returns empty array for empty input', () => {
@@ -104,6 +134,41 @@ describe('buildMonthlyEvolutionFromDaily', () => {
   it('returns empty array for empty input', () => {
     expect(buildMonthlyEvolutionFromDaily([])).toEqual([])
   })
+
+  it('scales up partial first month', () => {
+    // Start on Mar 18 → only 14 days of March (18-31)
+    const daily = Array.from({ length: 14 }, (_, i) => ({
+      day: `2025-03-${String(i + 18).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildMonthlyEvolutionFromDaily(daily, '2025-03-18', '2025-03-31')
+
+    expect(result).toHaveLength(1)
+    // 140 raw, scaled: 140 * 31 / 14 = 310
+    expect(result[0]!.value).toBe(Math.round((140 * 31) / 14))
+  })
+
+  it('scales up partial last month', () => {
+    // Full January + 9 days of February
+    const daily = [
+      ...Array.from({ length: 31 }, (_, i) => ({
+        day: `2025-01-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+      ...Array.from({ length: 9 }, (_, i) => ({
+        day: `2025-02-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+    ]
+
+    const result = buildMonthlyEvolutionFromDaily(daily, '2025-01-01', '2025-02-09')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(310) // full month, no scaling
+    // Feb: 90 raw, scaled: 90 * 28 / 9 = 280
+    expect(result[1]!.value).toBe(Math.round((90 * 28) / 9))
+  })
 })
 
 describe('buildYearlyEvolutionFromDaily', () => {
@@ -123,6 +188,35 @@ describe('buildYearlyEvolutionFromDaily', () => {
   it('returns empty array for empty input', () => {
     expect(buildYearlyEvolutionFromDaily([])).toEqual([])
   })
+
+  it('scales up partial first year', () => {
+    // Start on Jul 1 → 184 days of 2025 (Jul 1 - Dec 31)
+    const daily = Array.from({ length: 184 }, (_, i) => {
+      const d = new Date(Date.UTC(2025, 6, 1))
+      d.setUTCDate(d.getUTCDate() + i)
+      return { day: d.toISOString().slice(0, 10), value: 10 }
+    })
+
+    const result = buildYearlyEvolutionFromDaily(daily, '2025-07-01', '2025-12-31')
+
+    expect(result).toHaveLength(1)
+    // 1840 raw, scaled: 1840 * 365 / 184
+    expect(result[0]!.value).toBe(Math.round((1840 * 365) / 184))
+  })
+})
+
+describe('fillPartialBucket', () => {
+  it('scales proportionally', () => {
+    expect(fillPartialBucket(100, 3, 7)).toBe(Math.round((100 * 7) / 3))
+  })
+
+  it('returns raw value when bucket is full', () => {
+    expect(fillPartialBucket(100, 7, 7)).toBe(100)
+  })
+
+  it('returns raw value when actualDays is 0', () => {
+    expect(fillPartialBucket(0, 0, 7)).toBe(0)
+  })
 })
 
 describe('getNpmPackageCreationDate', () => {

From 1691364dbdf9537562f29a3db8c75cd05d2f9675 Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 08:10:07 +0100
Subject: [PATCH 2/6] extract some logic

---
 app/composables/useCharts.ts                  | 199 ++--------------
 app/utils/chart-data-buckets.ts               | 173 ++++++++++++++
 test/unit/app/composables/use-charts.spec.ts  | 215 +-----------------
 .../unit/app/utils/chart-data-buckets.spec.ts | 203 +++++++++++++++++
 vitest.config.ts                              |   1 +
 5 files changed, 392 insertions(+), 399 deletions(-)
 create mode 100644 app/utils/chart-data-buckets.ts
 create mode 100644 test/unit/app/utils/chart-data-buckets.spec.ts

diff --git a/app/composables/useCharts.ts b/app/composables/useCharts.ts
index 55c13cbb6c..5f3c53377d 100644
--- a/app/composables/useCharts.ts
+++ b/app/composables/useCharts.ts
@@ -13,6 +13,12 @@ import { parseRepoUrl } from '#shared/utils/git-providers'
 import type { PackageMetaResponse } from '#shared/types'
 import { encodePackageName } from '#shared/utils/npm'
 import { fetchNpmDownloadsRange } from '~/utils/npm/api'
+import {
+  buildDailyEvolution,
+  buildWeeklyEvolution,
+  buildMonthlyEvolution,
+  buildYearlyEvolution,
+} from '~/utils/chart-data-buckets'
 
 export type PackumentLikeForTime = {
   time?: Record<string, string>
@@ -32,25 +38,6 @@ function startOfUtcMonth(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1))
 }
 
-function daysInMonth(year: number, month: number): number {
-  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
-}
-
-function daysInYear(year: number): number {
-  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
-}
-
-/**
- * Scale up a partial bucket value proportionally.
- * @param value - the raw sum for the partial bucket
- * @param actualDays - number of days with data in the bucket
- * @param totalDays - expected full bucket size in days
- */
-export function fillPartialBucket(value: number, actualDays: number, totalDays: number): number {
-  if (actualDays <= 0 || actualDays >= totalDays) return value
-  return Math.round((value * totalDays) / actualDays)
-}
-
 function startOfUtcYear(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), 0, 1))
 }
@@ -108,164 +95,6 @@ function mergeDailyPoints(points: DailyRawPoint[]): DailyRawPoint[] {
     .map(([day, value]) => ({ day, value }))
 }
 
-export function buildDailyEvolutionFromDaily(daily: DailyRawPoint[]): DailyDataPoint[] {
-  return daily
-    .slice()
-    .sort((a, b) => a.day.localeCompare(b.day))
-    .map(item => {
-      const dayDate = parseIsoDateOnly(item.day)
-      const timestamp = dayDate.getTime()
-
-      return { day: item.day, value: item.value, timestamp }
-    })
-}
-
-export function buildRollingWeeklyEvolutionFromDaily(
-  daily: DailyRawPoint[],
-  rangeStartIso: string,
-  rangeEndIso: string,
-): WeeklyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  if (sorted.length === 0) return []
-
-  const rangeStartDate = parseIsoDateOnly(rangeStartIso)
-  // Align from last day with actual data (npm has 1-2 day delay, today is incomplete)
-  const lastNonZero = sorted.findLast(d => d.value > 0)
-  const effectiveEnd = lastNonZero
-    ? parseIsoDateOnly(lastNonZero.day)
-    : parseIsoDateOnly(rangeEndIso)
-  const pickerEnd = parseIsoDateOnly(rangeEndIso)
-  const rangeEndDate = effectiveEnd.getTime() < pickerEnd.getTime() ? effectiveEnd : pickerEnd
-
-  // Build 7-day buckets from END backwards
-  const groupedByIndex = new Map<number, number>()
-
-  for (const item of sorted) {
-    const itemDate = parseIsoDateOnly(item.day)
-    const dayOffsetFromEnd = Math.floor((rangeEndDate.getTime() - itemDate.getTime()) / 86400000)
-    if (dayOffsetFromEnd < 0) continue
-
-    const weekIndex = Math.floor(dayOffsetFromEnd / 7)
-    groupedByIndex.set(weekIndex, (groupedByIndex.get(weekIndex) ?? 0) + item.value)
-  }
-
-  return Array.from(groupedByIndex.entries())
-    .sort(([a], [b]) => b - a) // reverse: highest index = oldest week
-    .map(([weekIndex, value]) => {
-      const weekEndDate = addDays(rangeEndDate, -(weekIndex * 7))
-      let weekStartDate = addDays(weekEndDate, -6)
-
-      // First bucket may be partial — scale up proportionally
-      if (weekStartDate.getTime() < rangeStartDate.getTime()) {
-        weekStartDate = rangeStartDate
-        const actualDays =
-          Math.floor((weekEndDate.getTime() - rangeStartDate.getTime()) / 86400000) + 1
-        value = fillPartialBucket(value, actualDays, 7)
-      }
-
-      const weekStartIso = toIsoDateString(weekStartDate)
-      const weekEndIso = toIsoDateString(weekEndDate)
-
-      const timestampStart = weekStartDate.getTime()
-      const timestampEnd = weekEndDate.getTime()
-
-      return {
-        value,
-        weekKey: `${weekStartIso}_${weekEndIso}`,
-        weekStart: weekStartIso,
-        weekEnd: weekEndIso,
-        timestampStart,
-        timestampEnd,
-      }
-    })
-}
-
-export function buildMonthlyEvolutionFromDaily(
-  daily: DailyRawPoint[],
-  rangeStartIso?: string,
-  rangeEndIso?: string,
-): MonthlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const valuesByMonth = new Map<string, number>()
-
-  for (const item of sorted) {
-    const month = item.day.slice(0, 7)
-    valuesByMonth.set(month, (valuesByMonth.get(month) ?? 0) + item.value)
-  }
-
-  const entries = Array.from(valuesByMonth.entries()).sort(([a], [b]) => a.localeCompare(b))
-
-  return entries.map(([month, value], index) => {
-    const monthStartDate = parseIsoDateOnly(`${month}-01`)
-    const [y, m] = month.split('-').map(Number) as [number, number]
-    const totalDays = daysInMonth(y, m - 1)
-
-    // Scale up partial first bucket
-    if (index === 0 && rangeStartIso) {
-      const rangeStartDay = Number(rangeStartIso.split('-')[2])
-      if (rangeStartDay > 1) {
-        value = fillPartialBucket(value, totalDays - rangeStartDay + 1, totalDays)
-      }
-    }
-
-    // Scale up partial last bucket
-    if (index === entries.length - 1 && rangeEndIso) {
-      const rangeEndDay = Number(rangeEndIso.split('-')[2])
-      if (rangeEndDay < totalDays) {
-        value = fillPartialBucket(value, rangeEndDay, totalDays)
-      }
-    }
-
-    const timestamp = monthStartDate.getTime()
-    return { month, value, timestamp }
-  })
-}
-
-export function buildYearlyEvolutionFromDaily(
-  daily: DailyRawPoint[],
-  rangeStartIso?: string,
-  rangeEndIso?: string,
-): YearlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
-  const valuesByYear = new Map<string, number>()
-
-  for (const item of sorted) {
-    const year = item.day.slice(0, 4)
-    valuesByYear.set(year, (valuesByYear.get(year) ?? 0) + item.value)
-  }
-
-  const entries = Array.from(valuesByYear.entries()).sort(([a], [b]) => a.localeCompare(b))
-
-  return entries.map(([year, value], index) => {
-    const y = Number(year)
-    const totalDays = daysInYear(y)
-
-    // Scale up partial first bucket
-    if (index === 0 && rangeStartIso) {
-      const rangeStart = parseIsoDateOnly(rangeStartIso)
-      const yearStart = parseIsoDateOnly(`${year}-01-01`)
-      const dayOfYear = Math.floor((rangeStart.getTime() - yearStart.getTime()) / 86400000)
-      if (dayOfYear > 0) {
-        value = fillPartialBucket(value, totalDays - dayOfYear, totalDays)
-      }
-    }
-
-    // Scale up partial last bucket
-    if (index === entries.length - 1 && rangeEndIso) {
-      const rangeEnd = parseIsoDateOnly(rangeEndIso)
-      const yearStart = parseIsoDateOnly(`${year}-01-01`)
-      const actualDays = Math.floor((rangeEnd.getTime() - yearStart.getTime()) / 86400000) + 1
-      if (actualDays < totalDays) {
-        value = fillPartialBucket(value, actualDays, totalDays)
-      }
-    }
-
-    const yearStartDate = parseIsoDateOnly(`${year}-01-01`)
-    const timestamp = yearStartDate.getTime()
-    return { year, value, timestamp }
-  })
-}
-
 const npmDailyRangeCache = import.meta.client ? new Map<string, Promise<DailyRawPoint[]>>() : null
 const likesEvolutionCache = import.meta.client ? new Map<string, Promise<DailyRawPoint[]>>() : null
 const contributorsEvolutionCache = import.meta.client
@@ -552,12 +381,12 @@ export function useCharts() {
 
     const sortedDaily = await fetchDailyRangeChunked(resolvedPackageName, startIso, endIso)
 
-    if (resolvedOptions.granularity === 'day') return buildDailyEvolutionFromDaily(sortedDaily)
+    if (resolvedOptions.granularity === 'day') return buildDailyEvolution(sortedDaily)
     if (resolvedOptions.granularity === 'week')
-      return buildRollingWeeklyEvolutionFromDaily(sortedDaily, startIso, endIso)
+      return buildWeeklyEvolution(sortedDaily, startIso, endIso)
     if (resolvedOptions.granularity === 'month')
-      return buildMonthlyEvolutionFromDaily(sortedDaily, startIso, endIso)
-    return buildYearlyEvolutionFromDaily(sortedDaily, startIso, endIso)
+      return buildMonthlyEvolution(sortedDaily, startIso, endIso)
+    return buildYearlyEvolution(sortedDaily, startIso, endIso)
   }
 
   async function fetchPackageLikesEvolution(
@@ -596,12 +425,12 @@ export function useCharts() {
 
     const filteredDaily = sortedDaily.filter(d => d.day >= startIso && d.day <= endIso)
 
-    if (resolvedOptions.granularity === 'day') return buildDailyEvolutionFromDaily(filteredDaily)
+    if (resolvedOptions.granularity === 'day') return buildDailyEvolution(filteredDaily)
     if (resolvedOptions.granularity === 'week')
-      return buildRollingWeeklyEvolutionFromDaily(filteredDaily, startIso, endIso)
+      return buildWeeklyEvolution(filteredDaily, startIso, endIso)
     if (resolvedOptions.granularity === 'month')
-      return buildMonthlyEvolutionFromDaily(filteredDaily, startIso, endIso)
-    return buildYearlyEvolutionFromDaily(filteredDaily, startIso, endIso)
+      return buildMonthlyEvolution(filteredDaily, startIso, endIso)
+    return buildYearlyEvolution(filteredDaily, startIso, endIso)
   }
 
   async function fetchRepoContributorsEvolution(
diff --git a/app/utils/chart-data-buckets.ts b/app/utils/chart-data-buckets.ts
new file mode 100644
index 0000000000..1f347b90d4
--- /dev/null
+++ b/app/utils/chart-data-buckets.ts
@@ -0,0 +1,173 @@
+import type {
+  DailyDataPoint,
+  DailyRawPoint,
+  MonthlyDataPoint,
+  WeeklyDataPoint,
+  YearlyDataPoint,
+} from '~/types/chart'
+
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+
+const DAY_MS = 86_400_000
+
+function parseIso(value: string): Date {
+  return new Date(`${value}T00:00:00.000Z`)
+}
+
+function toIso(date: Date): string {
+  return date.toISOString().slice(0, 10)
+}
+
+function addDays(date: Date, days: number): Date {
+  const d = new Date(date)
+  d.setUTCDate(d.getUTCDate() + days)
+  return d
+}
+
+function daysInMonth(year: number, month: number): number {
+  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
+}
+
+function daysInYear(year: number): number {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
+}
+
+// ---------------------------------------------------------------------------
+// Fill partial bucket
+// ---------------------------------------------------------------------------
+
+/** Proportionally scale a partial bucket to estimate the full-period value. */
+export function fillPartialBucket(value: number, actualDays: number, totalDays: number): number {
+  if (actualDays <= 0 || actualDays >= totalDays) return value
+  return Math.round((value * totalDays) / actualDays)
+}
+
+// ---------------------------------------------------------------------------
+// Builders
+// ---------------------------------------------------------------------------
+
+export function buildDailyEvolution(daily: DailyRawPoint[]): DailyDataPoint[] {
+  return daily
+    .slice()
+    .sort((a, b) => a.day.localeCompare(b.day))
+    .map(item => ({ day: item.day, value: item.value, timestamp: parseIso(item.day).getTime() }))
+}
+
+export function buildWeeklyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso: string,
+  rangeEndIso: string,
+): WeeklyDataPoint[] {
+  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  if (sorted.length === 0) return []
+
+  const rangeStartDate = parseIso(rangeStartIso)
+
+  // Align from last day with actual data (npm has 1-2 day delay, today is incomplete)
+  const lastNonZero = sorted.findLast(d => d.value > 0)
+  const pickerEnd = parseIso(rangeEndIso)
+  const effectiveEnd = lastNonZero ? parseIso(lastNonZero.day) : pickerEnd
+  const rangeEndDate = effectiveEnd.getTime() < pickerEnd.getTime() ? effectiveEnd : pickerEnd
+
+  // Group into 7-day buckets from END backwards
+  const buckets = new Map<number, number>()
+  for (const item of sorted) {
+    const offset = Math.floor((rangeEndDate.getTime() - parseIso(item.day).getTime()) / DAY_MS)
+    if (offset < 0) continue
+    const idx = Math.floor(offset / 7)
+    buckets.set(idx, (buckets.get(idx) ?? 0) + item.value)
+  }
+
+  return Array.from(buckets.entries())
+    .sort(([a], [b]) => b - a)
+    .map(([idx, value]) => {
+      const weekEndDate = addDays(rangeEndDate, -(idx * 7))
+      let weekStartDate = addDays(weekEndDate, -6)
+
+      // First bucket may be partial
+      if (weekStartDate.getTime() < rangeStartDate.getTime()) {
+        weekStartDate = rangeStartDate
+        const actualDays =
+          Math.floor((weekEndDate.getTime() - rangeStartDate.getTime()) / DAY_MS) + 1
+        value = fillPartialBucket(value, actualDays, 7)
+      }
+
+      const weekStartIso = toIso(weekStartDate)
+      const weekEndIso = toIso(weekEndDate)
+      return {
+        value,
+        weekKey: `${weekStartIso}_${weekEndIso}`,
+        weekStart: weekStartIso,
+        weekEnd: weekEndIso,
+        timestampStart: weekStartDate.getTime(),
+        timestampEnd: weekEndDate.getTime(),
+      }
+    })
+}
+
+export function buildMonthlyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): MonthlyDataPoint[] {
+  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  const byMonth = new Map<string, number>()
+  for (const item of sorted) {
+    const m = item.day.slice(0, 7)
+    byMonth.set(m, (byMonth.get(m) ?? 0) + item.value)
+  }
+
+  const entries = Array.from(byMonth.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([month, value], i) => {
+    const [y, m] = month.split('-').map(Number) as [number, number]
+    const total = daysInMonth(y, m - 1)
+
+    if (i === 0 && rangeStartIso) {
+      const startDay = Number(rangeStartIso.split('-')[2])
+      if (startDay > 1) value = fillPartialBucket(value, total - startDay + 1, total)
+    }
+    if (i === entries.length - 1 && rangeEndIso) {
+      const endDay = Number(rangeEndIso.split('-')[2])
+      if (endDay < total) value = fillPartialBucket(value, endDay, total)
+    }
+
+    return { month, value, timestamp: parseIso(`${month}-01`).getTime() }
+  })
+}
+
+export function buildYearlyEvolution(
+  daily: DailyRawPoint[],
+  rangeStartIso?: string,
+  rangeEndIso?: string,
+): YearlyDataPoint[] {
+  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  const byYear = new Map<string, number>()
+  for (const item of sorted) {
+    const y = item.day.slice(0, 4)
+    byYear.set(y, (byYear.get(y) ?? 0) + item.value)
+  }
+
+  const entries = Array.from(byYear.entries()).sort(([a], [b]) => a.localeCompare(b))
+
+  return entries.map(([year, value], i) => {
+    const total = daysInYear(Number(year))
+    const yearStart = parseIso(`${year}-01-01`)
+
+    if (i === 0 && rangeStartIso) {
+      const dayOfYear = Math.floor(
+        (parseIso(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS,
+      )
+      if (dayOfYear > 0) value = fillPartialBucket(value, total - dayOfYear, total)
+    }
+    if (i === entries.length - 1 && rangeEndIso) {
+      const actualDays =
+        Math.floor((parseIso(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
+      if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
+    }
+
+    return { year, value, timestamp: yearStart.getTime() }
+  })
+}
diff --git a/test/unit/app/composables/use-charts.spec.ts b/test/unit/app/composables/use-charts.spec.ts
index 1c702f7949..53021ad76a 100644
--- a/test/unit/app/composables/use-charts.spec.ts
+++ b/test/unit/app/composables/use-charts.spec.ts
@@ -4,220 +4,7 @@ vi.mock('~/utils/npm/api', () => ({
   fetchNpmDownloadsRange: vi.fn(),
 }))
 
-import {
-  buildDailyEvolutionFromDaily,
-  buildRollingWeeklyEvolutionFromDaily,
-  buildMonthlyEvolutionFromDaily,
-  buildYearlyEvolutionFromDaily,
-  getNpmPackageCreationDate,
-  fillPartialBucket,
-} from '../../../../app/composables/useCharts'
-
-describe('buildDailyEvolutionFromDaily', () => {
-  it('adds timestamps and preserves values', () => {
-    const result = buildDailyEvolutionFromDaily([
-      { day: '2025-03-01', value: 10 },
-      { day: '2025-03-02', value: 20 },
-    ])
-
-    expect(result).toEqual([
-      { day: '2025-03-01', value: 10, timestamp: Date.UTC(2025, 2, 1) },
-      { day: '2025-03-02', value: 20, timestamp: Date.UTC(2025, 2, 2) },
-    ])
-  })
-
-  it('sorts by day', () => {
-    const result = buildDailyEvolutionFromDaily([
-      { day: '2025-03-03', value: 3 },
-      { day: '2025-03-01', value: 1 },
-      { day: '2025-03-02', value: 2 },
-    ])
-
-    expect(result.map(r => r.day)).toEqual(['2025-03-01', '2025-03-02', '2025-03-03'])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildDailyEvolutionFromDaily([])).toEqual([])
-  })
-})
-
-describe('buildRollingWeeklyEvolutionFromDaily', () => {
-  it('groups daily data into 7-day buckets aligned from end', () => {
-    const daily = Array.from({ length: 14 }, (_, i) => ({
-      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
-      value: 10,
-    }))
-
-    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-14')
-
-    expect(result).toHaveLength(2)
-    // Buckets built from end (Mar 14) backwards: [Mar 1–7, Mar 8–14]
-    expect(result[0]!.value).toBe(70)
-    expect(result[0]!.weekStart).toBe('2025-03-01')
-    expect(result[0]!.weekEnd).toBe('2025-03-07')
-    expect(result[1]!.value).toBe(70)
-    expect(result[1]!.weekStart).toBe('2025-03-08')
-    expect(result[1]!.weekEnd).toBe('2025-03-14') // last bucket is always complete
-  })
-
-  it('scales up partial first bucket proportionally', () => {
-    // 10 days = 1 full week (Mar 4-10) + 3 partial days (Mar 1-3) at start
-    const daily = Array.from({ length: 10 }, (_, i) => ({
-      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
-      value: 10,
-    }))
-
-    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-10')
-
-    expect(result).toHaveLength(2)
-    // First bucket: 3 days (Mar 1-3) with value 30, scaled up to 7 days → 70
-    expect(result[0]!.value).toBe(Math.round((30 * 7) / 3))
-    expect(result[0]!.weekStart).toBe('2025-03-01')
-    expect(result[0]!.weekEnd).toBe('2025-03-03')
-    // Second bucket: full 7 days
-    expect(result[1]!.value).toBe(70)
-    expect(result[1]!.weekStart).toBe('2025-03-04')
-    expect(result[1]!.weekEnd).toBe('2025-03-10')
-  })
-
-  it('aligns from last non-zero data day, ignoring trailing zeros', () => {
-    const daily = [
-      { day: '2025-03-01', value: 10 },
-      { day: '2025-03-02', value: 10 },
-      { day: '2025-03-03', value: 10 },
-      { day: '2025-03-04', value: 10 },
-      { day: '2025-03-05', value: 10 },
-      { day: '2025-03-06', value: 10 },
-      { day: '2025-03-07', value: 10 },
-      { day: '2025-03-08', value: 0 },
-      { day: '2025-03-09', value: 0 },
-    ]
-
-    // End date is Mar 09 but last real data is Mar 07
-    const result = buildRollingWeeklyEvolutionFromDaily(daily, '2025-03-01', '2025-03-09')
-
-    expect(result).toHaveLength(1)
-    expect(result[0]!.value).toBe(70)
-    expect(result[0]!.weekStart).toBe('2025-03-01')
-    expect(result[0]!.weekEnd).toBe('2025-03-07')
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildRollingWeeklyEvolutionFromDaily([], '2025-03-01', '2025-03-14')).toEqual([])
-  })
-})
-
-describe('buildMonthlyEvolutionFromDaily', () => {
-  it('aggregates daily data by month', () => {
-    const result = buildMonthlyEvolutionFromDaily([
-      { day: '2025-01-15', value: 10 },
-      { day: '2025-01-20', value: 5 },
-      { day: '2025-02-10', value: 20 },
-    ])
-
-    expect(result).toEqual([
-      { month: '2025-01', value: 15, timestamp: Date.UTC(2025, 0, 1) },
-      { month: '2025-02', value: 20, timestamp: Date.UTC(2025, 1, 1) },
-    ])
-  })
-
-  it('sorts by month', () => {
-    const result = buildMonthlyEvolutionFromDaily([
-      { day: '2025-03-01', value: 1 },
-      { day: '2025-01-01', value: 1 },
-      { day: '2025-02-01', value: 1 },
-    ])
-
-    expect(result.map(r => r.month)).toEqual(['2025-01', '2025-02', '2025-03'])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildMonthlyEvolutionFromDaily([])).toEqual([])
-  })
-
-  it('scales up partial first month', () => {
-    // Start on Mar 18 → only 14 days of March (18-31)
-    const daily = Array.from({ length: 14 }, (_, i) => ({
-      day: `2025-03-${String(i + 18).padStart(2, '0')}`,
-      value: 10,
-    }))
-
-    const result = buildMonthlyEvolutionFromDaily(daily, '2025-03-18', '2025-03-31')
-
-    expect(result).toHaveLength(1)
-    // 140 raw, scaled: 140 * 31 / 14 = 310
-    expect(result[0]!.value).toBe(Math.round((140 * 31) / 14))
-  })
-
-  it('scales up partial last month', () => {
-    // Full January + 9 days of February
-    const daily = [
-      ...Array.from({ length: 31 }, (_, i) => ({
-        day: `2025-01-${String(i + 1).padStart(2, '0')}`,
-        value: 10,
-      })),
-      ...Array.from({ length: 9 }, (_, i) => ({
-        day: `2025-02-${String(i + 1).padStart(2, '0')}`,
-        value: 10,
-      })),
-    ]
-
-    const result = buildMonthlyEvolutionFromDaily(daily, '2025-01-01', '2025-02-09')
-
-    expect(result).toHaveLength(2)
-    expect(result[0]!.value).toBe(310) // full month, no scaling
-    // Feb: 90 raw, scaled: 90 * 28 / 9 = 280
-    expect(result[1]!.value).toBe(Math.round((90 * 28) / 9))
-  })
-})
-
-describe('buildYearlyEvolutionFromDaily', () => {
-  it('aggregates daily data by year', () => {
-    const result = buildYearlyEvolutionFromDaily([
-      { day: '2024-06-15', value: 100 },
-      { day: '2024-12-01', value: 50 },
-      { day: '2025-03-01', value: 200 },
-    ])
-
-    expect(result).toEqual([
-      { year: '2024', value: 150, timestamp: Date.UTC(2024, 0, 1) },
-      { year: '2025', value: 200, timestamp: Date.UTC(2025, 0, 1) },
-    ])
-  })
-
-  it('returns empty array for empty input', () => {
-    expect(buildYearlyEvolutionFromDaily([])).toEqual([])
-  })
-
-  it('scales up partial first year', () => {
-    // Start on Jul 1 → 184 days of 2025 (Jul 1 - Dec 31)
-    const daily = Array.from({ length: 184 }, (_, i) => {
-      const d = new Date(Date.UTC(2025, 6, 1))
-      d.setUTCDate(d.getUTCDate() + i)
-      return { day: d.toISOString().slice(0, 10), value: 10 }
-    })
-
-    const result = buildYearlyEvolutionFromDaily(daily, '2025-07-01', '2025-12-31')
-
-    expect(result).toHaveLength(1)
-    // 1840 raw, scaled: 1840 * 365 / 184
-    expect(result[0]!.value).toBe(Math.round((1840 * 365) / 184))
-  })
-})
-
-describe('fillPartialBucket', () => {
-  it('scales proportionally', () => {
-    expect(fillPartialBucket(100, 3, 7)).toBe(Math.round((100 * 7) / 3))
-  })
-
-  it('returns raw value when bucket is full', () => {
-    expect(fillPartialBucket(100, 7, 7)).toBe(100)
-  })
-
-  it('returns raw value when actualDays is 0', () => {
-    expect(fillPartialBucket(0, 0, 7)).toBe(0)
-  })
-})
+import { getNpmPackageCreationDate } from '../../../../app/composables/useCharts'
 
 describe('getNpmPackageCreationDate', () => {
   it('returns created date from packument time', () => {
diff --git a/test/unit/app/utils/chart-data-buckets.spec.ts b/test/unit/app/utils/chart-data-buckets.spec.ts
new file mode 100644
index 0000000000..83109d9038
--- /dev/null
+++ b/test/unit/app/utils/chart-data-buckets.spec.ts
@@ -0,0 +1,203 @@
+import { describe, expect, it } from 'vitest'
+import {
+  fillPartialBucket,
+  buildDailyEvolution,
+  buildWeeklyEvolution,
+  buildMonthlyEvolution,
+  buildYearlyEvolution,
+} from '../../../../app/utils/chart-data-buckets'
+
+describe('fillPartialBucket', () => {
+  it('scales proportionally', () => {
+    expect(fillPartialBucket(100, 3, 7)).toBe(Math.round((100 * 7) / 3))
+  })
+
+  it('returns raw value when bucket is full', () => {
+    expect(fillPartialBucket(100, 7, 7)).toBe(100)
+  })
+
+  it('returns raw value when actualDays is 0', () => {
+    expect(fillPartialBucket(0, 0, 7)).toBe(0)
+  })
+})
+
+describe('buildDailyEvolution', () => {
+  it('adds timestamps and preserves values', () => {
+    const result = buildDailyEvolution([
+      { day: '2025-03-01', value: 10 },
+      { day: '2025-03-02', value: 20 },
+    ])
+
+    expect(result).toEqual([
+      { day: '2025-03-01', value: 10, timestamp: Date.UTC(2025, 2, 1) },
+      { day: '2025-03-02', value: 20, timestamp: Date.UTC(2025, 2, 2) },
+    ])
+  })
+
+  it('sorts by day', () => {
+    const result = buildDailyEvolution([
+      { day: '2025-03-03', value: 3 },
+      { day: '2025-03-01', value: 1 },
+      { day: '2025-03-02', value: 2 },
+    ])
+
+    expect(result.map(r => r.day)).toEqual(['2025-03-01', '2025-03-02', '2025-03-03'])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildDailyEvolution([])).toEqual([])
+  })
+})
+
+describe('buildWeeklyEvolution', () => {
+  it('groups daily data into 7-day buckets aligned from end', () => {
+    const daily = Array.from({ length: 14 }, (_, i) => ({
+      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-14')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(70)
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-07')
+    expect(result[1]!.value).toBe(70)
+    expect(result[1]!.weekStart).toBe('2025-03-08')
+    expect(result[1]!.weekEnd).toBe('2025-03-14')
+  })
+
+  it('scales up partial first bucket proportionally', () => {
+    const daily = Array.from({ length: 10 }, (_, i) => ({
+      day: `2025-03-${String(i + 1).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-10')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(Math.round((30 * 7) / 3))
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-03')
+    expect(result[1]!.value).toBe(70)
+    expect(result[1]!.weekStart).toBe('2025-03-04')
+    expect(result[1]!.weekEnd).toBe('2025-03-10')
+  })
+
+  it('aligns from last non-zero data day, ignoring trailing zeros', () => {
+    const daily = [
+      { day: '2025-03-01', value: 10 },
+      { day: '2025-03-02', value: 10 },
+      { day: '2025-03-03', value: 10 },
+      { day: '2025-03-04', value: 10 },
+      { day: '2025-03-05', value: 10 },
+      { day: '2025-03-06', value: 10 },
+      { day: '2025-03-07', value: 10 },
+      { day: '2025-03-08', value: 0 },
+      { day: '2025-03-09', value: 0 },
+    ]
+
+    const result = buildWeeklyEvolution(daily, '2025-03-01', '2025-03-09')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(70)
+    expect(result[0]!.weekStart).toBe('2025-03-01')
+    expect(result[0]!.weekEnd).toBe('2025-03-07')
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildWeeklyEvolution([], '2025-03-01', '2025-03-14')).toEqual([])
+  })
+})
+
+describe('buildMonthlyEvolution', () => {
+  it('aggregates daily data by month', () => {
+    const result = buildMonthlyEvolution([
+      { day: '2025-01-15', value: 10 },
+      { day: '2025-01-20', value: 5 },
+      { day: '2025-02-10', value: 20 },
+    ])
+
+    expect(result).toEqual([
+      { month: '2025-01', value: 15, timestamp: Date.UTC(2025, 0, 1) },
+      { month: '2025-02', value: 20, timestamp: Date.UTC(2025, 1, 1) },
+    ])
+  })
+
+  it('sorts by month', () => {
+    const result = buildMonthlyEvolution([
+      { day: '2025-03-01', value: 1 },
+      { day: '2025-01-01', value: 1 },
+      { day: '2025-02-01', value: 1 },
+    ])
+
+    expect(result.map(r => r.month)).toEqual(['2025-01', '2025-02', '2025-03'])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildMonthlyEvolution([])).toEqual([])
+  })
+
+  it('scales up partial first month', () => {
+    const daily = Array.from({ length: 14 }, (_, i) => ({
+      day: `2025-03-${String(i + 18).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildMonthlyEvolution(daily, '2025-03-18', '2025-03-31')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((140 * 31) / 14))
+  })
+
+  it('scales up partial last month', () => {
+    const daily = [
+      ...Array.from({ length: 31 }, (_, i) => ({
+        day: `2025-01-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+      ...Array.from({ length: 9 }, (_, i) => ({
+        day: `2025-02-${String(i + 1).padStart(2, '0')}`,
+        value: 10,
+      })),
+    ]
+
+    const result = buildMonthlyEvolution(daily, '2025-01-01', '2025-02-09')
+
+    expect(result).toHaveLength(2)
+    expect(result[0]!.value).toBe(310)
+    expect(result[1]!.value).toBe(Math.round((90 * 28) / 9))
+  })
+})
+
+describe('buildYearlyEvolution', () => {
+  it('aggregates daily data by year', () => {
+    const result = buildYearlyEvolution([
+      { day: '2024-06-15', value: 100 },
+      { day: '2024-12-01', value: 50 },
+      { day: '2025-03-01', value: 200 },
+    ])
+
+    expect(result).toEqual([
+      { year: '2024', value: 150, timestamp: Date.UTC(2024, 0, 1) },
+      { year: '2025', value: 200, timestamp: Date.UTC(2025, 0, 1) },
+    ])
+  })
+
+  it('returns empty array for empty input', () => {
+    expect(buildYearlyEvolution([])).toEqual([])
+  })
+
+  it('scales up partial first year', () => {
+    const daily = Array.from({ length: 184 }, (_, i) => {
+      const d = new Date(Date.UTC(2025, 6, 1))
+      d.setUTCDate(d.getUTCDate() + i)
+      return { day: d.toISOString().slice(0, 10), value: 10 }
+    })
+
+    const result = buildYearlyEvolution(daily, '2025-07-01', '2025-12-31')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((1840 * 365) / 184))
+  })
+})
diff --git a/vitest.config.ts b/vitest.config.ts
index ba3986903b..794f176d83 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
       {
         resolve: {
           alias: {
+            '~': `${rootDir}/app`,
             '#shared': `${rootDir}/shared`,
             '#server': `${rootDir}/server`,
           },

From 98e26a62c98b40bffeb164942b02869bb66040ee Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 08:17:11 +0100
Subject: [PATCH 3/6] refacto date

---
 app/composables/useCharts.ts     | 43 +++++---------
 app/utils/chart-data-buckets.ts  | 55 ++++++------------
 app/utils/date.ts                | 24 ++++++++
 test/unit/app/utils/date.spec.ts | 98 ++++++++++++++++++++++++++++++++
 4 files changed, 151 insertions(+), 69 deletions(-)
 create mode 100644 app/utils/date.ts
 create mode 100644 test/unit/app/utils/date.spec.ts

diff --git a/app/composables/useCharts.ts b/app/composables/useCharts.ts
index 5f3c53377d..3a7954f768 100644
--- a/app/composables/useCharts.ts
+++ b/app/composables/useCharts.ts
@@ -13,6 +13,7 @@ import { parseRepoUrl } from '#shared/utils/git-providers'
 import type { PackageMetaResponse } from '#shared/types'
 import { encodePackageName } from '#shared/utils/npm'
 import { fetchNpmDownloadsRange } from '~/utils/npm/api'
+import { parseIsoDate, toIsoDate, addDays } from '~/utils/date'
 import {
   buildDailyEvolution,
   buildWeeklyEvolution,
@@ -24,16 +25,6 @@ export type PackumentLikeForTime = {
   time?: Record<string, string>
 }
 
-function toIsoDateString(date: Date): string {
-  return date.toISOString().slice(0, 10)
-}
-
-function addDays(date: Date, days: number): Date {
-  const updatedDate = new Date(date)
-  updatedDate.setUTCDate(updatedDate.getUTCDate() + days)
-  return updatedDate
-}
-
 function startOfUtcMonth(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1))
 }
@@ -42,17 +33,9 @@ function startOfUtcYear(date: Date): Date {
   return new Date(Date.UTC(date.getUTCFullYear(), 0, 1))
 }
 
-function parseIsoDateOnly(value: string): Date {
-  return new Date(`${value}T00:00:00.000Z`)
-}
-
-function formatIsoDateOnly(date: Date): string {
-  return date.toISOString().slice(0, 10)
-}
-
 function differenceInUtcDaysInclusive(startIso: string, endIso: string): number {
-  const start = parseIsoDateOnly(startIso)
-  const end = parseIsoDateOnly(endIso)
+  const start = parseIsoDate(startIso)
+  const end = parseIsoDate(endIso)
   return Math.floor((end.getTime() - start.getTime()) / 86400000) + 1
 }
 
@@ -65,8 +48,8 @@ function splitIsoRangeIntoChunksInclusive(
   if (totalDays <= maximumDaysPerRequest) return [{ startIso, endIso }]
 
   const chunks: Array<{ startIso: string; endIso: string }> = []
-  let cursorStart = parseIsoDateOnly(startIso)
-  const finalEnd = parseIsoDateOnly(endIso)
+  let cursorStart = parseIsoDate(startIso)
+  const finalEnd = parseIsoDate(endIso)
 
   while (cursorStart.getTime() <= finalEnd.getTime()) {
     const cursorEnd = addDays(cursorStart, maximumDaysPerRequest - 1)
@@ -149,8 +132,8 @@ function buildWeeklyEvolutionFromContributorCounts(
 
       const clampedWeekEndDate = weekEndDate.getTime() > rangeEnd.getTime() ? rangeEnd : weekEndDate
 
-      const weekStartIso = toIsoDateString(weekStartDate)
-      const weekEndIso = toIsoDateString(clampedWeekEndDate)
+      const weekStartIso = toIsoDate(weekStartDate)
+      const weekEndIso = toIsoDate(clampedWeekEndDate)
 
       return {
         value,
@@ -326,11 +309,11 @@ export function useCharts() {
     )
 
     const endDateOnly = toDateOnly(evolutionOptions.endDate)
-    const end = endDateOnly ? parseIsoDateOnly(endDateOnly) : yesterday
+    const end = endDateOnly ? parseIsoDate(endDateOnly) : yesterday
 
     const startDateOnly = toDateOnly(evolutionOptions.startDate)
     if (startDateOnly) {
-      const start = parseIsoDateOnly(startDateOnly)
+      const start = parseIsoDate(startDateOnly)
       return { start, end }
     }
 
@@ -376,8 +359,8 @@ export function useCharts() {
 
     const { start, end } = resolveDateRange(resolvedOptions, resolvedCreatedIso)
 
-    const startIso = toIsoDateString(start)
-    const endIso = toIsoDateString(end)
+    const startIso = toIsoDate(start)
+    const endIso = toIsoDate(end)
 
     const sortedDaily = await fetchDailyRangeChunked(resolvedPackageName, startIso, endIso)
 
@@ -420,8 +403,8 @@ export function useCharts() {
     const sortedDaily = await dailyLikesPromise
 
     const { start, end } = resolveDateRange(resolvedOptions, null)
-    const startIso = toIsoDateString(start)
-    const endIso = toIsoDateString(end)
+    const startIso = toIsoDate(start)
+    const endIso = toIsoDate(end)
 
     const filteredDaily = sortedDaily.filter(d => d.day >= startIso && d.day <= endIso)
 
diff --git a/app/utils/chart-data-buckets.ts b/app/utils/chart-data-buckets.ts
index 1f347b90d4..bcdd795859 100644
--- a/app/utils/chart-data-buckets.ts
+++ b/app/utils/chart-data-buckets.ts
@@ -5,34 +5,7 @@ import type {
   WeeklyDataPoint,
   YearlyDataPoint,
 } from '~/types/chart'
-
-// ---------------------------------------------------------------------------
-// Date helpers
-// ---------------------------------------------------------------------------
-
-const DAY_MS = 86_400_000
-
-function parseIso(value: string): Date {
-  return new Date(`${value}T00:00:00.000Z`)
-}
-
-function toIso(date: Date): string {
-  return date.toISOString().slice(0, 10)
-}
-
-function addDays(date: Date, days: number): Date {
-  const d = new Date(date)
-  d.setUTCDate(d.getUTCDate() + days)
-  return d
-}
-
-function daysInMonth(year: number, month: number): number {
-  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
-}
-
-function daysInYear(year: number): number {
-  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
-}
+import { DAY_MS, parseIsoDate, toIsoDate, addDays, daysInMonth, daysInYear } from '~/utils/date'
 
 // ---------------------------------------------------------------------------
 // Fill partial bucket
@@ -52,7 +25,11 @@ export function buildDailyEvolution(daily: DailyRawPoint[]): DailyDataPoint[] {
   return daily
     .slice()
     .sort((a, b) => a.day.localeCompare(b.day))
-    .map(item => ({ day: item.day, value: item.value, timestamp: parseIso(item.day).getTime() }))
+    .map(item => ({
+      day: item.day,
+      value: item.value,
+      timestamp: parseIsoDate(item.day).getTime(),
+    }))
 }
 
 export function buildWeeklyEvolution(
@@ -63,18 +40,18 @@ export function buildWeeklyEvolution(
   const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
   if (sorted.length === 0) return []
 
-  const rangeStartDate = parseIso(rangeStartIso)
+  const rangeStartDate = parseIsoDate(rangeStartIso)
 
   // Align from last day with actual data (npm has 1-2 day delay, today is incomplete)
   const lastNonZero = sorted.findLast(d => d.value > 0)
-  const pickerEnd = parseIso(rangeEndIso)
-  const effectiveEnd = lastNonZero ? parseIso(lastNonZero.day) : pickerEnd
+  const pickerEnd = parseIsoDate(rangeEndIso)
+  const effectiveEnd = lastNonZero ? parseIsoDate(lastNonZero.day) : pickerEnd
   const rangeEndDate = effectiveEnd.getTime() < pickerEnd.getTime() ? effectiveEnd : pickerEnd
 
   // Group into 7-day buckets from END backwards
   const buckets = new Map<number, number>()
   for (const item of sorted) {
-    const offset = Math.floor((rangeEndDate.getTime() - parseIso(item.day).getTime()) / DAY_MS)
+    const offset = Math.floor((rangeEndDate.getTime() - parseIsoDate(item.day).getTime()) / DAY_MS)
     if (offset < 0) continue
     const idx = Math.floor(offset / 7)
     buckets.set(idx, (buckets.get(idx) ?? 0) + item.value)
@@ -94,8 +71,8 @@ export function buildWeeklyEvolution(
         value = fillPartialBucket(value, actualDays, 7)
       }
 
-      const weekStartIso = toIso(weekStartDate)
-      const weekEndIso = toIso(weekEndDate)
+      const weekStartIso = toIsoDate(weekStartDate)
+      const weekEndIso = toIsoDate(weekEndDate)
       return {
         value,
         weekKey: `${weekStartIso}_${weekEndIso}`,
@@ -134,7 +111,7 @@ export function buildMonthlyEvolution(
       if (endDay < total) value = fillPartialBucket(value, endDay, total)
     }
 
-    return { month, value, timestamp: parseIso(`${month}-01`).getTime() }
+    return { month, value, timestamp: parseIsoDate(`${month}-01`).getTime() }
   })
 }
 
@@ -154,17 +131,17 @@ export function buildYearlyEvolution(
 
   return entries.map(([year, value], i) => {
     const total = daysInYear(Number(year))
-    const yearStart = parseIso(`${year}-01-01`)
+    const yearStart = parseIsoDate(`${year}-01-01`)
 
     if (i === 0 && rangeStartIso) {
       const dayOfYear = Math.floor(
-        (parseIso(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS,
+        (parseIsoDate(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS,
       )
       if (dayOfYear > 0) value = fillPartialBucket(value, total - dayOfYear, total)
     }
     if (i === entries.length - 1 && rangeEndIso) {
       const actualDays =
-        Math.floor((parseIso(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
+        Math.floor((parseIsoDate(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
       if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
     }
 
diff --git a/app/utils/date.ts b/app/utils/date.ts
new file mode 100644
index 0000000000..c3165feb2e
--- /dev/null
+++ b/app/utils/date.ts
@@ -0,0 +1,24 @@
+// TODO: when temporal?
+export const DAY_MS = 86_400_000
+
+export function parseIsoDate(value: string): Date {
+  return new Date(`${value}T00:00:00.000Z`)
+}
+
+export function toIsoDate(date: Date): string {
+  return date.toISOString().slice(0, 10)
+}
+
+export function addDays(date: Date, days: number): Date {
+  const d = new Date(date)
+  d.setUTCDate(d.getUTCDate() + days)
+  return d
+}
+
+export function daysInMonth(year: number, month: number): number {
+  return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
+}
+
+export function daysInYear(year: number): number {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 366 : 365
+}
diff --git a/test/unit/app/utils/date.spec.ts b/test/unit/app/utils/date.spec.ts
new file mode 100644
index 0000000000..0e3d24e06c
--- /dev/null
+++ b/test/unit/app/utils/date.spec.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest'
+import {
+  addDays,
+  DAY_MS,
+  daysInMonth,
+  daysInYear,
+  parseIsoDate,
+  toIsoDate,
+} from '../../../../app/utils/date'
+
+describe('DAY_MS', () => {
+  it('equals 86 400 000', () => {
+    expect(DAY_MS).toBe(86_400_000)
+  })
+})
+
+describe('parseIsoDate', () => {
+  it('returns a UTC midnight date', () => {
+    const d = parseIsoDate('2024-03-15')
+    expect(d.toISOString()).toBe('2024-03-15T00:00:00.000Z')
+  })
+
+  it('does not shift across timezones', () => {
+    const d = parseIsoDate('2024-01-01')
+    expect(d.getUTCHours()).toBe(0)
+    expect(d.getUTCFullYear()).toBe(2024)
+  })
+})
+
+describe('toIsoDate', () => {
+  it('formats a date as YYYY-MM-DD', () => {
+    expect(toIsoDate(new Date('2024-03-15T00:00:00.000Z'))).toBe('2024-03-15')
+  })
+
+  it('roundtrips with parseIsoDate', () => {
+    const iso = '2024-12-31'
+    expect(toIsoDate(parseIsoDate(iso))).toBe(iso)
+  })
+})
+
+describe('addDays', () => {
+  it('adds positive days', () => {
+    const d = parseIsoDate('2024-03-01')
+    expect(toIsoDate(addDays(d, 5))).toBe('2024-03-06')
+  })
+
+  it('subtracts with negative days', () => {
+    const d = parseIsoDate('2024-03-10')
+    expect(toIsoDate(addDays(d, -3))).toBe('2024-03-07')
+  })
+
+  it('crosses month boundary', () => {
+    const d = parseIsoDate('2024-01-30')
+    expect(toIsoDate(addDays(d, 3))).toBe('2024-02-02')
+  })
+
+  it('does not mutate the original date', () => {
+    const d = parseIsoDate('2024-06-15')
+    addDays(d, 10)
+    expect(toIsoDate(d)).toBe('2024-06-15')
+  })
+})
+
+describe('daysInMonth', () => {
+  it('returns 31 for January', () => {
+    expect(daysInMonth(2024, 0)).toBe(31)
+  })
+
+  it('returns 29 for Feb in a leap year', () => {
+    expect(daysInMonth(2024, 1)).toBe(29)
+  })
+
+  it('returns 28 for Feb in a non-leap year', () => {
+    expect(daysInMonth(2023, 1)).toBe(28)
+  })
+
+  it('returns 30 for April', () => {
+    expect(daysInMonth(2024, 3)).toBe(30)
+  })
+})
+
+describe('daysInYear', () => {
+  it('returns 366 for a leap year', () => {
+    expect(daysInYear(2024)).toBe(366)
+  })
+
+  it('returns 365 for a non-leap year', () => {
+    expect(daysInYear(2023)).toBe(365)
+  })
+
+  it('returns 365 for century non-leap year', () => {
+    expect(daysInYear(1900)).toBe(365)
+  })
+
+  it('returns 366 for year 2000 (divisible by 400)', () => {
+    expect(daysInYear(2000)).toBe(366)
+  })
+})

From c733c1b58cdc9b51b4fecb947b415dacc96cc885 Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 08:21:16 +0100
Subject: [PATCH 4/6] manage single point serie

---
 app/utils/chart-data-buckets.ts               | 41 ++++++++++---------
 .../unit/app/utils/chart-data-buckets.spec.ts | 27 ++++++++++++
 2 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/app/utils/chart-data-buckets.ts b/app/utils/chart-data-buckets.ts
index bcdd795859..54e850146c 100644
--- a/app/utils/chart-data-buckets.ts
+++ b/app/utils/chart-data-buckets.ts
@@ -101,15 +101,14 @@ export function buildMonthlyEvolution(
   return entries.map(([month, value], i) => {
     const [y, m] = month.split('-').map(Number) as [number, number]
     const total = daysInMonth(y, m - 1)
+    const isFirst = i === 0
+    const isLast = i === entries.length - 1
 
-    if (i === 0 && rangeStartIso) {
-      const startDay = Number(rangeStartIso.split('-')[2])
-      if (startDay > 1) value = fillPartialBucket(value, total - startDay + 1, total)
-    }
-    if (i === entries.length - 1 && rangeEndIso) {
-      const endDay = Number(rangeEndIso.split('-')[2])
-      if (endDay < total) value = fillPartialBucket(value, endDay, total)
-    }
+    const startDay = isFirst && rangeStartIso ? Number(rangeStartIso.split('-')[2]) : 1
+    const endDay = isLast && rangeEndIso ? Number(rangeEndIso.split('-')[2]) : total
+    const actualDays = endDay - startDay + 1
+
+    if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
 
     return { month, value, timestamp: parseIsoDate(`${month}-01`).getTime() }
   })
@@ -132,18 +131,20 @@ export function buildYearlyEvolution(
   return entries.map(([year, value], i) => {
     const total = daysInYear(Number(year))
     const yearStart = parseIsoDate(`${year}-01-01`)
-
-    if (i === 0 && rangeStartIso) {
-      const dayOfYear = Math.floor(
-        (parseIsoDate(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS,
-      )
-      if (dayOfYear > 0) value = fillPartialBucket(value, total - dayOfYear, total)
-    }
-    if (i === entries.length - 1 && rangeEndIso) {
-      const actualDays =
-        Math.floor((parseIsoDate(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
-      if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
-    }
+    const isFirst = i === 0
+    const isLast = i === entries.length - 1
+
+    const startOffset =
+      isFirst && rangeStartIso
+        ? Math.floor((parseIsoDate(rangeStartIso).getTime() - yearStart.getTime()) / DAY_MS)
+        : 0
+    const endOffset =
+      isLast && rangeEndIso
+        ? Math.floor((parseIsoDate(rangeEndIso).getTime() - yearStart.getTime()) / DAY_MS) + 1
+        : total
+    const actualDays = endOffset - startOffset
+
+    if (actualDays < total) value = fillPartialBucket(value, actualDays, total)
 
     return { year, value, timestamp: yearStart.getTime() }
   })
diff --git a/test/unit/app/utils/chart-data-buckets.spec.ts b/test/unit/app/utils/chart-data-buckets.spec.ts
index 83109d9038..8538f18138 100644
--- a/test/unit/app/utils/chart-data-buckets.spec.ts
+++ b/test/unit/app/utils/chart-data-buckets.spec.ts
@@ -138,6 +138,19 @@ describe('buildMonthlyEvolution', () => {
     expect(buildMonthlyEvolution([])).toEqual([])
   })
 
+  it('scales single month partial on both ends without double-scaling', () => {
+    // 2025-01-10 to 2025-01-20 = 11 days out of 31
+    const daily = Array.from({ length: 11 }, (_, i) => ({
+      day: `2025-01-${String(i + 10).padStart(2, '0')}`,
+      value: 10,
+    }))
+
+    const result = buildMonthlyEvolution(daily, '2025-01-10', '2025-01-20')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((110 * 31) / 11))
+  })
+
   it('scales up partial first month', () => {
     const daily = Array.from({ length: 14 }, (_, i) => ({
       day: `2025-03-${String(i + 18).padStart(2, '0')}`,
@@ -188,6 +201,20 @@ describe('buildYearlyEvolution', () => {
     expect(buildYearlyEvolution([])).toEqual([])
   })
 
+  it('scales single year partial on both ends without double-scaling', () => {
+    // 2025-04-01 to 2025-06-30 = 91 days out of 365
+    const daily = Array.from({ length: 91 }, (_, i) => {
+      const d = new Date(Date.UTC(2025, 3, 1))
+      d.setUTCDate(d.getUTCDate() + i)
+      return { day: d.toISOString().slice(0, 10), value: 10 }
+    })
+
+    const result = buildYearlyEvolution(daily, '2025-04-01', '2025-06-30')
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.value).toBe(Math.round((910 * 365) / 91))
+  })
+
   it('scales up partial first year', () => {
     const daily = Array.from({ length: 184 }, (_, i) => {
       const d = new Date(Date.UTC(2025, 6, 1))

From 1f5b832dca22055816b2667e43cbaa1eda635094 Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 08:25:56 +0100
Subject: [PATCH 5/6] tentative

---
 app/utils/chart-data-buckets.ts | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/app/utils/chart-data-buckets.ts b/app/utils/chart-data-buckets.ts
index 54e850146c..1165c4541f 100644
--- a/app/utils/chart-data-buckets.ts
+++ b/app/utils/chart-data-buckets.ts
@@ -7,29 +7,22 @@ import type {
 } from '~/types/chart'
 import { DAY_MS, parseIsoDate, toIsoDate, addDays, daysInMonth, daysInYear } from '~/utils/date'
 
-// ---------------------------------------------------------------------------
-// Fill partial bucket
-// ---------------------------------------------------------------------------
-
 /** Proportionally scale a partial bucket to estimate the full-period value. */
 export function fillPartialBucket(value: number, actualDays: number, totalDays: number): number {
   if (actualDays <= 0 || actualDays >= totalDays) return value
   return Math.round((value * totalDays) / actualDays)
 }
 
-// ---------------------------------------------------------------------------
-// Builders
-// ---------------------------------------------------------------------------
+function sortedDaily(daily: DailyRawPoint[]): DailyRawPoint[] {
+  return daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+}
 
 export function buildDailyEvolution(daily: DailyRawPoint[]): DailyDataPoint[] {
-  return daily
-    .slice()
-    .sort((a, b) => a.day.localeCompare(b.day))
-    .map(item => ({
-      day: item.day,
-      value: item.value,
-      timestamp: parseIsoDate(item.day).getTime(),
-    }))
+  return sortedDaily(daily).map(item => ({
+    day: item.day,
+    value: item.value,
+    timestamp: parseIsoDate(item.day).getTime(),
+  }))
 }
 
 export function buildWeeklyEvolution(
@@ -37,7 +30,7 @@ export function buildWeeklyEvolution(
   rangeStartIso: string,
   rangeEndIso: string,
 ): WeeklyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  const sorted = sortedDaily(daily)
   if (sorted.length === 0) return []
 
   const rangeStartDate = parseIsoDate(rangeStartIso)
@@ -89,7 +82,7 @@ export function buildMonthlyEvolution(
   rangeStartIso?: string,
   rangeEndIso?: string,
 ): MonthlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  const sorted = sortedDaily(daily)
   const byMonth = new Map<string, number>()
   for (const item of sorted) {
     const m = item.day.slice(0, 7)
@@ -119,7 +112,7 @@ export function buildYearlyEvolution(
   rangeStartIso?: string,
   rangeEndIso?: string,
 ): YearlyDataPoint[] {
-  const sorted = daily.slice().sort((a, b) => a.day.localeCompare(b.day))
+  const sorted = sortedDaily(daily)
   const byYear = new Map<string, number>()
   for (const item of sorted) {
     const y = item.day.slice(0, 4)

From 410b4f6c727576783b532ae3a3b65fa4277a7d7a Mon Sep 17 00:00:00 2001
From: jycouet <jycouet@gmail.com>
Date: Thu, 12 Mar 2026 21:48:33 +0100
Subject: [PATCH 6/6] fix: replace leftover formatIsoDateOnly with toIsoDate

---
 app/composables/useCharts.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/composables/useCharts.ts b/app/composables/useCharts.ts
index 3a7954f768..0fc07ab6a0 100644
--- a/app/composables/useCharts.ts
+++ b/app/composables/useCharts.ts
@@ -56,8 +56,8 @@ function splitIsoRangeIntoChunksInclusive(
     const actualEnd = cursorEnd.getTime() < finalEnd.getTime() ? cursorEnd : finalEnd
 
     chunks.push({
-      startIso: formatIsoDateOnly(cursorStart),
-      endIso: formatIsoDateOnly(actualEnd),
+      startIso: toIsoDate(cursorStart),
+      endIso: toIsoDate(actualEnd),
     })
 
     cursorStart = addDays(actualEnd, 1)