vue invoke 在官方文档中提到的内容很少，很多同学应该会对它比较陌生

输入如下命令：

vue invoke
pwa

之后，它到底做了啥呢？

先抛一句命令行的 description

invoke the
generator of 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-…

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))
}))

本文来自微信公众号：前端新视野