/
cli.ts
129 lines (107 loc) · 3.47 KB
/
cli.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import cac from 'cac'
import { cyan, dim, red } from 'kolorist'
import { createServer } from 'vite'
import { version } from '../package.json'
import { ViteNodeServer } from './server'
import { ViteNodeRunner } from './client'
import type { ViteNodeServerOptions } from './types'
import { toArray } from './utils'
const cli = cac('vite-node')
cli
.version(version)
.option('-r, --root <path>', 'Use specified root directory')
.option('-c, --config <path>', 'Use specified config file')
.option('-w, --watch', 'Restart on file changes, similar to "nodemon"')
.option('--options <options>', 'Use specified Vite server options')
.help()
cli
.command('[...files]')
.action(run)
cli.parse()
export interface CliOptions {
root?: string
config?: string
watch?: boolean
options?: ViteNodeServerOptionsCLI
'--'?: string[]
}
async function run(files: string[], options: CliOptions = {}) {
if (!files.length) {
console.error(red('No files specified.'))
cli.outputHelp()
process.exit(1)
}
// forward argv
process.argv = [...process.argv.slice(0, 2), ...(options['--'] || [])]
const parsedServerOptions = options.options
? parseServerOptions(options.options)
: undefined
const server = await createServer({
logLevel: 'error',
configFile: options.config,
root: options.root,
})
await server.pluginContainer.buildStart({})
const node = new ViteNodeServer(server, parsedServerOptions)
const runner = new ViteNodeRunner({
root: server.config.root,
base: server.config.base,
fetchModule(id) {
return node.fetchModule(id)
},
resolveId(id, importer) {
return node.resolveId(id, importer)
},
})
// provide the vite define variable in this context
await runner.executeId('/@vite/env')
for (const file of files)
await runner.executeFile(file)
if (!options.watch)
await server.close()
server.watcher.on('change', async (path) => {
console.log(`${cyan('[vite-node]')} File change detected. ${dim(path)}`)
// invalidate module cache but not node_modules
Array.from(runner.moduleCache.keys())
.forEach((i) => {
if (!i.includes('node_modules'))
runner.moduleCache.delete(i)
})
for (const file of files)
await runner.executeFile(file)
})
}
function parseServerOptions(serverOptions: ViteNodeServerOptionsCLI): ViteNodeServerOptions {
return {
...serverOptions,
deps: {
...serverOptions.deps,
inline: toArray(serverOptions.deps?.inline).map((dep) => {
return dep.startsWith('/') && dep.endsWith('/')
? new RegExp(dep)
: dep
}),
external: toArray(serverOptions.deps?.external).map((dep) => {
return dep.startsWith('/') && dep.endsWith('/')
? new RegExp(dep)
: dep
}),
},
transformMode: {
...serverOptions.transformMode,
ssr: toArray(serverOptions.transformMode?.ssr).map(dep => new RegExp(dep)),
web: toArray(serverOptions.transformMode?.web).map(dep => new RegExp(dep)),
},
}
}
type Optional<T> = T | undefined
type ComputeViteNodeServerOptionsCLI<T extends Record<string, any>> = {
[K in keyof T]: T[K] extends Optional<RegExp[]>
? string | string[]
: T[K] extends Optional<(string | RegExp)[]>
? string | string[]
: T[K] extends Optional<Record<string, any>>
? ComputeViteNodeServerOptionsCLI<T[K]>
: T[K]
}
export type ViteNodeServerOptionsCLI = ComputeViteNodeServerOptionsCLI<ViteNodeServerOptions>