chore: clean up oxlint pedantic warnings

.oxlintrc.json

@@ -41,7 +41,7 @@
 	"categories": {
 		"correctness": "error",
 		"suspicious": "warn",
-		"pedantic": "off",
+		"pedantic": "warn",
 		"perf": "warn",
 		"restriction": "off",
 		"style": "off"

perf/bench.ts

@@ -69,11 +69,11 @@ try {
 		const samplesMs: number[] = [];
 
 		try {
-			for (let _ = 0; _ < config.warmups; _ += 1) {
+			for (let warmupIndex = 0; warmupIndex < config.warmups; warmupIndex += 1) {
 				await runtime.clone();
 			}
 
-			for (let _ = 0; _ < config.iterations; _ += 1) {
+			for (let iterationIndex = 0; iterationIndex < config.iterations; iterationIndex += 1) {
 				const startedAt = performance.now();
 				await runtime.clone();
 				samplesMs.push(performance.now() - startedAt);

src/bin.ts

@@ -9,7 +9,7 @@
 import degit from './index.js';
 import { base, tryRequire } from './utils.js';
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 
 type Choice = {
 	message: string;
@@ -94,11 +94,11 @@
 	};
 
 	return glob('**/map.json', { cwd: base })
 		.flatMap(getChoices)
 		.toSorted((a, b) => (accessLookup.get(b.value) || 0) - (accessLookup.get(a.value) || 0));
 }
 
 async function promptForSource(): Promise<PromptResult> {
 	const sourcePrompt = {
 		choices: getInteractiveChoices(),
 		message: 'Repo to clone?',
@@ -106,7 +106,7 @@
 		suggest: (input: string, promptChoices: Choice[]) =>
 			promptChoices.filter(({ value }) => fuzzysearch(input, value)),
 		type: 'autocomplete',
-	} as any;
+	};
 
 	return enquirer.prompt<PromptResult>([
 		sourcePrompt,
@@ -121,7 +121,7 @@
 			name: 'cache',
 			type: 'toggle',
 		},
-	] as any);
+	]);
 }
 
 async function confirmOverwrite(): Promise<boolean> {
@@ -131,7 +131,7 @@
 			name: 'force',
 			type: 'toggle',
 		},
-	] as any);
+	]);
 
 	return force;
 }
@@ -152,7 +152,7 @@
 		const empty = !fs.existsSync(options.dest) || fs.readdirSync(options.dest).length === 0;
 
 		if (!empty) {
 			if (!(await confirmOverwrite())) {
 				console.error(colors.magenta('! Directory not empty — aborting'));
 				return;
 			}
@@ -221,8 +221,8 @@
 }
 
 if (!process.env.VITEST) {
 	main(process.argv).catch((error) => {
 		console.error(error);
 		process.exit(1);
 	});
 }

src/git-client.ts

@@ -117,7 +117,7 @@
 	};
 }
 
