4f:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 50:T1299,export type GitHubRepo = { id: number name: string /** `owner/name` as it lives on GitHub. */ fullName: string description: string | null /** GitHub HTML URL. */ url: string /** Primary language, if any. */ language: string | null /** Star count. For forks this is the upstream repo's star count. */ stars: number isFork: boolean /** `owner/name` of the upstream repo, when this is a fork. */ upstream: string | null /** ISO timestamp of the last push. */ pushedAt: string } export type GitHubContributionState = "merged" | "closed" | "open" export type GitHubContribution = { id: number /** `owner/name` of the repository the pull request targets. */ repo: string title: string url: string state: GitHubContributionState createdAt: string } export type GitHubData = { /** Authored pull requests against repositories the viewer does not own. */ contributions: GitHubContribution[] /** Repositories the viewer forked, ranked by the original repo's stars. */ forks: GitHubRepo[] /** Repositories the viewer owns (non-forks). */ owned: GitHubRepo[] } export type RawGitHubRepo = { id: number name: string full_name: string description: string | null html_url: string language: string | null stargazers_count: number fork: boolean pushed_at: string /** Immediate upstream repo. Only returned by single-repo endpoints. */ parent?: { full_name: string; stargazers_count: number } | null /** Root repo of the fork network. Only returned by single-repo endpoints. */ source?: { full_name: string; stargazers_count: number } | null } export type RawGitHubIssue = { id: number title: string html_url: string state: string created_at: string repository_url: string pull_request?: { merged_at: string | null } | null } const GITHUB_REPOS_API = "https://api.github.com/repos/" /** GitHub list endpoints return a bare array; search endpoints wrap items. */ export function extractRepoPage(data: unknown): RawGitHubRepo[] { return Array.isArray(data) ? (data as RawGitHubRepo[]) : [] } export function extractIssuePage(data: unknown): RawGitHubIssue[] { const items = (data as { items?: unknown }).items return Array.isArray(items) ? (items as RawGitHubIssue[]) : [] } /** Reads the `rel="next"` URL from a GitHub `Link` header, if present. */ export function getNextLink(link: string | null | undefined): string | null { if (!link) { return null } for (const segment of link.split(",")) { const match = segment.match(/<([^>]+)>;\s*rel="next"/) if (match) { return match[1] } } return null } export function mapRepo(raw: RawGitHubRepo): GitHubRepo { // Prefer the fork network's root (`source`) so the label and star count point // at the original project rather than an intermediate fork. const upstream = raw.fork ? (raw.source ?? raw.parent ?? null) : null return { id: raw.id, name: raw.name, fullName: raw.full_name, description: raw.description, url: raw.html_url, language: raw.language, stars: upstream ? upstream.stargazers_count : raw.stargazers_count, isFork: raw.fork, upstream: upstream ? upstream.full_name : null, pushedAt: raw.pushed_at, } } /** * Maps a search-issue result to a contribution. Pull requests against the * viewer's own repositories are dropped: those are fork-sync or self-authored * PRs, not outside contributions. */ export function mapContribution( raw: RawGitHubIssue, viewer: string ): GitHubContribution | null { const repo = raw.repository_url.startsWith(GITHUB_REPOS_API) ? raw.repository_url.slice(GITHUB_REPOS_API.length) : raw.repository_url const owner = repo.split("/")[0] if (owner.toLowerCase() === viewer.toLowerCase()) { return null } const merged = Boolean(raw.pull_request?.merged_at) const state: GitHubContributionState = merged ? "merged" : raw.state === "open" ? "open" : "closed" return { id: raw.id, repo, title: raw.title, url: raw.html_url, state, createdAt: raw.created_at, } } function byStarsThenName(a: GitHubRepo, b: GitHubRepo): number { return b.stars - a.stars || a.name.localeCompare(b.name) } export function groupGitHubData( repos: RawGitHubRepo[], issues: RawGitHubIssue[], viewer: string ): GitHubData { const mapped = repos.map(mapRepo) return { contributions: issues .map((issue) => mapContribution(issue, viewer)) .filter((item): item is GitHubContribution => item !== null) .sort((a, b) => b.createdAt.localeCompare(a.createdAt)), forks: mapped.filter((repo) => repo.isFork).sort(byStarsThenName), owned: mapped.filter((repo) => !repo.isFork).sort(byStarsThenName), } } 51:T106b,import { unstable_cache } from "next/cache" import { extractIssuePage, extractRepoPage, getNextLink, groupGitHubData, type GitHubData, type RawGitHubIssue, type RawGitHubRepo, } from "@/registry/lib/get-github-data/github-data" const GITHUB_API = "https://api.github.com" function getHeaders(): Record { const headers: Record = { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", } const token = process.env.GITHUB_API_TOKEN if (token) { headers.Authorization = `Bearer ${token}` } return headers } /** Follows `Link` pagination until exhausted, with a safety cap. */ async function fetchAllPages( url: string, extract: (data: unknown) => T[] ): Promise { const items: T[] = [] let next: string | null = url while (next) { const res = await fetch(next, { headers: getHeaders() }) if (!res.ok) { throw new Error(`GitHub API request failed (${res.status})`) } items.push(...extract(await res.json())) next = getNextLink(res.headers.get("link")) if (items.length >= 1000) { break } } return items } /** * Number of per-fork upstream requests to run at once, to stay clear of * GitHub's secondary (burst) rate limits. */ const UPSTREAM_FETCH_CONCURRENCY = 8 /** * The user-repos list endpoint omits `parent`/`source`, so forks arrive with no * upstream. Fetch each fork's own record to recover the original project (the * network root, `source`) so forks can be labelled and ranked by the original * repo's stars. Failures leave the fork unenriched rather than failing the run. */ async function withUpstreamRepos( repos: RawGitHubRepo[] ): Promise { const forks = repos.filter( (repo) => repo.fork && !repo.parent && !repo.source ) if (forks.length === 0) { return repos } const upstreamByFullName = new Map< string, RawGitHubRepo["parent"] | undefined >() for (let i = 0; i < forks.length; i += UPSTREAM_FETCH_CONCURRENCY) { const chunk = forks.slice(i, i + UPSTREAM_FETCH_CONCURRENCY) await Promise.all( chunk.map(async (repo) => { try { const res = await fetch(`${GITHUB_API}/repos/${repo.full_name}`, { headers: getHeaders(), }) if (!res.ok) { return } const data = (await res.json()) as RawGitHubRepo upstreamByFullName.set(repo.full_name, data.source ?? data.parent) } catch { // Ignore; the fork renders without upstream metadata. } }) ) } return repos.map((repo) => { const upstream = upstreamByFullName.get(repo.full_name) return upstream ? { ...repo, parent: upstream } : repo }) } /** * Fetches a user's repositories (owned + forks) and their authored pull * requests. Throws on failure so the cache layer never stores an error result; * callers of `getCachedGithubData` receive `null` instead. */ async function fetchGithubData(username: string): Promise { const [repos, issues] = await Promise.all([ fetchAllPages( `${GITHUB_API}/users/${username}/repos?per_page=100&sort=updated&type=owner`, extractRepoPage ), fetchAllPages( `${GITHUB_API}/search/issues?q=${encodeURIComponent( `author:${username} type:pr` )}&per_page=100&sort=created&order=desc`, extractIssuePage ), ]) return groupGitHubData(await withUpstreamRepos(repos), issues, username) } const getCachedGithubDataUncached = unstable_cache( fetchGithubData, ["github-data"], { revalidate: 86400 } // 1 day ) /** * Cached wrapper around {@link fetchGithubData}. Returns `null` when the API is * unreachable or rate-limited, so callers can render nothing instead of an * empty shell. Failures are not cached, so a transient error does not hide the * data for a full revalidation window. */ export async function getCachedGithubData( username: string ): Promise { if (!username) { return null } try { return await getCachedGithubDataUncached(username) } catch { return null } } 4e:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[null,["$","$L4f",null,{"files":[{"path":"src/registry/lib/get-github-data/github-data.ts","content":"$50","type":"registry:lib","target":"@lib/get-github-data/github-data.ts"},{"path":"src/registry/lib/get-github-data/get-cached-github-data.ts","content":"$51","type":"registry:lib","target":"@lib/get-github-data/get-cached-github-data.ts"}],"className":"h-[70svh] min-h-80"}]]}]