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

package/src/node/plugins/asset.ts

@@ -1,365 +0,0 @@
-import path from 'path'
-import { parse as parseUrl } from 'url'
-import fs, { promises as fsp } from 'fs'
-import mime from 'mime/lite'
-import { Plugin } from '../plugin'
-import { ResolvedConfig } from '../config'
-import { cleanUrl } from '../utils'
-import { FS_PREFIX } from '../constants'
-import { OutputOptions, PluginContext, RenderedChunk } from 'rollup'
-import MagicString from 'magic-string'
-import { createHash } from 'crypto'
-import { normalizePath } from '../utils'
-
-export const assetUrlRE = /__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?/g
-
-// urls in JS must be quoted as strings, so when replacing them we need
-// a different regex
-const assetUrlQuotedRE = /"__VITE_ASSET__([a-z\d]{8})__(?:\$_(.*?)__)?"/g
-
-const rawRE = /(\?|&)raw(?:&|$)/
-const urlRE = /(\?|&)url(?:&|$)/
-
-export const chunkToEmittedAssetsMap = new WeakMap<RenderedChunk, Set<string>>()
-
-const assetCache = new WeakMap<ResolvedConfig, Map<string, string>>()
-
-const assetHashToFilenameMap = new WeakMap<
-  ResolvedConfig,
-  Map<string, string>
->()
-// save hashes of the files that has been emitted in build watch
-const emittedHashMap = new WeakMap<ResolvedConfig, Set<string>>()
-
-/**
- * Also supports loading plain strings with import text from './foo.txt?raw'
- */
-export function assetPlugin(config: ResolvedConfig): Plugin {
-  // assetHashToFilenameMap initialization in buildStart causes getAssetFilename to return undefined
-  assetHashToFilenameMap.set(config, new Map())
-  return {
-    name: 'vite:asset',
-
-    buildStart() {
-      assetCache.set(config, new Map())
-      emittedHashMap.set(config, new Set())
-    },
-
-    resolveId(id) {
-      if (!config.assetsInclude(cleanUrl(id))) {
-        return
-      }
-      // imports to absolute urls pointing to files in /public
-      // will fail to resolve in the main resolver. handle them here.
-      const publicFile = checkPublicFile(id, config)
-      if (publicFile) {
-        return id
-      }
-    },
-
-    async load(id) {
-      if (id.startsWith('\0')) {
-        // Rollup convention, this id should be handled by the
-        // plugin that marked it with \0
-        return
-      }
-
-      // raw requests, read from disk
-      if (rawRE.test(id)) {
-        const file = checkPublicFile(id, config) || cleanUrl(id)
-        // raw query, read file and return as string
-        return `export default ${JSON.stringify(
-          await fsp.readFile(file, 'utf-8')
-        )}`
-      }
-
-      if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
-        return
-      }
-
-      id = id.replace(urlRE, '$1').replace(/[\?&]$/, '')
-      const url = await fileToUrl(id, config, this)
-      return `export default ${JSON.stringify(url)}`
-    },
-
-    renderChunk(code, chunk) {
-      let match: RegExpExecArray | null
-      let s: MagicString | undefined
-      while ((match = assetUrlQuotedRE.exec(code))) {
-        s = s || (s = new MagicString(code))
-        const [full, hash, postfix = ''] = match
-        // some internal plugins may still need to emit chunks (e.g. worker) so
-        // fallback to this.getFileName for that.
-        const file = getAssetFilename(hash, config) || this.getFileName(hash)
-        registerAssetToChunk(chunk, file)
-        const outputFilepath = config.base + file + postfix
-        s.overwrite(
-          match.index,
-          match.index + full.length,
-          JSON.stringify(outputFilepath)
-        )
-      }
-      if (s) {
-        return {
-          code: s.toString(),
-          map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-        }
-      } else {
-        return null
-      }
-    },
-
-    generateBundle(_, bundle) {
-      // do not emit assets for SSR build
-      if (config.command === 'build' && config.build.ssr) {
-        for (const file in bundle) {
-          if (
-            bundle[file].type === 'asset' &&
-            !file.includes('ssr-manifest.json')
-          ) {
-            delete bundle[file]
-          }
-        }
-      }
-    }
-  }
-}
-
-export function registerAssetToChunk(chunk: RenderedChunk, file: string): void {
-  let emitted = chunkToEmittedAssetsMap.get(chunk)
-  if (!emitted) {
-    emitted = new Set()
-    chunkToEmittedAssetsMap.set(chunk, emitted)
-  }
-  emitted.add(cleanUrl(file))
-}
-
-export function checkPublicFile(
-  url: string,
-  { publicDir }: ResolvedConfig
-): string | undefined {
-  // note if the file is in /public, the resolver would have returned it
-  // as-is so it's not going to be a fully resolved path.
-  if (!publicDir || !url.startsWith('/')) {
-    return
-  }
-  const publicFile = path.join(publicDir, cleanUrl(url))
-  if (fs.existsSync(publicFile)) {
-    return publicFile
-  } else {
-    return
-  }
-}
-
-export function fileToUrl(
-  id: string,
-  config: ResolvedConfig,
-  ctx: PluginContext
-): string | Promise<string> {
-  if (config.command === 'serve') {
-    return fileToDevUrl(id, config)
-  } else {
-    return fileToBuiltUrl(id, config, ctx)
-  }
-}
-
-function fileToDevUrl(id: string, config: ResolvedConfig) {
-  let rtn: string
-  if (checkPublicFile(id, config)) {
-    // in public dir, keep the url as-is
-    rtn = id
-  } else if (id.startsWith(config.root)) {
-    // in project root, infer short public path
-    rtn = '/' + path.posix.relative(config.root, id)
-  } else {
-    // outside of project root, use absolute fs path
-    // (this is special handled by the serve static middleware
-    rtn = path.posix.join(FS_PREFIX + id)
-  }
-  return config.base + rtn.replace(/^\//, '')
-}
-
-export function getAssetFilename(
-  hash: string,
-  config: ResolvedConfig
-): string | undefined {
-  return assetHashToFilenameMap.get(config)?.get(hash)
-}
-
-/**
- * converts the source filepath of the asset to the output filename based on the assetFileNames option. \
- * this function imitates the behavior of rollup.js. \
- * https://rollupjs.org/guide/en/#outputassetfilenames
- *
- * @example
- * ```ts
- * const content = Buffer.from('text');
- * const fileName = assetFileNamesToFileName(
- *   'assets/[name].[hash][extname]',
- *   '/path/to/file.txt',
- *   getAssetHash(content),
- *   content
- * )
- * // fileName: 'assets/file.982d9e3e.txt'
- * ```
- *
- * @param assetFileNames filename pattern. e.g. `'assets/[name].[hash][extname]'`
- * @param file filepath of the asset
- * @param contentHash hash of the asset. used for `'[hash]'` placeholder
- * @param content content of the asset. passed to `assetFileNames` if `assetFileNames` is a function
- * @returns output filename
- */
-export function assetFileNamesToFileName(
-  assetFileNames: Exclude<OutputOptions['assetFileNames'], undefined>,
-  file: string,
-  contentHash: string,
-  content: string | Buffer
-): string {
-  const basename = path.basename(file)
-
-  // placeholders for `assetFileNames`
-  // `hash` is slightly different from the rollup's one
-  const extname = path.extname(basename)
-  const ext = extname.substr(1)
-  const name = basename.slice(0, -extname.length)
-  const hash = contentHash
-
-  if (typeof assetFileNames === 'function') {
-    assetFileNames = assetFileNames({
-      name: file,
-      source: content,
-      type: 'asset'
-    })
-    if (typeof assetFileNames !== 'string') {
-      throw new TypeError('assetFileNames must return a string')
-    }
-  } else if (typeof assetFileNames !== 'string') {
-    throw new TypeError('assetFileNames must be a string or a function')
-  }
-
-  const fileName = assetFileNames.replace(
-    /\[\w+\]/g,
-    (placeholder: string): string => {
-      switch (placeholder) {
-        case '[ext]':
-          return ext
-
-        case '[extname]':
-          return extname
-
-        case '[hash]':
-          return hash
-
-        case '[name]':
-          return name
-      }
-      throw new Error(
-        `invalid placeholder ${placeholder} in assetFileNames "${assetFileNames}"`
-      )
-    }
-  )
-
-  return fileName
-}
-
-/**
- * Register an asset to be emitted as part of the bundle (if necessary)
- * and returns the resolved public URL
- */
-async function fileToBuiltUrl(
-  id: string,
-  config: ResolvedConfig,
-  pluginContext: PluginContext,
-  skipPublicCheck = false
-): Promise<string> {
-  if (!skipPublicCheck && checkPublicFile(id, config)) {
-    return config.base + id.slice(1)
-  }
-
-  const cache = assetCache.get(config)!
-  const cached = cache.get(id)
-  if (cached) {
-    return cached
-  }
-
-  const file = cleanUrl(id)
-  const content = await fsp.readFile(file)
-
-  let url: string
-  if (
-    config.build.lib ||
-    (!file.endsWith('.svg') &&
-      content.length < Number(config.build.assetsInlineLimit))
-  ) {
-    // base64 inlined as a string
-    url = `data:${mime.getType(file)};base64,${content.toString('base64')}`
-  } else {
-    // emit as asset
-    // rollup supports `import.meta.ROLLUP_FILE_URL_*`, but it generates code
-    // that uses runtime url sniffing and it can be verbose when targeting
-    // non-module format. It also fails to cascade the asset content change
-    // into the chunk's hash, so we have to do our own content hashing here.
-    // https://bundlers.tooling.report/hashing/asset-cascade/
-    // https://github.com/rollup/rollup/issues/3415
-    const map = assetHashToFilenameMap.get(config)!
-    const contentHash = getAssetHash(content)
-    const { search, hash } = parseUrl(id)
-    const postfix = (search || '') + (hash || '')
-    const output = config.build?.rollupOptions?.output
-    const assetFileNames =
-      (output && !Array.isArray(output) ? output.assetFileNames : undefined) ??
-      // defaults to '<assetsDir>/[name].[hash][extname]'
-      // slightly different from rollup's one ('assets/[name]-[hash][extname]')
-      path.posix.join(config.build.assetsDir, '[name].[hash][extname]')
-    const fileName = assetFileNamesToFileName(
-      assetFileNames,
-      file,
-      contentHash,
-      content
-    )
-    if (!map.has(contentHash)) {
-      map.set(contentHash, fileName)
-    }
-    const emittedSet = emittedHashMap.get(config)!
-    if (!emittedSet.has(contentHash)) {
-      const name = normalizePath(path.relative(config.root, file))
-      pluginContext.emitFile({
-        name,
-        fileName,
-        type: 'asset',
-        source: content
-      })
-      emittedSet.add(contentHash)
-    }
-
-    url = `__VITE_ASSET__${contentHash}__${postfix ? `$_${postfix}__` : ``}`
-  }
-
-  cache.set(id, url)
-  return url
-}
-
-export function getAssetHash(content: Buffer): string {
-  return createHash('sha256').update(content).digest('hex').slice(0, 8)
-}
-
-export async function urlToBuiltUrl(
-  url: string,
-  importer: string,
-  config: ResolvedConfig,
-  pluginContext: PluginContext
-): Promise<string> {
-  if (checkPublicFile(url, config)) {
-    return config.base + url.slice(1)
-  }
-  const file = url.startsWith('/')
-    ? path.join(config.root, url)
-    : path.join(path.dirname(importer), url)
-  return fileToBuiltUrl(
-    file,
-    config,
-    pluginContext,
-    // skip public check since we just did it above
-    true
-  )
-}

package/src/node/plugins/assetImportMetaUrl.ts

@@ -1,99 +0,0 @@
-import { Plugin } from '../plugin'
-import MagicString from 'magic-string'
-import path from 'path'
-import { fileToUrl } from './asset'
-import { ResolvedConfig } from '../config'
-import { multilineCommentsRE, singlelineCommentsRE } from '../utils'
-
-/**
- * Convert `new URL('./foo.png', import.meta.url)` to its resolved built URL
- *
- * Supports tempalte string with dynamic segments:
- * ```
- * new URL(`./dir/${name}.png`, import.meta.url)
- * // transformed to
- * import.meta.globEager('./dir/**.png')[`./dir/${name}.png`].default
- * ```
- */
-export function assetImportMetaUrlPlugin(config: ResolvedConfig): Plugin {
-  return {
-    name: 'vite:asset-import-meta-url',
-    async transform(code, id, ssr) {
-      if (code.includes('new URL') && code.includes(`import.meta.url`)) {
-        const importMetaUrlRE =
-          /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\)/g
-        const noCommentsCode = code
-          .replace(multilineCommentsRE, (m) => ' '.repeat(m.length))
-          .replace(singlelineCommentsRE, (m) => ' '.repeat(m.length))
-        let s: MagicString | null = null
-        let match: RegExpExecArray | null
-        while ((match = importMetaUrlRE.exec(noCommentsCode))) {
-          const { 0: exp, 1: rawUrl, index } = match
-
-          if (ssr) {
-            this.error(
-              `\`new URL(url, import.meta.url)\` is not supported in SSR.`,
-              index
-            )
-          }
-
-          if (!s) s = new MagicString(code)
-
-          // potential dynamic template string
-          if (rawUrl[0] === '`' && /\$\{/.test(rawUrl)) {
-            const ast = this.parse(rawUrl)
-            const templateLiteral = (ast as any).body[0].expression
-            if (templateLiteral.expressions.length) {
-              const pattern = buildGlobPattern(templateLiteral)
-              // Note: native import.meta.url is not supported in the baseline
-              // target so we use window.location here -
-              s.overwrite(
-                index,
-                index + exp.length,
-                `new URL(import.meta.globEagerDefault(${JSON.stringify(
-                  pattern
-                )})[${rawUrl}], window.location)`
-              )
-              continue
-            }
-          }
-
-          const url = rawUrl.slice(1, -1)
-          const file = path.resolve(path.dirname(id), url)
-          const builtUrl = await fileToUrl(file, config, this)
-          s.overwrite(
-            index,
-            index + exp.length,
-            `new URL(${JSON.stringify(builtUrl)}, window.location)`
-          )
-        }
-        if (s) {
-          return {
-            code: s.toString(),
-            map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
-          }
-        }
-      }
-      return null
-    }
-  }
-}
-
-function buildGlobPattern(ast: any) {
-  let pattern = ''
-  let lastElementIndex = -1
-  for (const exp of ast.expressions) {
-    for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-      const el = ast.quasis[i]
-      if (el.end < exp.start) {
-        pattern += el.value.raw
-        lastElementIndex = i
-      }
-    }
-    pattern += '**'
-  }
-  for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
-    pattern += ast.quasis[i].value.raw
-  }
-  return pattern
-}

