const path = require('path') const hash = require('hash-sum') const { semver, matchesPluginId } = require('@vue/cli-shared-utils') // Note: if a plugin-registered command needs to run in a specific default mode, // the plugin needs to expose it via `module.exports.defaultModes` in the form // of { [commandName]: mode }. This is because the command mode needs to be // known and applied before loading user options / applying plugins. class PluginAPI { /** * @param {string} id - Id of the plugin. * @param {Service} service - A vue-cli-service instance. */ constructor (id, service) { this.id = id this.service = service } get version () { return require('../package.json').version } assertVersion (range) { if (typeof range === 'number') { if (!Number.isInteger(range)) { throw new Error('Expected string or integer value.') } range = `^${range}.0.0-0` } if (typeof range !== 'string') { throw new Error('Expected string or integer value.') } if (semver.satisfies(this.version, range, { includePrerelease: true })) return throw new Error( `Require @vue/cli-service "${range}", but was loaded with "${this.version}".` ) } /** * Current working directory. */ getCwd () { return this.service.context } /** * Resolve path for a project. * * @param {string} _path - Relative path from project root * @return {string} The resolved absolute path. */ resolve (_path) { return path.resolve(this.service.context, _path) } /** * Check if the project has a given plugin. * * @param {string} id - Plugin id, can omit the (@vue/|vue-|@scope/vue)-cli-plugin- prefix * @return {boolean} */ hasPlugin (id) { return this.service.plugins.some(p => matchesPluginId(id, p.id)) } /** * Register a command that will become available as `vue-cli-service [name]`. * * @param {string} name * @param {object} [opts] * { * description: string, * usage: string, * options: { [string]: string } * } * @param {function} fn * (args: { [string]: string }, rawArgs: string[]) => ?Promise */ registerCommand (name, opts, fn) { if (typeof opts === 'function') { fn = opts opts = null } this.service.commands[name] = { fn, opts: opts || {}} } /** * Register a function that will receive a chainable webpack config * the function is lazy and won't be called until `resolveWebpackConfig` is * called * * @param {function} fn */ chainWebpack (fn) { this.service.webpackChainFns.push(fn) } /** * Register * - a webpack configuration object that will be merged into the config * OR * - a function that will receive the raw webpack config. * the function can either mutate the config directly or return an object * that will be merged into the config. * * @param {object | function} fn */ configureWebpack (fn) { this.service.webpackRawConfigFns.push(fn) } /** * Register a dev serve config function. It will receive the express `app` * instance of the dev server. * * @param {function} fn */ configureDevServer (fn) { this.service.devServerConfigFns.push(fn) } /** * Resolve the final raw webpack config, that will be passed to webpack. * * @param {ChainableWebpackConfig} [chainableConfig] * @return {object} Raw webpack config. */ resolveWebpackConfig (chainableConfig) { return this.service.resolveWebpackConfig(chainableConfig) } /** * Resolve an intermediate chainable webpack config instance, which can be * further tweaked before generating the final raw webpack config. * You can call this multiple times to generate different branches of the * base webpack config. * See https://github.com/mozilla-neutrino/webpack-chain * * @return {ChainableWebpackConfig} */ resolveChainableWebpackConfig () { return this.service.resolveChainableWebpackConfig() } /** * Generate a cache identifier from a number of variables */ genCacheConfig (id, partialIdentifier, configFiles = []) { const fs = require('fs') const cacheDirectory = this.resolve(`node_modules/.cache/${id}`) // replace \r\n to \n generate consistent hash const fmtFunc = conf => { if (typeof conf === 'function') { return conf.toString().replace(/\r\n?/g, '\n') } return conf } const variables = { partialIdentifier, 'cli-service': require('../package.json').version, 'cache-loader': require('cache-loader/package.json').version, env: process.env.NODE_ENV, test: !!process.env.VUE_CLI_TEST, config: [ fmtFunc(this.service.projectOptions.chainWebpack), fmtFunc(this.service.projectOptions.configureWebpack) ] } if (!Array.isArray(configFiles)) { configFiles = [configFiles] } configFiles = configFiles.concat([ 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml' ]) const readConfig = file => { const absolutePath = this.resolve(file) if (!fs.existsSync(absolutePath)) { return } if (absolutePath.endsWith('.js')) { // should evaluate config scripts to reflect environment variable changes try { return JSON.stringify(require(absolutePath)) } catch (e) { return fs.readFileSync(absolutePath, 'utf-8') } } else { return fs.readFileSync(absolutePath, 'utf-8') } } variables.configFiles = configFiles.map(file => { const content = readConfig(file) return content && content.replace(/\r\n?/g, '\n') }) const cacheIdentifier = hash(variables) return { cacheDirectory, cacheIdentifier } } } module.exports = PluginAPI