fix: remove any types and pass eslint

Author: Vivek Trivedi

lib/calculate.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { calculateStreak, calculateMonthlyStats } from './calculate';
+import {
+  calculateStreak,
+  calculateMonthlyStats,
+  calculateWrappedStats,
+  aggregateCalendars,
+} from './calculate';
 import type { ContributionCalendar } from '../types';
 
 // Turns a flat array of daily counts into the ContributionCalendar shape,
@@ -386,28 +391,197 @@ describe('calculateStreak — empty and sparse year edge cases', () => {
     expect(result.totalContributions).toBe(2);
   });
 });
-it('handles different week start days correctly', () => {
-  // Simulating 2 full weeks (Sunday start vs Monday start shouldn't break logic)
-  const calendar = buildCalendar([
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1, // week 1
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1, // week 2
-  ]);
-
-  const result = calculateStreak(calendar);
-
-  expect(result.currentStreak).toBe(14);
-  expect(result.longestStreak).toBe(14);
-  expect(result.totalContributions).toBe(14);
+const DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+
+it('todayDate matches YYYY-MM-DD for a normal calendar', () => {
+  // A typical calendar with contributions — todayDate must always be a valid date string
+  // regardless of the contribution data, so the SVG pulse animation targets the right tower.
+  const calendar = buildCalendar([1, 0, 1, 1, 0, 1, 1]);
+  const fixedNow = new Date('2024-01-07T12:00:00Z');
+  const result = calculateStreak(calendar, 'UTC', fixedNow);
+  expect(result.todayDate).toMatch(DATE_REGEX);
+});
+
+it('todayDate matches YYYY-MM-DD for an empty calendar', () => {
+  // An empty calendar has no days to fall back on, so todayDate is derived
+  // purely from the current date — it must still be a valid YYYY-MM-DD string.
+  const emptyCalendar = buildCalendar([]);
+  const fixedNow = new Date('2024-03-15T00:00:00Z');
+  const result = calculateStreak(emptyCalendar, 'UTC', fixedNow);
+  expect(result.todayDate).toMatch(DATE_REGEX);
+});
+
+it('todayDate matches YYYY-MM-DD when a non-UTC timezone shifts the local date', () => {
+  // When the caller passes a timezone like Asia/Kolkata, the local date can differ
+  // from UTC (e.g. UTC is still Jan 14 but IST is already Jan 15).
+  // The format must remain YYYY-MM-DD regardless of which day the timezone lands on.
+  const calendar = buildCalendar([1, 1, 1, 1, 1, 1, 1]);
+  const fixedNow = new Date('2024-01-07T20:00:00Z'); // 01:30 Jan 8 in IST (UTC+5:30)
+  const result = calculateStreak(calendar, 'Asia/Kolkata', fixedNow);
+  expect(result.todayDate).toMatch(DATE_REGEX);
+});
+
+describe('calculateStreak — year boundary transition (Dec 31 → Jan 1)', () => {
+  // Streak math relies on the flattened day array being chronologically ordered,
+  // so a run that crosses from December into January must be counted as a single
+  // continuous streak. This guards against off-by-one bugs where the calendar
+  // year rollover (e.g. 2024-12-31 → 2025-01-01) is mistakenly treated as a gap.
+  it('counts a streak that spans the Dec 31 → Jan 1 boundary as one continuous run', () => {
+    const calendar: ContributionCalendar = {
+      totalContributions: 7,
+      weeks: [
+        {
+          contributionDays: [
+            { contributionCount: 0, date: '2024-12-26' }, // gap before the streak begins
+            { contributionCount: 1, date: '2024-12-27' },
+            { contributionCount: 1, date: '2024-12-28' },
+            { contributionCount: 1, date: '2024-12-29' },
+            { contributionCount: 1, date: '2024-12-30' },
+            { contributionCount: 1, date: '2024-12-31' }, // last day of the year
+            { contributionCount: 1, date: '2025-01-01' }, // first day of the new year
+          ],
+        },
+        {
+          contributionDays: [
+            { contributionCount: 1, date: '2025-01-02' }, // "today"
+          ],
+        },
+      ],
+    };
+
+    // Pin "now" to Jan 2 so the final day is treated as today and the streak is live.
+    const now = new Date('2025-01-02T12:00:00Z');
+    const result = calculateStreak(calendar, 'UTC', now);
+
+    // The 7-day run (Dec 27 → Jan 2) must not be split by the year rollover.
+    expect(result.currentStreak).toBe(7);
+    expect(result.longestStreak).toBe(7);
+    expect(result.totalContributions).toBe(7);
+    expect(result.todayDate).toBe('2025-01-02');
+  });
+});
+
+// ---------- EPIC ENHANCEMENT TESTS ----------
+
+describe('aggregateCalendars', () => {
+  it('handles calendars with different numbers of weeks', () => {
+    const cal1 = {
+      totalContributions: 15,
+      weeks: [
+        {
+          contributionDays: [{ date: '2024-01-01', contributionCount: 5 }],
+        },
+        {
+          contributionDays: [{ date: '2024-01-08', contributionCount: 10 }],
+        },
+      ],
+    };
+
+    const cal2 = {
+      totalContributions: 3,
+      weeks: [
+        {
+          contributionDays: [{ date: '2024-01-01', contributionCount: 3 }],
+        },
+      ],
+    };
+
+    const result = aggregateCalendars([cal1, cal2]);
+
+    expect(result.weeks).toHaveLength(2);
+    expect(result.weeks[0].contributionDays[0].contributionCount).toBe(8);
+    expect(result.weeks[1].contributionDays[0].contributionCount).toBe(10);
+  });
+
+  it('returns an empty calendar if no calendars are provided', () => {
+    const result = aggregateCalendars([]);
+    expect(result.totalContributions).toBe(0);
+    expect(result.weeks).toEqual([]);
+  });
+
+  it('aggregates multiple calendars correctly for orgs', () => {
+    const cal1 = buildCalendar([1, 0, 2]); // total: 3
+    const cal2 = buildCalendar([0, 3, 1]); // total: 4
+
+    const result = aggregateCalendars([cal1, cal2]);
+
+    expect(result.totalContributions).toBe(7);
+    expect(result.weeks[0].contributionDays[0].contributionCount).toBe(1); // 1 + 0
+    expect(result.weeks[0].contributionDays[1].contributionCount).toBe(3); // 0 + 3
+    expect(result.weeks[0].contributionDays[2].contributionCount).toBe(3); // 2 + 1
+  });
+});
+
+describe('calculateWrappedStats', () => {
+  it('returns weekendRatio as 0 when all contributions occur on weekdays', () => {
+    const calendar = {
+      totalContributions: 25,
+      weeks: [
+        {
+          contributionDays: [
+            { date: '2024-01-01', contributionCount: 5 }, // Mon
+            { date: '2024-01-02', contributionCount: 5 }, // Tue
+            { date: '2024-01-03', contributionCount: 5 }, // Wed
+            { date: '2024-01-04', contributionCount: 5 }, // Thu
+            { date: '2024-01-05', contributionCount: 5 }, // Fri
+          ],
+        },
+      ],
+    };
+
+    const result = calculateWrappedStats(calendar);
+
+    expect(result.weekendRatio).toBe(0);
+  });
+
+  it('calculates GitHub Wrapped stats accurately', () => {
+    // 2024-01-01 was a Monday. Indices 5 (Sat) and 6 (Sun) are the weekend.
+    const cal = buildCalendar([0, 0, 0, 0, 0, 5, 15]);
+
+    const result = calculateWrappedStats(cal);
+
+    expect(result.totalContributions).toBe(20);
+    expect(result.highestDailyCount).toBe(15);
+    expect(result.mostActiveDate).toBe('2024-01-07');
+    expect(result.busiestMonth).toBe('2024-01');
+    expect(result.weekendRatio).toBe(100);
+  });
+
+  // ISSUE OBJECTIVE #1056: Verify empty calendar returns safe zero values
+  it('verify empty calendar returns safe zero values', () => {
+    // 1. Call calculateWrappedStats with empty data
+    expect(() => calculateWrappedStats({ totalContributions: 0, weeks: [] })).not.toThrow();
+
+    // 2. Actually get the result to test its properties
+    const result = calculateWrappedStats({ totalContributions: 0, weeks: [] });
+
+    // 3. Assert weekendRatio === 0 (and specifically not NaN)
+    expect(result.weekendRatio).toBe(0);
+
+    // 4. Assert highestDailyCount === 0
+    expect(result.highestDailyCount).toBe(0);
+  });
+
+  // ISSUE OBJECTIVE: Verify weekendRatio is 100 when all commits are on weekends
+  // =========================================================================
+  it('returns weekendRatio === 100 when all contributions are on weekends', () => {
+    // Note: 2026-05-02 is a Saturday, 2026-05-03 is a Sunday, 2026-05-04 is a Monday
+    const weekendCalendar = {
+      totalContributions: 10,
+      weeks: [
+        {
+          contributionDays: [
+            { date: '2026-05-02', contributionCount: 5 }, // Saturday (Weekend)
+            { date: '2026-05-03', contributionCount: 5 }, // Sunday (Weekend)
+            { date: '2026-05-04', contributionCount: 0 }, // Monday (Weekday - 0 commits)
+          ],
+        },
+      ],
+    } as Parameters<typeof calculateWrappedStats>[0]; // Safely infers the exact type the function expects!
+
+    const result = calculateWrappedStats(weekendCalendar);
+
+    // Assert the ratio is exactly 100%
+    expect(result.weekendRatio).toBe(100);
+  });
 });