@kubohiroya/turbowarp-plus-editor-git 0.0.0-stage → 0.7.0

package/src/block-diff-preview.tsx

@@ -0,0 +1,36 @@
+import React, {useEffect, useRef, useState} from 'react';
+import type {BlockPart, BlockSide} from './project-source-patch.js';
+import type {ProjectBlockRenderer, ScriptBlockMark} from './scratch-block-diff-renderer.js';
+
+export type LocationStatus = 'locating' | 'located' | 'missingLocation';
+type PreviewLabels = Record<'absent' | 'loading' | 'unavailable', string> & Partial<Record<LocationStatus | 'locate', string>>;
+
+export function BlockPreview({side, title, parts, marks, renderBlock, withContext, labels, onLocate, locationStatus}: {
+    side?: BlockSide; title: string; parts?: readonly BlockPart[]; marks?: readonly ScriptBlockMark[]; renderBlock: ProjectBlockRenderer;
+    withContext: boolean; labels: PreviewLabels; onLocate?: () => void; locationStatus?: LocationStatus;
+}) {
+    const host = useRef<HTMLDivElement>(null);
+    const [status, setStatus] = useState<'loading' | 'ready' | 'failed'>('loading');
+    useEffect(() => {
+        if (!side || !host.current) return;
+        const container = host.current;
+        const abort = new AbortController();
+        let dispose: (() => void) | undefined;
+        setStatus('loading');
+        void Promise.resolve().then(() => renderBlock({...side, container, withContext, parts, marks, signal: abort.signal})).then(cleanup => {
+            if (abort.signal.aborted) cleanup?.();
+            else {dispose = cleanup; setStatus('ready');}
+        }, () => {if (!abort.signal.aborted) setStatus('failed');});
+        return () => {abort.abort(); dispose?.();};
+    }, [side, renderBlock, withContext, parts, marks]);
+    return <div className="twgit-block-diff-side">
+        <h4>{title}</h4>
+        {!side && <p>{labels.absent}</p>}
+        {side && status === 'loading' && <p role="status">{labels.loading}</p>}
+        {side && status === 'failed' && <p role="status">{labels.unavailable}</p>}
+        <div ref={host} className="twgit-block-diff-preview"/>
+        {side && onLocate && <button type="button" aria-label={`${title} · ${labels.locate}`}
+            onClick={onLocate}>{labels.locate}</button>}
+        {locationStatus && <p role="status">{labels[locationStatus]}</p>}
+    </div>;
+}

package/src/browser.ts

@@ -0,0 +1,5 @@
+import 'react-diff-view/style/index.css';
+import './style.css';
+import './project-source-diff.css';
+
+export * from './index.js';

package/src/connection-settings.tsx

