vite 2.6.0-beta.0 → 2.6.0-beta.4

package/src/node/plugins/modulePreloadPolyfill.ts

@@ -1,100 +0,0 @@
-import { ResolvedConfig } from '..'
-import { Plugin } from '../plugin'
-import { isModernFlag } from './importAnalysisBuild'
-
-export const modulePreloadPolyfillId = 'vite/modulepreload-polyfill'
-
-export function modulePreloadPolyfillPlugin(config: ResolvedConfig): Plugin {
-  const skip = config.build.ssr
-  let polyfillString: string | undefined
-
-  return {
-    name: 'vite:modulepreload-polyfill',
-    resolveId(id) {
-      if (id === modulePreloadPolyfillId) {
-        return id
-      }
-    },
-    load(id) {
-      if (id === modulePreloadPolyfillId) {
-        if (skip) {
-          return ''
-        }
-        if (!polyfillString) {
-          polyfillString =
-            `const p = ${polyfill.toString()};` + `${isModernFlag}&&p();`
-        }
-        return polyfillString
-      }
-    }
-  }
-}
-
-/**
-The following polyfill function is meant to run in the browser and adapted from
-https://github.com/guybedford/es-module-shims
-MIT License
-Copyright (C) 2018-2021 Guy Bedford
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-*/
-
-declare const document: any
-declare const MutationObserver: any
-declare const fetch: any
-
-function polyfill() {
-  const relList = document.createElement('link').relList
-  if (relList && relList.supports && relList.supports('modulepreload')) {
-    return
-  }
-
-  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
-    processPreload(link)
-  }
-
-  new MutationObserver((mutations: any) => {
-    for (const mutation of mutations) {
-      if (mutation.type !== 'childList') {
-        continue
-      }
-      for (const node of mutation.addedNodes) {
-        if (node.tagName === 'LINK' && node.rel === 'modulepreload')
-          processPreload(node)
-      }
-    }
-  }).observe(document, { childList: true, subtree: true })
-
-  function getFetchOpts(script: any) {
-    const fetchOpts = {} as any
-    if (script.integrity) fetchOpts.integrity = script.integrity
-    if (script.referrerpolicy) fetchOpts.referrerPolicy = script.referrerpolicy
-    if (script.crossorigin === 'use-credentials')
-      fetchOpts.credentials = 'include'
-    else if (script.crossorigin === 'anonymous') fetchOpts.credentials = 'omit'
-    else fetchOpts.credentials = 'same-origin'
-    return fetchOpts
-  }
-
-  function processPreload(link: any) {
-    if (link.ep)
-      // ep marker = processed
-      return
-    link.ep = true
-    // prepopulate the load record
-    const fetchOpts = getFetchOpts(link)
-    fetch(link.href, fetchOpts)
-  }
-}

package/src/node/plugins/preAlias.ts

@@ -1,22 +0,0 @@
-import { ViteDevServer } from '..'
-import { Plugin } from '../plugin'
-import { bareImportRE } from '../utils'
-import { tryOptimizedResolve } from './resolve'
-
-/**
- * A plugin to avoid an aliased AND optimized dep from being aliased in src
- */
-export function preAliasPlugin(): Plugin {
-  let server: ViteDevServer
-  return {
-    name: 'vite:pre-alias',
-    configureServer(_server) {
-      server = _server
-    },
-    resolveId(id, importer, _, ssr) {
-      if (!ssr && bareImportRE.test(id)) {
-        return tryOptimizedResolve(id, server, importer)
-      }
-    }
-  }
-}

package/src/node/plugins/reporter.ts

