@dxos/plugin-github 0.7.4 → 0.14.0

package/src/containers/PullRequestsArticle/arrange.ts

@@ -0,0 +1,245 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Filter } from '@dxos/echo';
+import { matchesFilter } from '@dxos/echo-query';
+import { PullRequest, type Task } from '@dxos/types';
+
+import { type GitHubOperation } from '#types';
+
+import type * as PullRequestsView from '../../types/PullRequestsView.ts';
+
+/** The live part of a pull request's standing, read from GitHub rather than stored. */
+export type PullRequestChecks = {
+  ci: GitHubOperation.CiState;
+  checks: GitHubOperation.CheckCounts;
+  review: GitHubOperation.ReviewState;
+  approvals: number;
+};
+
+/** One row of the list: the stored pull request, its live checks once they arrive, and the tasks that list it. */
+export type PullRequestRow = {
+  pullRequest: PullRequest.PullRequest;
+  checks?: PullRequestChecks;
+  tasks: readonly Task.Task[];
+};
+
+export type PullRequestRowGroup = {
+  id: string;
+  /** A literal (a repository, an author) or a translation key in the plugin's namespace. */
+  label: string;
+  translate?: boolean;
+  icon: string;
+  hue?: string;
+  rows: readonly PullRequestRow[];
+};
+
+/** What a free-text term searches: what a reader sees in the row. */
+const rowText = (pullRequest: PullRequest.PullRequest) => [
+  pullRequest.title,
+  PullRequest.reference(pullRequest),
+  pullRequest.author,
+  pullRequest.headBranch,
+];
+
+/** The rows the toolbar's query keeps, in input order; an absent filter keeps every row. */
+export const filterRows = (rows: readonly PullRequestRow[], filter?: Filter.Any): readonly PullRequestRow[] =>
+  filter ? rows.filter(({ pullRequest }) => matchesFilter(filter, pullRequest, { text: rowText })) : rows;
+
+const STATE_WEIGHT: Record<PullRequest.State, number> = { open: 1_000, draft: 600, merged: 100, closed: 0 };
+
+/**
+ * How much a row asks of the reader now: an open pull request outranks a draft, which outranks a
+ * finished one; within those, red CI or requested changes (something to fix) outrank one ready to
+ * merge, which outranks one still waiting; and a pull request some task tracks is nudged up.
+ */
+export const relevance = ({ pullRequest, checks, tasks }: PullRequestRow): number => {
+  let score = STATE_WEIGHT[pullRequest.state];
+  if (pullRequest.state === 'open' || pullRequest.state === 'draft') {
+    if (checks?.ci === 'failure') {
+      score += 300;
+    }
+    if (checks?.review === 'changes_requested') {
+      score += 250;
+    }
+    if (checks?.review === 'approved' && checks.ci !== 'failure' && checks.ci !== 'pending') {
+      score += 200;
+    }
+    if (checks?.ci === 'pending') {
+      score += 50;
+    }
+  }
+  if (tasks.length > 0) {
+    score += 25;
+  }
+  return score;
+};
+
+const time = (value: string | undefined): number => {
+  const parsed = value ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+
+/** Newest activity GitHub reported, falling back to when it was opened. */
+const activity = (pullRequest: PullRequest.PullRequest): number =>
+  time(pullRequest.updatedAt) || time(pullRequest.createdAt);
+
+const byRecency = (left: PullRequestRow, right: PullRequestRow): number =>
+  activity(left.pullRequest) - activity(right.pullRequest) || left.pullRequest.number - right.pullRequest.number;
+
+const compareBy: Record<PullRequestsView.SortField, (left: PullRequestRow, right: PullRequestRow) => number> = {
+  // Ties broken by recency, so equally urgent rows read newest first under the default (descending) order.
+  relevance: (left, right) => relevance(left) - relevance(right) || byRecency(left, right),
+  updated: byRecency,
+  created: (left, right) =>
+    time(left.pullRequest.createdAt) - time(right.pullRequest.createdAt) ||
+    left.pullRequest.number - right.pullRequest.number,
+  number: (left, right) => left.pullRequest.number - right.pullRequest.number,
+  title: (left, right) =>
+    (left.pullRequest.title ?? '').localeCompare(right.pullRequest.title ?? '', undefined, { sensitivity: 'base' }),
+};
+
+/** The rows reordered by `sort`, ties kept in input order. */
+export const sortRows = (rows: readonly PullRequestRow[], sort: PullRequestsView.Sort): readonly PullRequestRow[] => {
+  const compare = compareBy[sort.field];
+  const sign = sort.direction === 'desc' ? -1 : 1;
+  const index = new Map(rows.map((row, position) => [row.pullRequest.id, position]));
+  return [...rows].sort(
+    (left, right) =>
+      sign * compare(left, right) || (index.get(left.pullRequest.id) ?? 0) - (index.get(right.pullRequest.id) ?? 0),
+  );
+};
+
+const STATE_ORDER: readonly PullRequest.State[] = ['open', 'draft', 'merged', 'closed'];
+const STATE_ICON: Record<PullRequest.State, string> = {
+  open: 'ph--git-pull-request--regular',
+  draft: 'ph--git-pull-request--regular',
+  merged: 'ph--git-merge--regular',
+  closed: 'ph--x-circle--regular',
+};
+export const STATE_HUE: Record<PullRequest.State, string> = {
+  open: 'green',
+  closed: 'red',
+  merged: 'purple',
+  draft: 'neutral',
+};
+
+const CI_ORDER: readonly GitHubOperation.CiState[] = ['failure', 'pending', 'success', 'none'];
+const CI_ICON: Record<GitHubOperation.CiState, string> = {
+  failure: 'ph--x-circle--regular',
+  pending: 'ph--circle-notch--regular',
+  success: 'ph--check-circle--regular',
+  none: 'ph--minus-circle--regular',
+};
+export const CI_HUE: Record<GitHubOperation.CiState, string> = {
+  success: 'green',
+  failure: 'red',
+  pending: 'amber',
+  none: 'neutral',
+};
+
+/** Rows partitioned by a string key, groups in first-seen order unless `order` ranks them; empty groups dropped. */
+const partition = <K extends string>(
+  rows: readonly PullRequestRow[],
+  key: (row: PullRequestRow) => K,
+  make: (key: K, rows: readonly PullRequestRow[]) => PullRequestRowGroup,
+  order?: (left: K, right: K) => number,
+): PullRequestRowGroup[] => {
+  const byKey = new Map<K, PullRequestRow[]>();
+  for (const row of rows) {
+    const value = key(row);
+    byKey.set(value, [...(byKey.get(value) ?? []), row]);
+  }
+  const keys = [...byKey.keys()];
+  if (order) {
+    keys.sort(order);
+  }
+  return keys.map((value) => make(value, byKey.get(value) ?? []));
+};
+
+const rankOf =
+  <T extends string>(values: readonly T[]) =>
+  (left: T, right: T) =>
+    values.indexOf(left) - values.indexOf(right);
+
+/**
+ * The rows partitioned by `field`, each group's rows in input order (so a sort applies within every
+ * group). Absent for `none`: an ungrouped list has no headers.
+ */
+export const groupRows = (
+  rows: readonly PullRequestRow[],
+  field: PullRequestsView.GroupField,
+): PullRequestRowGroup[] | undefined => {
+  switch (field) {
+    case 'none':
+      return undefined;
+
+    case 'repo':
+      return partition(
+        rows,
+        ({ pullRequest }) => `${pullRequest.owner}/${pullRequest.repo}`,
+        (repo, rows) => ({ id: `repo-${repo}`, label: repo, icon: 'ph--git-branch--regular', rows }),
+        (left, right) => left.localeCompare(right),
+      );
+
+    case 'state':
+      return partition(
+        rows,
+        ({ pullRequest }) => pullRequest.state,
+        (state, rows) => ({
+          id: `state-${state}`,
+          label: `pull-request-state.${state}.label`,
+          translate: true,
+          icon: STATE_ICON[state],
+          hue: STATE_HUE[state],
+          rows,
+        }),
+        rankOf(STATE_ORDER),
+      );
+
+    case 'checks':
+      return [
+        ...partition(
+          rows.filter((row) => row.checks),
+          ({ checks }): GitHubOperation.CiState => checks?.ci ?? 'none',
+          (ci, rows) => ({
+            id: `checks-${ci}`,
+            label: `ci-status.${ci}.label`,
+            translate: true,
+            icon: CI_ICON[ci],
+            hue: CI_HUE[ci],
+            rows,
+          }),
+          rankOf(CI_ORDER),
+        ),
+        // Rows whose checks have not arrived (or are not fetched, e.g. a merged pull request) last.
+        ...partition(
+          rows.filter((row) => !row.checks),
+          () => 'unknown' as const,
+          (_, rows) => ({
+            id: 'checks-unknown',
+            label: 'ci-status.unknown.label',
+            translate: true,
+            icon: 'ph--question--regular',
+            rows,
+          }),
+        ),
+      ];
+
+    case 'author':
+      return partition(
+        rows,
+        ({ pullRequest }) => pullRequest.author ?? '',
+        (author, rows) => ({
+          id: `author-${author}`,
+          label: author || 'group-no-author.label',
+          translate: !author,
+          icon: author ? 'ph--user--regular' : 'ph--user-circle-dashed--regular',
+          rows,
+        }),
+        // Unknown authors last; the rest by name.
+        (left, right) => (left === '' ? 1 : right === '' ? -1 : left.localeCompare(right)),
+      );
+  }
+};

package/src/containers/PullRequestsArticle/format.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+const UNITS: readonly [Intl.RelativeTimeFormatUnit, number][] = [
+  ['year', 365 * 24 * 60 * 60_000],
+  ['month', 30 * 24 * 60 * 60_000],
+  ['week', 7 * 24 * 60 * 60_000],
+  ['day', 24 * 60 * 60_000],
+  ['hour', 60 * 60_000],
+  ['minute', 60_000],
+];
+
+// Built once: constructing an `Intl` formatter resolves the locale each time, and every row formats.
+let formatter: Intl.RelativeTimeFormat | undefined;
+
+/** `5 minutes ago`, `yesterday`, `3 weeks ago` — in the largest unit that fits; empty for an invalid date. */
+export const formatRelative = (value: string, now = Date.now()): string => {
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) {
+    return '';
+  }
+  formatter ??= new Intl.RelativeTimeFormat(undefined, { numeric: 'auto' });
+  const elapsed = date - now;
+  for (const [unit, size] of UNITS) {
+    if (Math.abs(elapsed) >= size) {
+      return formatter.format(Math.round(elapsed / size), unit);
+    }
+  }
+  return formatter.format(0, 'minute');
+};

