Merge branch 'main' into docs/cache-getorset-comments

Author: khyatiisingh25

app/components/ScrollRestoration.type-compiler.test.tsx

@@ -0,0 +1,49 @@
+import { render } from '@testing-library/react';
+import { describe, expect, expectTypeOf, it, vi } from 'vitest';
+import ScrollRestoration from './ScrollRestoration';
+
+vi.mock('next/navigation', () => ({
+  usePathname: () => '/contributors',
+}));
+
+type ScrollRestorationComponent = typeof ScrollRestoration;
+type ScrollRestorationProps = Parameters<ScrollRestorationComponent>;
+
+function validateScrollStorageKey(key: string) {
+  return /^scroll-position-\/.+/.test(key);
+}
+
+describe('ScrollRestoration type compiler validation', () => {
+  it('exports a callable React component with no required props', () => {
+    expectTypeOf(ScrollRestoration).toBeFunction();
+    expectTypeOf<ScrollRestorationProps>().toEqualTypeOf<[]>();
+  });
+
+  it('renders without visible DOM output', () => {
+    const { container } = render(<ScrollRestoration />);
+
+    expect(container.textContent).toBe('');
+    expect(container.firstElementChild).toBeNull();
+  });
+
+  it('blocks invalid prop parameters at compile time', () => {
+    expectTypeOf<ScrollRestorationProps>().not.toEqualTypeOf<[{ pathname: string }]>();
+  });
+
+  it('accepts optional pathname-like values in schema helper checks', () => {
+    type OptionalPathname = string | undefined;
+
+    const optionalPathname: OptionalPathname = '/contributors';
+
+    expectTypeOf<OptionalPathname>().toEqualTypeOf<string | undefined>();
+
+    expect(validateScrollStorageKey(`scroll-position-${optionalPathname}`)).toBe(true);
+  });
+
+  it('returns strict validation reports for scroll storage key constraints', () => {
+    expect(validateScrollStorageKey('scroll-position-/contributors')).toBe(true);
+    expect(validateScrollStorageKey('scroll-position-')).toBe(false);
+    expect(validateScrollStorageKey('contributors')).toBe(false);
+    expect(validateScrollStorageKey('')).toBe(false);
+  });
+});

app/contributors/loading.accessibility.test.tsx

@@ -0,0 +1,70 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import Loading from './loading';
+
+function hasClasses(element: Element | null, classes: string[]) {
+  expect(element).not.toBeNull();
+
+  for (const className of classes) {
+    expect(element!.classList.contains(className)).toBe(true);
+  }
+}
+
+describe('Contributors loading accessibility', () => {
+  it('exposes the loading state through a screen-reader status region', () => {
+    render(<Loading />);
+
+    const status = screen.getByRole('status');
+
+    expect(status.getAttribute('aria-live')).toBe('polite');
+    expect(status.textContent).toContain('Loading the collective...');
+    expect(status.textContent).toContain('Fetching contributor data from GitHub');
+  });
+
+  it('keeps descriptive loading text available to assistive technologies', () => {
+    render(<Loading />);
+
+    expect(screen.getByText('Loading the collective...')).toBeTruthy();
+    expect(screen.getByText('Fetching contributor data from GitHub')).toBeTruthy();
+  });
+
+  it('does not expose decorative spinner elements as interactive controls', () => {
+    render(<Loading />);
+
+    expect(screen.queryByRole('button')).toBeNull();
+    expect(screen.queryByRole('link')).toBeNull();
+    expect(screen.queryByRole('textbox')).toBeNull();
+  });
+
+  it('preserves visual focus-friendly layout without hidden foreground text', () => {
+    render(<Loading />);
+
+    const status = screen.getByRole('status');
+    const page = status.parentElement;
+
+    hasClasses(page, [
+      'flex',
+      'min-h-screen',
+      'items-center',
+      'justify-center',
+      'bg-[#050505]',
+      'text-white',
+    ]);
+
+    expect(status.classList.contains('sr-only')).toBe(false);
+    expect(status.classList.contains('hidden')).toBe(false);
+    expect(status.classList.contains('text-transparent')).toBe(false);
+  });
+
+  it('keeps DOM reading order logical for keyboard and screen-reader traversal', () => {
+    render(<Loading />);
+
+    const status = screen.getByRole('status');
+    const children = Array.from(status.children);
+
+    expect(children.length).toBeGreaterThanOrEqual(3);
+    expect(children[0].tagName.toLowerCase()).toBe('div');
+    expect(children[1].textContent).toBe('Loading the collective...');
+    expect(children[2].textContent).toBe('Fetching contributor data from GitHub');
+  });
+});