@@ -1,244 +0,0 @@
-import path from 'path'
-import chalk from 'chalk'
-import { gzip } from 'zlib'
-import { promisify } from 'util'
-import { Plugin } from 'rollup'
-import { ResolvedConfig } from '../config'
-import { normalizePath } from '../utils'
-import { LogLevels } from '../logger'
-
-const enum WriteType {
-  JS,
-  CSS,
-  ASSET,
-  HTML,
-  SOURCE_MAP
-}
-
-const writeColors = {
-  [WriteType.JS]: chalk.cyan,
-  [WriteType.CSS]: chalk.magenta,
-  [WriteType.ASSET]: chalk.green,
-  [WriteType.HTML]: chalk.blue,
-  [WriteType.SOURCE_MAP]: chalk.gray
-}
-
-export function buildReporterPlugin(config: ResolvedConfig): Plugin {
-  const compress = promisify(gzip)
-  const chunkLimit = config.build.chunkSizeWarningLimit
-
-  function isLarge(code: string | Uint8Array): boolean {
-    // bail out on particularly large chunks
-    return code.length / 1024 > chunkLimit
-  }
-
-  async function getCompressedSize(code: string | Uint8Array): Promise<string> {
-    if (
-      config.build.ssr ||
-      !config.build.reportCompressedSize ||
-      config.build.brotliSize === false
-    ) {
-      return ''
-    }
-    return ` / gzip: ${(
-      (await compress(typeof code === 'string' ? code : Buffer.from(code)))
-        .length / 1024
-    ).toFixed(2)} KiB`
-  }
-
-  function printFileInfo(
-    filePath: string,
-    content: string | Uint8Array,
-    type: WriteType,
-    maxLength: number,
-    compressedSize = ''
-  ) {
-    const outDir =
-      normalizePath(
-        path.relative(
-          config.root,
-          path.resolve(config.root, config.build.outDir)
-        )
-      ) + '/'
-    const kibs = content.length / 1024
-    const sizeColor = kibs > chunkLimit ? chalk.yellow : chalk.dim
-    config.logger.info(
-      `${chalk.gray(chalk.white.dim(outDir))}${writeColors[type](
-        filePath.padEnd(maxLength + 2)
-      )} ${sizeColor(`${kibs.toFixed(2)} KiB${compressedSize}`)}`
-    )
-  }
-
-  const tty = process.stdout.isTTY && !process.env.CI
-  const shouldLogInfo = LogLevels[config.logLevel || 'info'] >= LogLevels.info
-  let hasTransformed = false
-  let hasRenderedChunk = false
-  let transformedCount = 0
-  let chunkCount = 0
-
-  const logTransform = throttle((id: string) => {
-    writeLine(
-      `transforming (${transformedCount}) ${chalk.dim(
-        path.relative(config.root, id)
-      )}`
-    )
-  })
-
-  return {
-    name: 'vite:reporter',
-
-    transform(_, id) {
-      transformedCount++
-      if (shouldLogInfo) {
-        if (!tty) {
-          if (!hasTransformed) {
-            config.logger.info(`transforming...`)
-          }
-        } else {
-          if (id.includes(`?`)) return
-          logTransform(id)
-        }
-        hasTransformed = true
-      }
-      return null
-    },
-
-    buildEnd() {
-      if (shouldLogInfo) {
-        if (tty) {
-          process.stdout.clearLine(0)
-          process.stdout.cursorTo(0)
-        }
-        config.logger.info(
-          `${chalk.green(`✓`)} ${transformedCount} modules transformed.`
-        )
-      }
-    },
-
-    renderStart() {
-      chunkCount = 0
-    },
-
-    renderChunk() {
-      chunkCount++
-      if (shouldLogInfo) {
-        if (!tty) {
-          if (!hasRenderedChunk) {
-            config.logger.info('rendering chunks...')
-          }
-        } else {
-          writeLine(`rendering chunks (${chunkCount})...`)
-        }
-        hasRenderedChunk = true
-      }
-      return null
-    },
-
-    generateBundle() {
-      if (shouldLogInfo && tty) {
-        process.stdout.clearLine(0)
-        process.stdout.cursorTo(0)
-      }
-    },
-
-    async writeBundle(_, output) {
-      let hasLargeChunks = false
-
-      if (shouldLogInfo) {
-        let longest = 0
-        for (const file in output) {
-          const l = output[file].fileName.length
-          if (l > longest) longest = l
-        }
-
-        // large chunks are deferred to be logged at the end so they are more
-        // visible.
-        const deferredLogs: (() => void)[] = []
-
-        await Promise.all(
-          Object.keys(output).map(async (file) => {
-            const chunk = output[file]
-            if (chunk.type === 'chunk') {
-              const log = async () => {
-                printFileInfo(
-                  chunk.fileName,
-                  chunk.code,
-                  WriteType.JS,
-                  longest,
-                  await getCompressedSize(chunk.code)
-                )
-                if (chunk.map) {
-                  printFileInfo(
-                    chunk.fileName + '.map',
-                    chunk.map.toString(),
-                    WriteType.SOURCE_MAP,
-                    longest
-                  )
-                }
-              }
-              if (isLarge(chunk.code)) {
-                hasLargeChunks = true
-                deferredLogs.push(log)
-              } else {
-                await log()
-              }
-            } else if (chunk.source) {
-              const isCSS = chunk.fileName.endsWith('.css')
-              printFileInfo(
-                chunk.fileName,
-                chunk.source,
-                isCSS ? WriteType.CSS : WriteType.ASSET,
-                longest,
-                isCSS ? await getCompressedSize(chunk.source) : undefined
-              )
-            }
-          })
-        )
-
-        await Promise.all(deferredLogs.map((l) => l()))
-      } else {
-        hasLargeChunks = Object.keys(output).some((file) => {
-          const chunk = output[file]
-          return chunk.type === 'chunk' && chunk.code.length / 1024 > chunkLimit
-        })
-      }
-
-      if (
-        hasLargeChunks &&
-        config.build.minify &&
-        !config.build.lib &&
-        !config.build.ssr
-      ) {
-        config.logger.warn(
-          chalk.yellow(
-            `\n(!) Some chunks are larger than ${chunkLimit} KiB after minification. Consider:\n` +
-              `- Using dynamic import() to code-split the application\n` +
-              `- Use build.rollupOptions.output.manualChunks to improve chunking: https://rollupjs.org/guide/en/#outputmanualchunks\n` +
-              `- Adjust chunk size limit for this warning via build.chunkSizeWarningLimit.`
-          )
-        )
-      }
-    }
-  }
-}
-
-function writeLine(output: string) {
-  process.stdout.clearLine(0)
-  process.stdout.cursorTo(0)
-  if (output.length < process.stdout.columns) {
-    process.stdout.write(output)
-  } else {
-    process.stdout.write(output.substring(0, process.stdout.columns - 1))
-  }
-}
-
-function throttle(fn: Function) {
-  let timerHandle: NodeJS.Timeout | null = null
-  return (...args: any[]) => {
-    if (timerHandle) return
-    fn(...args)
-    timerHandle = setTimeout(() => {
-      timerHandle = null
-    }, 100)
-  }
-}