package/src/containers/PullRequestsArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { PullRequestsArticle as default } from './PullRequestsArticle.tsx';

package/src/containers/WalkthroughArticle/WalkthroughArticle.tsx

@@ -0,0 +1,31 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React from 'react';
+
+import type * as AppSurface from '@dxos/app-toolkit/AppSurface';
+import { Filter, Obj } from '@dxos/echo';
+import { useObject, useQuery } from '@dxos/echo-react';
+import { PullRequest } from '@dxos/types';
+
+import { type Walkthrough } from '#types';
+
+import { PullRequestArticle } from '../PullRequestArticle/PullRequestArticle.tsx';
+
+export type WalkthroughArticleProps = AppSurface.ObjectArticleProps<Walkthrough.Walkthrough>;
+
+/**
+ * A walkthrough opened directly — from a search result, or a link written before the pull request
+ * became the subject — shown as the review of the pull request it narrates.
+ *
+ * The ref is resolved to a snapshot and the live object queried back by id: the article writes to
+ * the pull request (approve, comment) through a ref of its own, which a snapshot cannot give.
+ */
+export const WalkthroughArticle = ({ subject, ...props }: WalkthroughArticleProps) => {
+  const [target] = useObject(subject.pullRequest);
+  const objects = useQuery(Obj.getDatabase(subject), target ? Filter.id(target.id) : Filter.nothing());
+  const pullRequest = objects.find(PullRequest.instanceOf);
+
+  return pullRequest ? <PullRequestArticle {...props} subject={pullRequest} /> : null;
+};

