first commit

node_modules/@vue/cli-service/lib/webpack/CorsPlugin.js

@@ -0,0 +1,67 @@
+module.exports = class CorsPlugin {
+  constructor ({ publicPath, crossorigin, integrity }) {
+    this.crossorigin = crossorigin
+    this.integrity = integrity
+    this.publicPath = publicPath
+  }
+
+  apply (compiler) {
+    const ID = `vue-cli-cors-plugin`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      const ssri = require('ssri')
+
+      const computeHash = url => {
+        const filename = url.replace(this.publicPath, '')
+        const asset = compilation.assets[filename]
+        if (asset) {
+          const src = asset.source()
+          const integrity = ssri.fromData(src, {
+            algorithms: ['sha384']
+          })
+          return integrity.toString()
+        }
+      }
+
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tap(ID, data => {
+        const tags = [...data.head, ...data.body]
+        if (this.crossorigin != null) {
+          tags.forEach(tag => {
+            if (tag.tagName === 'script' || tag.tagName === 'link') {
+              tag.attributes.crossorigin = this.crossorigin
+            }
+          })
+        }
+        if (this.integrity) {
+          tags.forEach(tag => {
+            if (tag.tagName === 'script') {
+              const hash = computeHash(tag.attributes.src)
+              if (hash) {
+                tag.attributes.integrity = hash
+              }
+            } else if (tag.tagName === 'link' && tag.attributes.rel === 'stylesheet') {
+              const hash = computeHash(tag.attributes.href)
+              if (hash) {
+                tag.attributes.integrity = hash
+              }
+            }
+          })
+
+          // when using SRI, Chrome somehow cannot reuse
+          // the preloaded resource, and causes the files to be downloaded twice.
+          // this is a Chrome bug (https://bugs.chromium.org/p/chromium/issues/detail?id=677022)
+          // for now we disable preload if SRI is used.
+          data.head = data.head.filter(tag => {
+            return !(
+              tag.tagName === 'link' &&
+              tag.attributes.rel === 'preload'
+            )
+          })
+        }
+      })
+
+      compilation.hooks.htmlWebpackPluginAfterHtmlProcessing.tap(ID, data => {
+        data.html = data.html.replace(/\scrossorigin=""/g, ' crossorigin')
+      })
+    })
+  }
+}

node_modules/@vue/cli-service/lib/webpack/DashboardPlugin.js