components/ShareButtons.accessibility.test.tsx

@@ -0,0 +1,69 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+
+import ShareButtons from './ShareButtons';
+
+describe('ShareButtons accessibility behavior', () => {
+  const url = 'https://example.com';
+  const title = 'Test Title';
+
+  const renderShareButtons = () => render(<ShareButtons url={url} title={title} />);
+
+  it('provides an accessible label for the LinkedIn share link', () => {
+    renderShareButtons();
+
+    const link = screen.getByRole('link', {
+      name: 'Share on LinkedIn (opens in a new tab)',
+    });
+
+    expect(link).toBeTruthy();
+  });
+
+  it('provides an accessible label for the X/Twitter share link', () => {
+    renderShareButtons();
+
+    const link = screen.getByRole('link', {
+      name: 'Share on X / Twitter (opens in a new tab)',
+    });
+
+    expect(link).toBeTruthy();
+  });
+
+  it('marks social media icons as decorative', () => {
+    const { container } = renderShareButtons();
+
+    const icons = container.querySelectorAll('svg[aria-hidden="true"]');
+
+    expect(icons).toHaveLength(2);
+  });
+
+  it('opens LinkedIn share link in a new tab securely', () => {
+    renderShareButtons();
+
+    const link = screen.getByRole('link', {
+      name: 'Share on LinkedIn (opens in a new tab)',
+    });
+
+    expect(link.getAttribute('target')).toBe('_blank');
+
+    const rel = link.getAttribute('rel') ?? '';
+
+    expect(rel).toContain('noopener');
+    expect(rel).toContain('noreferrer');
+  });
+
+  it('opens X/Twitter share link in a new tab securely', () => {
+    renderShareButtons();
+
+    const link = screen.getByRole('link', {
+      name: 'Share on X / Twitter (opens in a new tab)',
+    });
+
+    expect(link.getAttribute('target')).toBe('_blank');
+
+    const rel = link.getAttribute('rel') ?? '';
+
+    expect(rel).toContain('noopener');
+    expect(rel).toContain('noreferrer');
+  });
+});

components/dashboard/DashboardClient.tsx

