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

package/src/node/plugins/importAnalysisBuild.ts

@@ -1,334 +0,0 @@
-import path from 'path'
-import { ResolvedConfig } from '../config'
-import { Plugin } from '../plugin'
-import MagicString from 'magic-string'
-import { ImportSpecifier, init, parse as parseImports } from 'es-module-lexer'
-import { OutputChunk } from 'rollup'
-import {
-  chunkToEmittedCssFileMap,
-  isCSSRequest,
-  removedPureCssFilesCache
-} from './css'
-import { transformImportGlob } from '../importGlob'
-import { bareImportRE } from '../utils'
-
-/**
- * A flag for injected helpers. This flag will be set to `false` if the output
- * target is not native es - so that injected helper logic can be conditionally
- * dropped.
- */
-export const isModernFlag = `__VITE_IS_MODERN__`
-export const preloadMethod = `__vitePreload`
-export const preloadMarker = `__VITE_PRELOAD__`
-export const preloadBaseMarker = `__VITE_PRELOAD_BASE__`
-
-const preloadHelperId = 'vite/preload-helper'
-const preloadMarkerRE = new RegExp(`"${preloadMarker}"`, 'g')
-
-/**
- * Helper for preloading CSS and direct imports of async chunks in parallel to
- * the async chunk itself.
- */
-
-function detectScriptRel() {
-  // @ts-ignore
-  const relList = document.createElement('link').relList
-  // @ts-ignore
-  return relList && relList.supports && relList.supports('modulepreload')
-    ? 'modulepreload'
-    : 'preload'
-}
-
-declare const scriptRel: string
-function preload(baseModule: () => Promise<{}>, deps?: string[]) {
-  // @ts-ignore
-  if (!__VITE_IS_MODERN__ || !deps || deps.length === 0) {
-    return baseModule()
-  }
-
-  return Promise.all(
-    deps.map((dep) => {
-      // @ts-ignore
-      dep = `${base}${dep}`
-      // @ts-ignore
-      if (dep in seen) return
-      // @ts-ignore
-      seen[dep] = true
-      const isCss = dep.endsWith('.css')
-      const cssSelector = isCss ? '[rel="stylesheet"]' : ''
-      // @ts-ignore check if the file is already preloaded by SSR markup
-      if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
-        return
-      }
-      // @ts-ignore
-      const link = document.createElement('link')
-      // @ts-ignore
-      link.rel = isCss ? 'stylesheet' : scriptRel
-      if (!isCss) {
-        link.as = 'script'
-        link.crossOrigin = ''
-      }
-      link.href = dep
-      // @ts-ignore
-      document.head.appendChild(link)
-      if (isCss) {
-        return new Promise((res, rej) => {
-          link.addEventListener('load', res)
-          link.addEventListener('error', rej)
-        })
-      }
-    })
-  ).then(() => baseModule())
-}
-
-/**
- * Build only. During serve this is performed as part of ./importAnalysis.
- */
-export function buildImportAnalysisPlugin(config: ResolvedConfig): Plugin {
-  const ssr = !!config.build.ssr
-  const insertPreload = !(ssr || !!config.build.lib)
-
-  const scriptRel = config.build.polyfillModulePreload
-    ? `'modulepreload'`
-    : `(${detectScriptRel.toString()})()`
-  const preloadCode = `const scriptRel = ${scriptRel};const seen = {};const base = '${preloadBaseMarker}';export const ${preloadMethod} = ${preload.toString()}`
-
-  return {
-    name: 'vite:import-analysis',
-
-    resolveId(id) {
-      if (id === preloadHelperId) {
-        return id
-      }
-    },
-
-    load(id) {
-      if (id === preloadHelperId) {
-        return preloadCode.replace(preloadBaseMarker, config.base)
-      }
-    },
-
-    async transform(source, importer) {
-      if (
-        importer.includes('node_modules') &&
-        !source.includes('import.meta.glob')
-      ) {
-        return
-      }
-
-      await init
-
-      let imports: readonly ImportSpecifier[] = []
-      try {
-        imports = parseImports(source)[0]
-      } catch (e: any) {
-        this.error(e, e.idx)
-      }
-
-      if (!imports.length) {
-        return null
-      }
-
-      let s: MagicString | undefined
-      const str = () => s || (s = new MagicString(source))
-      let needPreloadHelper = false
-
-      for (let index = 0; index < imports.length; index++) {
-        const {
-          s: start,
-          e: end,
-          ss: expStart,
-          n: specifier,
-          d: dynamicIndex
-        } = imports[index]
-
-        // import.meta.glob
-        if (
-          source.slice(start, end) === 'import.meta' &&
-          source.slice(end, end + 5) === '.glob'
-        ) {
-          const { importsString, exp, endIndex, isEager } =
-            await transformImportGlob(
-              source,
-              start,
-              importer,
-              index,
-              config.root,
-              undefined,
-              insertPreload
-            )
-          str().prepend(importsString)
-          str().overwrite(expStart, endIndex, exp)
-          if (!isEager) {
-            needPreloadHelper = true
-          }
-          continue
-        }
-
-        if (dynamicIndex > -1 && insertPreload) {
-          needPreloadHelper = true
-          const dynamicEnd = source.indexOf(`)`, end) + 1
-          const original = source.slice(dynamicIndex, dynamicEnd)
-          const replacement = `${preloadMethod}(() => ${original},${isModernFlag}?"${preloadMarker}":void 0)`
-          str().overwrite(dynamicIndex, dynamicEnd, replacement)
-        }
-
-        // Differentiate CSS imports that use the default export from those that
-        // do not by injecting a ?used query - this allows us to avoid including
-        // the CSS string when unnecessary (esbuild has trouble treeshaking
-        // them)
-        if (
-          specifier &&
-          isCSSRequest(specifier) &&
-          source.slice(expStart, start).includes('from') &&
-          // edge case for package names ending with .css (e.g normalize.css)
-          !(bareImportRE.test(specifier) && !specifier.includes('/'))
-        ) {
-          const url = specifier.replace(/\?|$/, (m) => `?used${m ? '&' : ''}`)
-          str().overwrite(start, end, dynamicIndex > -1 ? `'${url}'` : url)
-        }
-      }
-
-      if (
-        needPreloadHelper &&
-        insertPreload &&
-        !source.includes(`const ${preloadMethod} =`)
-      ) {
-        str().prepend(`import { ${preloadMethod} } from "${preloadHelperId}";`)
-      }
-
-      if (s) {
-        return {
-          code: s.toString(),
-          map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-        }
-      }
-    },
-
-    renderChunk(code, _, { format }) {
-      // make sure we only perform the preload logic in modern builds.
-      if (code.indexOf(isModernFlag) > -1) {
-        const re = new RegExp(isModernFlag, 'g')
-        const isModern = String(format === 'es')
-        if (config.build.sourcemap) {
-          const s = new MagicString(code)
-          let match: RegExpExecArray | null
-          while ((match = re.exec(code))) {
-            s.overwrite(
-              match.index,
-              match.index + isModernFlag.length,
-              isModern
-            )
-          }
-          return {
-            code: s.toString(),
-            map: s.generateMap({ hires: true })
-          }
-        } else {
-          return code.replace(re, isModern)
-        }
-      }
-      return null
-    },
-
-    generateBundle({ format }, bundle) {
-      if (format !== 'es' || ssr) {
-        return
-      }
-
-      for (const file in bundle) {
-        const chunk = bundle[file]
-        // can't use chunk.dynamicImports.length here since some modules e.g.
-        // dynamic import to constant json may get inlined.
-        if (chunk.type === 'chunk' && chunk.code.indexOf(preloadMarker) > -1) {
-          const code = chunk.code
-          let imports: ImportSpecifier[]
-          try {
-            imports = parseImports(code)[0].filter((i) => i.d > -1)
-          } catch (e: any) {
-            this.error(e, e.idx)
-          }
-
-          if (imports.length) {
-            const s = new MagicString(code)
-            for (let index = 0; index < imports.length; index++) {
-              const { s: start, e: end, d: dynamicIndex } = imports[index]
-              // check the chunk being imported
-              const url = code.slice(start, end)
-              const deps: Set<string> = new Set()
-              let hasRemovedPureCssChunk = false
-
-              if (url[0] === `"` && url[url.length - 1] === `"`) {
-                const ownerFilename = chunk.fileName
-                // literal import - trace direct imports and add to deps
-                const analyzed: Set<string> = new Set<string>()
-                const addDeps = (filename: string) => {
-                  if (filename === ownerFilename) return
-                  if (analyzed.has(filename)) return
-                  analyzed.add(filename)
-                  const chunk = bundle[filename] as OutputChunk | undefined
-                  if (chunk) {
-                    deps.add(chunk.fileName)
-                    const cssFiles = chunkToEmittedCssFileMap.get(chunk)
-                    if (cssFiles) {
-                      cssFiles.forEach((file) => {
-                        deps.add(file)
-                      })
-                    }
-                    chunk.imports.forEach(addDeps)
-                  } else {
-                    const removedPureCssFiles =
-                      removedPureCssFilesCache.get(config)!
-                    const chunk = removedPureCssFiles.get(filename)
-                    if (chunk) {
-                      const cssFiles = chunkToEmittedCssFileMap.get(chunk)
-                      if (cssFiles && cssFiles.size > 0) {
-                        cssFiles.forEach((file) => {
-                          deps.add(file)
-                        })
-                        hasRemovedPureCssChunk = true
-                      }
-
-                      s.overwrite(dynamicIndex, end + 1, 'Promise.resolve({})')
-                    }
-                  }
-                }
-                const normalizedFile = path.posix.join(
-                  path.posix.dirname(chunk.fileName),
-                  url.slice(1, -1)
-                )
-                addDeps(normalizedFile)
-              }
-
-              let markPos = code.indexOf(preloadMarker, end)
-              // fix issue #3051
-              if (markPos === -1 && imports.length === 1) {
-                markPos = code.indexOf(preloadMarker)
-              }
-
-              if (markPos > 0) {
-                s.overwrite(
-                  markPos - 1,
-                  markPos + preloadMarker.length + 1,
-                  // the dep list includes the main chunk, so only need to
-                  // preload when there are actual other deps.
-                  deps.size > 1 ||
-                    // main chunk is removed
-                    (hasRemovedPureCssChunk && deps.size > 0)
-                    ? `[${[...deps].map((d) => JSON.stringify(d)).join(',')}]`
-                    : `[]`
-                )
-              }
-            }
-            chunk.code = s.toString()
-            // TODO source map
-          }
-
-          // there may still be markers due to inlined dynamic imports, remove
-          // all the markers regardless
-          chunk.code = chunk.code.replace(preloadMarkerRE, 'void 0')
-        }
-      }
-    }
-  }
-}