@@ -0,0 +1,103 @@
+import React, {useEffect, useRef, useState} from 'react';
+import type {GetRemoteSession, RemoteOperation} from './remote-operations.js';
+
+type Mode = 'desktop' | 'cloudflare';
+type Status = 'disconnected' | 'connecting' | 'connected' | 'reauth-required';
+export interface GitConnectionSettings {
+    modes: readonly Mode[];
+    getView(): {
+        mode: Mode | null;
+        state: {status: Status; account?: {login: string}; expiresAt?: number};
+        proxyOrigin?: string;
+        write?: boolean;
+        authorization?: {url: string; userCode?: string};
+    };
+    select(mode: Mode): Promise<void>;
+    connect(remote: string, write?: boolean): Promise<void>;
+    refresh(): Promise<void>;
+    disconnect(): Promise<void>;
+    getSession?: GetRemoteSession;
+}
+
+const en = {
+    title: 'GitHub connection', mode: 'Connection mode', select: 'Choose a connection',
+    desktop: 'Desktop local', cloudflare: 'Cloudflare', proxy: 'Proxy', account: 'Account',
+    'disconnected': 'Disconnected', 'connecting': 'Waiting for GitHub', 'connected': 'Connected',
+    'reauth-required': 'Sign in again', connect: 'Connect to GitHub', open: 'Open GitHub authorization',
+    check: 'Check connection', disconnect: 'Disconnect', noRemote: 'Choose a repository with a GitHub HTTPS origin.',
+    unavailable: 'No GitHub connection is configured.', changed: 'Switching disconnects the current session.',
+    error: 'GitHub connection failed. Retry using the selected connection.',
+    invalid: 'The selected repository needs a GitHub HTTPS origin.',
+    allowPush: 'Authorize push', fetch: 'Fetch', pull: 'Pull (fast-forward only)', push: 'Push'
+};
+const ja: typeof en = {
+    title: 'GitHub 接続', mode: '接続方式', select: '接続方式を選択',
+    desktop: 'Desktop ローカル', cloudflare: 'Cloudflare', proxy: 'プロキシ', account: 'アカウント',
+    'disconnected': '未接続', 'connecting': 'GitHub の認証待ち', 'connected': '接続済み',
+    'reauth-required': '再認証が必要', connect: 'GitHub に接続', open: 'GitHub の認証を開く',
+    check: '接続を確認', disconnect: '切断', noRemote: 'GitHub の HTTPS リモート origin があるリポジトリを選択してください。',
+    unavailable: 'GitHub 接続先が設定されていません。', changed: '方式を切り替えると現在のセッションを切断します。',
+    error: 'GitHub 接続に失敗しました。選択中の方式で再試行してください。',
+    invalid: '選択したリポジトリには GitHub の HTTPS リモート origin が必要です。',
+    allowPush: 'push を許可する', fetch: 'Fetch', pull: 'Pull（fast-forward のみ）', push: 'Push'
+};
+
+export function ConnectionSettings({settings, locale, readOrigin, runOperation}: {
+    settings: GitConnectionSettings; locale: string; readOrigin?: () => Promise<string | undefined>;
+    runOperation?: (operation: RemoteOperation) => Promise<void>;
+}) {
+    const labels = locale.startsWith('ja') ? ja : en;
+    const [, update] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const [allowPush, setAllowPush] = useState(false);
+    const [error, setError] = useState<'error' | 'invalid' | null>(null);
+    const active = useRef(true);
+    useEffect(() => {active.current = true; return () => {active.current = false;};}, []);
+    const run = async (action: () => Promise<void>) => {
+        if (busy) return;
+        setBusy(true);
+        setError(null);
+        try {await action();} catch (failure) {
+            if (active.current) setError((failure as Error).message === 'INVALID_REMOTE' ? 'invalid' : 'error');
+        } finally {
+            if (active.current) {setBusy(false); update(value => value + 1);}
+        }
+    };
+    const {mode, state, proxyOrigin, authorization, write} = settings.getView();
+    const connect = () => run(async () => {
+        const remote = await readOrigin?.();
+        if (!remote) throw new Error('INVALID_REMOTE');
+        await settings.connect(remote, allowPush);
+    });
+    return <details className="twgit-connection">
+        <summary>{labels.title}</summary>
+        {!settings.modes.length ? <p>{labels.unavailable}</p> : <>
+            <label>{labels.mode} <select value={mode ?? ''} disabled={busy}
+                onChange={event => {const choice = event.currentTarget.value as Mode; void run(() => settings.select(choice));}}>
+                <option value="" disabled>{labels.select}</option>
+                {settings.modes.map(choice => <option key={choice} value={choice}>{labels[choice]}</option>)}
+            </select></label>
+            <p>{labels.changed}</p>
+            <p data-git-connection-state="" role="status">{labels[state.status]}</p>
+            {proxyOrigin && <p>{labels.proxy} · <code>{proxyOrigin}</code></p>}
+            {state.account && <p>{labels.account} · {state.account.login}</p>}
+            {!readOrigin && <p>{labels.noRemote}</p>}
+            {mode && <>
+                {runOperation && <label><input type="checkbox" checked={allowPush}
+                    disabled={busy || state.status === 'connecting' || state.status === 'connected'}
+                    onChange={event => setAllowPush(event.currentTarget.checked)}/> {labels.allowPush}</label>}
+                <button disabled={busy || !readOrigin || state.status === 'connecting' || state.status === 'connected'}
+                    onClick={connect}>{labels.connect}</button>
+                {authorization && <p>{authorization.userCode && <code>{authorization.userCode} </code>}
+                    <a href={authorization.url} target="_blank" rel="noopener noreferrer">{labels.open}</a></p>}
+                {state.status !== 'disconnected' && <button disabled={busy}
+                    onClick={() => void run(settings.refresh)}>{labels.check}</button>}
+                <button disabled={busy} onClick={() => void run(settings.disconnect)}>{labels.disconnect}</button>
+                {runOperation && state.status === 'connected' && (['fetch', 'pull', 'push'] as const).map(operation =>
+                    <button key={operation} disabled={busy || !readOrigin || (operation === 'push' && !write)}
+                        onClick={() => void run(() => runOperation(operation))}>{labels[operation]}</button>)}
+            </>}
+            {error && <p className="twgit-error" role="alert">{labels[error]}</p>}
+        </>}
+    </details>;
+}