@@ -0,0 +1,204 @@
+// From https://github.com/FormidableLabs/webpack-dashboard/blob/7f99b31c5f00a7818d8129cb8a8fc6eb1b71799c/plugin/index.js
+// Modified by Guillaume Chau (Akryum)
+
+/* eslint-disable max-params, max-statements */
+'use strict'
+
+const path = require('path')
+const fs = require('fs-extra')
+const webpack = require('webpack')
+const { IpcMessenger } = require('@vue/cli-shared-utils')
+const { analyzeBundle } = require('./analyzeBundle')
+
+const ID = 'vue-cli-dashboard-plugin'
+const ONE_SECOND = 1000
+const FILENAME_QUERY_REGEXP = /\?.*$/
+
+const ipc = new IpcMessenger()
+
+function getTimeMessage (timer) {
+  let time = Date.now() - timer
+
+  if (time >= ONE_SECOND) {
+    time /= ONE_SECOND
+    time = Math.round(time)
+    time += 's'
+  } else {
+    time += 'ms'
+  }
+
+  return ` (${time})`
+}
+
+class DashboardPlugin {
+  constructor (options) {
+    this.type = options.type
+    if (this.type === 'build' && options.modernBuild) {
+      this.type = 'build-modern'
+    }
+    this.watching = false
+    this.autoDisconnect = !options.keepAlive
+  }
+
+  cleanup () {
+    this.sendData = null
+    if (this.autoDisconnect) ipc.disconnect()
+  }
+
+  apply (compiler) {
+    let sendData = this.sendData
+    let timer
+
+    let assetSources = new Map()
+
+    if (!sendData) {
+      sendData = data => ipc.send({
+        webpackDashboardData: {
+          type: this.type,
+          value: data
+        }
+      })
+    }
+
+    // Progress status
+    let progressTime = Date.now()
+    const progressPlugin = new webpack.ProgressPlugin((percent, msg) => {
+      // Debouncing
+      const time = Date.now()
+      if (time - progressTime > 300) {
+        progressTime = time
+        sendData([
+          {
+            type: 'status',
+            value: 'Compiling'
+          },
+          {
+            type: 'progress',
+            value: percent
+          },
+          {
+            type: 'operations',
+            value: msg + getTimeMessage(timer)
+          }
+        ])
+      }
+    })
+    progressPlugin.apply(compiler)
+
+    compiler.hooks.watchRun.tap(ID, c => {
+      this.watching = true
+    })
+
+    compiler.hooks.run.tap(ID, c => {
+      this.watching = false
+    })
+
+    compiler.hooks.compile.tap(ID, () => {
+      timer = Date.now()
+
+      sendData([
+        {
+          type: 'status',
+          value: 'Compiling'
+        },
+        {
+          type: 'progress',
+          value: 0
+        }
+      ])
+    })
+
+    compiler.hooks.invalid.tap(ID, () => {
+      sendData([
+        {
+          type: 'status',
+          value: 'Invalidated'
+        },
+        {
+          type: 'progress',
+          value: 0
+        },
+        {
+          type: 'operations',
+          value: 'idle'
+        }
+      ])
+    })
+
+    compiler.hooks.failed.tap(ID, () => {
+      sendData([
+        {
+          type: 'status',
+          value: 'Failed'
+        },
+        {
+          type: 'operations',
+          value: `idle${getTimeMessage(timer)}`
+        }
+      ])
+    })
+
+    compiler.hooks.afterEmit.tap(ID, compilation => {
+      assetSources = new Map()
+      for (const name in compilation.assets) {
+        const asset = compilation.assets[name]
+        assetSources.set(name.replace(FILENAME_QUERY_REGEXP, ''), asset.source())
+      }
+    })
+
+    compiler.hooks.done.tap(ID, stats => {
+      let statsData = stats.toJson()
+      // Sometimes all the information is located in `children` array
+      if ((!statsData.assets || !statsData.assets.length) && statsData.children && statsData.children.length) {
+        statsData = statsData.children[0]
+      }
+
+      const outputPath = compiler.options.output.path
+      statsData.assets.forEach(asset => {
+        // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
+        asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '')
+        asset.fullPath = path.join(outputPath, asset.name)
+      })
+      // Analyze the assets and update sizes on assets and modules
+      analyzeBundle(statsData, assetSources)
+
+      const hasErrors = stats.hasErrors()
+
+      sendData([
+        {
+          type: 'status',
+          value: hasErrors ? 'Failed' : 'Success'
+        },
+        {
+          type: 'progress',
+          value: 1
+        },
+        {
+          type: 'operations',
+          value: `idle${getTimeMessage(timer)}`
+        }
+      ])
+
+      const statsFile = path.resolve(process.cwd(), `./node_modules/.stats-${this.type}.json`)
+      fs.writeJson(statsFile, {
+        errors: hasErrors,
+        warnings: stats.hasWarnings(),
+        data: statsData
+      }).then(() => {
+        sendData([
+          {
+            type: 'stats'
+          }
+        ])
+
+        if (!this.watching) {
+          this.cleanup()
+        }
+      }).catch(error => {
+        console.error(error)
+      })
+    })
+  }
+}
+
+module.exports = DashboardPlugin

node_modules/@vue/cli-service/lib/webpack/ModernModePlugin.js