package/src/containers/WalkthroughArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { WalkthroughArticle as default } from './WalkthroughArticle.tsx';

package/src/containers/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const ImportPullRequestDialog: ComponentType<any> = lazy(() => import('./ImportPullRequestDialog/index.ts'));
+export const PullRequestCardMenu: ComponentType<any> = lazy(() => import('./PullRequestCardMenu/index.ts'));
+export const PullRequestArticle: ComponentType<any> = lazy(() => import('./PullRequestArticle/index.ts'));
+export const PullRequestsArticle: ComponentType<any> = lazy(() => import('./PullRequestsArticle/index.ts'));
+export const WalkthroughArticle: ComponentType<any> = lazy(() => import('./WalkthroughArticle/index.ts'));

package/src/errors.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Predicate from 'effect/Predicate';
+
+import { BaseError } from '@dxos/errors';
+
+/** The binding names no repository: no `externalId` and no GitHub foreign key on the target. */
+export class GitHubRepoUnresolvedError extends BaseError.extend(
+  'GitHubRepoUnresolvedError',
+  'Binding does not name a GitHub repository.',
+) {}
+
+/** The connection's token cannot see the repository the binding names (un-shared or revoked). */
+export class GitHubRepoInaccessibleError extends BaseError.extend(
+  'GitHubRepoInaccessibleError',
+  'Repository is not accessible to the connection token.',
+) {}
+
+/** The pull request is not stored: a preview card mints one in memory, and it has no database. */
+export class GitHubPullRequestUnstoredError extends BaseError.extend(
+  'GitHubPullRequestUnstoredError',
+  'Pull request is not stored in a space.',
+) {}
+
+/** The text a user typed names no pull request: neither a github.com URL nor `owner/repo#123`. */
+export class GitHubPullRequestReferenceError extends BaseError.extend(
+  'GitHubPullRequestReferenceError',
+  'Not a pull request reference.',
+) {}
+
+/** The local Project could not be re-resolved after its upsert. */
+export class GitHubProjectMissingError extends BaseError.extend(
+  'GitHubProjectMissingError',
+  'Local project missing after upsert.',
+) {}
+
+/**
+ * User-facing / persisted diagnostic string for failures from GitHub sync paths.
+ */
+export const formatGitHubSyncFailure = (error: unknown): string => {
+  if (error instanceof BaseError) {
+    const keys = Object.keys(error.context);
+    return keys.length > 0 ? `${error.name}: ${JSON.stringify(error.context)}` : error.name;
+  }
+  if (Predicate.isObject(error) && typeof error._tag === 'string') {
+    if (
+      error._tag === 'ResponseError' &&
+      Predicate.isObject(error.response) &&
+      typeof error.response.status === 'number'
+    ) {
+      return `HTTP ${error.response.status}`;
+    }
+    return error._tag;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};

package/src/extensions/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './links.ts';
+export * from './references.ts';

package/src/extensions/links.test.ts

@@ -0,0 +1,133 @@
+//
+// Copyright 2026 DXOS.org
+//
+// @vitest-environment happy-dom
+
+import { forceParsing } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+import { EditorView, WidgetType } from '@codemirror/view';
+import { describe, test } from 'vitest';
+
+import { AnchorWidget, type WidgetDef, createMarkdownExtensions, decorationSetToArray } from '@dxos/ui-editor';
+
+import { parseGitHubLink, parsePullRequestReference } from '../github-link.ts';
+import { type GitHubLinkProps, githubLinks } from './links.ts';
+
+/** Widget whose props are inspectable so tests can assert what the factory was handed. */
+class TestWidget extends WidgetType {
+  constructor(readonly props: GitHubLinkProps) {
+    super();
+  }
+
+  override eq(other: this): boolean {
+    return other instanceof TestWidget && other.props.url === this.props.url;
+  }
+
+  override toDOM(): HTMLElement {
+    return document.createElement('span');
+  }
+}
+
+const widgets = <T extends WidgetType>(doc: string, link?: WidgetDef<GitHubLinkProps>): T[] => {
+  const view = new EditorView({
+    state: EditorState.create({ doc, extensions: [createMarkdownExtensions(), githubLinks({ link })] }),
+    parent: document.createElement('div'),
+  });
+  forceParsing(view, view.state.doc.length, 5_000);
+  const out: T[] = [];
+  for (const source of view.state.facet(EditorView.decorations)) {
+    const set = typeof source === 'function' ? source(view) : source;
+    if (!set) {
+      continue;
+    }
+    for (const { value } of decorationSetToArray(set)) {
+      if (value.spec?.widget instanceof WidgetType) {
+        out.push(value.spec.widget as T);
+      }
+    }
+  }
+  view.destroy();
+  return out;
+};
+
+describe('githubLinks', () => {
+  test('parses repository, pull request and issue URLs', ({ expect }) => {
+    expect(parseGitHubLink('https://github.com/dxos/dxos/pull/13031')).toEqual({
+      owner: 'dxos',
+      repo: 'dxos',
+      kind: 'pull',
+      number: 13031,
+      url: 'https://github.com/dxos/dxos/pull/13031',
+    });
+    expect(parseGitHubLink('https://github.com/dxos/dxos/issues/12?x=1#top')?.kind).toBe('issue');
+    expect(parseGitHubLink('https://github.com/dxos/dxos')).toEqual({
+      owner: 'dxos',
+      repo: 'dxos',
+      kind: 'repo',
+      url: 'https://github.com/dxos/dxos',
+    });
+    expect(parseGitHubLink('https://github.com/dxos/dxos/#readme')?.kind).toBe('repo');
+    expect(parseGitHubLink('https://github.com/dxos/dxos/blob/main/README.md')).toBeUndefined();
+    expect(parseGitHubLink('https://github.com/dxos')).toBeUndefined();
+    expect(parseGitHubLink('https://example.com/dxos/dxos/pull/1')).toBeUndefined();
+  });
+
+  test('a pull request link becomes an anchor chip; other links are left alone', ({ expect }) => {
+    const found = widgets<AnchorWidget>(
+      'See [the fix](https://github.com/dxos/dxos/pull/13031) and [docs](https://example.com).',
+    );
+    expect(found.every((widget) => widget instanceof AnchorWidget)).toBe(true);
+    expect(found.map((widget) => widget._dxn)).toEqual(['https://github.com/dxos/dxos/pull/13031']);
+    expect(found[0]._label).toBe('the fix');
+  });
+
+  test('a host-provided link widget receives the parsed parts with the link props', ({ expect }) => {
+    const found = widgets<TestWidget>('Fixed in [#7](https://github.com/dxos/dxos/issues/7).', {
+      factory: (props) => new TestWidget(props),
+    });
+    expect(found).toHaveLength(1);
+    expect(found[0].props).toMatchObject({
+      label: '#7',
+      url: 'https://github.com/dxos/dxos/issues/7',
+      owner: 'dxos',
+      repo: 'dxos',
+      kind: 'issue',
+      number: 7,
+      block: false,
+    });
+  });
+
+  test('a pull request reference is read from a URL or from owner/repo#number', ({ expect }) => {
+    expect(parsePullRequestReference('dxos/dxos#13031')).toEqual({ owner: 'dxos', repo: 'dxos', number: 13031 });
+    expect(parsePullRequestReference('  dxos/dxos#13031  ')).toEqual({ owner: 'dxos', repo: 'dxos', number: 13031 });
+    expect(parsePullRequestReference('https://github.com/dxos/dxos/pull/13031')).toEqual({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 13031,
+    });
+    // GitHub serves a pull request under its issue URL too, so the reader who copied that one still
+    // named the same change.
+    expect(parsePullRequestReference('https://github.com/dxos/dxos/issues/7')).toEqual({
+      owner: 'dxos',
+      repo: 'dxos',
+      number: 7,
+    });
+    expect(parsePullRequestReference('https://github.com/dxos/dxos')).toBeUndefined();
+    expect(parsePullRequestReference('dxos/dxos')).toBeUndefined();
+    expect(parsePullRequestReference('#13031')).toBeUndefined();
+  });
+
+  // The extension's page action matches `https://github.com/*/*/pull/*` and passes the page's URL
+  // straight through, so every URL that pattern admits must name a pull request here.
+  test('every pull request page the extension matches is a readable reference', ({ expect }) => {
+    for (const url of [
+      'https://github.com/dxos/dxos/pull/1',
+      'https://github.com/dxos/dxos/pull/1/files',
+      'https://github.com/dxos/dxos/pull/1/commits',
+      'https://github.com/dxos/dxos/pull/1#issuecomment-1',
+      'https://github.com/dxos/dxos/pull/1?w=1',
+    ]) {
+      expect(parsePullRequestReference(url), url).toEqual({ owner: 'dxos', repo: 'dxos', number: 1 });
+    }
+  });
+});

package/src/extensions/links.ts

@@ -0,0 +1,91 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Extension } from '@codemirror/state';
+import { createElement } from 'react';
+
+import { AnchorWidget, type LinkWidgetProps, type WidgetDef, linkWidgets, matchPattern } from '@dxos/ui-editor';
+
+import { GITHUB_LINK, type GitHubLink, parseGitHubLink } from '../github-link.ts';
+
+export * from '../github-link.ts';
+
+/** A link widget's props, with the URL's parts alongside it. */
+export type GitHubLinkProps<TContext = any> = LinkWidgetProps<TContext> & GitHubLink;
+
+/** The chip's leading icon for a pull request, in GitHub's open-state green. */
+export const PULL_REQUEST_ICON = { icon: 'ph--git-pull-request--regular', classNames: 'text-green-500' };
+
+/** The chip icon for a GitHub URL: a pull request's; none for an issue or a repository. */
+export const githubLinkIcon = (url: string): typeof PULL_REQUEST_ICON | undefined =>
+  parseGitHubLink(url)?.kind === 'pull' ? PULL_REQUEST_ICON : undefined;
+
+export type GitHubLinksOptions = {
+  /** Overrides the default chip's preview trigger. */
+  trigger?: 'hover' | 'click';
+  /** The inline widget for `[label](https://github.com/…/pull/123)`; the anchor chip by default. */
+  link?: WidgetDef<GitHubLinkProps>;
+};
+
+/**
+ * GitHub pull request and issue links as widgets: a `linkWidgets` matcher on the URL's shape rather
+ * than its scheme, whose widget gets the parsed parts. The default anchor chip carries the URL to
+ * the preview popover, where this plugin's link resolver answers with the pull request or issue.
+ * Contributed through `MarkdownCapabilities.ExtensionProvider` rather than built into the editor.
+ */
+/**
+ * What a chip says for a link the reader wrote as a bare URL: `#123`, or `owner/repo` for a
+ * repository. The URL is its own text in that form, and a chip repeating it is longer than the text
+ * it replaced — the read-only renderer makes the same substitution.
+ */
+const bareLabel = ({ number, owner, repo }: GitHubLink): string => (number ? `#${number}` : `${owner}/${repo}`);
+
+export const githubLinks = ({
+  trigger,
+  link = {
+    factory: (props) =>
+      new AnchorWidget(
+        props.label === props.url ? bareLabel(props) : props.label,
+        props.url,
+        trigger,
+        undefined,
+        props.kind === 'pull' ? PULL_REQUEST_ICON : undefined,
+      ),
+  },
+}: GitHubLinksOptions = {}): Extension =>
+  linkWidgets({
+    match: matchPattern(GITHUB_LINK),
+    link: withGitHubLink(link),
+  });
+
+/** The definition over link props, with the URL parsed into the parts the GitHub-side code reads. */
+const withGitHubLink = (def: WidgetDef<GitHubLinkProps>): WidgetDef<LinkWidgetProps> => {
+  const { factory, Component, estimatedHeight, ...rest } = def;
+  const githubProps = (props: LinkWidgetProps): GitHubLinkProps | undefined => {
+    const link = parseGitHubLink(props.url);
+    return link && { ...props, ...link };
+  };
+
+  return {
+    ...rest,
+    ...(factory && {
+      factory: (props) => {
+        const parsed = githubProps(props);
+        return parsed ? factory(parsed) : null;
+      },
+    }),
+    ...(Component && {
+      Component: (props) => {
+        const parsed = githubProps(props);
+        return parsed ? createElement(Component, parsed) : null;
+      },
+    }),
+    ...(estimatedHeight && {
+      estimatedHeight: (props) => {
+        const parsed = githubProps(props);
+        return parsed ? estimatedHeight(parsed) : 0;
+      },
+    }),
+  };
+};