bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/guides/test/{coverage-threshold.md → coverage-threshold.mdx}

@@ -1,12 +1,16 @@
 ---
-name: Set a code coverage threshold with the Bun test runner
+title: Set a code coverage threshold with the Bun test runner
+sidebarTitle: Coverage threshold
+mode: center
 ---
 
 Bun's test runner supports built-in code coverage reporting via the `--coverage` flag.
 
-```sh
-$ bun test --coverage
+```sh terminal icon="terminal"
+bun test --coverage
+```
 
+```txt
 test.test.ts:
 ✓ math > add [0.71ms]
 ✓ math > multiply [0.03ms]
@@ -28,7 +32,7 @@ All files    |   66.67 |   77.78 |
 
 To set a minimum coverage threshold, add the following line to your `bunfig.toml`. This requires that 90% of your codebase is covered by tests.
 
-```toml
+```toml bunfig.toml icon="settings"
 [test]
 # to require 90% line-level and function-level coverage
 coverageThreshold = 0.9
@@ -38,8 +42,11 @@ coverageThreshold = 0.9
 
 If your test suite does not meet this threshold, `bun test` will exit with a non-zero exit code to signal a failure.
 
-```sh
-$ bun test --coverage
+```sh terminal icon="terminal"
+bun test --coverage
+```
+
+```txt
 <test output>
 $ echo $?
 1 # this is the exit code of the previous command
@@ -49,7 +56,7 @@ $ echo $?
 
 Different thresholds can be set for line-level and function-level coverage.
 
-```toml
+```toml bunfig.toml icon="settings"
 [test]
 # to set different thresholds for lines and functions
 coverageThreshold = { lines = 0.5, functions = 0.7 }