@@ -0,0 +1,111 @@
+const fs = require('fs-extra')
+const path = require('path')
+
+// https://gist.github.com/samthor/64b114e4a4f539915a95b91ffd340acc
+const safariFix = `!function(){var e=document,t=e.createElement("script");if(!("noModule"in t)&&"onbeforeload"in t){var n=!1;e.addEventListener("beforeload",function(e){if(e.target===t)n=!0;else if(!e.target.hasAttribute("nomodule")||!n)return;e.preventDefault()},!0),t.type="module",t.src=".",e.head.appendChild(t),t.remove()}}();`
+
+class ModernModePlugin {
+  constructor ({ targetDir, isModernBuild, unsafeInline, jsDirectory }) {
+    this.targetDir = targetDir
+    this.isModernBuild = isModernBuild
+    this.unsafeInline = unsafeInline
+    this.jsDirectory = jsDirectory
+  }
+
+  apply (compiler) {
+    if (!this.isModernBuild) {
+      this.applyLegacy(compiler)
+    } else {
+      this.applyModern(compiler)
+    }
+  }
+
+  applyLegacy (compiler) {
+    const ID = `vue-cli-legacy-bundle`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(ID, async (data, cb) => {
+        // get stats, write to disk
+        await fs.ensureDir(this.targetDir)
+        const htmlName = path.basename(data.plugin.options.filename)
+        // Watch out for output files in sub directories
+        const htmlPath = path.dirname(data.plugin.options.filename)
+        const tempFilename = path.join(this.targetDir, htmlPath, `legacy-assets-${htmlName}.json`)
+        await fs.mkdirp(path.dirname(tempFilename))
+        await fs.writeFile(tempFilename, JSON.stringify(data.body))
+        cb()
+      })
+    })
+  }
+
+  applyModern (compiler) {
+    const ID = `vue-cli-modern-bundle`
+    compiler.hooks.compilation.tap(ID, compilation => {
+      compilation.hooks.htmlWebpackPluginAlterAssetTags.tapAsync(ID, async (data, cb) => {
+        // use <script type="module"> for modern assets
+        data.body.forEach(tag => {
+          if (tag.tagName === 'script' && tag.attributes) {
+            tag.attributes.type = 'module'
+          }
+        })
+
+        // use <link rel="modulepreload"> instead of <link rel="preload">
+        // for modern assets
+        data.head.forEach(tag => {
+          if (tag.tagName === 'link' &&
+              tag.attributes.rel === 'preload' &&
+              tag.attributes.as === 'script') {
+            tag.attributes.rel = 'modulepreload'
+          }
+        })
+
+        // inject links for legacy assets as <script nomodule>
+        const htmlName = path.basename(data.plugin.options.filename)
+        // Watch out for output files in sub directories
+        const htmlPath = path.dirname(data.plugin.options.filename)
+        const tempFilename = path.join(this.targetDir, htmlPath, `legacy-assets-${htmlName}.json`)
+        const legacyAssets = JSON.parse(await fs.readFile(tempFilename, 'utf-8'))
+          .filter(a => a.tagName === 'script' && a.attributes)
+        legacyAssets.forEach(a => { a.attributes.nomodule = '' })
+
+        if (this.unsafeInline) {
+          // inject inline Safari 10 nomodule fix
+          data.body.push({
+            tagName: 'script',
+            closeTag: true,
+            innerHTML: safariFix
+          })
+        } else {
+          // inject the fix as an external script
+          const safariFixPath = path.join(this.jsDirectory, 'safari-nomodule-fix.js')
+          const fullSafariFixPath = path.join(compilation.options.output.publicPath, safariFixPath)
+          compilation.assets[safariFixPath] = {
+            source: function () {
+              return new Buffer(safariFix)
+            },
+            size: function () {
+              return Buffer.byteLength(safariFix)
+            }
+          }
+          data.body.push({
+            tagName: 'script',
+            closeTag: true,
+            attributes: {
+              src: fullSafariFixPath
+            }
+          })
+        }
+
+        data.body.push(...legacyAssets)
+        await fs.remove(tempFilename)
+        cb()
+      })
+
+      compilation.hooks.htmlWebpackPluginAfterHtmlProcessing.tap(ID, data => {
+        data.html = data.html.replace(/\snomodule="">/g, ' nomodule>')
+      })
+    })
+  }
+}
+
+ModernModePlugin.safariFix = safariFix
+module.exports = ModernModePlugin

node_modules/@vue/cli-service/lib/webpack/MovePlugin.js

@@ -0,0 +1,16 @@
+const fs = require('fs-extra')
+
+module.exports = class MovePlugin {
+  constructor (from, to) {
+    this.from = from
+    this.to = to
+  }
+
+  apply (compiler) {
+    compiler.hooks.done.tap('move-plugin', () => {
+      if (fs.existsSync(this.from)) {
+        fs.moveSync(this.from, this.to, { overwrite: true })
+      }
+    })
+  }
+}

node_modules/@vue/cli-service/lib/webpack/analyzeBundle.js

