@fuzdev/fuz_gitops 0.78.0 → 0.78.1

package/src/lib/dependency_updater.ts

@@ -1,15 +1,15 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {join} from 'node:path';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { join } from 'node:path';
 
-import type {LocalRepo} from './local_repo.ts';
-import type {PublishedVersion} from './multi_repo_publisher.ts';
+import type { LocalRepo } from './local_repo.ts';
+import type { PublishedVersion } from './multi_repo_publisher.ts';
 import {
 	create_changeset_for_dependency_updates,
-	create_dependency_updates,
+	create_dependency_updates
 } from './changeset_generator.ts';
-import {needs_update, get_update_prefix} from './version_utils.ts';
-import type {GitOperations, FsOperations} from './operations.ts';
-import {default_git_operations, default_fs_operations} from './operations_defaults.ts';
+import { needs_update, get_update_prefix } from './version_utils.ts';
+import type { GitOperations, FsOperations } from './operations.ts';
+import { default_git_operations, default_fs_operations } from './operations_defaults.ts';
 
 export type VersionStrategy = 'exact' | 'caret' | 'tilde' | 'gte';
 
@@ -38,21 +38,21 @@ export interface UpdatePackageJsonOptions {
 export const update_package_json = async (
 	repo: LocalRepo,
 	updates: Map<string, string>,
-	options: UpdatePackageJsonOptions = {},
+	options: UpdatePackageJsonOptions = {}
 ): Promise<void> => {
 	const {
 		strategy = 'caret',
 		published_versions,
 		log,
 		git_ops = default_git_operations,
-		fs_ops = default_fs_operations,
+		fs_ops = default_fs_operations
 	} = options;
 	if (updates.size === 0) return;
 
 	const package_json_path = join(repo.repo_dir, 'package.json');
 
 	// Read current package.json
-	const content_result = await fs_ops.readFile({path: package_json_path, encoding: 'utf8'});
+	const content_result = await fs_ops.readFile({ path: package_json_path, encoding: 'utf8' });
 	if (!content_result.ok) {
 		throw new Error(`Failed to read package.json: ${content_result.message}`);
 	}
@@ -105,7 +105,7 @@ export const update_package_json = async (
 	// Write updated package.json
 	const write_result = await fs_ops.writeFile({
 		path: package_json_path,
-		content: JSON.stringify(package_json, null, '\t') + '\n',
+		content: JSON.stringify(package_json, null, '\t') + '\n'
 	});
 	if (!write_result.ok) {
 		throw new Error(`Failed to write package.json: ${write_result.message}`);
@@ -145,11 +145,11 @@ export const update_package_json = async (
 			const changeset_path = await create_changeset_for_dependency_updates(
 				repo,
 				dependency_updates,
-				{log, fs_ops},
+				{ log, fs_ops }
 			);
 
 			// Add changeset to git
-			const add_result = await git_ops.add({files: changeset_path, cwd: repo.repo_dir});
+			const add_result = await git_ops.add({ files: changeset_path, cwd: repo.repo_dir });
 			if (!add_result.ok) {
 				throw new Error(`Failed to stage changeset: ${add_result.message}`);
 			}
@@ -157,14 +157,14 @@ export const update_package_json = async (
 	}
 
 	// Commit the changes (including both package.json and changeset)
-	const add_pkg_result = await git_ops.add({files: 'package.json', cwd: repo.repo_dir});
+	const add_pkg_result = await git_ops.add({ files: 'package.json', cwd: repo.repo_dir });
 	if (!add_pkg_result.ok) {
 		throw new Error(`Failed to stage package.json: ${add_pkg_result.message}`);
 	}
 
 	const commit_result = await git_ops.commit({
 		message: `update dependencies after publishing`,
-		cwd: repo.repo_dir,
+		cwd: repo.repo_dir
 	});
 	if (!commit_result.ok) {
 		throw new Error(`Failed to commit: ${commit_result.message}`);
@@ -181,16 +181,16 @@ export interface UpdateAllReposOptions {
 export const update_all_repos = async (
 	repos: Array<LocalRepo>,
 	published: Map<string, string>,
-	options: UpdateAllReposOptions = {},
-): Promise<{updated: number; failed: Array<{repo: string; error: Error}>}> => {
+	options: UpdateAllReposOptions = {}
+): Promise<{ updated: number; failed: Array<{ repo: string; error: Error }> }> => {
 	const {
 		strategy = 'caret',
 		log,
 		git_ops = default_git_operations,
-		fs_ops = default_fs_operations,
+		fs_ops = default_fs_operations
 	} = options;
 	let updated_count = 0;
-	const failed: Array<{repo: string; error: Error}> = [];
+	const failed: Array<{ repo: string; error: Error }> = [];
 
 	for (const repo of repos) {
 		const updates: Map<string, string> = new Map();
@@ -226,29 +226,29 @@ export const update_all_repos = async (
 		if (updates.size === 0) continue;
 
 		try {
-			await update_package_json(repo, updates, {strategy, log, git_ops, fs_ops});
+			await update_package_json(repo, updates, { strategy, log, git_ops, fs_ops });
 			updated_count++;
 			log?.info(`    Updated ${updates.size} dependencies in ${repo.library.name}`);
 		} catch (error) {
 			const err = error instanceof Error ? error : new Error(String(error));
-			failed.push({repo: repo.library.name, error: err});
+			failed.push({ repo: repo.library.name, error: err });
 			log?.error(`    Failed to update ${repo.library.name}: ${err.message}`);
 		}
 	}
 
-	return {updated: updated_count, failed};
+	return { updated: updated_count, failed };
 };
 
 export const find_updates_needed = (
 	repo: LocalRepo,
-	published: Map<string, string>,
+	published: Map<string, string>
 ): Map<
 	string,
-	{current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies'}
+	{ current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies' }
 > => {
 	const updates: Map<
 		string,
-		{current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies'}
+		{ current: string; new: string; type: 'dependencies' | 'devDependencies' | 'peerDependencies' }
 	> = new Map();
 
 	// Check dependencies
@@ -259,7 +259,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'dependencies',
+					type: 'dependencies'
 				});
 			}
 		}
@@ -273,7 +273,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'devDependencies',
+					type: 'devDependencies'
 				});
 			}
 		}
@@ -287,7 +287,7 @@ export const find_updates_needed = (
 				updates.set(dep_name, {
 					current: current_version,
 					new: new_version,
-					type: 'peerDependencies',
+					type: 'peerDependencies'
 				});
 			}
 		}

package/src/lib/fetch_repo_data.ts

@@ -1,10 +1,10 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {wait} from '@fuzdev/fuz_util/async.ts';
-import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { wait } from '@fuzdev/fuz_util/async.ts';
+import type { FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
 
-import {fetch_github_check_runs, fetch_github_pull_requests} from './github.ts';
-import type {RepoJson} from './repo.svelte.ts';
-import type {LocalRepo} from './local_repo.ts';
+import { fetch_github_check_runs, fetch_github_pull_requests } from './github.ts';
+import type { RepoJson } from './repo.svelte.ts';
+import type { LocalRepo } from './local_repo.ts';
 
 /**
  * Fetches GitHub metadata (CI status, PRs) for all repos.
@@ -25,10 +25,10 @@ export const fetch_repo_data = async (
 	cache?: FetchValueCache,
 	log?: Logger,
 	delay = 33,
-	github_api_version?: string,
+	github_api_version?: string
 ): Promise<Array<RepoJson>> => {
 	const repos: Array<RepoJson> = [];
-	for (const {library, package_json, repo_config} of resolved_repos) {
+	for (const { library, package_json, repo_config } of resolved_repos) {
 		const repo_url = library.repo_url;
 
 		// CI status
@@ -38,7 +38,7 @@ export const fetch_repo_data = async (
 			log,
 			token,
 			api_version: github_api_version,
-			ref: repo_config.branch,
+			ref: repo_config.branch
 		});
 		if (!check_runs) log?.error('failed to fetch CI status: ' + repo_url);
 
@@ -48,7 +48,7 @@ export const fetch_repo_data = async (
 			cache,
 			log,
 			token,
-			api_version: github_api_version,
+			api_version: github_api_version
 		});
 		if (!pull_requests) log?.error('failed to fetch issues: ' + repo_url);
 
@@ -56,7 +56,7 @@ export const fetch_repo_data = async (
 			library_json: library.library_json,
 			package_json,
 			check_runs,
-			pull_requests,
+			pull_requests
 		});
 	}
 	return repos;

package/src/lib/fs_fetch_value_cache.ts

@@ -1,9 +1,13 @@
-import {mkdir, readFile, rm, writeFile} from 'node:fs/promises';
-import {dirname, join} from 'node:path';
-import {paths} from '@fuzdev/gro/paths.ts';
-import {format_file} from '@fuzdev/gro/format_file.ts';
-import {deserialize_cache, serialize_cache, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
-import {existsSync} from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { paths } from '@fuzdev/gro/paths.ts';
+import { format_file } from '@fuzdev/gro/format_file.ts';
+import {
+	deserialize_cache,
+	serialize_cache,
+	type FetchValueCache
+} from '@fuzdev/fuz_util/fetch.ts';
+import { existsSync } from 'node:fs';
 
 // TODO upstream to Gro probably, and rename/redesign?
 
@@ -31,7 +35,7 @@ export interface FetchCache {
  */
 export const create_fs_fetch_value_cache = async (
 	name: string,
-	dir = join(paths.build, 'fetch'),
+	dir = join(paths.build, 'fetch')
 ): Promise<FetchCache> => {
 	const data_path = join(dir, name + '.json');
 	let data: FetchValueCache;
@@ -54,10 +58,10 @@ export const create_fs_fetch_value_cache = async (
 			if (deep_equal_maps(initial, data)) {
 				return false; // no changes to save
 			}
-			await mkdir(dirname(data_path), {recursive: true});
-			await writeFile(data_path, await format_file(serialize_cache(data), {filepath: data_path}));
+			await mkdir(dirname(data_path), { recursive: true });
+			await writeFile(data_path, format_file(serialize_cache(data), { lang: 'json' }));
 			return true;
-		},
+		}
 	};
 };
 

package/src/lib/git_operations.ts

@@ -1,5 +1,5 @@
-import {spawn_out, spawn_result_to_message} from '@fuzdev/fuz_util/process.ts';
-import type {SpawnOptions} from 'node:child_process';
+import { spawn_out, spawn_result_to_message } from '@fuzdev/fuz_util/process.ts';
+import type { SpawnOptions } from 'node:child_process';
 import {
 	git_check_clean_workspace as gro_git_check_clean_workspace,
 	git_checkout as gro_git_checkout,
@@ -7,7 +7,7 @@ import {
 	git_current_branch_name as gro_git_current_branch_name,
 	git_current_commit_hash as gro_git_current_commit_hash,
 	type GitBranch,
-	type GitOrigin,
+	type GitOrigin
 } from '@fuzdev/fuz_util/git.ts';
 
 /**
@@ -15,13 +15,13 @@ import {
  */
 export const git_add = async (
 	files: string | Array<string>,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	const file_list = Array.isArray(files) ? files : [files];
-	const {result, stderr} = await spawn_out('git', ['add', ...file_list], options);
+	const { result, stderr } = await spawn_out('git', ['add', ...file_list], options);
 	if (!result.ok) {
 		throw Error(
-			`git_add failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_add failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -30,10 +30,10 @@ export const git_add = async (
  * Commits staged changes with a message and throws if anything goes wrong.
  */
 export const git_commit = async (message: string, options?: SpawnOptions): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['commit', '-m', message], options);
+	const { result, stderr } = await spawn_out('git', ['commit', '-m', message], options);
 	if (!result.ok) {
 		throw Error(
-			`git_commit failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_commit failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -44,7 +44,7 @@ export const git_commit = async (message: string, options?: SpawnOptions): Promi
 export const git_add_and_commit = async (
 	files: string | Array<string>,
 	message: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	await git_add(files, options);
 	await git_commit(message, options);
@@ -56,14 +56,14 @@ export const git_add_and_commit = async (
 export const git_tag = async (
 	tag_name: string,
 	message?: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	const args = message ? ['tag', '-a', tag_name, '-m', message] : ['tag', tag_name];
 
-	const {result, stderr} = await spawn_out('git', args, options);
+	const { result, stderr } = await spawn_out('git', args, options);
 	if (!result.ok) {
 		throw Error(
-			`git_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -74,12 +74,12 @@ export const git_tag = async (
 export const git_push_tag = async (
 	tag_name: string,
 	origin: GitOrigin = 'origin' as GitOrigin,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['push', origin, tag_name], options);
+	const { result, stderr } = await spawn_out('git', ['push', origin, tag_name], options);
 	if (!result.ok) {
 		throw Error(
-			`git_push_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_push_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -90,7 +90,7 @@ export const git_push_tag = async (
  * which reports only tracked working-tree changes relative to HEAD.
  */
 export const git_has_changes = async (options?: SpawnOptions): Promise<boolean> => {
-	const {stdout} = await spawn_out('git', ['status', '--porcelain'], options);
+	const { stdout } = await spawn_out('git', ['status', '--porcelain'], options);
 	return stdout ? stdout.trim().length > 0 : false;
 };
 
@@ -98,9 +98,9 @@ export const git_has_changes = async (options?: SpawnOptions): Promise<boolean>
  * Lists uncommitted files in the working tree (`git diff --name-only HEAD`).
  */
 export const git_list_uncommitted_files = async (
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<Array<string>> => {
-	const {stdout} = await spawn_out('git', ['diff', '--name-only', 'HEAD'], options);
+	const { stdout } = await spawn_out('git', ['diff', '--name-only', 'HEAD'], options);
 	if (!stdout) return [];
 
 	return stdout
@@ -113,12 +113,12 @@ export const git_has_file_changed = async (
 	from_commit: string,
 	to_commit: string,
 	file_path: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
-	const {stdout} = await spawn_out(
+	const { stdout } = await spawn_out(
 		'git',
 		['diff', '--name-only', from_commit, to_commit, '--', file_path],
-		options,
+		options
 	);
 	return stdout ? stdout.trim().length > 0 : false;
 };
@@ -129,10 +129,10 @@ export const git_has_file_changed = async (
 export const git_stash = async (message?: string, options?: SpawnOptions): Promise<void> => {
 	const args = message ? ['stash', 'push', '-m', message] : ['stash', 'push'];
 
-	const {result, stderr} = await spawn_out('git', args, options);
+	const { result, stderr } = await spawn_out('git', args, options);
 	if (!result.ok) {
 		throw Error(
-			`git_stash failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_stash failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -141,10 +141,10 @@ export const git_stash = async (message?: string, options?: SpawnOptions): Promi
  * Applies stashed changes and throws if anything goes wrong.
  */
 export const git_stash_pop = async (options?: SpawnOptions): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['stash', 'pop'], options);
+	const { result, stderr } = await spawn_out('git', ['stash', 'pop'], options);
 	if (!result.ok) {
 		throw Error(
-			`git_stash_pop failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_stash_pop failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -155,7 +155,7 @@ export const git_stash_pop = async (options?: SpawnOptions): Promise<void> => {
 export const git_switch_branch = async (
 	branch: GitBranch,
 	pull: boolean = true,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	// Check if workspace is clean first
 	const error = await gro_git_check_clean_workspace(options);
@@ -194,7 +194,7 @@ export const git_current_branch_name_required = async (options?: SpawnOptions):
  */
 export const git_current_commit_hash_required = async (
 	branch?: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<string> => {
 	const hash = await gro_git_current_commit_hash(branch, options);
 	if (!hash) {
@@ -207,7 +207,7 @@ export const git_current_commit_hash_required = async (
  * Wrapper for gro's `git_check_clean_workspace` that returns a boolean.
  */
 export const git_check_clean_workspace_as_boolean = async (
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
 	const error = await gro_git_check_clean_workspace(options);
 	return error === null;
@@ -215,9 +215,9 @@ export const git_check_clean_workspace_as_boolean = async (
 
 export const git_has_remote = async (
 	remote: string = 'origin',
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
-	const {stdout} = await spawn_out('git', ['remote'], options);
+	const { stdout } = await spawn_out('git', ['remote'], options);
 	if (!stdout) return false;
 	const remotes = stdout
 		.split('\n')

package/src/lib/github.ts

@@ -1,6 +1,6 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {z} from 'zod';
-import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { z } from 'zod';
+import { fetch_value, type FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
 
 /**
  * Minimal interface for GitHub API calls - works with both `Pkg` and `Repo`.
@@ -17,9 +17,9 @@ export const GithubPullRequest = z.object({
 	number: z.number(),
 	title: z.string(),
 	user: z.object({
-		login: z.string(),
+		login: z.string()
 	}),
-	draft: z.boolean(),
+	draft: z.boolean()
 });
 export type GithubPullRequest = z.infer<typeof GithubPullRequest>;
 export const GithubPullRequests = z.array(GithubPullRequest);
@@ -35,24 +35,24 @@ export const fetch_github_pull_requests = async (
 		log?: Logger;
 		token?: string;
 		api_version?: string;
-	} = {},
+	} = {}
 ): Promise<GithubPullRequests | null> => {
-	const {cache, log, token, api_version} = options;
+	const { cache, log, token, api_version } = options;
 	if (!repo_info.owner_name) throw Error('owner_name is required');
-	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
+	const headers = api_version ? new Headers({ 'x-github-api-version': api_version }) : undefined;
 	const url = `https://api.github.com/repos/${repo_info.owner_name}/${repo_info.repo_name}/pulls`;
 	const fetched = await fetch_value(url, {
-		request: {headers},
+		request: { headers },
 		parse: GithubPullRequests.parse,
 		token,
 		cache,
-		log,
+		log
 	});
 	if (!fetched.ok) {
 		// TODO @many this is messy but I think it's the main case we need to worry about?
 		if (fetched.status === 401) {
 			throw Error(
-				'401 response fetching github pull requests - check your SECRET_GITHUB_API_TOKEN',
+				'401 response fetching github pull requests - check your SECRET_GITHUB_API_TOKEN'
 			);
 		}
 		return null;
@@ -67,12 +67,12 @@ export const GithubCheckRunsItem = z.object({
 	status: z.enum(['queued', 'in_progress', 'completed']),
 	conclusion: z
 		.enum(['success', 'failure', 'neutral', 'cancelled', 'skipped', 'timed_out', 'action_required'])
-		.nullable(),
+		.nullable()
 });
 export type GithubCheckRunsItem = z.infer<typeof GithubCheckRunsItem>;
 export const GithubCheckRuns = z.object({
 	total_count: z.number(),
-	check_runs: z.array(GithubCheckRunsItem),
+	check_runs: z.array(GithubCheckRunsItem)
 });
 export type GithubCheckRuns = z.infer<typeof GithubCheckRuns>;
 
@@ -87,18 +87,18 @@ export const fetch_github_check_runs = async (
 		token?: string;
 		api_version?: string;
 		ref?: string;
-	} = {},
+	} = {}
 ): Promise<GithubCheckRunsItem | null> => {
-	const {cache, log, token, api_version, ref = 'main'} = options;
+	const { cache, log, token, api_version, ref = 'main' } = options;
 	if (!repo_info.owner_name) throw Error('owner_name is required');
-	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
+	const headers = api_version ? new Headers({ 'x-github-api-version': api_version }) : undefined;
 	const url = `https://api.github.com/repos/${repo_info.owner_name}/${repo_info.repo_name}/commits/${ref}/check-runs`;
 	const fetched = await fetch_value(url, {
-		request: {headers},
+		request: { headers },
 		parse: (v) => reduce_check_runs(GithubCheckRuns.parse(v).check_runs),
 		token,
 		cache,
-		log,
+		log
 	});
 	if (!fetched.ok) {
 		// TODO @many this is messy but I think it's the main case we need to worry about?
@@ -123,5 +123,5 @@ const reduce_check_runs = (check_runs: Array<GithubCheckRunsItem>): GithubCheckR
 			conclusion = check_run.conclusion;
 		}
 	}
-	return {status, conclusion};
+	return { status, conclusion };
 };

package/src/lib/github_helpers.ts

@@ -1,7 +1,7 @@
-import {ensure_end} from '@fuzdev/fuz_util/string.ts';
+import { ensure_end } from '@fuzdev/fuz_util/string.ts';
 
-import type {GithubPullRequest} from './github.ts';
-import type {Repo} from './repo.svelte.ts';
+import type { GithubPullRequest } from './github.ts';
+import type { Repo } from './repo.svelte.ts';
 
 export type FilterPullRequest = (pull_request: GithubPullRequest, repo: Repo) => boolean;
 
@@ -12,7 +12,7 @@ export interface PullRequestMeta {
 
 export const to_pull_requests = (
 	repos: Array<Repo>,
-	filter_pull_request?: FilterPullRequest,
+	filter_pull_request?: FilterPullRequest
 ): Array<PullRequestMeta> =>
 	repos
 		.flatMap((repo) => {
@@ -21,8 +21,8 @@ export const to_pull_requests = (
 			return repo.pull_requests.map((pull_request) =>
 				repo.package_json.homepage &&
 				(!filter_pull_request || filter_pull_request(pull_request, repo))
-					? {repo, pull_request}
-					: null,
+					? { repo, pull_request }
+					: null
 			);
 		})
 		.filter((v) => v !== null);