package/src/file-diff-view.tsx

@@ -0,0 +1,43 @@
+import React, {useState} from 'react';
+import {Diff, Hunk, parseDiff} from 'react-diff-view';
+import {ProjectSourceComparison} from './project-source-review.js';
+import type {FileChange, FileDiff} from './repository.js';
+import type {labelsFor} from './messages.js';
+import type {ProjectBlockRenderer} from './scratch-block-diff-renderer.js';
+
+const en = {view: 'Show changes as', blocks: 'Blocks', text: 'Text'};
+const ja: typeof en = {view: '変更の表示', blocks: 'ブロック', text: 'テキスト'};
+
+/** Project sources are the files the panel opens as projects. */
+export const isProjectSource = (path: string) => path.split('/').pop() === 'project.source.json';
+
+/**
+ * Shows one changed file. Project sources are compared as blocks by default, with their text diff one switch away.
+ */
+export function FileDiffView({change, diff, labels, locale, renderBlock}: {
+    change: FileChange; diff: FileDiff | null; labels: ReturnType<typeof labelsFor>; locale: string;
+    renderBlock?: ProjectBlockRenderer;
+}) {
+    const [view, setView] = useState<'blocks' | 'text'>('blocks');
+    const names = locale.startsWith('ja') ? ja : en;
+    const parsed = diff?.patch ? parseDiff(diff.patch)[0] : null;
+    const text = <>
+        <p>{labels.mode} · {change.oldMode?.toString(8) || '—'} → {change.newMode?.toString(8) || '—'}</p>
+        {diff && <p>{diff.beforeSize} → {diff.afterSize} {labels.bytes}</p>}
+        {diff?.binary && <p>{labels.binary}</p>}
+        {diff?.tooLarge && <p>{labels.large}</p>}
+        {parsed && <Diff viewType="unified" diffType={parsed.type} hunks={parsed.hunks}>
+            {hunks => hunks.map(hunk => <Hunk key={hunk.content} hunk={hunk}/>)}</Diff>}
+        {diff && !diff.binary && !diff.tooLarge && !parsed?.hunks.length && <p>{labels.unchanged}</p>}
+    </>;
+    const sources = renderBlock && diff?.text && isProjectSource(change.path) ? diff.text : null;
+    return <>
+        <h3>{change.path}</h3>
+        {sources && <div className="twgit-view-switch" role="group" aria-label={names.view}>
+            {(['blocks', 'text'] as const).map(mode => <button key={mode} type="button" aria-pressed={view === mode}
+                data-git-view={mode} onClick={() => setView(mode)}>{names[mode]}</button>)}
+        </div>}
+        {sources && view === 'blocks' ? <ProjectSourceComparison renderBlock={renderBlock!} locale={locale} fallback={text}
+            before={change.before === null ? null : sources.before} after={change.after === null ? null : sources.after}/> : text}
+    </>;
+}

package/src/filesystem.ts

