@stoked-ui/github 0.0.0-a.0 → 0.1.0-alpha.11.1

package/apiHandlers/createGithubEventsHandler.js

@@ -0,0 +1,50 @@
+import githubEventsQuery from './getGithubEvents';
+function getQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function parseNumber(value, fallback) {
+  const parsed = Number(getQueryValue(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export default function createGithubEventsHandler(config = {}) {
+  return async function handler(req, res) {
+    if (req.method !== 'GET') {
+      var _res$setHeader;
+      (_res$setHeader = res.setHeader) == null || _res$setHeader.call(res, 'Allow', 'GET');
+      return res.status(405).json({
+        message: 'Method not allowed'
+      });
+    }
+    const githubUser = getQueryValue(req.query.username);
+    if (!githubUser) {
+      return res.status(400).json({
+        message: 'username is required'
+      });
+    }
+    const query = {
+      page: parseNumber(req.query.page, 1),
+      per_page: parseNumber(req.query.per_page, 40),
+      repo: getQueryValue(req.query.repo) || undefined,
+      action: getQueryValue(req.query.action) || undefined,
+      date: getQueryValue(req.query.date) || undefined,
+      description: getQueryValue(req.query.description) || undefined
+    };
+    try {
+      var _config$getGithubToke, _res$setHeader2;
+      const githubToken = ((_config$getGithubToke = config.getGithubToken) == null ? void 0 : _config$getGithubToke.call(config, req)) || process.env.GITHUB_TOKEN;
+      const data = await githubEventsQuery({
+        query,
+        githubUser,
+        githubToken
+      });
+      (_res$setHeader2 = res.setHeader) == null || _res$setHeader2.call(res, 'Cache-Control', 's-maxage=300, stale-while-revalidate=3600');
+      return res.status(200).json(data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes('username is required') ? 400 : 502;
+      return res.status(status).json({
+        message
+      });
+    }
+  };
+}

package/apiHandlers/getBranchCompareDetails.d.ts

@@ -0,0 +1,9 @@
+import { GithubBranchData } from '../types/github';
+type GetBranchCompareDetailsParams = {
+    owner: string;
+    repo: string;
+    base: string;
+    head: string;
+};
+export default function getBranchCompareDetails(params: GetBranchCompareDetailsParams): Promise<GithubBranchData>;
+export {};

package/apiHandlers/getBranchCompareDetails.js

@@ -0,0 +1,29 @@
+import { buildGithubContributors, fetchGithubResource, normalizeGithubCommit, normalizeGithubFile, summarizeGithubStats } from './githubApi';
+export default async function getBranchCompareDetails(params) {
+  const {
+    owner,
+    repo,
+    base,
+    head
+  } = params;
+  if (!owner || !repo || !base || !head) {
+    throw new Error('Missing required parameters: owner, repo, base, head');
+  }
+  const compare = await fetchGithubResource(`/repos/${owner}/${repo}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`);
+  const commits = (compare.commits || []).map(commit => normalizeGithubCommit(commit));
+  const files = (compare.files || []).map(file => normalizeGithubFile(file));
+  return {
+    repo: `${owner}/${repo}`,
+    baseRef: base,
+    headRef: head,
+    status: compare.status || 'unknown',
+    aheadBy: compare.ahead_by || 0,
+    behindBy: compare.behind_by || 0,
+    totalCommits: compare.total_commits || commits.length,
+    url: compare.html_url || `https://github.com/${owner}/${repo}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`,
+    contributors: buildGithubContributors(compare.commits || []),
+    commits,
+    files,
+    stats: summarizeGithubStats(files)
+  };
+}

package/apiHandlers/getCommitDetails.d.ts

@@ -0,0 +1,8 @@
+import { GithubCommitData } from '../types/github';
+type GetCommitDetailsParams = {
+    owner: string;
+    repo: string;
+    ref: string;
+};
+export default function getCommitDetails(params: GetCommitDetailsParams): Promise<GithubCommitData>;
+export {};

package/apiHandlers/getCommitDetails.js

@@ -0,0 +1,34 @@
+import { buildGithubContributors, fetchGithubResource, getGithubMessageSummary, getGithubShortRef, normalizeGithubCommit, normalizeGithubFile, summarizeGithubStats } from './githubApi';
+export default async function getCommitDetails(params) {
+  var _commit$commit, _commit$commit2, _commit$commit3, _commit$commit4;
+  const {
+    owner,
+    repo,
+    ref
+  } = params;
+  if (!owner || !repo || !ref) {
+    throw new Error('Missing required parameters: owner, repo, ref');
+  }
+  const commit = await fetchGithubResource(`/repos/${owner}/${repo}/commits/${encodeURIComponent(ref)}`);
+  const files = (commit.files || []).map(file => normalizeGithubFile(file));
+  const commits = [normalizeGithubCommit(commit)];
+  const contributor = buildGithubContributors([commit])[0] || {
+    login: commits[0].author.login,
+    name: commits[0].author.name,
+    avatarUrl: commits[0].author.avatar,
+    contributions: 1
+  };
+  return {
+    repo: `${owner}/${repo}`,
+    ref: commit.sha || ref,
+    shortRef: getGithubShortRef(commit.sha || ref),
+    url: commit.html_url || `https://github.com/${owner}/${repo}/commit/${encodeURIComponent(commit.sha || ref)}`,
+    summary: getGithubMessageSummary(((_commit$commit = commit.commit) == null ? void 0 : _commit$commit.message) || ''),
+    message: ((_commit$commit2 = commit.commit) == null ? void 0 : _commit$commit2.message) || '',
+    committedAt: ((_commit$commit3 = commit.commit) == null || (_commit$commit3 = _commit$commit3.author) == null ? void 0 : _commit$commit3.date) || ((_commit$commit4 = commit.commit) == null || (_commit$commit4 = _commit$commit4.committer) == null ? void 0 : _commit$commit4.date) || '',
+    contributor,
+    commits,
+    files,
+    stats: summarizeGithubStats(files)
+  };
+}

package/apiHandlers/getGithubContributions.d.ts

@@ -0,0 +1,8 @@
+import { GithubContributionsResponse } from '../types/github';
+export interface GetGithubContributionsParams {
+    githubUser: string;
+    githubToken?: string;
+    from?: string;
+    to?: string;
+}
+export default function getGithubContributions({ githubUser, githubToken, from, to, }: GetGithubContributionsParams): Promise<GithubContributionsResponse>;

package/apiHandlers/getGithubContributions.js

@@ -0,0 +1,126 @@
+const CONTRIBUTION_LEVEL_MAP = {
+  NONE: 0,
+  FIRST_QUARTILE: 1,
+  SECOND_QUARTILE: 2,
+  THIRD_QUARTILE: 3,
+  FOURTH_QUARTILE: 4
+};
+const GITHUB_CONTRIBUTIONS_QUERY = `
+  query GithubContributions($login: String!, $from: DateTime!, $to: DateTime!) {
+    user(login: $login) {
+      contributionsCollection(from: $from, to: $to) {
+        contributionCalendar {
+          totalContributions
+          weeks {
+            contributionDays {
+              date
+              contributionCount
+              contributionLevel
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+function isValidDateInput(value) {
+  if (!value) {
+    return false;
+  }
+  return !Number.isNaN(new Date(value).getTime());
+}
+function toDateRange(from, to) {
+  const rangeEnd = isValidDateInput(to) ? new Date(to) : new Date();
+  const rangeStart = isValidDateInput(from) ? new Date(from) : new Date(rangeEnd);
+  if (!isValidDateInput(from)) {
+    rangeStart.setFullYear(rangeEnd.getFullYear() - 1);
+  }
+  if (rangeStart > rangeEnd) {
+    throw new Error('Invalid contribution range: "from" must be before "to".');
+  }
+  return {
+    from: rangeStart,
+    to: rangeEnd
+  };
+}
+function buildContributionTotals(contributions) {
+  return contributions.reduce((acc, contribution) => {
+    const year = contribution.date.slice(0, 4);
+    acc[year] = (acc[year] || 0) + contribution.count;
+    return acc;
+  }, {});
+}
+function buildCountLabel(total, from, to) {
+  const fromYear = from.getFullYear();
+  const toYear = to.getFullYear();
+  if (fromYear === toYear) {
+    return `${total} contributions in ${fromYear}`;
+  }
+  return `${total} contributions from ${fromYear} to ${toYear}`;
+}
+export default async function getGithubContributions({
+  githubUser,
+  githubToken = process.env.GITHUB_TOKEN,
+  from,
+  to
+}) {
+  var _payload$errors2, _payload$data;
+  if (!githubUser) {
+    throw new Error('Missing required parameter: githubUser');
+  }
+  if (!githubToken) {
+    throw new Error('GitHub token not configured');
+  }
+  const range = toDateRange(from, to);
+  const response = await fetch('https://api.github.com/graphql', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'User-Agent': 'stoked-ui-github-calendar',
+      Authorization: `Bearer ${githubToken}`
+    },
+    body: JSON.stringify({
+      query: GITHUB_CONTRIBUTIONS_QUERY,
+      variables: {
+        login: githubUser,
+        from: range.from.toISOString(),
+        to: range.to.toISOString()
+      }
+    })
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    var _payload$errors;
+    const message = (payload == null ? void 0 : payload.message) || (payload == null || (_payload$errors = payload.errors) == null || (_payload$errors = _payload$errors[0]) == null ? void 0 : _payload$errors.message) || `GitHub GraphQL error: ${response.status}`;
+    throw new Error(message);
+  }
+  if (payload != null && (_payload$errors2 = payload.errors) != null && _payload$errors2.length) {
+    throw new Error(payload.errors.map(error => error.message || 'Unknown GitHub GraphQL error').join('; '));
+  }
+  const calendar = payload == null || (_payload$data = payload.data) == null || (_payload$data = _payload$data.user) == null || (_payload$data = _payload$data.contributionsCollection) == null ? void 0 : _payload$data.contributionCalendar;
+  if (!calendar) {
+    throw new Error(`No contribution calendar returned for "${githubUser}".`);
+  }
+  const contributions = (calendar.weeks || []).flatMap(week => week.contributionDays || []).map(day => {
+    var _CONTRIBUTION_LEVEL_M;
+    return {
+      date: day.date,
+      count: day.contributionCount,
+      level: (_CONTRIBUTION_LEVEL_M = CONTRIBUTION_LEVEL_MAP[day.contributionLevel]) != null ? _CONTRIBUTION_LEVEL_M : 0
+    };
+  }).sort((a, b) => {
+    if (a.date < b.date) {
+      return -1;
+    }
+    if (a.date > b.date) {
+      return 1;
+    }
+    return 0;
+  });
+  const total = buildContributionTotals(contributions);
+  return {
+    total,
+    contributions,
+    countLabel: buildCountLabel(calendar.totalContributions || 0, range.from, range.to)
+  };
+}

package/apiHandlers/getGithubEvents.d.ts

@@ -0,0 +1,25 @@
+import { GitHubEvent } from '../types/github';
+export type EventsQuery = {
+    page?: number;
+    per_page?: number;
+    repo?: string;
+    action?: string;
+    date?: string;
+    description?: string;
+};
+export declare function githubEventsQuery({ query, githubUser, githubToken }: {
+    query: EventsQuery;
+    githubUser: string;
+    githubToken?: string;
+}): Promise<{
+    events: GitHubEvent[];
+    total: number;
+    repositories: string[];
+    actionTypes: string[];
+    page: number;
+    per_page: number;
+    total_pages: number;
+    total_fetched_events: number;
+    max_pages_fetched: number;
+}>;
+export default githubEventsQuery;

package/apiHandlers/getGithubEvents.js

@@ -0,0 +1,142 @@
+function parseLinkHeader(header) {
+  if (!header) return {};
+  return header.split(',').reduce((links, part) => {
+    const match = part.match(/<(.+)>;\s*rel="([\w]+)"/);
+    if (match) {
+      const [, url, rel] = match;
+      if (rel === 'next' || rel === 'last') {
+        links[rel] = url;
+      }
+    }
+    return links;
+  }, {});
+}
+export async function githubEventsQuery({
+  query,
+  githubUser,
+  githubToken
+}) {
+  try {
+    const {
+      page = query.page || 1,
+      per_page = query.per_page || 100,
+      repo,
+      action,
+      date,
+      description
+    } = query;
+    const pageNum = Number(page);
+    const perPage = Number(per_page);
+    console.log(`Fetching events for user: ${githubUser}, page: ${pageNum}, per_page: ${perPage}`);
+    let allEvents = [];
+    let hasMore = true;
+    let githubPage = 1;
+    const maxPages = 30;
+    const fetchPerPage = 100;
+    while (hasMore && githubPage <= maxPages) {
+      console.log(`Fetching page ${githubPage}...`);
+      const fetchOptions = {
+        headers: {
+          'User-Agent': 'brianstoker.com-website'
+        }
+      };
+      if (githubToken) {
+        fetchOptions.headers.Authorization = `token ${githubToken}`;
+      }
+      const queryParams = new URLSearchParams({
+        page: String(githubPage),
+        per_page: String(fetchPerPage)
+      });
+      const response = await fetch(`https://api.github.com/users/${githubUser}/events?${queryParams}`, fetchOptions);
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`GitHub API error: ${response.status}`, errorText);
+        throw new Error(`GitHub API error: ${response.status} - ${errorText}`);
+      }
+      const data = await response.json();
+      console.log(`Page ${githubPage}: Received ${data.length} events`);
+      if (data.length === 0) {
+        hasMore = false;
+      } else {
+        allEvents = [...allEvents, ...data];
+        console.log(`Total events so far: ${allEvents.length}`);
+        const linkHeader = response.headers.get('Link');
+        const links = parseLinkHeader(linkHeader);
+        hasMore = !!links.next;
+        githubPage++;
+      }
+    }
+    allEvents = Array.from(new Map(allEvents.map(event => [event.id, event])).values());
+    console.log(`Final total events: ${allEvents.length}`);
+    let filteredEvents = allEvents;
+    if (repo) {
+      filteredEvents = filteredEvents.filter(event => event.repo.name === repo);
+    }
+    if (action) {
+      filteredEvents = filteredEvents.filter(event => event.type.replace('Event', '') === action);
+    }
+    if (date) {
+      const now = new Date();
+      let cutoffDate;
+      switch (date) {
+        case 'today':
+          cutoffDate = new Date(now.setHours(0, 0, 0, 0));
+          break;
+        case 'yesterday':
+          cutoffDate = new Date(now);
+          cutoffDate.setDate(cutoffDate.getDate() - 1);
+          cutoffDate.setHours(0, 0, 0, 0);
+          break;
+        case 'week':
+          cutoffDate = new Date(now);
+          cutoffDate.setDate(cutoffDate.getDate() - 7);
+          cutoffDate.setHours(0, 0, 0, 0);
+          break;
+        case 'month':
+          cutoffDate = new Date(now);
+          cutoffDate.setMonth(cutoffDate.getMonth() - 1);
+          cutoffDate.setHours(0, 0, 0, 0);
+          break;
+        default:
+          cutoffDate = new Date(0);
+      }
+      filteredEvents = filteredEvents.filter(event => new Date(event.created_at) >= cutoffDate);
+    }
+    if (description) {
+      filteredEvents = filteredEvents.filter(event => {
+        var _event$payload$commit, _event$payload$pull_r, _event$payload$issue, _event$payload$issue2;
+        let eventDescription = '';
+        if (event.type === 'PushEvent' && (_event$payload$commit = event.payload.commits) != null && _event$payload$commit.length) {
+          eventDescription = `Pushed ${event.payload.commits.length} commits`;
+        } else if (event.type === 'PullRequestEvent' && (_event$payload$pull_r = event.payload.pull_request) != null && _event$payload$pull_r.title) {
+          eventDescription = event.payload.pull_request.title;
+        } else if (event.type === 'IssuesEvent' && (_event$payload$issue = event.payload.issue) != null && _event$payload$issue.title) {
+          eventDescription = event.payload.issue.title;
+        } else if (event.type === 'IssueCommentEvent' && (_event$payload$issue2 = event.payload.issue) != null && _event$payload$issue2.title) {
+          eventDescription = `Commented on issue: ${event.payload.issue.title}`;
+        }
+        return eventDescription.toLowerCase().includes(description.toLowerCase());
+      });
+    }
+    const startIndex = (pageNum - 1) * perPage;
+    const endIndex = startIndex + perPage;
+    const paginatedEvents = filteredEvents.slice(startIndex, endIndex);
+    const repositories = Array.from(new Set(allEvents.map(event => event.repo.name))).sort();
+    const actionTypes = Array.from(new Set(allEvents.map(event => event.type.replace('Event', '')))).sort();
+    return {
+      events: paginatedEvents,
+      total: filteredEvents.length,
+      repositories,
+      actionTypes,
+      page: pageNum,
+      per_page: perPage,
+      total_pages: Math.ceil(filteredEvents.length / perPage),
+      total_fetched_events: allEvents.length,
+      max_pages_fetched: githubPage - 1
+    };
+  } catch (error) {
+    console.error('Error fetching GitHub events:', error);
+    throw new Error(`${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+export default githubEventsQuery;

package/apiHandlers/getPullRequestDetails.js

@@ -37,7 +37,7 @@ export default async function getPullRequestDetails(params) {
     if (githubToken) {
       headers.Authorization = `token ${githubToken}`;
     }
-    async function fetchWithRateLimit(url) {
+    const fetchWithRateLimit = async url => {
       const response = await fetch(url, {
         headers
       });
@@ -59,7 +59,7 @@ export default async function getPullRequestDetails(params) {
         data: await response.json(),
         rateLimit
       };
-    }
+    };
 
     // Fetch basic PR information
     const {

package/apiHandlers/githubApi.d.ts

@@ -0,0 +1,17 @@
+import { GithubChangedFile, GithubCommitListItem, GithubCommitStats, GithubContributor, GithubDiffLine } from '../types/github';
+export declare function fetchGithubResource<T>(path: string): Promise<T>;
+export declare function parseGithubDiff(patch: string | undefined, maxLines?: number): GithubDiffLine[];
+export declare function normalizeGithubFile(file: {
+    filename?: string;
+    path?: string;
+    status?: string;
+    additions?: number;
+    deletions?: number;
+    patch?: string;
+    diff?: GithubDiffLine[];
+}, maxDiffLines?: number): GithubChangedFile;
+export declare function normalizeGithubCommit(commit: any): GithubCommitListItem;
+export declare function buildGithubContributors(commits: any[]): GithubContributor[];
+export declare function summarizeGithubStats(files: GithubChangedFile[]): GithubCommitStats;
+export declare function getGithubMessageSummary(message: string): string;
+export declare function getGithubShortRef(ref: string, length?: number): string;

package/apiHandlers/githubApi.js

@@ -0,0 +1,155 @@
+const GITHUB_API_BASE_URL = 'https://api.github.com';
+const DEFAULT_DIFF_LINE_LIMIT = 24;
+function getGithubHeaders() {
+  const githubToken = process.env.GITHUB_TOKEN;
+  const headers = {
+    'User-Agent': 'stoked-ui-github-components',
+    Accept: 'application/vnd.github+json'
+  };
+  if (githubToken) {
+    headers.Authorization = `token ${githubToken}`;
+  }
+  return headers;
+}
+export async function fetchGithubResource(path) {
+  const response = await fetch(`${GITHUB_API_BASE_URL}${path}`, {
+    headers: getGithubHeaders()
+  });
+  const rateLimit = {
+    remaining: response.headers.get('x-ratelimit-remaining'),
+    reset: response.headers.get('x-ratelimit-reset')
+  };
+  if (!response.ok) {
+    const body = await response.text();
+    if (response.status === 403 && rateLimit.remaining === '0') {
+      const resetDate = rateLimit.reset ? new Date(Number(rateLimit.reset) * 1000).toLocaleString() : 'later';
+      throw new Error(`GitHub rate limit exceeded. Resets at ${resetDate}.`);
+    }
+    throw new Error(body || `GitHub API error: ${response.status}`);
+  }
+  return response.json();
+}
+export function parseGithubDiff(patch, maxLines = DEFAULT_DIFF_LINE_LIMIT) {
+  if (!patch) {
+    return [];
+  }
+  const patchLines = patch.split('\n');
+  const visibleLines = patchLines.slice(0, maxLines);
+  const diffLines = visibleLines.map((line, index) => {
+    let type = 'context';
+    if (line.startsWith('+')) {
+      type = 'addition';
+    } else if (line.startsWith('-')) {
+      type = 'deletion';
+    }
+    return {
+      type,
+      content: line,
+      lineNumber: index + 1
+    };
+  });
+  if (patchLines.length > maxLines) {
+    diffLines.push({
+      type: 'context',
+      content: `... ${patchLines.length - maxLines} more diff lines`,
+      lineNumber: diffLines.length + 1
+    });
+  }
+  return diffLines;
+}
+function toFileChangeType(status) {
+  switch (status) {
+    case 'added':
+      return 'added';
+    case 'removed':
+      return 'deleted';
+    default:
+      return 'modified';
+  }
+}
+export function normalizeGithubFile(file, maxDiffLines = DEFAULT_DIFF_LINE_LIMIT) {
+  return {
+    path: file.filename || file.path || 'unknown',
+    type: toFileChangeType(file.status),
+    additions: file.additions || 0,
+    deletions: file.deletions || 0,
+    diff: file.diff || parseGithubDiff(file.patch, maxDiffLines)
+  };
+}
+function getGithubIdentity(commit) {
+  var _commit$commit, _commit$commit2;
+  const apiAuthor = commit.author || commit.committer || {};
+  const commitAuthor = ((_commit$commit = commit.commit) == null ? void 0 : _commit$commit.author) || ((_commit$commit2 = commit.commit) == null ? void 0 : _commit$commit2.committer) || {};
+  return {
+    login: apiAuthor.login || commitAuthor.name || commitAuthor.email || commit.sha || 'unknown',
+    name: commitAuthor.name || apiAuthor.login || commitAuthor.email || 'Unknown author',
+    avatarUrl: apiAuthor.avatar_url || ''
+  };
+}
+export function normalizeGithubCommit(commit) {
+  var _commit$commit3, _commit$commit4, _commit$commit5;
+  const identity = getGithubIdentity(commit);
+  return {
+    id: commit.sha || commit.node_id || identity.login,
+    message: ((_commit$commit3 = commit.commit) == null ? void 0 : _commit$commit3.message) || '',
+    author: {
+      name: identity.name,
+      login: identity.login,
+      avatar: identity.avatarUrl
+    },
+    date: ((_commit$commit4 = commit.commit) == null || (_commit$commit4 = _commit$commit4.author) == null ? void 0 : _commit$commit4.date) || ((_commit$commit5 = commit.commit) == null || (_commit$commit5 = _commit$commit5.committer) == null ? void 0 : _commit$commit5.date) || '',
+    hash: commit.sha || '',
+    url: commit.html_url || ''
+  };
+}
+export function buildGithubContributors(commits) {
+  const contributors = new Map();
+  commits.forEach(commit => {
+    const identity = getGithubIdentity(commit);
+    const key = identity.login || identity.name;
+    const current = contributors.get(key);
+    if (current) {
+      current.contributions += 1;
+      if (!current.avatarUrl && identity.avatarUrl) {
+        current.avatarUrl = identity.avatarUrl;
+      }
+      if (current.name === 'Unknown author' && identity.name) {
+        current.name = identity.name;
+      }
+      return;
+    }
+    contributors.set(key, {
+      login: identity.login,
+      name: identity.name,
+      avatarUrl: identity.avatarUrl,
+      contributions: 1
+    });
+  });
+  return Array.from(contributors.values()).sort((a, b) => {
+    if (b.contributions !== a.contributions) {
+      return b.contributions - a.contributions;
+    }
+    return a.login.localeCompare(b.login);
+  });
+}
+export function summarizeGithubStats(files) {
+  return files.reduce((stats, file) => ({
+    additions: stats.additions + file.additions,
+    deletions: stats.deletions + file.deletions,
+    changedFiles: stats.changedFiles + 1
+  }), {
+    additions: 0,
+    deletions: 0,
+    changedFiles: 0
+  });
+}
+export function getGithubMessageSummary(message) {
+  var _message$split$;
+  return ((_message$split$ = message.split('\n')[0]) == null ? void 0 : _message$split$.trim()) || 'Untitled commit';
+}
+export function getGithubShortRef(ref, length = 7) {
+  if (!ref) {
+    return '';
+  }
+  return ref.length > length ? ref.slice(0, length) : ref;
+}

package/apiHandlers/index.d.ts

@@ -1 +1,10 @@
+export { default as createGithubBranchHandler } from './createGithubBranchHandler';
+export { default as createGithubCommitHandler } from './createGithubCommitHandler';
+export { default as getBranchCompareDetails } from './getBranchCompareDetails';
+export { default as getCommitDetails } from './getCommitDetails';
 export { default as getPullRequestDetails } from './getPullRequestDetails';
+export { default as getGithubContributions } from './getGithubContributions';
+export { default as createGithubContributionsHandler } from './createGithubContributionsHandler';
+export { default as getGithubEvents, githubEventsQuery } from './getGithubEvents';
+export type { EventsQuery } from './getGithubEvents';
+export { default as createGithubEventsHandler } from './createGithubEventsHandler';

package/apiHandlers/index.js

@@ -1 +1,9 @@
-export { default as getPullRequestDetails } from './getPullRequestDetails';
+export { default as createGithubBranchHandler } from './createGithubBranchHandler';
+export { default as createGithubCommitHandler } from './createGithubCommitHandler';
+export { default as getBranchCompareDetails } from './getBranchCompareDetails';
+export { default as getCommitDetails } from './getCommitDetails';
+export { default as getPullRequestDetails } from './getPullRequestDetails';
+export { default as getGithubContributions } from './getGithubContributions';
+export { default as createGithubContributionsHandler } from './createGithubContributionsHandler';
+export { default as getGithubEvents, githubEventsQuery } from './getGithubEvents';
+export { default as createGithubEventsHandler } from './createGithubEventsHandler';

package/components/GithubContributorsList.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { GithubContributor } from '../types/github';
+interface GithubContributorsListProps {
+    contributors: GithubContributor[];
+    title: string;
+}
+export default function GithubContributorsList({ contributors, title, }: GithubContributorsListProps): React.JSX.Element | null;
+export {};