[Vue CLI 3]源码系列之 invoke

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 => {}

一、处理全的 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
}

二、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}`
    }

三、默认状况

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

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