Bun TypeScript 支持 #

// index.ts
interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "Bun",
  age: 3,
};

console.log(`Hello, ${user.name}!`);

# 直接运行，无需编译
bun run index.ts

# 安装 Bun 类型
bun add -d bun-types

# 安装 Node.js 类型（兼容层）
bun add -d @types/node

{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ESNext"],
    "strict": true,
    "skipLibCheck": true,
    "noEmit": true,
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "isolatedModules": true
  },
  "include": ["src/**/*", "index.ts"],
  "exclude": ["node_modules"]
}

{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "lib": ["ESNext"],
    "types": ["bun-types"],
    "strict": true,
    "skipLibCheck": true,
    "noEmit": true,
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "react-jsx",
    "jsxImportSource": "react",
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["src/**/*", "*.ts"],
  "exclude": ["node_modules", "dist"]
}

// 原始类型
const name: string = "Bun";
const version: number = 1.2;
const isFast: boolean = true;

// 数组
const numbers: number[] = [1, 2, 3];
const names: Array<string> = ["a", "b", "c"];

// 元组
const tuple: [string, number] = ["Bun", 1];

// 对象
const obj: { name: string; age: number } = {
  name: "Bun",
  age: 3,
};

// any 和 unknown
let anything: any = "anything";
let safe: unknown = "safe";

interface User {
  id: number;
  name: string;
  email: string;
  age?: number;  // 可选属性
  readonly createdAt: Date;  // 只读属性
}

interface Admin extends User {
  role: "admin";
  permissions: string[];
}

const user: User = {
  id: 1,
  name: "Bun",
  email: "bun@example.com",
  createdAt: new Date(),
};

type ID = string | number;

type Status = "pending" | "active" | "inactive";

type User = {
  id: ID;
  name: string;
  status: Status;
};

type Point = {
  x: number;
  y: number;
};

type Vector = Point & {
  z: number;
};

// 泛型函数
function identity<T>(arg: T): T {
  return arg;
}

const str = identity<string>("hello");
const num = identity(42);  // 类型推断

// 泛型接口
interface Response<T> {
  data: T;
  status: number;
  message: string;
}

// 泛型类
class Container<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

// 泛型约束
interface Lengthwise {
  length: number;
}

function logLength<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

// 联合类型
type StringOrNumber = string | number;

function format(input: StringOrNumber): string {
  if (typeof input === "string") {
    return input;
  }
  return input.toString();
}

// 交叉类型
type Name = { name: string };
type Age = { age: number };
type Person = Name & Age;

const person: Person = {
  name: "Bun",
  age: 3,
};

// 类型守卫
function isString(value: unknown): value is string {
  return typeof value === "string";
}

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"],
      "@components/*": ["./src/components/*"],
      "@utils/*": ["./src/utils/*"],
      "@types/*": ["./src/types/*"]
    }
  }
}

// 不使用别名
import { Button } from "../../../components/Button";
import { formatDate } from "../../../utils/format";

// 使用别名
import { Button } from "@/components/Button";
import { formatDate } from "@utils/format";

[run]
# Bun 自动读取 tsconfig.json 的路径映射

// types/global.d.ts
declare global {
  interface Window {
    customProperty: string;
  }

  var globalVar: number;
}

export {};

// types/module.d.ts
declare module "my-module" {
  export function doSomething(): void;
  export const version: string;
}

// 扩展现有模块
declare module "express" {
  interface Request {
    user?: {
      id: string;
      name: string;
    };
  }
}

// env.d.ts
interface ImportMetaEnv {
  readonly VITE_API_URL: string;
  readonly NODE_ENV: string;
}

interface ImportMeta {
  readonly env: ImportMetaEnv;
}

// Partial - 所有属性可选
type PartialUser = Partial<User>;

// Required - 所有属性必需
type RequiredUser = Required<User>;

// Pick - 选择属性
type UserName = Pick<User, "id" | "name">;

// Omit - 排除属性
type UserWithoutEmail = Omit<User, "email">;

// Record - 记录类型
type UserMap = Record<string, User>;

// ReturnType - 返回类型
function getUser() {
  return { id: 1, name: "Bun" };
}
type User = ReturnType<typeof getUser>;

// Parameters - 参数类型
type UserParams = Parameters<typeof getUser>;

// NonNullable - 排除 null 和 undefined
type NonNullableString = NonNullable<string | null | undefined>;

// 条件类型
type IsString<T> = T extends string ? true : false;

type A = IsString<string>;  // true
type B = IsString<number>;  // false

// infer 关键字
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type Result = UnwrapPromise<Promise<string>>;  // string

// 映射类型
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

type Optional<T> = {
  [P in keyof T]?: T[P];
};

// 使用
interface User {
  name: string;
  age: number;
}

type ReadonlyUser = Readonly<User>;
type OptionalUser = Optional<User>;

# 安装 TypeScript
bun add -d typescript

# 类型检查
bunx tsc --noEmit

# 添加到 package.json
{
  "scripts": {
    "typecheck": "tsc --noEmit"
  }
}

// scripts/typecheck.ts
import { $ } from "bun";

try {
  await $`tsc --noEmit`;
  console.log("✅ Type check passed!");
} catch (error) {
  console.error("❌ Type check failed!");
  process.exit(1);
}

// 类型断言
const value: unknown = "hello";
const str = value as string;

// 双重断言（不推荐）
const num = value as unknown as number;

// const 断言
const config = {
  name: "Bun",
  version: 1.2,
} as const;
// { readonly name: "Bun"; readonly version: 1.2 }

// 非空断言
const element = document.getElementById("app")!;

// 安装类型
bun add -d @types/react @types/react-dom

// 使用
import { useState, useEffect } from "react";

function Counter(): JSX.Element {
  const [count, setCount] = useState<number>(0);
  return <button onClick={() => setCount(c => c + 1)}>{count}</button>;
}

// types/jsx.d.ts
declare global {
  namespace JSX {
    interface IntrinsicElements {
      "my-custom-element": {
        customProp?: string;
      };
    }
  }
}

src/
├── index.ts
├── types/
│   ├── index.ts       # 导出所有类型
│   ├── user.ts
│   ├── product.ts
│   └── api.ts
├── services/
│   ├── user.ts
│   └── product.ts
└── utils/
    ├── index.ts
    └── helpers.ts

// types/index.ts
export * from "./user";
export * from "./product";
export * from "./api";

// types/user.ts
export interface User {
  id: string;
  name: string;
  email: string;
}

export type UserCreateInput = Omit<User, "id">;
export type UserUpdateInput = Partial<UserCreateInput>;

export interface UserResponse {
  success: boolean;
  data?: User;
  error?: string;
}

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "exactOptionalPropertyTypes": true
  }
}

// 使用 type 关键字明确类型导入
import type { User, Product } from "./types";
import { UserService } from "./services";

// 内联类型导入
import { UserService, type User } from "./services";

// 问题：找不到模块
import { something } from "./utils";

// 解决：确保扩展名正确或配置 paths
import { something } from "./utils/index.ts";

// 问题：类型扩展不生效
// 解决：确保声明文件被包含
// tsconfig.json
{
  "include": ["src/**/*", "types/**/*"]
}

# 安装类型定义
bun add -d @types/express
bun add -d @types/lodash

# 或使用 DefinitelyTyped
bun add -d @types/node