package/src/node/plugins/index.ts

@@ -1,69 +0,0 @@
-import { ResolvedConfig } from '../config'
-import { Plugin } from '../plugin'
-import aliasPlugin from '@rollup/plugin-alias'
-import { jsonPlugin } from './json'
-import { resolvePlugin } from './resolve'
-import { esbuildPlugin } from './esbuild'
-import { importAnalysisPlugin } from './importAnalysis'
-import { cssPlugin, cssPostPlugin } from './css'
-import { assetPlugin } from './asset'
-import { clientInjectionsPlugin } from './clientInjections'
-import { htmlInlineScriptProxyPlugin } from './html'
-import { wasmPlugin } from './wasm'
-import { modulePreloadPolyfillPlugin } from './modulePreloadPolyfill'
-import { webWorkerPlugin } from './worker'
-import { preAliasPlugin } from './preAlias'
-import { definePlugin } from './define'
-
-export async function resolvePlugins(
-  config: ResolvedConfig,
-  prePlugins: Plugin[],
-  normalPlugins: Plugin[],
-  postPlugins: Plugin[]
-): Promise<Plugin[]> {
-  const isBuild = config.command === 'build'
-
-  const buildPlugins = isBuild
-    ? (await import('../build')).resolveBuildPlugins(config)
-    : { pre: [], post: [] }
-
-  return [
-    isBuild ? null : preAliasPlugin(),
-    aliasPlugin({ entries: config.resolve.alias }),
-    ...prePlugins,
-    config.build.polyfillModulePreload
-      ? modulePreloadPolyfillPlugin(config)
-      : null,
-    resolvePlugin({
-      ...config.resolve,
-      root: config.root,
-      isProduction: config.isProduction,
-      isBuild,
-      ssrConfig: config.ssr,
-      asSrc: true
-    }),
-    htmlInlineScriptProxyPlugin(),
-    cssPlugin(config),
-    config.esbuild !== false ? esbuildPlugin(config.esbuild) : null,
-    jsonPlugin(
-      {
-        namedExports: true,
-        ...config.json
-      },
-      isBuild
-    ),
-    wasmPlugin(config),
-    webWorkerPlugin(config),
-    assetPlugin(config),
-    ...normalPlugins,
-    definePlugin(config),
-    cssPostPlugin(config),
-    ...buildPlugins.pre,
-    ...postPlugins,
-    ...buildPlugins.post,
-    // internal server-only plugins are always applied after everything else
-    ...(isBuild
-      ? []
-      : [clientInjectionsPlugin(config), importAnalysisPlugin(config)])
-  ].filter(Boolean) as Plugin[]
-}