package/docs/guides/test/{coverage.md → coverage.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Generate code coverage reports with the Bun test runner
+title: Generate code coverage reports with the Bun test runner
+sidebarTitle: Coverage reports
+mode: center
 ---
 
 Bun's test runner supports built-in _code coverage reporting_. This makes it easy to see how much of the codebase is covered by tests and find areas that are not currently well-tested.
@@ -10,8 +12,11 @@ Pass the `--coverage` flag to `bun test` to enable this feature. This will print
 
 The coverage report lists the source files that were executed during the test run, the percentage of functions and lines that were executed, and the line ranges that were not executed during the run.
 
-```sh
-$ bun test --coverage
+```sh terminal icon="terminal"
+bun test --coverage
+```
+
+```txt
 
 test.test.ts:
 ✓ math > add [0.71ms]
@@ -34,7 +39,7 @@ All files    |   66.67 |   77.78 |
 
 To always enable coverage reporting by default, add the following line to your `bunfig.toml`:
 
-```toml
+```toml bunfig.toml icon="settings"
 [test]
 coverage = true # always enable coverage
 ```

package/docs/guides/test/{happy-dom.md → happy-dom.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Write browser DOM tests with Bun and happy-dom
+title: Write browser DOM tests with Bun and happy-dom
+sidebarTitle: DOM tests
+mode: center
 ---
 
 You can write and run browser tests with Bun's test runner in conjunction with [Happy DOM](https://github.com/capricorn86/happy-dom). Happy DOM implements mocked versions of browser APIs like `document` and `location`.
@@ -8,15 +10,15 @@ You can write and run browser tests with Bun's test runner in conjunction with [
 
 To get started, install `happy-dom`.
 
-```sh
-$ bun add -d @happy-dom/global-registrator
+```sh terminal icon="terminal"
+bun add -d @happy-dom/global-registrator
 ```
 
 ---
 
 This module exports a "registrator" that injects the mocked browser APIs to the global scope.
 
-```ts#happydom.ts
+```ts happydom.ts icon="/icons/typescript.svg"
 import { GlobalRegistrator } from "@happy-dom/global-registrator";
 
 GlobalRegistrator.register();
@@ -28,7 +30,7 @@ We need to make sure this file is executed before any of our test files. That's
 
 The `./happydom.ts` file should contain the registration code above.
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [test]
 preload = "./happydom.ts"
 ```
@@ -37,7 +39,7 @@ preload = "./happydom.ts"
 
 Now running `bun test` inside our project will automatically execute `happydom.ts` first. We can start writing tests that use browser APIs.
 
-```ts
+```ts dom.test.ts icon="/icons/typescript.svg"
 import { test, expect } from "bun:test";
 
 test("set button text", () => {
@@ -51,8 +53,11 @@ test("set button text", () => {
 
 With Happy DOM properly configured, this test runs as expected.
 
-```sh
-$ bun test
+```sh terminal icon="terminal"
+bun test
+```
+
+```txt
 
 dom.test.ts:
 ✓ set button text [0.82ms]

package/docs/guides/test/{migrate-from-jest.md → migrate-from-jest.mdx}

@@ -1,13 +1,15 @@
 ---
-name: Migrate from Jest to Bun's test runner
+title: Migrate from Jest to Bun's test runner
+sidebarTitle: Migrate from Jest
+mode: center
 ---
 
 In many cases, Bun's test runner can run Jest test suites with no code changes. Just run `bun test` instead of `npx jest`, `yarn test`, etc.
 
-```sh
-- $ npx jest
-- $ yarn test
-+ $ bun test
+```sh terminal icon="terminal"
+npx jest # [!code --]
+yarn test # [!code --]
+bun test # [!code ++]
 ```
 
 ---
@@ -19,9 +21,9 @@ There's often no need for code changes.
 
 But if you'd rather switch to the `bun:test` imports, you can do that too.
 
-```ts-diff
-- import {test, expect} from "@jest/globals";
-+ import {test, expect} from "bun:test";
+```ts title="test.ts" icon="/icons/typescript.svg"
+import { test, expect } from "@jest/globals"; // [!code --]
+import { test, expect } from "bun:test"; // [!code ++]
 ```
 
 ---
@@ -34,7 +36,7 @@ Add this directive to _just one file_ in your project, such as:
 - Your test `preload.ts` setup file (if using `preload` in bunfig.toml)
 - Any single `.ts` file that TypeScript includes in your compilation
 
-```ts
+```ts title="global.d.ts" icon="/icons/typescript.svg"
 /// <reference types="bun-types/test-globals" />
 ```
 
@@ -42,7 +44,7 @@ Add this directive to _just one file_ in your project, such as:
 
 Once added, all test files in your project automatically get TypeScript support for Jest globals:
 
-```ts#math.test.ts
+```ts math.test.ts icon="/icons/typescript.svg"
 describe("my test suite", () => {
   test("should work", () => {
     expect(1 + 1).toBe(2);
@@ -72,7 +74,7 @@ If you're using `testEnvironment: "jsdom"` to run your tests in a browser-like e
 
 At the moment jsdom does not work in Bun due to its internal use of V8 APIs. Track support for it [here](https://github.com/oven-sh/bun/issues/3554).
 
-```toml#bunfig.toml
+```toml bunfig.toml
 [test]
 preload = ["./happy-dom.ts"]
 ```
@@ -81,44 +83,24 @@ preload = ["./happy-dom.ts"]
 
 Replace `bail` in your Jest config with the `--bail` CLI flag.
 
-<!-- ```ts-diff
-- import type {Config} from 'jest';
--
-- const config: Config = {
--   bail: 3
-- };
-``` -->
-
-```sh
-$ bun test --bail=3
+```sh terminal icon="terminal"
+bun test --bail=3
 ```
 
 ---
 
 Replace `collectCoverage` with the `--coverage` CLI flag.
 
-<!-- ```ts-diff
-- import type {Config} from 'jest';
--
-- const config: Config = {
--   collectCoverageFrom: [
--     '**/*.{js,jsx}',
--     '!**/node_modules/**',
--     '!**/vendor/**',
--   ],
-- };
-``` -->
-
-```sh
-$ bun test --coverage
+```sh terminal icon="terminal"
+bun test --coverage
 ```
 
 ---
 
 Replace `testTimeout` with the `--test-timeout` CLI flag.
 
-```sh
-$ bun test --timeout 10000
+```sh terminal icon="terminal"
+bun test --timeout 10000
 ```
 
 ---

package/docs/guides/test/{mock-clock.md → mock-clock.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Set the system time in Bun's test runner
+title: Set the system time in Bun's test runner
+sidebarTitle: Mock system time
+mode: center
 ---
 
 Bun's test runner supports setting the system time programmatically with the `setSystemTime` function.

package/docs/guides/test/{mock-functions.md → mock-functions.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Mock functions in `bun test`
+title: Mock functions in `bun test`
+sidebarTitle: Mock functions
+mode: center
 ---
 
 Create mocks with the `mock` function from `bun:test`.
 
-```ts
+```ts test.ts icon="/icons/typescript.svg"
 import { test, expect, mock } from "bun:test";
 
 const random = mock(() => Math.random());
@@ -14,7 +16,7 @@ const random = mock(() => Math.random());
 
 The mock function can accept arguments.
 
-```ts
+```ts test.ts icon="/icons/typescript.svg"
 import { test, expect, mock } from "bun:test";
 
 const random = mock((multiplier: number) => multiplier * Math.random());
@@ -24,7 +26,7 @@ const random = mock((multiplier: number) => multiplier * Math.random());
 
 The result of `mock()` is a new function that's been decorated with some additional properties.
 
-```ts
+```ts test.ts icon="/icons/typescript.svg"
 import { mock } from "bun:test";
 
 const random = mock((multiplier: number) => multiplier * Math.random());
@@ -46,7 +48,7 @@ random.mock.results;
 
 These extra properties make it possible to write `expect` assertions about usage of the mock function, including how many times it was called, the arguments, and the return values.
 
-```ts
+```ts test.ts icon="/icons/typescript.svg"
 import { test, expect, mock } from "bun:test";
 
 const random = mock((multiplier: number) => multiplier * Math.random());

package/docs/guides/test/{rerun-each.md → rerun-each.mdx}

@@ -1,12 +1,14 @@
 ---
-name: Re-run tests multiple times with the Bun test runner
+title: Re-run tests multiple times with the Bun test runner
+sidebarTitle: Re-run tests
+mode: center
 ---
 
 Use the `--rerun-each` flag to re-run every test multiple times with the Bun test runner. This is useful for finding flaky or non-deterministic tests.
 
-```sh
+```sh terminal icon="terminal"
 # re-run each test 10 times
-$ bun test --rerun-each 10
+bun test --rerun-each 10
 ```
 
 ---

package/docs/guides/test/{run-tests.md → run-tests.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Run your tests with the Bun test runner
+title: Run your tests with the Bun test runner
+sidebarTitle: Run tests
+mode: center
 ---
 
 Bun has a built-in [test runner](https://bun.sh/docs/cli/test) with a Jest-like `expect` API.
@@ -8,7 +10,7 @@ Bun has a built-in [test runner](https://bun.sh/docs/cli/test) with a Jest-like
 
 To use it, run the `bun test` command from your project directory. The test runner will recursively search for all files in the directory that match the following patterns and execute the tests they contain.
 
-```txt
+```txt File Tree icon="folder-tree"
 *.test.{js|jsx|ts|tsx}
 *_test.{js|jsx|ts|tsx}
 *.spec.{js|jsx|ts|tsx}
@@ -19,10 +21,11 @@ To use it, run the `bun test` command from your project directory. The test runn
 
 Here's what the output of a typical test run looks like. In this case, there are three tests files (`test.test.js`, `test2.test.js`, and `test3.test.js`) containing two tests each (`add` and `multiply`).
 
-```sh
-$ bun test
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test
+```
 
+```txt
 test.test.js:
 ✓ add [0.87ms]
 ✓ multiply [0.02ms]
@@ -45,10 +48,11 @@ Ran 6 tests across 3 files. [9.00ms]
 
 To only run certain test files, pass a positional argument to `bun test`. The runner will only execute files that contain that argument in their path.
 
-```sh
-$ bun test test3
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test test3
+```
 
+```txt
 test3.test.js:
 ✓ add [1.40ms]
 ✓ multiply [0.03ms]
@@ -83,10 +87,11 @@ To filter which tests are executed by name, use the `-t`/`--test-name-pattern` f
 
 Adding `-t add` will only run tests with "add" in the name. This works with test names defined with `test` or test suite names defined with `describe`.
 
-```sh
-$ bun test -t add
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test -t add
+```
 
+```txt
 test.test.js:
 ✓ add [1.79ms]
 » multiply

package/docs/guides/test/{skip-tests.md → skip-tests.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Skip tests with the Bun test runner
+title: Skip tests with the Bun test runner
+sidebarTitle: Skip tests
+mode: center
 ---
 
 To skip a test with the Bun test runner, use the `test.skip` function.
 
-```ts
+```ts test.ts icon="/icons/typescript.svg"
 import { test } from "bun:test";
 
 test.skip("unimplemented feature", () => {
@@ -16,9 +18,11 @@ test.skip("unimplemented feature", () => {
 
 Running `bun test` will not execute this test. It will be marked as skipped in the terminal output.
 
-```sh
-$ bun test
+```sh terminal icon="terminal"
+bun test
+```
 
+```txt
 test.test.ts:
 ✓ add [0.03ms]
 ✓ multiply [0.02ms]

package/docs/guides/test/{snapshot.md → snapshot.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Use snapshot testing in `bun test`
+title: Use snapshot testing in `bun test`
+sidebarTitle: Snapshot testing
+mode: center
 ---
 
 Bun's test runner supports Jest-style snapshot testing via `.toMatchSnapshot()`.
 
-```ts#snap.test.ts
+```ts snap.test.ts icon="/icons/typescript.svg"
 import { test, expect } from "bun:test";
 
 test("snapshot", () => {
@@ -16,10 +18,11 @@ test("snapshot", () => {
 
 The first time this test is executed, Bun will evaluate the value passed into `expect()` and write it to disk in a directory called `__snapshots__` that lives alongside the test file. (Note the `snapshots: +1 added` line in the output.)
 
-```sh
-$ bun test test/snap
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test test/snap
+```
 
+```txt
 test/snap.test.ts:
 ✓ snapshot [1.48ms]
 
@@ -34,7 +37,7 @@ Ran 1 tests across 1 files. [82.00ms]
 
 The `__snapshots__` directory contains a `.snap` file for each test file in the directory.
 
-```txt
+```txt File Tree icon="folder-tree"
 test
 ├── __snapshots__
 │   └── snap.test.ts.snap
@@ -45,7 +48,7 @@ test
 
 The `snap.test.ts.snap` file is a JavaScript file that exports a serialized version of the value passed into `expect()`. The `{foo: "bar"}` object has been serialized to JSON.
 
-```js
+```js snap.test.ts.snap icon="file-code"
 // Bun Snapshot v1, https://bun.sh/docs/test/snapshots
 
 exports[`snapshot 1`] = `
@@ -59,10 +62,12 @@ exports[`snapshot 1`] = `
 
 Later, when this test file is executed again, Bun will read the snapshot file and compare it to the value passed into `expect()`. If the values are different, the test will fail.
 
-```sh
-$ bun test
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test
+bun test v1.3.1 (9c68abdb)
+```
 
+```txt
 test/snap.test.ts:
 ✓ snapshot [1.05ms]
 
@@ -76,10 +81,12 @@ Ran 1 tests across 1 files. [101.00ms]
 
 To update snapshots, use the `--update-snapshots` flag.
 
-```sh
-$ bun test --update-snapshots
-bun test v1.3.2-canary.20251105T140650 (9c68abdb)
+```sh terminal icon="terminal"
+bun test --update-snapshots
+bun test v1.3.1 (9c68abdb)
+```
 
+```txt
 test/snap.test.ts:
 ✓ snapshot [0.86ms]
 

package/docs/guides/test/spy-on.mdx

@@ -0,0 +1,49 @@
+---
+title: Spy on methods in `bun test`
+sidebarTitle: Spy on methods
+mode: center
+---
+
+Use the `spyOn` utility to track method calls with Bun's test runner.
+
+```ts
+import { test, expect, spyOn } from "bun:test";
+
+const leo = {
+  name: "Leonardo",
+  sayHi(thing: string) {
+    console.log(`Sup I'm ${this.name} and I like ${thing}`);
+  },
+};
+
+const spy = spyOn(leo, "sayHi");
+```
+
+---
+
+Once the spy is created, it can be used to write `expect` assertions relating to method calls.
+
+```ts
+import { test, expect, spyOn } from "bun:test";
+
+const leo = {
+  name: "Leonardo",
+  sayHi(thing: string) {
+    console.log(`Sup I'm ${this.name} and I like ${thing}`);
+  },
+};
+
+const spy = spyOn(leo, "sayHi");
+
+test("turtles", () => {
+  // [!code ++]
+  expect(spy).toHaveBeenCalledTimes(0); // [!code ++]
+  leo.sayHi("pizza"); // [!code ++]
+  expect(spy).toHaveBeenCalledTimes(1); // [!code ++]
+  expect(spy.mock.calls).toEqual([["pizza"]]); // [!code ++]
+}); // [!code ++]
+```
+
+---
+
+See [Docs > Test Runner > Mocks](https://bun.sh/docs/test/mocks) for complete documentation on mocking with the Bun test runner.

package/docs/guides/test/{svelte-test.md → svelte-test.mdx}

@@ -1,18 +1,20 @@
 ---
-name: "import, require, and test Svelte components with bun test"
+title: "import, require, and test Svelte components with bun test"
+sidebarTitle: Test Svelte
+mode: center
 ---
 
-Bun's [Plugin API](/docs/runtime/plugins) lets you add custom loaders to your project. The `test.preload` option in `bunfig.toml` lets you configure your loader to start before your tests run.
+Bun's [Plugin API](/runtime/plugins) lets you add custom loaders to your project. The `test.preload` option in `bunfig.toml` lets you configure your loader to start before your tests run.
 
 Firstly, install `@testing-library/svelte`, `svelte`, and `@happy-dom/global-registrator`.
 
-```bash
-$ bun add @testing-library/svelte svelte@4 @happy-dom/global-registrator
+```bash terminal icon="terminal"
+bun add @testing-library/svelte svelte@4 @happy-dom/global-registrator
 ```
 
 Then, save this plugin in your project.
 
-```ts#svelte-loader.js
+```ts svelte-loader.js icon="/icons/typescript.svg"
 import { plugin } from "bun";
 import { compile } from "svelte/compiler";
 import { readFileSync } from "fs";
@@ -28,20 +30,14 @@ afterEach(async () => {
 });
 
 plugin({
-  name: "svelte loader",
+  title: "svelte loader",
   setup(builder) {
     builder.onLoad({ filter: /\.svelte(\?[^.]+)?$/ }, ({ path }) => {
       try {
-        const source = readFileSync(
-          path.substring(
-            0,
-            path.includes("?") ? path.indexOf("?") : path.length
-          ),
-          "utf-8"
-        );
+        const source = readFileSync(path.substring(0, path.includes("?") ? path.indexOf("?") : path.length), "utf-8");
 
         const result = compile(source, {
-          filename: path,
+          filetitle: path,
           generate: "client",
           dev: false,
         });
@@ -56,14 +52,13 @@ plugin({
     });
   },
 });
-
 ```
 
 ---
 
 Add this to `bunfig.toml` to tell Bun to preload the plugin, so it loads before your tests run.
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [test]
 # Tell Bun to load this plugin before your tests run
 preload = ["./svelte-loader.js"]
@@ -76,20 +71,20 @@ preload = ["./svelte-loader.js"]
 
 Add an example `.svelte` file in your project.
 
-```html#Counter.svelte
+```html Counter.svelte icon="file-code"
 <script>
   export let initialCount = 0;
   let count = initialCount;
 </script>
 
-<button on:click={() => (count += 1)}>+1</button>
+<button on:click="{()" ="">(count += 1)}>+1</button>
 ```
 
 ---
 
 Now you can `import` or `require` `*.svelte` files in your tests, and it will load the Svelte component as a JavaScript module.
 
-```ts#hello-svelte.test.ts
+```ts hello-svelte.test.ts icon="/icons/typescript.svg"
 import { test, expect } from "bun:test";
 import { render, fireEvent } from "@testing-library/svelte";
 import Counter from "./Counter.svelte";
@@ -113,8 +108,6 @@ test("Counter increments when clicked", async () => {
 
 Use `bun test` to run your tests.
 
-```bash
-$ bun test
+```bash terminal icon="terminal"
+bun test
 ```
-
----