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

设置 commanddescriptionallowUnknownOptionaction

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

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

本文固定链接: http://www.js-code.com/vue-js/vue-js_27251.html