package/src/node/plugins/json.ts

@@ -1,75 +0,0 @@
-/**
- * https://github.com/rollup/plugins/blob/master/packages/json/src/index.js
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/rollup/plugins/blob/master/LICENSE
- */
-
-import { dataToEsm } from '@rollup/pluginutils'
-import { Plugin } from 'rollup'
-import { SPECIAL_QUERY_RE } from '../constants'
-
-export interface JsonOptions {
-  /**
-   * Generate a named export for every property of the JSON object
-   * @default true
-   */
-  namedExports?: boolean
-  /**
-   * Generate performant output as JSON.parse("stringified").
-   * Enabling this will disable namedExports.
-   * @default false
-   */
-  stringify?: boolean
-}
-
-// Custom json filter for vite
-const jsonExtRE = /\.json($|\?)(?!commonjs-proxy)/
-
-export function jsonPlugin(
-  options: JsonOptions = {},
-  isBuild: boolean
-): Plugin {
-  return {
-    name: 'vite:json',
-
-    transform(json, id) {
-      if (!jsonExtRE.test(id)) return null
-      if (SPECIAL_QUERY_RE.test(id)) return null
-
-      try {
-        if (options.stringify) {
-          if (isBuild) {
-            return {
-              // during build, parse then double-stringify to remove all
-              // unnecessary whitespaces to reduce bundle size.
-              code: `export default JSON.parse(${JSON.stringify(
-                JSON.stringify(JSON.parse(json))
-              )})`,
-              map: { mappings: '' }
-            }
-          } else {
-            return `export default JSON.parse(${JSON.stringify(json)})`
-          }
-        }
-
-        const parsed = JSON.parse(json)
-        return {
-          code: dataToEsm(parsed, {
-            preferConst: true,
-            namedExports: options.namedExports
-          }),
-          map: { mappings: '' }
-        }
-      } catch (e) {
-        const errorMessageList = /[\d]+/.exec(e.message)
-        const position = errorMessageList && parseInt(errorMessageList[0], 10)
-        const msg = position
-          ? `, invalid JSON syntax found at line ${position}`
-          : `.`
-        this.error(`Failed to parse JSON file` + msg, e.idx)
-      }
-    }
-  }
-}

