bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/ecosystem/stric.md

@@ -1,38 +0,0 @@
-[Stric](https://github.com/bunsvr) is a minimalist, fast web framework for Bun.
-
-```ts#index.ts
-import { Router } from '@stricjs/router';
-
-// Export the fetch handler and serve with Bun
-export default new Router()
-  // Return 'Hi' on every request
-  .get('/', () => new Response('Hi'));
-```
-
-Stric provides support for [ArrowJS](https://www.arrow-js.com), a library for building reactive interfaces.
-
-{% codetabs %}
-
-```ts#src/App.ts
-import { html } from '@stricjs/arrow/utils';
-
-// Code inside this function can use web APIs
-export function render() {
-  // Render a <p> element with text 'Hi'
-  html`<p>Hi</p>`;
-};
-
-// Set the path to handle
-export const path = '/';
-```
-
-```ts#index.ts
-import { PageRouter } from '@stricjs/arrow';
-
-// Create a page router, build and serve directly
-new PageRouter().serve();
-```
-
-{% /codetabs %}
-
-For more info, see Stric's [documentation](https://stricjs.gitbook.io/docs).

package/docs/guides/ecosystem/prisma.md

@@ -1,141 +0,0 @@
----
-name: Use Prisma with Bun
----
-
-{% callout %}
-**Note** — At the moment Prisma needs Node.js to be installed to run certain generation code. Make sure Node.js is installed in the environment where you're running `bunx prisma` commands.
-{% /callout %}
-
----
-
-Prisma works out of the box with Bun. First, create a directory and initialize it with `bun init`.
-
-```bash
-$ mkdir prisma-app
-$ cd prisma-app
-$ bun init
-```
-
----
-
-Then install the Prisma CLI (`prisma`) and Prisma Client (`@prisma/client`) as dependencies.
-
-```bash
-$ bun add -d prisma
-$ bun add @prisma/client
-```
-
----
-
-We'll use the Prisma CLI with `bunx` to initialize our schema and migration directory. For simplicity we'll be using an in-memory SQLite database.
-
-```bash
-$ bunx --bun prisma init --datasource-provider sqlite
-```
-
----
-
-Open `prisma/schema.prisma` and add a simple `User` model.
-
-```prisma-diff#prisma/schema.prisma
-  generator client {
-    provider = "prisma-client-js"
-    output = "../generated/prisma"
-  }
-
-  datasource db {
-    provider = "sqlite"
-    url      = env("DATABASE_URL")
-  }
-
-+ model User {
-+   id    Int     @id @default(autoincrement())
-+   email String  @unique
-+   name  String?
-+ }
-```
-
----
-
-Then generate and run initial migration.
-
-This will generate a `.sql` migration file in `prisma/migrations`, create a new SQLite instance, and execute the migration against the new instance.
-
-```bash
-$ bunx prisma migrate dev --name init
-Environment variables loaded from .env
-Prisma schema loaded from prisma/schema.prisma
-Datasource "db": SQLite database "dev.db" at "file:./dev.db"
-
-SQLite database dev.db created at file:./dev.db
-
-Applying migration `20230928182242_init`
-
-The following migration(s) have been created and applied from new schema changes:
-
-migrations/
-  └─ 20230928182242_init/
-    └─ migration.sql
-
-Your database is now in sync with your schema.
-
-✔ Generated Prisma Client (v6.11.1) to ./generated/prisma in 41ms
-```
-
----
-
-As indicated in the output, Prisma re-generates our _Prisma client_ whenever we execute a new migration. The client provides a fully typed API for reading and writing from our database. You can manually re-generate the client with the Prisma CLI.
-
-```sh
-$ bunx prisma generate
-```
-
----
-
-We can import the generated client from `@prisma/client`.
-
-```ts#src/index.ts
-import {PrismaClient} from "@prisma/client";
-```
-
----
-
-Let's write a simple script to create a new user, then count the number of users in the database.
-
-```ts#index.ts
-import { PrismaClient } from "@prisma/client";
-
-const prisma = new PrismaClient();
-
-// create a new user
-await prisma.user.create({
-  data: {
-    name: "John Dough",
-    email: `john-${Math.random()}@example.com`,
-  },
-});
-
-// count the number of users
-const count = await prisma.user.count();
-console.log(`There are ${count} users in the database.`);
-```
-
----
-
-Let's run this script with `bun run`. Each time we run it, a new user is created.
-
-```bash
-$ bun run index.ts
-Created john-0.12802932895402364@example.com
-There are 1 users in the database.
-$ bun run index.ts
-Created john-0.8671308799782803@example.com
-There are 2 users in the database.
-$ bun run index.ts
-Created john-0.4465968383115295@example.com
-There are 3 users in the database.
-```
-
----
-
-That's it! Now that you've set up Prisma using Bun, we recommend referring to the [official Prisma docs](https://www.prisma.io/docs/concepts/components/prisma-client) as you continue to develop your application.

package/docs/guides/ecosystem/render.md

@@ -1,79 +0,0 @@
----
-name: Deploy a Bun application on Render
----
-
-[Render](https://render.com/) is a cloud platform that lets you flexibly build, deploy, and scale your apps.
-
-It offers features like auto deploys from GitHub, a global CDN, private networks, automatic HTTPS setup, and managed PostgreSQL and Redis.
-
-Render supports Bun natively. You can deploy Bun apps as web services, background workers, cron jobs, and more.
-
----
-
-As an example, let's deploy a simple Express HTTP server to Render.
-
----
-
-Create a new GitHub repo named `myapp`. Git clone it locally.
-
-```sh
-$ git clone git@github.com:my-github-username/myapp.git
-$ cd myapp
-```
-
----
-
-Add the Express library.
-
-```sh
-$ bun add express
-```
-
----
-
-Define a simple server with Express:
-
-```ts#app.ts
-import express from "express";
-
-const app = express();
-const port = process.env.PORT || 3001;
-
-app.get("/", (req, res) => {
-  res.send("Hello World!");
-});
-
-app.listen(port, () => {
-  console.log(`Listening on port ${port}...`);
-});
-```
-
----
-
-Commit your changes and push to GitHub.
-
-```sh
-$ git add app.ts bun.lock package.json
-$ git commit -m "Create simple Express app"
-$ git push origin main
-```
-
----
-
-In your [Render Dashboard](https://dashboard.render.com/), click `New` > `Web Service` and connect your `myapp` repo.
-
----
-
-In the Render UI, provide the following values during web service creation:
-
-|                   |               |
-| ----------------- | ------------- |
-| **Runtime**       | `Node`        |
-| **Build Command** | `bun install` |
-| **Start Command** | `bun app.ts`  |
-
----
-
-That's it! Your web service will be live at its assigned `onrender.com` URL as soon as the build finishes.
-
-You can view the [deploy logs](https://docs.render.com/logging#logs-for-an-individual-deploy-or-job) for details. Refer to [Render's documentation](https://docs.render.com/deploys) for a complete overview of deploying on Render.

package/docs/guides/install/add-git.md

@@ -1,36 +0,0 @@
----
-name: Add a Git dependency
----
-
-Bun supports directly adding GitHub repositories as dependencies of your project.
-
-```sh
-$ bun add github:lodash/lodash
-```
-
----
-
-This will add the following line to your `package.json`:
-
-```json-diff#package.json
-{
-  "dependencies": {
-+   "lodash": "github:lodash/lodash"
-  }
-}
-```
-
----
-
-Bun supports a number of protocols for specifying Git dependencies.
-
-```sh
-$ bun add git+https://github.com/lodash/lodash.git
-$ bun add git+ssh://github.com/lodash/lodash.git#4.17.21
-$ bun add git@github.com:lodash/lodash.git
-$ bun add github:colinhacks/zod
-```
-
----
-
-See [Docs > Package manager](https://bun.com/docs/cli/install) for complete documentation of Bun's package manager.

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

@@ -1,46 +0,0 @@
----
-name: Spy on methods in `bun test`
----
-
-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-diff
-  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", ()=>{
-+   expect(spy).toHaveBeenCalledTimes(0);
-+   leo.sayHi("pizza");
-+   expect(spy).toHaveBeenCalledTimes(1);
-+   expect(spy.mock.calls).toEqual([[ "pizza" ]]);
-+ })
-```
-
----
-
-See [Docs > Test Runner > Mocks](https://bun.sh/docs/test/mocks) for complete documentation on mocking with the Bun test runner.

package/docs/install/index.md

@@ -1,248 +0,0 @@
-The `bun` CLI contains an `npm`-compatible package manager designed to be a faster replacement for existing package management tools like `npm`, `yarn`, and `pnpm`. It's designed for Node.js compatibility; use it in any Bun or Node.js project.
-
-{% callout %}
-
-**⚡️ 80x faster** — Switch from `npm install` to `bun install` in any Node.js project to make your installations up to 80x faster.
-
-{% image src="https://user-images.githubusercontent.com/709451/147004342-571b6123-17a9-49a2-8bfd-dcfc5204047e.png" height="200" /%}
-
-{% /callout %}
-
-{% details summary="For Linux users" %}
-The minimum Linux Kernel version is 5.1. If you're on Linux kernel 5.1 - 5.5, `bun install` should still work, but HTTP requests will be slow due to a lack of support for io_uring's `connect()` operation.
-
-If you're using Ubuntu 20.04, here's how to install a [newer kernel](https://wiki.ubuntu.com/Kernel/LTSEnablementStack):
-
-```bash
-# If this returns a version >= 5.6, you don't need to do anything
-uname -r
-
-# Install the official Ubuntu hardware enablement kernel
-sudo apt install --install-recommends linux-generic-hwe-20.04
-```
-
-{% /details %}
-
-## Manage dependencies
-
-### `bun install`
-
-To install all dependencies of a project:
-
-```bash
-$ bun install
-```
-
-On Linux, `bun install` tends to install packages 20-100x faster than `npm install`. On macOS, it's more like 4-80x.
-
-![package install benchmark](https://user-images.githubusercontent.com/709451/147004342-571b6123-17a9-49a2-8bfd-dcfc5204047e.png)
-
-Running `bun install` will:
-
-- **Install** all `dependencies`, `devDependencies`, and `optionalDependencies`. Bun will install `peerDependencies` by default.
-- **Run** your project's `{pre|post}install` scripts at the appropriate time. For security reasons Bun _does not execute_ lifecycle scripts of installed dependencies.
-- **Write** a `bun.lock` lockfile to the project root.
-
-To install in production mode (i.e. without `devDependencies`):
-
-```bash
-$ bun install --production
-```
-
-To install dependencies without allowing changes to lockfile (useful on CI):
-
-```bash
-$ bun install --frozen-lockfile
-```
-
-To exclude dependency types from installing, use `--omit` with `dev`, `optional`, or `peer`:
-
-```bash
-# Disable devDependencies and optionalDependencies
-$ bun install --omit=dev --omit=optional
-```
-
-To perform a dry run (i.e. don't actually install anything or update the lockfile):
-
-```bash
-$ bun install --dry-run
-```
-
-To generate a lockfile without install packages:
-
-```bash
-$ bun install --lockfile-only
-```
-
-To modify logging verbosity:
-
-```bash
-$ bun install --verbose # debug logging
-$ bun install --silent  # no logging
-```
-
-To use isolated installs instead of the default hoisted strategy:
-
-```bash
-$ bun install --linker isolated
-```
-
-Isolated installs create strict dependency isolation similar to pnpm, preventing phantom dependencies and ensuring more deterministic builds. For complete documentation, see [Isolated installs](https://bun.com/docs/install/isolated).
-
-To protect against supply chain attacks, set a minimum age (in seconds) for package versions:
-
-```bash
-$ bun install --minimum-release-age 259200 # 3 days
-```
-
-{% details summary="Configuring behavior" %}
-The default behavior of `bun install` can be configured in `bunfig.toml`:
-
-```toml
-[install]
-
-# whether to install optionalDependencies
-optional = true
-
-# whether to install devDependencies
-dev = true
-
-# whether to install peerDependencies
-peer = true
-
-# equivalent to `--production` flag
-production = false
-
-# equivalent to `--save-text-lockfile` flag
-saveTextLockfile = false
-
-# equivalent to `--frozen-lockfile` flag
-frozenLockfile = false
-
-# equivalent to `--dry-run` flag
-dryRun = false
-
-# equivalent to `--concurrent-scripts` flag
-concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
-
-# installation strategy: "hoisted" or "isolated"
-# default: "hoisted"
-linker = "hoisted"
-
-# minimum package age in seconds (protects against supply chain attacks)
-minimumReleaseAge = 259200 # 3 days
-
-# exclude packages from age requirement
-minimumReleaseAgeExcludes = ["@types/node", "typescript"]
-```
-
-{% /details %}
-
-### `bun add`
-
-To add a particular package:
-
-```bash
-$ bun add preact
-```
-
-To specify a version, version range, or tag:
-
-```bash
-$ bun add zod@3.20.0
-$ bun add zod@^3.0.0
-$ bun add zod@latest
-```
-
-To add a package as a dev dependency (`"devDependencies"`):
-
-```bash
-$ bun add --dev @types/react
-$ bun add -d @types/react
-```
-
-To add a package as an optional dependency (`"optionalDependencies"`):
-
-```bash
-$ bun add --optional lodash
-```
-
-To add a package as a peer dependency (`"peerDependencies"`):
-
-```bash
-$ bun add --peer @types/bun
-```
-
-To install a package globally:
-
-```bash
-$ bun add --global cowsay # or `bun add -g cowsay`
-$ cowsay "Bun!"
- ______
-< Bun! >
- ------
-        \   ^__^
-         \  (oo)\_______
-            (__)\       )\/\
-                ||----w |
-                ||     ||
-```
-
-{% details summary="Configuring global installation behavior" %}
-
-```toml
-[install]
-# where `bun install --global` installs packages
-globalDir = "~/.bun/install/global"
-
-# where globally-installed package bins are linked
-globalBinDir = "~/.bun/bin"
-```
-
-{% /details %}
-To view a complete list of options for a given command:
-
-```bash
-$ bun add --help
-```
-
-### `bun remove`
-
-To remove a dependency:
-
-```bash
-$ bun remove preact
-```
-
-## Git dependencies
-
-To add a dependency from a git repository:
-
-```bash
-$ bun install git@github.com:moment/moment.git
-```
-
-Bun supports a variety of protocols, including [`github`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#github-urls), [`git`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#git-urls-as-dependencies), `git+ssh`, `git+https`, and many more.
-
-```json
-{
-  "dependencies": {
-    "dayjs": "git+https://github.com/iamkun/dayjs.git",
-    "lodash": "git+ssh://github.com/lodash/lodash.git#4.17.21",
-    "moment": "git@github.com:moment/moment.git",
-    "zod": "github:colinhacks/zod"
-  }
-}
-```
-
-## Tarball dependencies
-
-A package name can correspond to a publicly hosted `.tgz` file. During `bun install`, Bun will download and install the package from the specified tarball URL, rather than from the package registry.
-
-```json#package.json
-{
-  "dependencies": {
-    "zod": "https://registry.npmjs.org/zod/-/zod-3.21.4.tgz"
-  }
-}
-```