@@ -86,19 +86,33 @@ interface DashboardClientProps {
 export interface ProfileMetrics {
   currentStreak: number;
   commitClock: { day: string; commits: number }[]; // e.g., Sun-Sat daily totals
-  hourlyData?: { hour: number; commits: number }[]; // Optional: 0-23 hour distribution
 }
 
 export interface CoderProfile {
   peakHourStart: number;
   peakHourEnd: number;
-  profileName: 'Night Owl 🌙' | 'Early Builder ☀' | 'Weekend Warrior 🚀' | 'Consistent Runner 🏃‍♂️';
+  profileName: 'Early Builder ☀' | 'Weekend Warrior 🚀' | 'Consistent Runner 🏃‍♂️';
   hourlyDistribution: number[];
   activeWeekdays: string[];
 }
 
+/**
+ * Generates a coder profile based on available metrics.
+ *
+ * NOTE: Night Owl classification via hourlyData is NOT IMPLEMENTED.
+ * GitHub's REST API only provides daily contribution granularity. Fetching hourly data
+ * would require querying individual commits across all repositories, which is:
+ * - Prohibitively expensive in latency (100s-1000s of requests per user)
+ * - Infeasible within serverless function timeout constraints (~10 seconds)
+ * - Not required for daily activity visualization use cases
+ *
+ * Instead, we classify developers into 3 profile types:
+ * - Consistent Runner: High daily commit frequency (streak >= 10)
+ * - Weekend Warrior: Most commits occur on weekends (>35% of commits)
+ * - Early Builder: Default for other patterns
+ */
 export function generateCoderProfile(metrics: ProfileMetrics): CoderProfile {
-  const { currentStreak, commitClock, hourlyData } = metrics;
+  const { currentStreak, commitClock } = metrics;
 
   let profileName: CoderProfile['profileName'] = 'Early Builder ☀';
 
@@ -112,45 +126,21 @@ export function generateCoderProfile(metrics: ProfileMetrics): CoderProfile {
     }
   }
 
-  // 2. Analyze Hourly Data for Night Owl vs Early Builder
-  let isNightOwl = false;
-  if (hourlyData && hourlyData.length > 0) {
-    const nightCommits = hourlyData
-      .filter((d) => d.hour >= 22 || d.hour <= 3)
-      .reduce((sum, d) => sum + d.commits, 0);
-
-    const morningCommits = hourlyData
-      .filter((d) => d.hour >= 5 && d.hour <= 10)
-      .reduce((sum, d) => sum + d.commits, 0);
-
-    isNightOwl = nightCommits > morningCommits;
-  }
-
-  // 3. Determine Final Profile Type
+  // 2. Determine Final Profile Type
   if (currentStreak >= 10) {
     profileName = 'Consistent Runner 🏃‍♂️';
   } else if (isWeekendWarrior) {
     profileName = 'Weekend Warrior 🚀';
-  } else if (isNightOwl) {
-    profileName = 'Night Owl 🌙';
   }
 
-  // 4. Populate UI properties based on the derived profile.
+  // 3. Populate UI properties based on the derived profile.
   // We use smooth curves here without the random 'hash' jitter for a cleaner UI.
   let peakHourStart = 9;
   let peakHourEnd = 17;
   let hourlyDistribution = new Array(24).fill(0);
   let activeWeekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'];
 
-  if (profileName === 'Night Owl 🌙') {
-    peakHourStart = 22;
-    peakHourEnd = 2;
-    hourlyDistribution = Array.from({ length: 24 }, (_, h) => {
-      const distFromMidnight = Math.min(Math.abs(h - 23), Math.abs(h + 1));
-      return Math.max(8, Math.round(100 - distFromMidnight * 9.5));
-    });
-    activeWeekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'];
-  } else if (profileName === 'Early Builder ☀') {
+  if (profileName === 'Early Builder ☀') {
     peakHourStart = 6;
     peakHourEnd = 10;
     hourlyDistribution = Array.from({ length: 24 }, (_, h) => {
@@ -309,12 +299,12 @@ function getPersonalityTags(
     tags.push('Backend Architect ⚙️');
   }
 
-  if (coderProfile.profileName === 'Night Owl 🌙') {
-    tags.push('Night Coder 🌙');
-  } else if (coderProfile.profileName === 'Early Builder ☀') {
+  if (coderProfile.profileName === 'Early Builder ☀') {
     tags.push('Early Builder ☀');
   } else if (coderProfile.profileName === 'Weekend Warrior 🚀') {
     tags.push('Weekend Warrior 🚀');
+  } else if (coderProfile.profileName === 'Consistent Runner 🏃‍♂️') {
+    tags.push('Consistent Runner 🏃‍♂️');
   }
 
   return tags.slice(0, 3);

services/github/background-refresh.theme-contrast.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
+import { BackgroundRefresh } from './background-refresh';
+import { getFullDashboardData } from '../../lib/github';
+
+// Mock the external github fetch integration
+vi.mock('../../lib/github', () => ({
+  getFullDashboardData: vi.fn(),
+}));
+
+describe('BackgroundRefresh - Theme Contrast Equivalent (Mode Cohesion)', () => {
+  let refresher: BackgroundRefresh;
+
+  beforeEach(() => {
+    // Note: since it's a singleton, we use getInstance and reset
+    // but the class is exported as a singleton instance 'backgroundRefresh'.
+    // We can just import the class and use getInstance.
+    refresher = BackgroundRefresh['getInstance']();
+    refresher.reset();
+    vi.clearAllMocks();
+  });
+
+  it('Dual Environment Setup: seamlessly swaps between Fresh (Light) and Stale (Dark) cache modes', () => {
+    vi.spyOn(Date, 'now').mockReturnValue(new Date('2024-01-01T12:00:00Z').getTime());
+
+    // Fresh Environment (Light Mode equivalent) - Synced 1 minute ago
+    const freshTimestamp = new Date('2024-01-01T11:59:00Z').toISOString();
+    expect(refresher.isStale(freshTimestamp)).toBe(false);
+
+    // Stale Environment (Dark Mode equivalent) - Synced 15 minutes ago
+    const staleTimestamp = new Date('2024-01-01T11:45:00Z').toISOString();
+    expect(refresher.isStale(staleTimestamp)).toBe(true);
+
+    vi.restoreAllMocks();
+  });
+
+  it('Behavior Adaptation Cohesion: accurately transitions user from Idle to Active Job state', () => {
+    // Mock getFullDashboardData to return a promise that doesn't resolve immediately
+    let resolveJob: (value?: unknown) => void;
+    (getFullDashboardData as Mock).mockReturnValue(
+      new Promise((resolve) => {
+        resolveJob = resolve;
+      })
+    );
+
+    // Idle State
+    expect(refresher.isJobActive('transition_user')).toBe(false);
+
+    // Trigger action
+    refresher.triggerRefresh('transition_user');
+
+    // Active State
+    expect(refresher.isJobActive('transition_user')).toBe(true);
+
+    // Cleanup: Resolve the promise to not leave hanging promises
+    resolveJob!(undefined);
+  });
+
+  it('Contrast Verification (Concurrency): rigidly rejects colliding background jobs to preserve active state contrast', () => {
+    let resolveJob1: (value?: unknown) => void;
+    (getFullDashboardData as Mock).mockReturnValue(
+      new Promise((resolve) => {
+        resolveJob1 = resolve;
+      })
+    );
+
+    // Trigger first job
+    refresher.triggerRefresh('collide_user');
+    expect(getFullDashboardData).toHaveBeenCalledTimes(1);
+    expect(refresher.isJobActive('collide_user')).toBe(true);
+
+    // Attempt to trigger overlapping second job
+    refresher.triggerRefresh('collide_user');
+
+    // The integration should NOT be called a second time
+    expect(getFullDashboardData).toHaveBeenCalledTimes(1);
+
+    resolveJob1!(undefined);
+  });
+
+  it('Configuration Preservation (Error Resilience): clears active state smoothly upon integration failures without getting stuck', async () => {
+    // Force a failure
+    (getFullDashboardData as Mock).mockReturnValue(Promise.reject(new Error('Network failure')));
+
+    refresher.triggerRefresh('error_user');
+    expect(refresher.isJobActive('error_user')).toBe(true);
+
+    // Wait for the microtask queue to process the catch/finally blocks
+    await new Promise(process.nextTick);
+
+    // State should have smoothly transitioned back to idle
+    expect(refresher.isJobActive('error_user')).toBe(false);
+  });
+
+  it('Foreground/Background Cohesion (Sanitization): flawlessly aligns active states across disparate formatting inputs', () => {
+    (getFullDashboardData as Mock).mockReturnValue(Promise.resolve());
+
+    // Start job with messy formatting
+    refresher.triggerRefresh('   Messy_User   ');
+
+    // Check state with clean formatting
+    expect(refresher.isJobActive('messy_user')).toBe(true);
+
+    // Check state with different messy formatting
+    expect(refresher.isJobActive('  MESSY_USER ')).toBe(true);
+  });
+});