package/src/node/plugins/loadFallback.ts

@@ -1,19 +0,0 @@
-import { promises as fs } from 'fs'
-import { Plugin } from '..'
-import { cleanUrl } from '../utils'
-
-/**
- * A plugin to provide build load fallback for arbitrary request with queries.
- */
-export function loadFallbackPlugin(): Plugin {
-  return {
-    name: 'vite:load-fallback',
-    async load(id) {
-      try {
-        return fs.readFile(cleanUrl(id), 'utf-8')
-      } catch (e) {
-        return fs.readFile(id, 'utf-8')
-      }
-    }
-  }
-}

package/src/node/plugins/manifest.ts

@@ -1,123 +0,0 @@
-import path from 'path'
-import { OutputChunk } from 'rollup'
-import { ResolvedConfig } from '..'
-import { Plugin } from '../plugin'
-import { chunkToEmittedCssFileMap } from './css'
-import { chunkToEmittedAssetsMap } from './asset'
-import { normalizePath } from '../utils'
-
-export type Manifest = Record<string, ManifestChunk>
-
-export interface ManifestChunk {
-  src?: string
-  file: string
-  css?: string[]
-  assets?: string[]
-  isEntry?: boolean
-  isDynamicEntry?: boolean
-  imports?: string[]
-  dynamicImports?: string[]
-}
-
-export function manifestPlugin(config: ResolvedConfig): Plugin {
-  const manifest: Manifest = {}
-
-  let outputCount: number
-
-  return {
-    name: 'vite:manifest',
-
-    buildStart() {
-      outputCount = 0
-    },
-
-    generateBundle({ format }, bundle) {
-      function getChunkName(chunk: OutputChunk) {
-        if (chunk.facadeModuleId) {
-          let name = normalizePath(
-            path.relative(config.root, chunk.facadeModuleId)
-          )
-          if (format === 'system' && !chunk.name.includes('-legacy')) {
-            const ext = path.extname(name)
-            name = name.slice(0, -ext.length) + `-legacy` + ext
-          }
-          return name
-        } else {
-          return `_` + path.basename(chunk.fileName)
-        }
-      }
-
-      function getInternalImports(imports: string[]): string[] {
-        const filteredImports: string[] = []
-
-        for (const file of imports) {
-          if (bundle[file] === undefined) {
-            continue
-          }
-
-          filteredImports.push(getChunkName(bundle[file] as OutputChunk))
-        }
-
-        return filteredImports
-      }
-
-      function createChunk(chunk: OutputChunk): ManifestChunk {
-        const manifestChunk: ManifestChunk = {
-          file: chunk.fileName
-        }
-
-        if (chunk.facadeModuleId) {
-          manifestChunk.src = getChunkName(chunk)
-        }
-        if (chunk.isEntry) {
-          manifestChunk.isEntry = true
-        }
-        if (chunk.isDynamicEntry) {
-          manifestChunk.isDynamicEntry = true
-        }
-
-        if (chunk.imports.length) {
-          const internalImports = getInternalImports(chunk.imports)
-          if (internalImports.length > 0) {
-            manifestChunk.imports = internalImports
-          }
-        }
-
-        if (chunk.dynamicImports.length) {
-          const internalImports = getInternalImports(chunk.dynamicImports)
-          if (internalImports.length > 0) {
-            manifestChunk.dynamicImports = internalImports
-          }
-        }
-
-        const cssFiles = chunkToEmittedCssFileMap.get(chunk)
-        if (cssFiles) {
-          manifestChunk.css = [...cssFiles]
-        }
-
-        const assets = chunkToEmittedAssetsMap.get(chunk)
-        if (assets) [(manifestChunk.assets = [...assets])]
-
-        return manifestChunk
-      }
-
-      for (const file in bundle) {
-        const chunk = bundle[file]
-        if (chunk.type === 'chunk') {
-          manifest[getChunkName(chunk)] = createChunk(chunk)
-        }
-      }
-
-      outputCount++
-      const output = config.build.rollupOptions?.output
-      const outputLength = Array.isArray(output) ? output.length : 1
-      if (outputCount >= outputLength) {
-        this.emitFile({
-          fileName: `manifest.json`,
-          type: 'asset',
-          source: JSON.stringify(manifest, null, 2)
-        })
-      }
-    }
-  }
-}