extract some logic

Author: jycouet

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(