1
import type { Plugin } from 'vite';
2
import { readFileSync } from 'node:fs';
3
import { resolve } from 'node:path';
4

5
export interface BuildInfoOptions {
6
  /** 要注入的字段，从环境变量读取 */
7
  fields: Record<string, string>;
8
  /** 注入到哪个虚拟模块 */
9
  virtualId?: string;
10
}
11

12
export default function injectBuildInfo(options: BuildInfoOptions): Plugin {
13
  const virtualId = options.virtualId ?? 'virtual:build-info';
14
  const resolvedId = '\0' + virtualId;
15
  const name = 'inject-build-info';
16

17
  return {
18
    name,
19
    resolveId(id) {
20
      if (id === virtualId) return resolvedId;
21
      return null;
22
    },
23
    load(id) {
24
      if (id !== resolvedId) return null;
25

26
      // 收集所有字段
27
      const data: Record<string, string> = {};
28
      for (const [key, envKey] of Object.entries(options.fields)) {
29
        data[key] = process.env[envKey] ?? '';
30
      }
31

32
      // 输出 ESM 模块
33
      return `export const buildInfo = ${JSON.stringify(data, null, 2)};`;
34
    },
35
  };
36
}

1
import type { Plugin } from 'vite';
2
import { statSync } from 'node:fs';
3

4
export default function markdownTimestamp(): Plugin {
5
  return {
6
    name: 'markdown-timestamp',
7
    enforce: 'pre', // 在 Vite 处理 .md 之前
8
    transform(code, id) {
9
      if (!id.endsWith('.md')) return null;
10

11
      try {
12
        const stats = statSync(id);
13
        const lastUpdated = stats.mtime.toISOString();
14
        // 注入 frontmatter
15
        if (code.startsWith('---')) {
16
          return {
17
            code: `---\nlastUpdated: ${lastUpdated}\n---\n${code.slice(3)}`,
18
            map: null,
19
          };
20
        }
21
        return {
22
          code: `---\nlastUpdated: ${lastUpdated}\n---\n\n${code}`,
23
          map: null,
24
        };
25
      } catch {
26
        return null;
27
      }
28
    },
29
  };
30
}

1
import type { Plugin } from 'vite';
2

3
interface ChunkInfo {
4
  name: string;
5
  size: number;
6
  gzip: number;
7
}
8

9
export default function buildAnalyzer(): Plugin {
10
  return {
11
    name: 'build-analyzer',
12
    apply: 'build',
13
    generateBundle(_options, bundle) {
14
      const { gzipSync } = require('node:zlib');
15
      const chunks: ChunkInfo[] = [];
16

17
      for (const [fileName, asset] of Object.entries(bundle)) {
18
        if (asset.type !== 'chunk') continue;
19
        const size = Buffer.byteLength(asset.code, 'utf-8');
20
        const gzip = gzipSync(Buffer.from(asset.code, 'utf-8')).length;
21
        chunks.push({ name: fileName, size, gzip });
22
      }
23

24
      chunks.sort((a, b) => b.size - a.size);
25

26
      console.log('\n📦 构建产物分析（按体积排序）');
27
      console.log('─'.repeat(60));
28
      console.log(
29
        'File'.padEnd(40) + 'Size'.padStart(10) + 'Gzip'.padStart(10)
30
      );
31
      console.log('─'.repeat(60));
32
      for (const c of chunks.slice(0, 20)) {
33
        console.log(
34
          c.name.padEnd(40) +
35
            `${(c.size / 1024).toFixed(2)}KB`.padStart(10) +
36
            `${(c.gzip / 1024).toFixed(2)}KB`.padStart(10)
37
        );
38
      }
39
      console.log('─'.repeat(60));
40
    },
41
  };
42
}

1
import type { Plugin } from 'vite';
2
import type { IncomingMessage, ServerResponse } from 'node:http';
3

4
type Handler = (req: IncomingMessage, res: ServerResponse, params: Record<string, string>) => void | Promise<void>;
5

6
interface Route {
7
  method: string;
8
  pattern: RegExp;
9
  paramNames: string[];
10
  handler: Handler;
11
}
12

13
export default function mockApi(routes: Array<{ method: string; path: string; handler: Handler }>): Plugin {
14
  const compiled: Route[] = routes.map((r) => {
15
    const paramNames: string[] = [];
16
    const pattern = new RegExp(
17
      '^' + r.path.replace(/:[a-zA-Z_]\w*/g, (m) => {
18
        paramNames.push(m.slice(1));
19
        return '([^/]+)';
20
      }) + '$'
21
    );
22
    return { method: r.method.toUpperCase(), pattern, paramNames, handler: r.handler };
23
  });
24

25
  return {
26
    name: 'mock-api',
27
    apply: 'serve',
28
    configureServer(server) {
29
      server.middlewares.use(async (req, res, next) => {
30
        if (!req.url || !req.method) return next();
31

32
        const url = new URL(req.url, 'http://localhost');
33
        const pathname = url.pathname;
34

35
        for (const route of compiled) {
36
          if (route.method !== req.method) continue;
37
          const match = pathname.match(route.pattern);
38
          if (!match) continue;
39

40
          const params: Record<string, string> = {};
41
          route.paramNames.forEach((name, i) => {
42
            params[name] = decodeURIComponent(match[i + 1]);
43
          });
44

45
          res.setHeader('Content-Type', 'application/json');
46
          try {
47
            await route.handler(req, res, params);
48
          } catch (err) {
49
            res.statusCode = 500;
50
            res.end(JSON.stringify({ error: String(err) }));
51
          }
52
          return;
53
        }
54

55
        next();
56
      });
57
    },
58
  };
59
}

1
import mockApi from './plugins/mock-api';
2

3
export default defineConfig({
4
  plugins: [
5
    mockApi([
6
      {
7
        method: 'GET',
8
        path: '/api/users/:id',
9
        handler: (req, res, params) => {
10
          res.end(JSON.stringify({ id: params.id, name: `User ${params.id}` }));
11
        },
12
      },
13
      {
14
        method: 'POST',
15
        path: '/api/orders',
16
        handler: (req, res) => {
17
          res.end(JSON.stringify({ ok: true, orderId: '12345' }));
18
        },
19
      },
20
    ]),
21
  ],
22
});