vue invoke 在官方文档中提到的内容很少，很多同学应该会对它比较陌生
输入如下命令：
vue invoke
pwa
之后，它到底做了啥呢？
先抛一句命令行的 description
invoke the
generatorof a plugin in an already created project
我们来从源码设计角度看看它多做了什么?
首先它也是 vue 的一个子命令，在 @vue/cli/bin/vue.js
这里是我们多次提到的命令行必备工具包 commander
const program = require('commander')
设置 command、description、allowUnknownOption 和 action
program
.command('invoke <plugin> [pluginOptions]')
.description('invoke the generator of a plugin in an already created project')
.allowUnknownOption()
.action((plugin) => {
require('../lib/invoke')(plugin, minimist(process.argv.slice(3)))
})
我们看一下 @vue/cli/lib/invoke.js
接受 3 个参数
pluginName
options 默认 {}
context 默认 process.cwd()
async function invoke (pluginName, options = {},
context = process.cwd()) {
}
先查看项目根目录下的 package.json 中是否定义了插件依赖：
const pkg = getPkg(context)
getPkg 的源码如下：
function getPkg (context) {}
这里的 fs 是来自工具包 fs-extra
const fs = require('fs-extra')
先获取 package.json 文件路径：
const path = require('path')
const pkgPath = path.resolve(context, 'package.json')
文件不存在（fs.existsSync）会抛错，代码如下
if (!fs.existsSync(pkgPath)) {
throw new Error(package.json not found in ${chalk.yellow(context)})
}
核心通过 fs.readJsonSync 读取对应文件路径：
const pkg = fs.readJsonSync(pkgPath)
同时会查看 vuePlugins.resolveFrom
if (pkg.vuePlugins && pkg.vuePlugins.resolveFrom) {
return getPkg(path.resolve(context, pkg.vuePlugins.resolveFrom))
}
return pkg
通过函数 findPlugin 从 devDependencies 和 dependencies 中查找：
const id = findPlugin(pkg.devDependencies) ||
findPlugin(pkg.dependencies)
这里返回的 id 为：@vue/cli-plugin-pwa
findPlugin 的源码设计，接受一个函数
const findPlugin = deps => {}
先找官方的 plugin：
if (!deps) return
let name
// official
if (deps[(name =@vue/cli-plugin-${pluginName})]) {
return name
}
// full id, scoped short, or default short
if (deps[(name = resolvePluginId(pluginName))]) {
return name
}
resolvePluginId 处理 3 种情况：
const {
resolvePluginId
} = require('@vue/cli-shared-utils')
内容如下：定义一个正则：
const pluginRE = /^(@vue/|vue-|@[\w-]+/vue-)cli-plugin-/
exports.resolvePluginId = id => {}
1、处理全的 id，如：vue-cli-plugin-foo、@vue/cli-plugin-fo 以及 @bar/vue-cli-plugin-foo
// already full id
// e.g. vue-cli-plugin-foo, @vue/cli-plugin-foo, @bar/vue-cli-plugin-foo
if (pluginRE.test(id)) {
return id
}
2、charAt 判断以 @开头的
定义一个正则：
const scopeRE = /^@[\w-]+//
具体如下：
// scoped short
// e.g. @vue/foo, @bar/foo
if (id.charAt(0) === '@') {}
const scopeMatch = id.match(scopeRE)
if (scopeMatch) {
const scope = scopeMatch[0]
const shortId = id.replace(scopeRE, '')
return `${scope}${scope === '@vue/' ? `` : `vue-`}cli-plugin-${shortId}`
}
3、默认情况
// default short
// e.g. foo
return `vue-cli-plugin-${id}`
发现没有定义就会提示
if (!id) {
throw new Error(
`Cannot resolve plugin ${chalk.yellow(pluginName)} from package.json. ` +
`Did you forget to install it?`)
}
所以我们在 package.json 定义了 devDependencies：
"devDependencies": {
"@vue/cli-plugin-pwa": "latest"
}
后面会查找它的 generator 如果不存在也会抛错
const pluginGenerator = loadModule(`${id}/generator`, context)
if (!pluginGenerator) {
throw new Error(`Plugin ${id} does not have a generator.`)
}
我们看一下 @vue/cli-plugin-pwa 的目录：
cli-plugin-pwa
generator
template
看看 loadModule，代码目录如下: @vue/cli-shared-utils/lib/module.js
const {
loadModule
} = require('@vue/cli-shared-utils')
接受 3 个参数：
- request
- context
- force 默认 false
exports.loadModule = function (request, context, force = false) {}
函数内部：
const resolvedPath = exports.resolveModule(request, context)
if (resolvedPath) {
if (force) {
clearRequireCache(resolvedPath)
}
return require(resolvedPath)
}
当命令行没有传入参数的时候，会默认做处理：
if (!Object.keys(options).length) {}
看一下 prompts 目录，目前官方的 plugin 中 cli-plugin-eslint
有 prompts.js 文件
地址：https://github.com/vuejs/vue-cli/blob/dev/packages/%40vue/cli-plugin-eslint/prompts.js
let pluginPrompts = loadModule(
${id}/prompts, context)
如果像 eslint 一样存在，判断对应的类型，最后调用工具包 inquirer
const inquirer = require('inquirer')
if (pluginPrompts) {
if (typeof pluginPrompts === 'function') {
pluginPrompts = pluginPrompts(pkg)
}
if (typeof pluginPrompts.getPrompts === 'function') {
pluginPrompts = pluginPrompts.getPrompts(pkg)
}
options = await inquirer.prompt(pluginPrompts)
}
-------------- 重点关注 vue add 的部分会重点关注 -----------------
runGenerator 函数：接受 3 个参数：
- context
- plugin
- pkg 默认 getPkg(context)
函数结构如下：
async function runGenerator (context, plugin, pkg = getPkg(context)) {}
依赖 @vue/cli/lib/Generator.js
const Generator = require('./Generator')
传入 5 个参数：
- pkg
- plugins
- files
- completeCbs
- invoking
const generator = new Generator(context, {
pkg,
plugins: [plugin],
files: await readFiles(context),
completeCbs: createCompleteCbs,
invoking: true
})
依赖 readFiles 函数，代码如下：这里加载了工具包 globby
const globby = require('globby')
readFiles 函数结构：
async function readFiles (context) {}
readFiles 函数内部：
const files = await globby(['**'], {
cwd: context,
onlyFiles: true,
gitignore: true,
ignore: ['**/node_modules/**', '**/.git/**'],
dot: true
})
创建一个对象，同时对应 key 的值通过 fs.readFileSync 读取内容
const res = {}
for (const file of files) {
const name = path.resolve(context, file)
res[file] = isBinary.sync(name)
? fs.readFileSync(name)
: fs.readFileSync(name, 'utf-8')
}
return normalizeFilePaths(res)
这里的 isBinary 使用了工具包 isbinaryfile：
const isBinary = require('isbinaryfile')
normalizeFilePaths 函数来自 util/normalizeFilePaths.js：
const normalizeFilePaths = require('./util/normalizeFilePaths')
调用工具包 slash
const slash = require('slash')
依赖的 normalizeFilePaths 函数如下：接受一个参数
module.exports = function normalizeFilePaths (files) {}
通过 Object.keys 进行循环
Object.keys(files).forEach(file => {
const normalized = slash(file)
if (file !== normalized) {
files[normalized] = files[file]
delete files[file]
}
})
return files
-------------- 重点关注 --------------
调用 generate 函数，接受 2 个参数：
- extractConfigFiles 默认 false
- checkExisting 默认 false
await generator.generate({
extractConfigFiles: true,
checkExisting: true
})
定义一个 class Generator
module.exports = class Generator {
async generate ({
} = {}) {
}
}
重置 package.json：
this.files['package.json'] = JSON.stringify(this.pkg, null, 2) + '\n'
writeFileTree 函数
const writeFileTree = require('./util/writeFileTree')
依赖的工具包：
const fs = require('fs-extra')
const path = require('path')
源码结构如下：接受 3 个参数
module.exports = async function writeFileTree (dir, files, previousFiles) {}
if (previousFiles) {
await deleteRemovedFiles(dir, files, previousFiles)
}
核心是 fs.ensureDir 和 fs.writeFile
return Promise.all(Object.keys(files).map(async (name) => {
const filePath = path.join(dir, name)
await fs.ensureDir(path.dirname(filePath))
await fs.writeFile(filePath, files[name])
}))
deleteRemovedFiles 函数结构如下：
function deleteRemovedFiles (directory, newFiles, previousFiles) {}
通过 Object.keys 找出要删除的文件 filesToDelete
// get all files that are not in the new filesystem and are still existing
const filesToDelete = Object.keys(previousFiles)
.filter(filename => !newFiles[filename])
通过 fs.unlink 删除
// delete each of these files
return Promise.all(filesToDelete.map(filename => {
return fs.unlink(path.join(directory, filename))
}))
本文来自微信公众号：前端新视野