@@ -0,0 +1,328 @@
+// From https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/ba3dbd71cec7becec0fbf529833204425f66efde/src/parseUtils.js
+// Modified by Guillaume Chau (Akryum)
+
+const acorn = require('acorn')
+const walk = require('acorn-walk')
+const mapValues = require('lodash.mapvalues')
+const transform = require('lodash.transform')
+const zlib = require('zlib')
+const { warn } = require('@vue/cli-shared-utils')
+
+exports.analyzeBundle = function analyzeBundle (bundleStats, assetSources) {
+  // Picking only `*.js` assets from bundle that has non-empty `chunks` array
+  const jsAssets = []
+  const otherAssets = []
+
+  // Separate JS assets
+  bundleStats.assets.forEach(asset => {
+    if (asset.name.endsWith('.js') && asset.chunks && asset.chunks.length) {
+      jsAssets.push(asset)
+    } else {
+      otherAssets.push(asset)
+    }
+  })
+
+  // Trying to parse bundle assets and get real module sizes
+  let bundlesSources = null
+  let parsedModules = null
+
+  bundlesSources = {}
+  parsedModules = {}
+
+  for (const asset of jsAssets) {
+    const source = assetSources.get(asset.name)
+    let bundleInfo
+
+    try {
+      bundleInfo = parseBundle(source)
+    } catch (err) {
+      bundleInfo = null
+    }
+
+    if (!bundleInfo) {
+      warn(
+        `\nCouldn't parse bundle asset "${asset.fullPath}".\n` +
+        'Analyzer will use module sizes from stats file.\n'
+      )
+      parsedModules = null
+      bundlesSources = null
+      break
+    }
+
+    bundlesSources[asset.name] = bundleInfo.src
+    Object.assign(parsedModules, bundleInfo.modules)
+  }
+
+  // Update sizes
+
+  bundleStats.modules.forEach(module => {
+    const parsedSrc = parsedModules && parsedModules[module.id]
+    module.size = {
+      stats: module.size
+    }
+    if (parsedSrc) {
+      module.size.parsed = parsedSrc.length
+      module.size.gzip = getGzipSize(parsedSrc)
+    } else {
+      module.size.parsed = module.size.stats
+      module.size.gzip = 0
+    }
+  })
+
+  jsAssets.forEach(asset => {
+    const src = bundlesSources && bundlesSources[asset.name]
+    asset.size = {
+      stats: asset.size
+    }
+    if (src) {
+      asset.size.parsed = src.length
+      asset.size.gzip = getGzipSize(src)
+    } else {
+      asset.size.parsed = asset.size.stats
+      asset.size.gzip = 0
+    }
+  }, {})
+
+  otherAssets.forEach(asset => {
+    const src = assetSources.get(asset.name)
+    asset.size = {
+      stats: asset.size,
+      parsed: asset.size
+    }
+    if (src) {
+      asset.size.gzip = getGzipSize(src)
+    } else {
+      asset.size.gzip = 0
+    }
+  })
+}
+
+function parseBundle (bundleContent) {
+  const ast = acorn.parse(bundleContent, {
+    sourceType: 'script',
+    // I believe in a bright future of ECMAScript!
+    // Actually, it's set to `2050` to support the latest ECMAScript version that currently exists.
+    // Seems like `acorn` supports such weird option value.
+    ecmaVersion: 2050
+  })
+
+  const walkState = {
+    locations: null
+  }
+
+  walk.recursive(
+    ast,
+    walkState,
+    {
+      CallExpression (node, state, c) {
+        if (state.sizes) return
+
+        const args = node.arguments
+
+        // Additional bundle without webpack loader.
+        // Modules are stored in second argument, after chunk ids:
+        // webpackJsonp([<chunks>], <modules>, ...)
+        // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+        if (
+          node.callee.type === 'Identifier' &&
+          args.length >= 2 &&
+          isArgumentContainsChunkIds(args[0]) &&
+          isArgumentContainsModulesList(args[1])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[1])
+          return
+        }
+
+        // Additional bundle without webpack loader, with module IDs optimized.
+        // Modules are stored in second arguments Array(n).concat() call
+        // webpackJsonp([<chunks>], Array([minimum ID]).concat([<module>, <module>, ...]))
+        // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
+        if (
+          node.callee.type === 'Identifier' &&
+          (args.length === 2 || args.length === 3) &&
+          isArgumentContainsChunkIds(args[0]) &&
+          isArgumentArrayConcatContainingChunks(args[1])
+        ) {
+          state.locations = getModulesLocationFromArrayConcat(args[1])
+          return
+        }
+
+        // Main bundle with webpack loader
+        // Modules are stored in first argument:
+        // (function (...) {...})(<modules>)
+        if (
+          node.callee.type === 'FunctionExpression' &&
+          !node.callee.id &&
+          args.length === 1 &&
+          isArgumentContainsModulesList(args[0])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[0])
+          return
+        }
+
+        // Additional bundles with webpack 4 are loaded with:
+        // (window.webpackJsonp=window.webpackJsonp||[]).push([[chunkId], [<module>, <module>], [[optional_entries]]]);
+        if (
+          isWindowPropertyPushExpression(node) &&
+          args.length === 1 &&
+          isArgumentContainingChunkIdsAndModulesList(args[0])
+        ) {
+          state.locations = getModulesLocationFromFunctionArgument(args[0].elements[1])
+          return
+        }
+
+        // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
+        // features (e.g. `umd` library output) can wrap modules list into additional IIFE.
+        args.forEach(arg => c(arg, state))
+      }
+    }
+  )
+
+  if (!walkState.locations) {
+    return null
+  }
+
+  return {
+    src: bundleContent,
+    modules: mapValues(walkState.locations,
+      loc => bundleContent.slice(loc.start, loc.end)
+    )
+  }
+}
+
+function getGzipSize (buffer) {
+  return zlib.gzipSync(buffer).length
+}
+
+function isArgumentContainsChunkIds (arg) {
+  // Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
+  return (arg.type === 'ArrayExpression' && arg.elements.every(isModuleId))
+}
+
+function isArgumentContainsModulesList (arg) {
+  if (arg.type === 'ObjectExpression') {
+    return arg.properties
+      .map(prop => prop.value)
+      .every(isModuleWrapper)
+  }
+
+  if (arg.type === 'ArrayExpression') {
+    // Modules are contained in array.
+    // Array indexes are module ids
+    return arg.elements.every(elem =>
+      // Some of array items may be skipped because there is no module with such id
+      !elem ||
+      isModuleWrapper(elem)
+    )
+  }
+
+  return false
+}
+
+function isArgumentContainingChunkIdsAndModulesList (arg) {
+  if (
+    arg.type === 'ArrayExpression' &&
+    arg.elements.length >= 2 &&
+    isArgumentContainsChunkIds(arg.elements[0]) &&
+    isArgumentContainsModulesList(arg.elements[1])
+  ) {
+    return true
+  }
+  return false
+}
+
+function isArgumentArrayConcatContainingChunks (arg) {
+  if (
+    arg.type === 'CallExpression' &&
+    arg.callee.type === 'MemberExpression' &&
+    // Make sure the object called is `Array(<some number>)`
+    arg.callee.object.type === 'CallExpression' &&
+    arg.callee.object.callee.type === 'Identifier' &&
+    arg.callee.object.callee.name === 'Array' &&
+    arg.callee.object.arguments.length === 1 &&
+    isNumericId(arg.callee.object.arguments[0]) &&
+    // Make sure the property X called for `Array(<some number>).X` is `concat`
+    arg.callee.property.type === 'Identifier' &&
+    arg.callee.property.name === 'concat' &&
+    // Make sure exactly one array is passed in to `concat`
+    arg.arguments.length === 1 &&
+    arg.arguments[0].type === 'ArrayExpression'
+  ) {
+    // Modules are contained in `Array(<minimum ID>).concat(` array:
+    // https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
+    // The `<minimum ID>` + array indexes are module ids
+    return true
+  }
+
+  return false
+}
+
+function isWindowPropertyPushExpression (node) {
+  return node.callee.type === 'MemberExpression' &&
+    node.callee.property.name === 'push' &&
+    node.callee.object.type === 'AssignmentExpression' &&
+    node.callee.object.left.object.name === 'window'
+}
+
+function isModuleWrapper (node) {
+  return (
+    // It's an anonymous function expression that wraps module
+    ((node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.id) ||
+    // If `DedupePlugin` is used it can be an ID of duplicated module...
+    isModuleId(node) ||
+    // or an array of shape [<module_id>, ...args]
+    (node.type === 'ArrayExpression' && node.elements.length > 1 && isModuleId(node.elements[0]))
+  )
+}
+
+function isModuleId (node) {
+  return (node.type === 'Literal' && (isNumericId(node) || typeof node.value === 'string'))
+}
+
+function isNumericId (node) {
+  return (node.type === 'Literal' && Number.isInteger(node.value) && node.value >= 0)
+}
+
+function getModulesLocationFromFunctionArgument (arg) {
+  if (arg.type === 'ObjectExpression') {
+    const modulesNodes = arg.properties
+
+    return transform(modulesNodes, (result, moduleNode) => {
+      const moduleId = moduleNode.key.name || moduleNode.key.value
+
+      result[moduleId] = getModuleLocation(moduleNode.value)
+    }, {})
+  }
+
+  if (arg.type === 'ArrayExpression') {
+    const modulesNodes = arg.elements
+
+    return transform(modulesNodes, (result, moduleNode, i) => {
+      if (!moduleNode) return
+
+      result[i] = getModuleLocation(moduleNode)
+    }, {})
+  }
+
+  return {}
+}
+
+function getModulesLocationFromArrayConcat (arg) {
+  // arg(CallExpression) =
+  //   Array([minId]).concat([<minId module>, <minId+1 module>, ...])
+  //
+  // Get the [minId] value from the Array() call first argument literal value
+  const minId = arg.callee.object.arguments[0].value
+  // The modules reside in the `concat()` function call arguments
+  const modulesNodes = arg.arguments[0].elements
+
+  return transform(modulesNodes, (result, moduleNode, i) => {
+    if (!moduleNode) return
+
+    result[i + minId] = getModuleLocation(moduleNode)
+  }, {})
+}
+
+function getModuleLocation (node) {
+  return { start: node.start, end: node.end }
+}