vendor-extracter/src/extracter.js

'use strict'

const fs = require('fs')
const path = require('path')
const babylon = require('babylon')
const traverse = require('babel-traverse')['default']
const t = require('babel-types')
const chalk = require('chalk')

class VendorExtracter {
  constructor (opts) {
    this.excludes = [] // 一些因为 alias 而可能会被误判成 vendor 的模块
    this.defaultExt = '.js'
    this.fileModuleFomatter = opts.fileModuleFomatter || (i => i)
    this.moduleFilter = opts.moduleFilter || (_ => true)
  }

  parse (entryFiles) {
    if (!Array.isArray(entryFiles)) entryFiles = [ entryFiles ]

    let vendorList = this._parseModules(entryFiles, [], [])
    return vendorList
  }

  _parseModules (files, parsed, result) {
    if (!Array.isArray(files) || files.length <= 0) return result

    const fileModules = [], parsedFileModules = []
    files.forEach(file => {
      // 保证其为绝对路径
      file = path.resolve(file)
      parsedFileModules.push(file)

      // 1. 读取入口点文件，解析其代码
      let codeContent
      try {
        codeContent = fs.readFileSync(file, { encoding: 'utf-8' })
      }
      catch (e) {
        console.log(chalk.red(`[Extracter] 读取入口 ${file} 失败，${e.message}`))
        return
      }

      let modules = this._parseModulesFromCode(codeContent, file)
      modules = modules.map(this.fileModuleFomatter)
      modules = modules.filter(this.moduleFilter)

      // 2. 根据 node.js 模块加载机制
      // - 获取所有依赖模块
      // - 过滤出来自 npm/tnpm 的模块
      modules.forEach(moduleName => {
        moduleName = this.fileModuleFomatter(moduleName)

        if (result.indexOf(moduleName) < 0 && this._isFromNodeModules(moduleName)) {
          result.push(moduleName)
        }

        if (!this._isFromNodeModules(moduleName)) {
          let base = path.dirname(file)
          let location = path.resolve(base, moduleName)

          if(!path.extname(location)) {
            location += this.defaultExt
          }
          fileModules.push(location)
        }
      })
    })

    parsed = [].concat(parsed, parsedFileModules)
    files = fileModules.filter(f => parsed.indexOf(f) < 0)

    return this._parseModules(files, parsed, result)
  }

  _isFromNodeModules (moduleName) {
    // 非 nodemodules 模块的例子：
    // - './xxx'
    // - '/xxx/xxx'
    // - '../xxx/xxx'
    return !/^[\./]/.test(moduleName)
  }

  _parseModulesFromCode (codeContent, fileName) {
    const modules = []
    const _self = this
    try {
      const ast = babylon.parse(codeContent, {
        sourceType: 'module', // or script
        plugins: [
          "jsx",
          "flow",
          "asyncFunctions",
          "classConstructorCall",
          "doExpressions",
          "trailingFunctionCommas",
          "objectRestSpread",
          "decorators",
          "classProperties",
          "exportExtensions",
          "exponentiationOperator",
          "asyncGenerators",
          "functionBind",
          "functionSent"
        ]
      })

      console.log(`[Extracter] 开始解析 ${fileName}`);

      traverse(ast, {
        enter (path) {
          // 遍历出
          // - ImportDeclaration
          // - CallExpression 中 callee 为 Identifier 且 name 为 require
          // - 所有 FunctionExpression 中的 require 表达式

          const node = path.node
          if (t.isImportDeclaration(node)) {
            modules.push(node.source.value)
          }
          if (t.isCallExpression(node) && node.callee.name == 'require') {
            const arg = node.arguments[0]
            if (!t.isStringLiteral(arg)) {
              console.log(`[Extracter] 解析 ${fileName} 时发现有模块不是以字符串字面量的形式引入的，当前版本不支持该形式`)
              return []
            }

            // 可能会有 require('lodash/func') 的写法
            // - 它的依赖应该被判断成 lodash
            // - 排除 @ali/dpl 这样的 scoped module
            // - 目前不支持抽取模块中部分文件的打包方式
            if (_self._isFromNodeModules(arg.value)) {
              const sub = arg.value.split('/')
              if (arg.value[0] == '@') { // scoped module
                modules.push(sub.slice(0, 2).join('/'))
              }
              else modules.push(sub[0])
            }
            else modules.push(arg.value)
          }
        }
      })
    }
    catch (e) {
      console.log(chalk.red(`[Extracter] 解析文件 ${fileName} 代码失败，${e.message}`))
      return []
    }

    return modules
  }

  output (vendorList) {
    const source =
      'module.exports = {' + '\n' +
      vendorList.map((name, i) => {
        if (i == vendorList.length - 1) {
          return `  "${name}": require('${name}')`
        }
        else return `  "${name}": require('${name}'),`
      }).join('\n') + '\n' +
      '};'

    return source
  }

  parseAndOutput (entryFiles) {
    const vendorList = this.parse(entryFiles)
    return this.output(vendorList)
  }
}

module.exports = VendorExtracter