node_modules

node_modules/@vue/preload-webpack-plugin/src/index.js

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const defaultOptions = require('./lib/default-options')
+const determineAsValue = require('./lib/determine-as-value')
+const doesChunkBelongToHTML = require('./lib/does-chunk-belong-to-html')
+const extractChunks = require('./lib/extract-chunks')
+
+class PreloadPlugin {
+  constructor (options) {
+    this.options = Object.assign({}, defaultOptions, options)
+  }
+
+  generateLinks (compilation, htmlPluginData) {
+    const options = this.options
+    const extractedChunks = extractChunks({
+      compilation,
+      optionsInclude: options.include
+    })
+
+    const htmlChunks = options.include === 'allAssets'
+      // Handle all chunks.
+      ? extractedChunks
+      // Only handle chunks imported by this HtmlWebpackPlugin.
+      : extractedChunks.filter((chunk) => doesChunkBelongToHTML({
+        chunk,
+        compilation,
+        htmlAssetsChunks: Object.values(htmlPluginData.assets.chunks)
+      }))
+
+    // Flatten the list of files.
+    const allFiles = htmlChunks.reduce((accumulated, chunk) => {
+      return accumulated.concat(chunk.files)
+    }, [])
+    const uniqueFiles = new Set(allFiles)
+    const filteredFiles = [...uniqueFiles].filter(file => {
+      return (
+        !this.options.fileWhitelist ||
+        this.options.fileWhitelist.some(regex => regex.test(file))
+      )
+    }).filter(file => {
+      return (
+        !this.options.fileBlacklist ||
+        this.options.fileBlacklist.every(regex => !regex.test(file))
+      )
+    })
+    // Sort to ensure the output is predictable.
+    const sortedFilteredFiles = filteredFiles.sort()
+
+    const links = []
+    const publicPath = compilation.outputOptions.publicPath || ''
+    for (const file of sortedFilteredFiles) {
+      const href = `${publicPath}${file}`
+
+      const attributes = {
+        href,
+        rel: options.rel
+      }
+
+      // If we're preloading this resource (as opposed to prefetching),
+      // then we need to set the 'as' attribute correctly.
+      if (options.rel === 'preload') {
+        attributes.as = determineAsValue({
+          href,
+          optionsAs: options.as
+        })
+
+        // On the off chance that we have a cross-origin 'href' attribute,
+        // set crossOrigin on the <link> to trigger CORS mode. Non-CORS
+        // fonts can't be used.
+        if (attributes.as === 'font') {
+          attributes.crossorigin = ''
+        }
+      }
+
+      links.push({
+        tagName: 'link',
+        attributes
+      })
+    }
+
+    this.resourceHints = links
+    return htmlPluginData
+  }
+
+  apply (compiler) {
+    const skip = data => {
+      const htmlFilename = data.plugin.options.filename
+      const exclude = this.options.excludeHtmlNames
+      const include = this.options.includeHtmlNames
+      return (
+        (include && !(include.includes(htmlFilename))) ||
+        (exclude && exclude.includes(htmlFilename))
+      )
+    }
+
+    compiler.hooks.compilation.tap(
+      this.constructor.name,
+      compilation => {
+        compilation.hooks.htmlWebpackPluginBeforeHtmlProcessing.tap(
+          this.constructor.name,
+          (htmlPluginData) => {
+            if (skip(htmlPluginData)) {
+              return
+            }
+            this.generateLinks(compilation, htmlPluginData)
+          }
+        )
+
+        compilation.hooks.htmlWebpackPluginAlterAssetTags.tap(
+          this.constructor.name,
+          (htmlPluginData) => {
+            if (skip(htmlPluginData)) {
+              return
+            }
+            if (this.resourceHints) {
+              htmlPluginData.head = [
+                ...this.resourceHints,
+                ...htmlPluginData.head
+              ]
+            }
+            return htmlPluginData
+          }
+        )
+      }
+    )
+  }
+}
+
+module.exports = PreloadPlugin

node_modules/@vue/preload-webpack-plugin/src/lib/default-options.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const defaultOptions = {
+  rel: 'preload',
+  include: 'asyncChunks',
+  excludeHtmlNames: [],
+  fileBlacklist: [/\.map/]
+}
+
+module.exports = defaultOptions