package/src/node/plugins/clientInjections.ts

@@ -1,72 +0,0 @@
-import path from 'path'
-import { Plugin } from '../plugin'
-import { ResolvedConfig } from '../config'
-import { CLIENT_ENTRY, ENV_ENTRY } from '../constants'
-import { normalizePath, isObject } from '../utils'
-
-// ids in transform are normalized to unix style
-const normalizedClientEntry = normalizePath(CLIENT_ENTRY)
-const normalizedEnvEntry = normalizePath(ENV_ENTRY)
-
-/**
- * some values used by the client needs to be dynamically injected by the server
- * @server-only
- */
-export function clientInjectionsPlugin(config: ResolvedConfig): Plugin {
-  return {
-    name: 'vite:client-inject',
-    transform(code, id) {
-      if (id === normalizedClientEntry || id === normalizedEnvEntry) {
-        let options = config.server.hmr
-        options = options && typeof options !== 'boolean' ? options : {}
-        const host = options.host || null
-        const protocol = options.protocol || null
-        const timeout = options.timeout || 30000
-        const overlay = options.overlay !== false
-        let port: number | string | undefined
-        if (isObject(config.server.hmr)) {
-          port = config.server.hmr.clientPort || config.server.hmr.port
-        }
-        if (config.server.middlewareMode) {
-          port = String(port || 24678)
-        } else {
-          port = String(port || options.port || config.server.port!)
-        }
-        let hmrBase = config.base
-        if (options.path) {
-          hmrBase = path.posix.join(hmrBase, options.path)
-        }
-        if (hmrBase !== '/') {
-          port = path.posix.normalize(`${port}${hmrBase}`)
-        }
-
-        return code
-          .replace(`__MODE__`, JSON.stringify(config.mode))
-          .replace(`__BASE__`, JSON.stringify(config.base))
-          .replace(`__DEFINES__`, serializeDefine(config.define || {}))
-          .replace(`__HMR_PROTOCOL__`, JSON.stringify(protocol))
-          .replace(`__HMR_HOSTNAME__`, JSON.stringify(host))
-          .replace(`__HMR_PORT__`, JSON.stringify(port))
-          .replace(`__HMR_TIMEOUT__`, JSON.stringify(timeout))
-          .replace(`__HMR_ENABLE_OVERLAY__`, JSON.stringify(overlay))
-      } else if (code.includes('process.env.NODE_ENV')) {
-        // replace process.env.NODE_ENV
-        return code.replace(
-          /\bprocess\.env\.NODE_ENV\b/g,
-          JSON.stringify(config.mode)
-        )
-      }
-    }
-  }
-}
-
-function serializeDefine(define: Record<string, any>): string {
-  let res = `{`
-  for (const key in define) {
-    const val = define[key]
-    res += `${JSON.stringify(key)}: ${
-      typeof val === 'string' ? `(${val})` : JSON.stringify(val)
-    }, `
-  }
-  return res + `}`
-}