1

npx tsc --noEmit --generateTrace ./trace

1
2
3

trace/
├── trace.json     # 时间线（Chrome Trace 格式）
└── types.json     # 类型与实例化统计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// analyze-types.mjs —— 找出实例化最多的类型
import { readFileSync } from "node:fs";

const data = JSON.parse(readFileSync("./trace/types.json", "utf8"));
const counts = new Map();

function walk(node) {
  if (!node || typeof node !== "object") return;
  if (node.name && node.count) {
    const key = `${node.name} (${node.kind ?? "?"})`;
    counts.set(key, (counts.get(key) ?? 0) + node.count);
  }
  for (const v of Object.values(node)) walk(v);
}
walk(data);

const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 30);
for (const [name, count] of top) {
  console.log(String(count).padStart(9), name.slice(0, 110));
}

1

node analyze-types.mjs

1
2
3
4
5

# 找出意外的文件（幽灵文件、多余 @types）
npx tsc --noEmit --explainFiles | head -60

# 找出编译了多少文件（对比预期）
npx tsc --noEmit --listFiles | wc -l

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 类型内联展开：每个使用点都重新计算
function a<T>(x: T): DeepReadonly<DeepPartial<Prettify<T>>> { /* ... */ }
function b<T>(x: T): DeepReadonly<DeepPartial<Prettify<T>>> { /* ... */ }
function c<T>(x: T): DeepReadonly<DeepPartial<Prettify<T>>> { /* ... */ }

// ✅ 具名别名：编译器可复用计算结果
type FrozenPatch<T> = DeepReadonly<DeepPartial<Prettify<T>>>;
function a2<T>(x: T): FrozenPatch<T> { /* ... */ }
function b2<T>(x: T): FrozenPatch<T> { /* ... */ }
function c2<T>(x: T): FrozenPatch<T> { /* ... */ }

1
2
3
4
5
6
7
8

// 🛑 深递归无限制
type DeepReadonly<T> = { readonly [K in keyof T]: DeepReadonly<T[K]> };

// ✅ 加深度计数器
type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
type SafeDeepReadonly<T, D extends number = 5> = D extends 0
  ? T
  : { readonly [K in keyof T]: SafeDeepReadonly<T[K], Prev[D]> };

1
2
3
4
5

// 🛑 深交叉：展开成本随层数增长
type A = B & C & D & E & F & G & H & I & J;

// ✅ 用 interface 继承（编译器处理得更高效，错误信息也更清晰）
interface A2 extends B, C, D, E, F, G, H, I, J {}

1
2
3
4
5
6
7
8
9

// 根 tsconfig.json ——解决方案文件
{
  "files": [],
  "references": [
    { "path": "./packages/types" },
    { "path": "./packages/core" },
    { "path": "./packages/web" }
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// packages/core/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "incremental": true,
    "rootDir": "./src",
    "outDir": "./dist"
  },
  "include": ["src"],
  "references": [{ "path": "../types" }]
}

1
2
3
4

npx tsc --build            # 按拓扑顺序增量构建 🔥
npx tsc --build --watch    # 监听
npx tsc --build --clean    # 清理
npx tsc --build --force    # 强制全量

1
2
3
4
5
6

{
  "compilerOptions": {
    "declaration": true,
    "isolatedDeclarations": true    // 声明生成不再依赖类型推断，可并行
  }
}

1
2
3

// 代价：所有导出必须有显式返回类型
export function f(x: number): number { return x * 2; }
//                 ~~~~~~~~~~~~~~~ 必须写，否则 TS9007

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# .github/workflows/ci.yml
jobs:
  typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 24
          cache: npm

      # 🔥 缓存 .tsbuildinfo，让增量生效
      - uses: actions/cache@v4
        with:
          path: |
            **/*.tsbuildinfo
            node_modules/.cache
          key: tsbuildinfo-${{ hashFiles('**/*.ts', '**/tsconfig*.json') }}
          restore-keys: tsbuildinfo-

      - run: npm ci
      - run: npx tsc --noEmit --incremental

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#!/bin/bash
# scripts/check-ts-perf.sh
OUTPUT=$(npx tsc --noEmit --extendedDiagnostics 2>&1)
INSTANTIATIONS=$(echo "$OUTPUT" | grep "Instantiations:" | grep -oE "[0-9]+")
MAX=500000

echo "Instantiations: $INSTANTIATIONS (门槛 $MAX)"
if [ "$INSTANTIATIONS" -gt "$MAX" ]; then
  echo "❌ 类型实例化数量超门槛，可能有类型体操过重"
  echo "$OUTPUT" | tail -20
  exit 1
fi