@@ -0,0 +1,125 @@
+export class GitPanelError extends Error {
+    constructor(public code: 'invalid' | 'changed' | 'large' | 'unsupported' | 'pullUnsafe' | 'diverged' |
+        'session' | 'pushUnknown' | 'pushRefresh' | 'rollbackFailed' | 'remoteFailed', message: string = code) {
+        super(message);
+        this.name = 'GitPanelError';
+    }
+}
+
+export const fileError = (code: string, path: string) => Object.assign(new Error(`${code}: ${path}`), {code});
+export const errorCode = (error: unknown) => (error as {code?: string})?.code;
+
+export function pathParts(path: string): string[] {
+    const parts = path.split('/').filter(part => part && part !== '.');
+    if (parts.some(part => part === '..' || part.includes('\0'))) throw fileError('EACCES', path);
+    return parts;
+}
+
+export function fileStat(file: {size: number; lastModified: number} | null) {
+    const time = file?.lastModified ?? 0;
+    return {
+        isFile: () => file !== null, isDirectory: () => file === null, isSymbolicLink: () => false,
+        size: file?.size ?? 0, mode: file ? 0o100644 : 0o40755,
+        mtimeMs: time, ctimeMs: time, atimeMs: time, birthtimeMs: time,
+        mtime: new Date(time), ctime: new Date(time), atime: new Date(time), birthtime: new Date(time),
+        dev: 0, ino: 0, uid: 0, gid: 0
+    };
+}
+
+/** Adapt granted handles without exposing any filesystem mutation. */
+export function createReadOnlyFs(root: FileSystemDirectoryHandle) {
+    const directory = async (parts: string[]) => {
+        let handle = root;
+        for (const name of parts) handle = await handle.getDirectoryHandle(name);
+        return handle;
+    };
+    const handle = async (path: string): Promise<FileSystemDirectoryHandle | FileSystemFileHandle> => {
+        const parts = pathParts(path);
+        if (!parts.length) return root;
+        const name = parts.pop()!;
+        try {
+            const parent = await directory(parts);
+            try {
+                return await parent.getFileHandle(name);
+            } catch (error) {
+                if ((error as DOMException).name !== 'TypeMismatchError') throw error;
+                return await parent.getDirectoryHandle(name);
+            }
+        } catch (error) {
+            if ((error as DOMException).name === 'NotFoundError') throw fileError('ENOENT', path);
+            if ((error as DOMException).name === 'TypeMismatchError') throw fileError('ENOTDIR', path);
+            throw error;
+        }
+    };
+    const reads = new Map<string, {size: number; modified: number}>();
+    const listings = new Map<string, string[]>();
+    const observe = (path: string, file: File) => {
+        const previous = reads.get(path);
+        if (previous && (previous.size !== file.size || previous.modified !== file.lastModified)) {
+            throw new GitPanelError('changed');
+        }
+        reads.set(path, {size: file.size, modified: file.lastModified});
+    };
+    const readFile = async (path: string, options?: string | {encoding?: string}) => {
+        const item = await handle(path);
+        if (item.kind !== 'file') throw fileError('EISDIR', path);
+        const file = await item.getFile();
+        observe(path, file);
+        const bytes = new Uint8Array(await file.arrayBuffer());
+        const encoding = typeof options === 'string' ? options : options?.encoding;
+        return encoding ? new TextDecoder(encoding).decode(bytes) : bytes;
+    };
+    const stat = async (path: string) => {
+        const item = await handle(path);
+        const file = item.kind === 'file' ? await item.getFile() : null;
+        if (file) observe(path, file);
+        return fileStat(file);
+    };
+    const rejectWrite = async (path: string): Promise<never> => {throw fileError('EROFS', path);};
+    return {
+        clearReads() {reads.clear(); listings.clear();},
+        async checkReads() {
+            for (const [path, expected] of reads) {
+                const item = await handle(path);
+                if (item.kind !== 'file') throw new GitPanelError('changed');
+                const file = await item.getFile();
+                if (file.size !== expected.size || file.lastModified !== expected.modified) throw new GitPanelError('changed');
+            }
+            for (const [path, expected] of listings) {
+                const item = await directory(pathParts(path));
+                const names: string[] = [];
+                for await (const name of (item as FileSystemDirectoryHandle & {keys(): AsyncIterable<string>}).keys()) names.push(name);
+                if (JSON.stringify(names.sort()) !== JSON.stringify(expected)) throw new GitPanelError('changed');
+            }
+        },
+        promises: {
+        readFile,
+        stat,
+        lstat: stat,
+        async readdir(path: string) {
+            const item = await handle(path);
+            if (item.kind !== 'directory') throw fileError('ENOTDIR', path);
+            const names: string[] = [];
+            for await (const name of (item as FileSystemDirectoryHandle & {keys(): AsyncIterable<string>}).keys()) {
+                names.push(name);
+            }
+            listings.set(path, names.sort());
+            return names;
+        },
+        writeFile: rejectWrite, unlink: rejectWrite, mkdir: rejectWrite, rmdir: rejectWrite,
+        symlink: rejectWrite, chmod: rejectWrite,
+        async readlink(): Promise<never> {throw new GitPanelError('unsupported');}
+    }};
+}
+
+export async function readOptional(fs: ReturnType<typeof createReadOnlyFs>, path: string): Promise<Uint8Array | null> {
+    try {
+        return await fs.promises.readFile(path) as Uint8Array;
+    } catch (error) {
+        if (errorCode(error) === 'ENOENT') return null;
+        throw error;
+    }
+}
+
+export const sameBytes = (left: Uint8Array | null, right: Uint8Array | null) =>
+    left === right || Boolean(left && right && left.length === right.length && left.every((byte, i) => byte === right[i]));