node_modules/@vue/preload-webpack-plugin/src/lib/determine-as-value.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const assert = require('assert')
+const path = require('path')
+const { URL } = require('url')
+
+function determineAsValue ({ optionsAs, href }) {
+  assert(href, `The 'href' parameter was not provided.`)
+
+  switch (typeof optionsAs) {
+    case 'string': {
+      return optionsAs
+    }
+
+    case 'function': {
+      return optionsAs(href)
+    }
+
+    case 'undefined': {
+      // If `as` value is not provided in option, dynamically determine the correct
+      // value based on the suffix of filename.
+
+      // We only care about the pathname, so just use any domain when constructing the URL.
+      const url = new URL(href, 'https://example.com')
+      const extension = path.extname(url.pathname)
+
+      if (extension === '.css') {
+        return 'style'
+      }
+
+      if (extension === '.woff2') {
+        return 'font'
+      }
+
+      return 'script'
+    }
+
+    default:
+      throw new Error(`The 'as' option isn't set to a recognized value: ${optionsAs}`)
+  }
+}
+
+module.exports = determineAsValue

node_modules/@vue/preload-webpack-plugin/src/lib/does-chunk-belong-to-html.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = function doesChunkBelongToHtml ({ chunk, htmlAssetsChunks, compilation }) {
+  // Get all the hashes of the HTML assets.
+  const rootHashes = Object.values(htmlAssetsChunks).map(({ hash }) => hash)
+  // Get a list of chunk groups that contain one of those hashes.
+  const rootChunkGroups = compilation.chunkGroups.filter((chunkGroup) => {
+    return chunkGroup.chunks.filter((chunk) => rootHashes.includes(chunk.renderedHash))
+  })
+  // Get an id for each of those chunk groups.
+  const rootChunkGroupsIds = new Set(rootChunkGroups.map(({ id }) => id))
+  // Return true iff the chunk we're passed belongs to a group whose id is in
+  // the list of root chunk groups.
+  return Array.from(chunk.groupsIterable).some(({ id }) => rootChunkGroupsIds.has(id))
+}

node_modules/@vue/preload-webpack-plugin/src/lib/extract-chunks.js

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function isAsync (chunk) {
+  if ('canBeInitial' in chunk) {
+    return !chunk.canBeInitial()
+  } else {
+    return !chunk.isInitial()
+  }
+}
+
+function getChunkEntryNames (chunk) {
+  if ('groupsIterable' in chunk) {
+    return Array.from(new Set(getNames(chunk.groupsIterable)))
+  } else {
+    return chunk.entrypoints.map(e => e.options.name)
+  }
+}
+
+function getNames (groups) {
+  const Entrypoint = require('webpack/lib/Entrypoint')
+  const names = []
+  for (const group of groups) {
+    if (group instanceof Entrypoint) {
+      // entrypoint
+      if (group.options.name) {
+        names.push(group.options.name)
+      }
+    } else {
+      names.push(...getNames(group.parentsIterable))
+    }
+  }
+  return names
+}
+
+function extractChunks ({ compilation, optionsInclude }) {
+  let includeChunks
+  let includeType
+  let includeEntryPoints
+  if (optionsInclude && typeof optionsInclude === 'object') {
+    includeType = optionsInclude.type
+    includeChunks = optionsInclude.chunks
+    includeEntryPoints = optionsInclude.entries
+  } else {
+    if (Array.isArray(optionsInclude)) {
+      includeChunks = optionsInclude
+    } else {
+      includeType = optionsInclude
+    }
+  }
+
+  let chunks = compilation.chunks
+
+  if (Array.isArray(includeChunks)) {
+    chunks = chunks.filter((chunk) => {
+      return chunk.name && includeChunks.includes(chunk.name)
+    })
+  }
+
+  if (Array.isArray(includeEntryPoints)) {
+    chunks = chunks.filter(chunk => {
+      const names = getChunkEntryNames(chunk)
+      return names.some(name => includeEntryPoints.includes(name))
+    })
+  }
+
+  // 'asyncChunks' are chunks intended for lazy/async loading usually generated as
+  // part of code-splitting with import() or require.ensure(). By default, asyncChunks
+  // get wired up using link rel=preload when using this plugin. This behaviour can be
+  // configured to preload all types of chunks or just prefetch chunks as needed.
+  if (includeType === undefined || includeType === 'asyncChunks') {
+    return chunks.filter(isAsync)
+  }
+
+  if (includeType === 'initial') {
+    return chunks.filter(chunk => !isAsync(chunk))
+  }
+
+  if (includeType === 'allChunks') {
+    // Async chunks, vendor chunks, normal chunks.
+    return chunks
+  }
+
+  if (includeType === 'allAssets') {
+    // Every asset, regardless of which chunk it's in.
+    // Wrap it in a single, "psuedo-chunk" return value.
+    return [{ files: Object.keys(compilation.assets) }]
+  }
+
+  return chunks
+}
+
+module.exports = extractChunks