@stats-forge/github-stats-forge-core 0.0.1

package/build/fetchers/stats.js

@@ -0,0 +1,498 @@
+import githubUsernameRegex from 'github-username-regex';
+import { calculateRank } from '../calculateRank.js';
+import { getGitHubYearRange, toGitHubDateTime } from '../common/date.js';
+import { CardError, USER_NOT_FOUND } from '../common/error.js';
+import { wrapTextMultiline } from '../common/fmt.js';
+import { createGraphQLFetcher, httpRequest } from '../common/http.js';
+import { logger } from '../common/log.js';
+import { buildSearchFilter, chunkArray, parseOwnerAffiliations } from '../common/ops.js';
+import { retryer } from '../common/retryer.js';
+import { buildContributionsDocument } from '../graphql/contributionsDocument.js';
+import { UserInfoDocument, UserReposDocument } from '../graphql/generated/stats.js';
+import { MAX_REPOSITORIES_LIMIT, buildReposContributedToDocument, } from '../graphql/reposContributedToDocument.js';
+const fetcher = createGraphQLFetcher(UserInfoDocument, 'bearer');
+/** Fetcher for the pages after the first, which only need `repositories`. */
+const reposFetcher = createGraphQLFetcher(UserReposDocument, 'bearer');
+/**
+ * Fetch stats information for a given username.
+ *
+ * @param variables Fetcher variables.
+ * @param variables.username GitHub username.
+ * @param variables.includeMergedPullRequests Include merged pull requests.
+ * @param variables.includeDiscussions Include discussions.
+ * @param variables.includeDiscussionsAnswers Include discussions answers.
+ * @param variables.startTime Time to start the count of total commits.
+ * @param variables.ownerAffiliations The owner affiliations to filter by. Default: OWNER.
+ * @param variables.includeUserRepositories Whether to include the user's own repositories in the repos contributed to.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns The stats response, with every fetched page's repos merged in.
+ *
+ * @description Supports multi-page fetching when the `FETCH_MULTI_PAGE_STARS`
+ * env variable is `true` or a fetch limit.
+ */
+const statsFetcher = async ({ username, includeMergedPullRequests, includeDiscussions, includeDiscussionsAnswers, startTime, ownerAffiliations, includeUserRepositories, }, config) => {
+    // only the first request carries the stats themselves
+    let stats = await retryer(fetcher, {
+        login: username,
+        after: null,
+        includeMergedPullRequests,
+        includeDiscussions,
+        includeDiscussionsAnswers,
+        startTime,
+        ownerAffiliations,
+        includeUserRepositories,
+    }, config);
+    if (stats.data.errors) {
+        return stats;
+    }
+    const pageLimit = config.fetchMultiPageStars;
+    const extraRepoNodes = [];
+    let pageRepositories = stats.data.data.user?.repositories;
+    let previousCursor = null;
+    let fetchedPages = 1;
+    while (fetchedPages < pageLimit &&
+        // an unstarred repo on the page means the starred ones are exhausted
+        !pageRepositories?.nodes?.some((node) => node?.stargazerCount === 0) &&
+        pageRepositories?.pageInfo.hasNextPage) {
+        const after = pageRepositories.pageInfo.endCursor;
+        // a null or non-advancing cursor would refetch the same page forever
+        if (after === null || after === previousCursor) {
+            break;
+        }
+        previousCursor = after;
+        const page = await retryer(reposFetcher, { login: username, after, ownerAffiliations }, config);
+        if (page.data.errors) {
+            return {
+                data: { ...stats.data, errors: page.data.errors },
+                statusText: page.statusText,
+            };
+        }
+        pageRepositories = page.data.data.user?.repositories;
+        extraRepoNodes.push(...(pageRepositories?.nodes ?? []));
+        fetchedPages++;
+    }
+    if (extraRepoNodes.length > 0) {
+        // deep copy to avoid mutating the response cached by the frontend
+        stats = structuredClone({
+            data: stats.data,
+            statusText: stats.statusText,
+        });
+        stats.data.data.user?.repositories.nodes?.push(...extraRepoNodes);
+    }
+    return stats;
+};
+/**
+ * Fetch total items count using the REST search API.
+ *
+ * @param variables Fetcher variables.
+ * @param token GitHub token.
+ * @param context What the retryer supplies each attempt.
+ * @param context.fetch Transport to send the request with.
+ * @returns The search response, carrying `total_count`.
+ *
+ * @see https://developer.github.com/v3/search/#search-commits
+ */
+const fetchTotalItems = (variables, token, { fetch }) => {
+    const type = String(variables['type']);
+    const filter = String(variables['filter']);
+    const repo = variables['repo'];
+    const owner = variables['owner'];
+    return httpRequest(fetch, `https://api.github.com/search/${type}?per_page=1&q=` +
+        buildSearchFilter(repo, owner).replaceAll(' ', '+') +
+        filter, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github.cloak-preview',
+            Authorization: `token ${token}`,
+        },
+    });
+};
+/**
+ * Fetch a total count for a given username via the REST search API.
+ *
+ * @param props Fetcher props.
+ * @param props.username GitHub username.
+ * @param props.repo Repositories the search is scoped to.
+ * @param props.owner Owners the search is scoped to.
+ * @param props.type Search endpoint to hit, `issues` or `commits`.
+ * @param props.filter Query fragment appended to the scope filter.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Total count.
+ *
+ * The GraphQL API can't return this.
+ * @see https://github.com/anuraghazra/github-readme-stats/issues/92#issuecomment-661026467
+ * @see https://github.com/anuraghazra/github-readme-stats/pull/211
+ */
+const totalItemsFetcher = async ({ username, repo, owner, type, filter, }, config) => {
+    if (!githubUsernameRegex.test(username)) {
+        logger.log('Invalid username provided.');
+        throw new CardError('Invalid username provided.', {
+            code: 'invalid_param',
+            param: 'username',
+        });
+    }
+    let res;
+    try {
+        res = await retryer(fetchTotalItems, { login: username, repo, owner, type, filter }, config);
+    }
+    catch (err) {
+        logger.log(err);
+        throw err;
+    }
+    const totalCount = res.data.total_count;
+    if (totalCount === undefined || isNaN(totalCount)) {
+        logger.error('GitHub error: ' + JSON.stringify(res.data));
+        throw new CardError('Could not fetch data from GitHub REST API.', {
+            code: 'upstream',
+        });
+    }
+    return totalCount;
+};
+/**
+ * Fetch the per-repository counts the REST search API answers, one request each.
+ *
+ * @param props Fetcher props.
+ * @param props.username GitHub username.
+ * @param props.repo Repositories the search is scoped to.
+ * @param props.owner Owners the search is scoped to.
+ * @param props.include_prs_authored Include count of PRs authored.
+ * @param props.include_prs_commented Include count of PRs commented.
+ * @param props.include_prs_reviewed Include count of PRs reviewed.
+ * @param props.include_issues_authored Include count of issues authored.
+ * @param props.include_issues_commented Include count of issues commented.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Only the counts that were asked for.
+ */
+const fetchRepoUserStats = async ({ username, repo = [], owner = [], include_prs_authored = false, include_prs_commented = false, include_prs_reviewed = false, include_issues_authored = false, include_issues_commented = false, }, config) => {
+    const stats = {};
+    if (include_prs_authored) {
+        stats.totalPRsAuthored = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'issues',
+            filter: `author:${username}+type:pr`,
+        }, config);
+    }
+    if (include_prs_commented) {
+        stats.totalPRsCommented = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'issues',
+            filter: `commenter:${username}+-author:${username}+type:pr`,
+        }, config);
+    }
+    if (include_prs_reviewed) {
+        stats.totalPRsReviewed = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'issues',
+            filter: `reviewed-by:${username}+-author:${username}+type:pr`,
+        }, config);
+    }
+    if (include_issues_authored) {
+        stats.totalIssuesAuthored = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'issues',
+            filter: `author:${username}+type:issue`,
+        }, config);
+    }
+    if (include_issues_commented) {
+        stats.totalIssuesCommented = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'issues',
+            filter: `commenter:${username}+-author:${username}+type:issue`,
+        }, config);
+    }
+    return stats;
+};
+/**
+ * Turn a GraphQL `errors` payload into the error to throw.
+ *
+ * @param errors Errors from the response envelope.
+ * @param statusText HTTP status text, used as the error type when GitHub gave a message.
+ * @param fallback Message when GitHub gave none.
+ */
+const graphqlError = (errors, statusText, fallback) => {
+    logger.error(errors);
+    const message = errors[0]?.message;
+    return message
+        ? new CardError(wrapTextMultiline(message, 525, 12)[0] ?? '', {
+            code: 'upstream',
+            secondaryMessage: statusText,
+        })
+        : new CardError(fallback, { code: 'upstream' });
+};
+/**
+ * Fetch all-time contributions by building a single GraphQL query
+ * for all the given years.
+ *
+ * Whether private contributions are included depends on the user's profile settings:
+ * https://docs.github.com/en/account-and-profile/how-tos/contribution-settings/manage-visibility-settings-for-private-contributions-and-achievements#changing-the-visibility-of-your-private-contributions
+ */
+const fetchTotalContributions = async (username, years, config) => {
+    if (years.length === 0) {
+        return 0;
+    }
+    const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(years), 'bearer');
+    const contribRes = await retryer(contributionsFetcher, { login: username }, config);
+    if (contribRes.data.errors) {
+        throw graphqlError(contribRes.data.errors, contribRes.statusText, 'Something went wrong while trying to retrieve the contributions data using the GraphQL API.');
+    }
+    const user = contribRes.data.data.user;
+    if (!user) {
+        return 0;
+    }
+    let total = 0;
+    for (const year of years) {
+        const yearBlock = user[`year_${year}`];
+        if (yearBlock?.contributionCalendar.totalContributions) {
+            total += yearBlock.contributionCalendar.totalContributions;
+        }
+    }
+    return total;
+};
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Ranges per request.
+ * Each costs roughly `4 * MAX_REPOSITORIES_LIMIT` nodes,
+ * so an unchunked round of a heavily split account would breach GitHub's 500k node ceiling
+ * and lose the ranges that had already resolved along with it.
+ */
+const MAX_RANGES_PER_REQUEST = 100;
+const REPOS_CONTRIBUTED_TO_ERROR = 'Something went wrong while trying to retrieve the repository contributions data using the GraphQL API.';
+/**
+ * Count the repositories a user contributed to across every contribution year.
+ *
+ * `repositoriesContributedTo` spans at most one year,
+ * so every year is fetched as an aliased `contributionsCollection(from, to)` in one request and the repos de-duplicated.
+ * A range returning `MAX_REPOSITORIES_LIMIT` results may have more,
+ * so it is halved and requeried in the next round.
+ *
+ * Whether private contributions are included depends on the used PAT.
+ *
+ * @param canonicalUsername Username as GitHub reports it; `nameWithOwner` uses its
+ *        casing, which the raw query-string username need not match.
+ * @param years Contribution years to walk.
+ * @param includeOwnRepos Whether to count the user's own repositories.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Count of repositories.
+ */
+const fetchAllTimeReposContributedTo = async (canonicalUsername, years, includeOwnRepos, config) => {
+    const repos = new Set();
+    let pending = years.map(getGitHubYearRange);
+    while (pending.length > 0) {
+        const nextPending = [];
+        for (const chunk of chunkArray(pending, MAX_RANGES_PER_REQUEST)) {
+            const fetcher = createGraphQLFetcher(buildReposContributedToDocument(chunk, includeOwnRepos), 'bearer');
+            const res = await retryer(fetcher, { login: canonicalUsername, maxRepositories: MAX_REPOSITORIES_LIMIT }, config);
+            if (res.data.errors) {
+                throw graphqlError(res.data.errors, res.statusText, REPOS_CONTRIBUTED_TO_ERROR);
+            }
+            const user = res.data.data.user;
+            if (!user) {
+                throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, { code: 'upstream' });
+            }
+            for (const [index, range] of chunk.entries()) {
+                const rangeResponse = user[`range_${index}`];
+                if (!rangeResponse) {
+                    throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, {
+                        code: 'upstream',
+                    });
+                }
+                const lists = [
+                    rangeResponse.commitContributionsByRepository,
+                    rangeResponse.issueContributionsByRepository,
+                    rangeResponse.pullRequestContributionsByRepository,
+                    (rangeResponse.repositoryContributions?.nodes ?? []).filter((node) => node !== null),
+                ];
+                const isSaturated = lists.some((list) => list.length >= MAX_REPOSITORIES_LIMIT);
+                const rangeDays = Math.round((range.to.getTime() - range.from.getTime()) / MS_PER_DAY);
+                // a range of 1 day or less can't be split any further
+                if (isSaturated && rangeDays >= 2) {
+                    // every `from` sits on UTC midnight, so the split lands on a day boundary too
+                    const mid = new Date(range.from.getTime() + Math.floor(rangeDays / 2) * MS_PER_DAY);
+                    // GitHub only reads the date portion,
+                    // so the first half ends 1 second before `mid` to keep the halves from sharing a day
+                    nextPending.push({ from: range.from, to: new Date(mid.getTime() - 1000) }, { from: mid, to: range.to });
+                    continue;
+                }
+                if (isSaturated) {
+                    logger.log(`Range ${range.from.toISOString()} - ${range.to.toISOString()} is saturated but cannot be split further.`);
+                }
+                for (const { repository } of lists.flat()) {
+                    const name = repository.nameWithOwner;
+                    if (includeOwnRepos || !name.startsWith(`${canonicalUsername}/`)) {
+                        repos.add(name);
+                    }
+                }
+            }
+        }
+        // each saturated range pushes both of its halves
+        const saturatedCount = nextPending.length / 2;
+        if (saturatedCount > 0) {
+            logger.log(`found ${saturatedCount} saturated ranges, splitting and retrying...`);
+        }
+        pending = nextPending;
+    }
+    return repos.size;
+};
+/**
+ * Fetch stats for a given username.
+ *
+ * @param props Fetcher props.
+ * @param props.username GitHub username.
+ * @param props.include_all_commits Include all commits.
+ * @param props.exclude_repo Repositories to exclude.
+ * @param props.include_merged_pull_requests Include merged pull requests.
+ * @param props.include_discussions Include discussions.
+ * @param props.include_discussions_answers Include discussions answers.
+ * @param props.commits_year Year to count total commits.
+ * @param props.repo Repositories to scope the REST search to.
+ * @param props.owner Owners to scope the REST search to.
+ * @param props.include_prs_authored Include count of PRs authored.
+ * @param props.include_prs_commented Include count of PRs commented.
+ * @param props.include_prs_reviewed Include count of PRs reviewed.
+ * @param props.include_issues_authored Include count of issues authored.
+ * @param props.include_issues_commented Include count of issues commented.
+ * @param props.ownerAffiliations Owner affiliations. Default: OWNER.
+ * @param props.include_contributions Include all-time contributions.
+ * @param props.include_all_time_contribs Include all-time count of repos contributed to.
+ * @param props.contribs_include_own_repos Include user-owned repos in contributed-to counts.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Stats data.
+ */
+const fetchStats = async ({ username, include_all_commits = false, exclude_repo = [], include_merged_pull_requests = false, include_discussions = false, include_discussions_answers = false, commits_year, repo = [], owner = [], include_prs_authored = false, include_prs_commented = false, include_prs_reviewed = false, include_issues_authored = false, include_issues_commented = false, ownerAffiliations = [], include_contributions = false, include_all_time_contribs = false, contribs_include_own_repos = false, }, config) => {
+    if (!username) {
+        throw CardError.missingParam(['username']);
+    }
+    const stats = {
+        name: '',
+        totalPRs: 0,
+        totalPRsMerged: 0,
+        mergedPRsPercentage: 0,
+        totalReviews: 0,
+        totalCommits: 0,
+        totalIssues: 0,
+        totalStars: 0,
+        totalDiscussionsStarted: 0,
+        totalDiscussionsAnswered: 0,
+        contributedTo: 0,
+        allTimeContributedTo: 0,
+        totalPRsAuthored: 0,
+        totalPRsCommented: 0,
+        totalPRsReviewed: 0,
+        totalIssuesAuthored: 0,
+        totalIssuesCommented: 0,
+        totalContributions: 0,
+        rank: { level: 'C', percentile: 100 },
+    };
+    const affiliations = parseOwnerAffiliations(ownerAffiliations);
+    const res = await statsFetcher({
+        username,
+        includeMergedPullRequests: include_merged_pull_requests,
+        includeDiscussions: include_discussions,
+        includeDiscussionsAnswers: include_discussions_answers,
+        startTime: commits_year === undefined
+            ? undefined
+            : toGitHubDateTime(getGitHubYearRange(commits_year).from),
+        ownerAffiliations: affiliations,
+        includeUserRepositories: contribs_include_own_repos,
+    }, config);
+    // Catch GraphQL errors.
+    if (res.data.errors) {
+        logger.error(res.data.errors);
+        const firstError = res.data.errors[0];
+        if (firstError?.type === 'NOT_FOUND') {
+            throw new CardError(firstError.message || 'Could not fetch user.', {
+                code: 'not_found',
+                secondaryMessage: USER_NOT_FOUND,
+            });
+        }
+        if (firstError?.message) {
+            throw new CardError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? '', {
+                code: 'upstream',
+                secondaryMessage: res.statusText,
+            });
+        }
+        throw new CardError('Something went wrong while trying to retrieve the stats data using the GraphQL API.', { code: 'upstream' });
+    }
+    const user = res.data.data.user;
+    if (!user) {
+        throw new CardError('Could not fetch user.', {
+            code: 'not_found',
+            secondaryMessage: USER_NOT_FOUND,
+        });
+    }
+    stats.name = user.name || user.login;
+    // if include_all_commits, fetch all commits using the REST API.
+    if (include_all_commits) {
+        stats.totalCommits = await totalItemsFetcher({
+            username,
+            repo,
+            owner,
+            type: 'commits',
+            filter: `author:${username}`,
+        }, config);
+    }
+    else {
+        stats.totalCommits = user.commits.totalCommitContributions;
+    }
+    const repoUserStats = await fetchRepoUserStats({
+        username,
+        repo,
+        owner,
+        include_prs_authored,
+        include_prs_commented,
+        include_prs_reviewed,
+        include_issues_authored,
+        include_issues_commented,
+    }, config);
+    Object.assign(stats, repoUserStats);
+    stats.totalPRs = user.pullRequests.totalCount;
+    if (include_merged_pull_requests) {
+        const mergedCount = user.mergedPullRequests?.totalCount ?? 0;
+        stats.totalPRsMerged = mergedCount;
+        stats.mergedPRsPercentage = (mergedCount / user.pullRequests.totalCount) * 100 || 0;
+    }
+    stats.totalReviews = user.reviews.totalPullRequestReviewContributions;
+    stats.totalIssues = user.openIssues.totalCount + user.closedIssues.totalCount;
+    if (include_discussions) {
+        stats.totalDiscussionsStarted = user.repositoryDiscussions?.totalCount ?? 0;
+    }
+    if (include_discussions_answers) {
+        stats.totalDiscussionsAnswered = user.repositoryDiscussionComments?.totalCount ?? 0;
+    }
+    stats.contributedTo = user.repositoriesContributedTo.totalCount;
+    if (include_contributions) {
+        stats.totalContributions = await fetchTotalContributions(username, user.contributionsCollection.contributionYears, config);
+    }
+    if (include_all_time_contribs) {
+        stats.allTimeContributedTo = await fetchAllTimeReposContributedTo(user.login, user.contributionsCollection.contributionYears, contribs_include_own_repos, config);
+    }
+    // Retrieve stars while filtering out repositories to be hidden.
+    const allExcludedRepos = [...exclude_repo, ...config.excludeRepositories];
+    const repoToHide = new Set(allExcludedRepos);
+    stats.totalStars = (user.repositories.nodes ?? [])
+        .filter((data) => !!data && !repoToHide.has(data.name))
+        .reduce((prev, curr) => prev + (curr?.stargazerCount ?? 0), 0);
+    stats.rank = calculateRank({
+        all_commits: include_all_commits,
+        commits: stats.totalCommits,
+        prs: stats.totalPRs,
+        reviews: stats.totalReviews,
+        issues: stats.totalIssues,
+        repos: user.repositories.totalCount,
+        stars: stats.totalStars,
+        followers: user.followers.totalCount,
+    });
+    return stats;
+};
+export { fetchStats, fetchRepoUserStats };