package/src/github-pull-requests.ts

@@ -0,0 +1,162 @@
+import {createProjectSourceDiff, isRecord} from './project-source-patch.js';
+import type {ProjectSourceReviewFile} from './project-source-review.js';
+
+type ErrorCode = 'unavailable' | 'rateLimit' | 'failed' | 'changed' | 'tooManyFiles';
+export class PullRequestError extends Error {
+    constructor(readonly code: ErrorCode) {super(code);}
+}
+
+const repositoryName = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const validRepository = (value: unknown): value is string => typeof value === 'string' &&
+    repositoryName.test(value) && value.split('/').every(segment => segment !== '.' && segment !== '..');
+const isSha = (value: unknown): value is string => typeof value === 'string' && /^[a-f0-9]{40}$/i.test(value);
+
+export function gitHubRepositoryFromOrigin(origin: string | undefined) {
+    const name = origin?.trim().match(/^(?:https:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git@github\.com:)([^/?#]+\/[^/?#]+)\/?$/i)?.[1];
+    const repository = name?.replace(/\.git$/i, '');
+    return validRepository(repository) ? repository : null;
+}
+
+function repoPath(repository: string) {
+    return '/repos/' + repository.split('/').map(encodeURIComponent).join('/');
+}
+const invalidResponse = () => new PullRequestError('failed');
+const emptyProject = '{"targets":[]}\n';
+const sourceLimit = 1024 * 1024;
+
+async function readText(response: Response, limit: number) {
+    if (Number(response.headers.get('Content-Length')) > limit || !response.body) throw invalidResponse();
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8', {fatal: true});
+    const chunks: string[] = [];
+    let length = 0;
+    try {
+        for (;;) {
+            const {done, value} = await reader.read();
+            if (done) return chunks.join('') + decoder.decode();
+            length += value.byteLength;
+            if (length > limit) throw invalidResponse();
+            chunks.push(decoder.decode(value, {stream: true}));
+        }
+    } catch (error) {
+        void reader.cancel().catch(() => {});
+        throw error;
+    }
+}
+
+function readSummary(value: unknown) {
+    if (!isRecord(value) || !Number.isSafeInteger(value.number) || Number(value.number) < 1 ||
+        typeof value.title !== 'string') throw invalidResponse();
+    return {number: Number(value.number), title: value.title};
+}
+
+function readRevision(value: unknown) {
+    if (!isRecord(value) || !isSha(value.sha) || typeof value.ref !== 'string') throw invalidResponse();
+    const repository = isRecord(value.repo) ? value.repo.full_name : null;
+    if (repository !== null && !validRepository(repository)) throw invalidResponse();
+    return {sha: value.sha, ref: value.ref, repository};
+}
+
+function readPullRequest(value: unknown) {
+    const summary = readSummary(value);
+    if (!isRecord(value) || (value.state !== 'open' && value.state !== 'closed') ||
+        !Number.isSafeInteger(value.changed_files) || Number(value.changed_files) < 0) throw invalidResponse();
+    const author = isRecord(value.user) && typeof value.user.login === 'string' ? value.user.login : undefined;
+    const description = typeof value.body_text === 'string' ? value.body_text : typeof value.body === 'string' ? value.body : '';
+    const state: 'open' | 'closed' | 'merged' | 'draft' = value.merged_at ? 'merged' : value.draft ? 'draft' : value.state;
+    return {...summary, author, description, base: readRevision(value.base), head: readRevision(value.head), state,
+        changedFiles: Number(value.changed_files)};
+}
+
+function readFile(value: unknown) {
+    if (!isRecord(value) || typeof value.filename !== 'string' || typeof value.status !== 'string') throw invalidResponse();
+    return {path: value.filename, previous: typeof value.previous_filename === 'string' ? value.previous_filename : undefined,
+        status: value.status};
+}
+
+function contentPath(path: string) {
+    const parts = path.split('/');
+    if (parts.some(part => !part || part === '.' || part === '..')) throw invalidResponse();
+    return parts.map(encodeURIComponent).join('/');
+}
+
+export function createGitHubPullRequests(repository: string, send: typeof fetch = fetch) {
+    if (!validRepository(repository)) throw invalidResponse();
+    const api = 'https://api.github.com';
+    const repo = repoPath(repository);
+    const request = async (path: string, signal: AbortSignal, accept = 'application/vnd.github+json') => {
+        const response = await send(api + path, {headers: {Accept: accept}, credentials: 'omit', redirect: 'error', signal});
+        if (!response.ok) {
+            if (response.status === 429 || (response.status === 403 && (response.headers.get('X-RateLimit-Remaining') === '0' ||
+                response.headers.has('Retry-After')))) throw new PullRequestError('rateLimit');
+            if (response.status === 404 || response.status === 403) throw new PullRequestError('unavailable');
+            throw invalidResponse();
+        }
+        return response;
+    };
+    const json = async (path: string, signal: AbortSignal, accept?: string): Promise<unknown> =>
+        JSON.parse(await readText(await request(path, signal, accept), 12 * sourceLimit));
+    const metadata = async (number: number, signal: AbortSignal) => readPullRequest(await json(
+        repo + '/pulls/' + number, signal, 'application/vnd.github.text+json'));
+    const source = async (name: string, path: string, revision: string, signal: AbortSignal) => readText(
+        await request(repoPath(name) + '/contents/' + contentPath(path) + '?ref=' + revision, signal, 'application/vnd.github.raw+json'), sourceLimit);
+
+    return {
+        async list(page: number, signal: AbortSignal) {
+            const result = await json(repo + '/pulls?state=all&sort=updated&per_page=20&page=' + page, signal);
+            if (!Array.isArray(result)) throw invalidResponse();
+            return {items: result.map(readSummary), more: result.length === 20};
+        },
+        async load(number: number, signal: AbortSignal) {
+            if (!Number.isSafeInteger(number) || number < 1) throw invalidResponse();
+            const pr = await metadata(number, signal);
+            if (pr.number !== number) throw invalidResponse();
+            if (pr.changedFiles > 3000) throw new PullRequestError('tooManyFiles');
+            const records: ReturnType<typeof readFile>[] = [];
+            for (let page = 1; page <= Math.ceil(pr.changedFiles / 100); page++) {
+                const result = await json(repo + '/pulls/' + number + '/files?per_page=100&page=' + page, signal);
+                if (!Array.isArray(result)) throw invalidResponse();
+                records.push(...result.map(readFile));
+            }
+            const current = await metadata(number, signal);
+            if (current.base.sha !== pr.base.sha || current.head.sha !== pr.head.sha ||
+                current.changedFiles !== pr.changedFiles || records.length !== pr.changedFiles) {
+                throw new PullRequestError('changed');
+            }
+            let base: string | undefined;
+            if (records.some(file => file.path.split('/').pop() === 'project.source.json' && file.status !== 'added' && file.status !== 'copied')) {
+                try {
+                    const comparison = await json(repo + '/compare/' + pr.base.sha + '...' + pr.head.sha + '?per_page=1', signal);
+                    const merge = isRecord(comparison) ? comparison.merge_base_commit : null;
+                    if (isRecord(merge) && isSha(merge.sha)) base = merge.sha;
+                } catch (error) {
+                    if (signal.aborted) throw error;
+                }
+            }
+
+            const files: ProjectSourceReviewFile[] = [];
+            for (const file of records) {
+                const status = file.status === 'removed' ? 'removed' : file.status === 'added' || file.status === 'copied' ? 'added' : 'updated';
+                const related = {path: file.path, status, previousPath: file.previous} as const;
+                if (file.path.split('/').pop() !== 'project.source.json') {
+                    files.push(related);
+                    continue;
+                }
+                try {
+                    if (status !== 'added' && !base) throw invalidResponse();
+                    const [before, after] = await Promise.all([
+                        status === 'added' ? emptyProject : source(repository, file.previous ?? file.path, base!, signal),
+                        status === 'removed' ? emptyProject : source(pr.head.repository ?? repository, file.path, pr.head.sha, signal)
+                    ]);
+                    files.push({path: file.path, previousPath: file.previous, patch: createProjectSourceDiff(before, after)});
+                } catch (error) {
+                    if (signal.aborted) throw error;
+                    files.push({...related, unavailable: true});
+                }
+            }
+            return {...pr, files, url: 'https://github.com/' + repository + '/pull/' + number};
+        }
+    };
+}
+
+export type GitHubPullRequests = ReturnType<typeof createGitHubPullRequests>;