-function mapServerRef(serverRef: any): Ref | undefined {
+function mapServerRef(serverRef: { hash?: string; name?: string; oid?: string; ref?: string }): Ref | undefined {
 	const refName = String(serverRef.ref || serverRef.name || '');
 	const refHash = String(serverRef.oid || serverRef.hash || '');
 
@@ -214,7 +214,7 @@
 	};
 }
 
 async function fetchRefsWithGitCli(repo: Repo) {
 	return new Promise<Ref[]>((resolve, reject) => {
 		const child = spawn('git', ['ls-remote', '--symref', getGitUrl(repo)], {
 			stdio: ['ignore', 'pipe', 'pipe'],
@@ -258,7 +258,7 @@
 	const url = getGitUrl(repo);
 	const normalizeRefs = (
 		refs: Array<{ hash?: string; oid?: string; ref?: string; name?: string }>,
 	) => dedupeRefs(refs.map(mapServerRef).filter((ref): ref is Ref => Boolean(ref)));
 
 	try {
 		const refs = await git.listServerRefs({
@@ -415,4 +415,4 @@
 	};
 }
 
 export const defaultGitClient = createGitClient();

src/utils.ts

@@ -64,7 +64,7 @@ export function fetch(url: string, dest: string, proxy?: string): Promise<void>
 		if (proxy) {
 			const parsedUrl = URL.parse(url);
 			options = {
-				agent: Agent(proxy) as unknown as import('node:http').Agent,
+				agent: Agent(proxy) as import('node:http').Agent,
 				hostname: parsedUrl.host,
 				path: parsedUrl.path,
 			};

test/helpers.ts

@@ -24,26 +24,26 @@ export function compareDirToExpected(dir, files) {
 
 export function createMockGit(stubs = {}) {
 	const calls = [];
-	const resolveStub = async (call, ...args) => {
+	const resolveStub = (call, ...args) => {
 		if (!Object.hasOwn(stubs, call)) {
-			return Promise.reject(new Error(`Unexpected git call: ${call}`));
+			throw new Error(`Unexpected git call: ${call}`);
 		}
 
 		const stub = stubs[call];
 		if (typeof stub === 'function') {
 			return stub(...args);
 		}
 
-		return Promise.resolve(stub);
+		return stub;
 	};
 
-	const fetchRefs = async (repo) => {
+	const fetchRefs = (repo) => {
 		const call = `fetchRefs ${getGitUrl(repo)}`;
 		calls.push(call);
 		return resolveStub(call, repo);
 	};
 
-	const clone = async (repo, dest, ref, transport) => {
+	const clone = (repo, dest, ref, transport) => {
 		const call = `clone ${getGitUrl(repo, transport)} ${dest}${ref ? ` ${ref}` : ''}`;
 		calls.push(call);
 		return resolveStub(call, repo, dest, ref, transport);
@@ -61,23 +61,21 @@ export function createMockFetch(steps) {
 
 		const response = steps[step++];
 		if (!response) {
-			return Promise.reject(new Error('No mock fetch step configured'));
+			throw new Error('No mock fetch step configured');
 		}
 
 		if (response.status >= 300 && response.status < 400) {
 			return fn(response.location, file, proxy);
 		}
 
 		if (response.status >= 400) {
-			return Promise.reject(
+			throw (
 				response.error || {
 					code: response.code || response.status,
 					message: response.message || 'mock fetch error',
-				},
+				}
 			);
 		}
-
-		return Promise.resolve();
 	};
 
 	return { calls, fn };
@@ -90,11 +88,10 @@ export function createCopyFetch(sourceFile) {
 	const copyWithRetry = (destination, attempt = 1) => {
 		try {
 			fs.copyFileSync(sourceFile, destination);
-			return Promise.resolve();
 		} catch (error) {
 			const isRetryable = error?.code === 'EPERM' || error?.code === 'EBUSY';
 			if (!isRetryable || attempt === maxAttempts) {
-				return Promise.reject(error);
+				throw error;
 			}
 
 			return delay(25 * attempt).then(() => copyWithRetry(destination, attempt + 1));
@@ -104,8 +101,6 @@ export function createCopyFetch(sourceFile) {
 	const fn = async (url, file, proxy) => {
 		calls.push({ file, proxy, url });
 		await copyWithRetry(file);
-
-		return Promise.resolve();
 	};
 
 	return { calls, fn };

test/integration/runner.ts

@@ -57,7 +57,7 @@ function createReleaseRunner() {
 	const { command, args } = getReleaseCommand();
 
 	return {
-		async clone(source: string, dest: string) {
+		clone(source: string, dest: string) {
 			const result = child_process.spawnSync(command, [...args, source, dest], {
 				encoding: 'utf8',
 				env: process.env,

test/unit/bin.test.ts

@@ -45,6 +45,26 @@ import enquirer from 'enquirer';
 const mockDegit = vi.mocked(degit);
 const mockPrompt = vi.mocked(enquirer.prompt);
 
+type MockDegitInstance = ReturnType<typeof degit>;
+
+function createMockDegit(
+	cloneImpl: () => Promise<void>,
+	handlers?: Record<string, (event: { message: string }) => void>,
+): MockDegitInstance {
+	const instance = {
+		clone: vi.fn(cloneImpl),
+		on(event: string, handler: (event: { message: string }) => void) {
+			if (handlers) {
+				handlers[event] = handler;
+			}
+
+			return instance;
+		},
+	};
+
+	return instance as MockDegitInstance;
+}
+
 async function waitForCondition(fn, timeoutMs = 3000, startedAt = Date.now()) {
 	if (fn()) {
 		return;
@@ -54,22 +74,20 @@ async function waitForCondition(fn, timeoutMs = 3000, startedAt = Date.now()) {
 		assert.fail('timeout waiting for condition');
 	}
 
-	await new Promise((r) => setTimeout(r, 5));
+	await new Promise<void>((resolve) => {
+		setTimeout(resolve, 5);
+	});
 	return waitForCondition(fn, timeoutMs, startedAt);
 }
 
 function mockEventClone(eventName, message) {
-	const handlers = {};
-	mockDegit.mockReturnValue({
-		clone: vi.fn().mockImplementation(() => {
-			handlers[eventName]({ message });
+	const handlers: Record<string, (event: { message: string }) => void> = {};
+	mockDegit.mockReturnValue(
+		createMockDegit(() => {
+			handlers[eventName]?.({ message });
 			return Promise.resolve();
-		}),
-		on: vi.fn(function on(ev, fn) {
-			handlers[ev] = fn;
-			return this;
-		}),
-	} as never);
+		}, handlers),
+	);
 	return handlers;
 }
 
@@ -78,12 +96,9 @@ async function withCloneFailure(
 	error: Error,
 	assertions: (exitSpy: ReturnType<typeof vi.spyOn>, errSpy: ReturnType<typeof vi.spyOn>) => void,
 ) {
-	mockDegit.mockReturnValue({
-		clone: vi.fn().mockReturnValue(Promise.reject(error)),
-		on: vi.fn().mockReturnThis(),
-	} as never);
+	mockDegit.mockReturnValue(createMockDegit(() => Promise.reject(error)));
 
-	const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never);
+	const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
 	const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
 	try {
@@ -97,7 +112,6 @@ async function withCloneFailure(
 	}
 }
 
-describe('degit bin', () => {
 	const binTmp = '.tmp/bin-suite';
 	const repoRoot = process.cwd();
 	const rootBin = path.join(repoRoot, 'degit');
@@ -107,34 +121,32 @@ describe('degit bin', () => {
 		fs.rmSync(interactiveBase, { force: true, recursive: true });
 	}
 
-	beforeEach(async () => {
-		await rimraf(binTmp);
-		clearInteractiveFixtures();
-		vi.clearAllMocks();
-		mockDegit.mockReturnValue({
-			clone: vi.fn().mockResolvedValue(undefined),
-			on: vi.fn().mockReturnThis(),
-		} as never);
-	});
-	afterEach(async () => {
-		await rimraf(binTmp);
-		clearInteractiveFixtures();
-	});
+beforeEach(async () => {
+	await rimraf(binTmp);
+	clearInteractiveFixtures();
+	vi.clearAllMocks();
+	mockDegit.mockReturnValue(createMockDegit(() => Promise.resolve()));
+});
 
-	it('runs the built root bin when --help is executed', () => {
-		const result = child_process.spawnSync('node', [rootBin, '--help'], {
-			env: {
-				...process.env,
-				VITEST: '',
-			},
-			encoding: 'utf8',
-		});
-		const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
-		assert.ok(output.length > 0);
-		assert.ok(output.includes('degit'));
+afterEach(async () => {
+	await rimraf(binTmp);
+	clearInteractiveFixtures();
+});
+
+it('runs the built root bin when --help is executed', () => {
+	const result = child_process.spawnSync('node', [rootBin, '--help'], {
+		env: {
+			...process.env,
+			VITEST: '',
+		},
+		encoding: 'utf8',
 	});
+	const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
+	assert.ok(output.length > 0);
+	assert.ok(output.includes('degit'));
+});
 
-	it('writes help to stdout when argv includes --help', async () => {
+it('writes help to stdout when argv includes --help', async () => {
 		const chunks: string[] = [];
 		const orig = process.stdout.write.bind(process.stdout);
 		process.stdout.write = ((chunk, enc, cb) => {
@@ -158,7 +170,7 @@ describe('degit bin', () => {
 		await main(['node', 'bin', 'user/repo', 'out', '-f']);
 		assert.equal(mockDegit.mock.calls.length, 1);
 		assert.equal(mockDegit.mock.calls[0][0], 'user/repo');
-		assert.equal((mockDegit.mock.calls[0][1] as any).force, true);
+		assert.equal(mockDegit.mock.calls[0][1]?.force, true);
 		const instance = mockDegit.mock.results[0].value;
 		assert.equal(instance.clone.mock.calls[0][0], 'out');
 	});
@@ -180,7 +192,7 @@ describe('degit bin', () => {
 			JSON.stringify({ main: '2026-01-01T00:00:00.000Z' }),
 		);
 
-		mockPrompt.mockImplementation(async (questions) => {
+		mockPrompt.mockImplementation((questions) => {
 			const srcQuestion = (
 				questions as Array<{ name?: string; choices?: Array<{ value: string }> }>
 			).find((question) => question.name === 'src');
@@ -269,10 +281,7 @@ describe('degit bin', () => {
 	});
 
 	it('forwards explicit git mode when argv passes --mode=git', async () => {
-		mockDegit.mockReturnValue({
-			clone: vi.fn().mockResolvedValue(undefined),
-			on: vi.fn().mockReturnThis(),
-		} as never);
+		mockDegit.mockReturnValue(createMockDegit(() => Promise.resolve()));
 		const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
 		try {
 			await main(['node', 'bin', 'a/b', 'dest', '--mode=git']);
@@ -284,4 +293,3 @@ describe('degit bin', () => {
 			warnSpy.mockRestore();
 		}
 	});
-});