package/build/fetchers/top-languages.d.ts

@@ -0,0 +1,23 @@
+import type { CardConfig } from '../common/config.js';
+import type { TopLangData } from './types.js';
+/**
+ * Fetch top languages for a given username.
+ *
+ * @param props Fetcher props.
+ * @param props.username GitHub username.
+ * @param props.exclude_repo List of repositories to exclude. Default: [].
+ * @param props.size_weight Weightage to be given to size.
+ * @param props.count_weight Weightage to be given to count.
+ * @param props.ownerAffiliations The owner affiliations to filter by. Default: OWNER.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Top languages data.
+ */
+declare const fetchTopLanguages: ({ username, exclude_repo, size_weight, count_weight, ownerAffiliations, }: {
+    username: string | undefined;
+    exclude_repo?: Array<string>;
+    size_weight?: number | undefined;
+    count_weight?: number | undefined;
+    ownerAffiliations?: Array<string>;
+}, config: CardConfig) => Promise<TopLangData>;
+export { fetchTopLanguages };
+//# sourceMappingURL=top-languages.d.ts.map

package/build/fetchers/top-languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"top-languages.d.ts","sourceRoot":"","sources":["../../src/fetchers/top-languages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAatD,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,YAAY,CAAC;AAIpD;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB,GACrB,2EAMG;IACD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC,EACD,QAAQ,UAAU,KACjB,OAAO,CAAC,WAAW,CAuFrB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/build/fetchers/top-languages.js

@@ -0,0 +1,89 @@
+import { CardError, USER_NOT_FOUND } from '../common/error.js';
+import { wrapTextMultiline } from '../common/fmt.js';
+import { createGraphQLFetcher } from '../common/http.js';
+import { logger } from '../common/log.js';
+import { parseOwnerAffiliations } from '../common/ops.js';
+import { retryer } from '../common/retryer.js';
+import { TopLanguagesDocument } from '../graphql/generated/top-languages.js';
+const fetcher = createGraphQLFetcher(TopLanguagesDocument, 'token');
+/**
+ * Fetch top languages for a given username.
+ *
+ * @param props Fetcher props.
+ * @param props.username GitHub username.
+ * @param props.exclude_repo List of repositories to exclude. Default: [].
+ * @param props.size_weight Weightage to be given to size.
+ * @param props.count_weight Weightage to be given to count.
+ * @param props.ownerAffiliations The owner affiliations to filter by. Default: OWNER.
+ * @param config Deployment config supplying the PAT pool.
+ * @returns Top languages data.
+ */
+const fetchTopLanguages = async ({ username, exclude_repo = [], size_weight = 1, count_weight = 0, ownerAffiliations = [], }, config) => {
+    if (!username) {
+        throw CardError.missingParam(['username']);
+    }
+    const affiliations = parseOwnerAffiliations(ownerAffiliations);
+    const res = await retryer(fetcher, {
+        login: username,
+        ownerAffiliations: affiliations,
+    }, config);
+    if (res.data.errors) {
+        logger.error(res.data.errors);
+        const firstError = res.data.errors[0];
+        if (firstError?.type === 'NOT_FOUND') {
+            throw new CardError(firstError.message || 'Could not fetch user.', {
+                code: 'not_found',
+                secondaryMessage: USER_NOT_FOUND,
+            });
+        }
+        if (firstError?.message) {
+            throw new CardError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? '', {
+                code: 'upstream',
+                secondaryMessage: res.statusText,
+            });
+        }
+        throw new CardError('Something went wrong while trying to retrieve the language data using the GraphQL API.', { code: 'upstream' });
+    }
+    const repoToHide = {};
+    const allExcludedRepos = [...exclude_repo, ...config.excludeRepositories];
+    // populate repoToHide map for quick lookup while filtering out
+    allExcludedRepos.forEach((repoName) => {
+        repoToHide[repoName] = true;
+    });
+    // filter out repositories to be hidden
+    const repoNodes = (res.data.data.user?.repositories.nodes ?? []).filter((node) => !!node && !repoToHide[node.name]);
+    // flatten edges across repos. Order matters: `concat(acc)` prepends, and the
+    // shared repoCount below depends on visitation order.
+    const languageEdges = repoNodes.reduce((acc, repo) => {
+        const edges = (repo.languages?.edges ?? []).filter((edge) => !!edge);
+        return edges.length > 0 ? edges.concat(acc) : acc;
+    }, []);
+    // accumulate size and repo count per language
+    const languageMap = {};
+    let repoCount = 0;
+    for (const edge of languageEdges) {
+        const existing = languageMap[edge.node.name];
+        // same language seen again: add to its size and bump count; else reset to 1
+        let langSize = edge.size;
+        if (existing && edge.node.name === existing.name) {
+            langSize = edge.size + existing.size;
+            repoCount += 1;
+        }
+        else {
+            repoCount = 1;
+        }
+        languageMap[edge.node.name] = {
+            name: edge.node.name,
+            color: edge.node.color,
+            size: langSize,
+            count: repoCount,
+        };
+    }
+    // comparison index calculation
+    for (const lang of Object.values(languageMap)) {
+        lang.size = Math.pow(lang.size, size_weight) * Math.pow(lang.count, count_weight);
+    }
+    // return languages sorted by (weighted) size, descending
+    return Object.fromEntries(Object.entries(languageMap).sort(([, a], [, b]) => b.size - a.size));
+};
+export { fetchTopLanguages };