Add TypeScript type definitions for package exports

[Copilot]

Plan: Add TypeScript type definitions for exports

• Understand repository structure and exports
• Create type definitions for ./jest export (jest.d.ts)
  • Re-export types from @jest/globals
• Create type definitions for ./expect export (expect.d.ts)
  • Re-export types from expect package
• Create type definitions for ./node export (node.d.ts)
  • Re-export types from node:test module (@types/node)
• Create type definitions for ./mock export (mock.d.ts)
  • Custom types for Exodus-specific APIs
• Create type definitions for ./tape export (tape.d.ts)
  • Custom types for tape-compatible API
• Create type definitions for ./benchmark export (benchmark.d.ts)
  • Custom types for benchmark API
• Update package.json to reference type definitions in exports
• Update tsconfig.json paths to point to .d.ts files
• Test TypeScript integration with type checking
• Fix type definitions to use declare keyword for esbuild compatibility
• Run linter and format code with prettier
• Address code review feedback
• Remove package-lock.json and add to .gitignore (repo uses pnpm)

Key Changes

This PR adds TypeScript type definitions for all package exports by re-exporting from official type packages wherever possible, following the "borrow from jest, node, etc" approach suggested in the issue.

Type Definitions Added

All type definition files now leverage official type definitions from the ecosystem:

• expect.d.ts (11 lines): Re-exports types from the expect package (existing optionalDependency)
• jest.d.ts (28 lines): Re-exports types from @jest/globals (existing devDependency)
• node.d.ts (28 lines): Re-exports types from node:test module (@types/node)
• mock.d.ts (49 lines): Custom types for Exodus-specific utilities (fetchReplay, websocketRecord, timersSpeedup, etc.)
• tape.d.ts (154 lines): Custom types for tape-compatible API
• benchmark.d.ts (35 lines): Custom types for benchmark API

Benefits

• Reduced maintenance burden: By re-exporting from official packages (expect, @jest/globals, node:test), we avoid maintaining duplicate type definitions
• Better type accuracy: Official type definitions are maintained by their respective package maintainers
• Smaller codebase: Total reduction of ~450 lines by leveraging existing types

Only mock.d.ts, tape.d.ts, and benchmark.d.ts contain custom type definitions for library-specific APIs that don't exist in standard packages.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>typings for exports</issue_title>
<issue_description>can prob "borrow" them from jest, node, etc</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes typings for exports #46

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[ChALkeR]

@copilot this repo uses pnpm, don't add package-lock

[Copilot]

@copilot this repo uses pnpm, don't add package-lock

Removed package-lock.json and added it to .gitignore in commit 7282e61.

[Copilot]

Pull request overview

This PR adds TypeScript type definitions for all package exports, enabling better IDE support and type checking for consumers of the @exodus/test package. The approach leverages official type definitions from ecosystem packages where possible (expect, @jest/globals, node:test) and provides custom types for library-specific APIs.

Changes:

• Added 6 new .d.ts type definition files covering all package exports (jest, node, tape, expect, mock, benchmark)
• Updated package.json exports to reference type definitions using the "types" field
• Updated tsconfig.json paths to point to the new type definition files
• Added package-lock.json to .gitignore (appropriate since repo uses pnpm)

Reviewed changes

Copilot reviewed 1 out of 9 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/jest.d.ts	Type definitions for Jest-compatible API (has critical issues with runtime exports)
src/node.d.ts	Type definitions for Node.js test runner API (has critical issues with runtime exports)
src/tape.d.ts	Custom type definitions for tape-compatible testing API
src/expect.d.ts	Type re-exports from expect package
src/mock.d.ts	Custom types for mocking and testing utilities
src/benchmark.d.ts	Custom types for benchmark API (incorrect return type)
package.json	Updated exports with "types" field and added .d.ts files to files array
tsconfig.json	Updated paths to point to .d.ts files instead of .js files
.gitignore	Added package-lock.json (appropriate for pnpm-based project)

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[ChALkeR]

Documentation can be improved later

[Copilot]

Pull request overview

Copilot reviewed 1 out of 9 changed files in this pull request and generated no new comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 1 out of 9 changed files in this pull request and generated no new comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[ChALkeR]

Let's land this and improve on top

[sparten11740]

We could make this generic over args for type checking of fn against args (or vice versa)

Suggested change

	export interface BenchmarkOptions {
	/** Array of arguments to pass to the benchmark function */
	args?: any[]
	/** Timeout in milliseconds (default: 1000) */
	timeout?: number
	/** Skip this benchmark */
	skip?: boolean
	}
	/**
	* Runs a benchmark
	* @param name - Name of the benchmark
	* @param options - Benchmark options
	* @param fn - Function to benchmark
	*/
	export declare function benchmark(
	name: string,
	options: BenchmarkOptions,
	fn: (arg?: any) => any | Promise<any>
	): Promise<void>
	export interface BenchmarkOptions<A> {
	/** Array of arguments to pass to the benchmark function */
	args?: A[]
	/** Timeout in milliseconds (default: 1000) */
	timeout?: number
	/** Skip this benchmark */
	skip?: boolean
	}
	/**
	* Runs a benchmark
	* @param name - Name of the benchmark
	* @param options - Benchmark options
	* @param fn - Function to benchmark
	*/
	export declare function benchmark<A>(
	name: string,
	options: BenchmarkOptions<A>,
	fn: (arg?: A) => any | Promise<any>
	): Promise<void>

[sparten11740]

I just checked the implementation: arg passed to fn is not optional, right? we pass the call count if no args are provided, so we should also accommodate for that in the type:

test/src/benchmark.js

Lines 42 to 45 in b6a9857

	const arg = args ? args[count % args.length] : count
	count++
	const start = getTime()
	const val = fn(arg)

[ChALkeR]

The function can ignore the passed argument
And in many benchmarks, there are no arguments expected by the function

[sparten11740]

The function can ignore the passed argument

it can but that is the point. Functions are contravariant. The function that you provide can accept more general or less parameters than the caller is expected to provide. I.e. you can provide a function that receives no arguments where a function that accepts one parameter is expected.

That also means in our function signature arg should not be optional (marked with a ?). The caller can still pass in a function that accepts no arg based on the contravariance rules

[ChALkeR]

@sparten11740 I will include the types proposed above, thanks!

[sparten11740]

can we improve on this? any type is no type. I am assuming a serializer is a function that accepts some args (what args?) and returns a string?

[ChALkeR]

Fixed in 229d4bd.