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

package/src/node/server/middlewares/transform.ts

@@ -1,196 +0,0 @@
-import path from 'path'
-import { ViteDevServer } from '..'
-import { Connect } from 'types/connect'
-import {
-  cleanUrl,
-  createDebugger,
-  injectQuery,
-  isImportRequest,
-  isJSRequest,
-  normalizePath,
-  prettifyUrl,
-  removeImportQuery,
-  removeTimestampQuery,
-  unwrapId
-} from '../../utils'
-import { send } from '../send'
-import { transformRequest } from '../transformRequest'
-import { isHTMLProxy } from '../../plugins/html'
-import chalk from 'chalk'
-import {
-  CLIENT_PUBLIC_PATH,
-  DEP_VERSION_RE,
-  NULL_BYTE_PLACEHOLDER
-} from '../../constants'
-import {
-  isCSSRequest,
-  isDirectCSSRequest,
-  isDirectRequest
-} from '../../plugins/css'
-
-/**
- * Time (ms) Vite has to full-reload the page before returning
- * an empty response.
- */
-const NEW_DEPENDENCY_BUILD_TIMEOUT = 1000
-
-const debugCache = createDebugger('vite:cache')
-const isDebug = !!process.env.DEBUG
-
-const knownIgnoreList = new Set(['/', '/favicon.ico'])
-
-export function transformMiddleware(
-  server: ViteDevServer
-): Connect.NextHandleFunction {
-  const {
-    config: { root, logger, cacheDir },
-    moduleGraph
-  } = server
-
-  // determine the url prefix of files inside cache directory
-  let cacheDirPrefix: string | undefined
-  if (cacheDir) {
-    const cacheDirRelative = normalizePath(path.relative(root, cacheDir))
-    if (cacheDirRelative.startsWith('../')) {
-      // if the cache directory is outside root, the url prefix would be something
-      // like '/@fs/absolute/path/to/node_modules/.vite'
-      cacheDirPrefix = `/@fs/${normalizePath(cacheDir).replace(/^\//, '')}`
-    } else {
-      // if the cache directory is inside root, the url prefix would be something
-      // like '/node_modules/.vite'
-      cacheDirPrefix = `/${cacheDirRelative}`
-    }
-  }
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return async function viteTransformMiddleware(req, res, next) {
-    if (req.method !== 'GET' || knownIgnoreList.has(req.url!)) {
-      return next()
-    }
-
-    if (
-      server._pendingReload &&
-      // always allow vite client requests so that it can trigger page reload
-      !req.url?.startsWith(CLIENT_PUBLIC_PATH) &&
-      !req.url?.includes('vite/dist/client')
-    ) {
-      // missing dep pending reload, hold request until reload happens
-      server._pendingReload.then(() =>
-        // If the refresh has not happened after timeout, Vite considers
-        // something unexpected has happened. In this case, Vite
-        // returns an empty response that will error.
-        setTimeout(() => {
-          // Don't do anything if response has already been sent
-          if (res.writableEnded) return
-          // status code request timeout
-          res.statusCode = 408
-          res.end(
-            `<h1>[vite] Something unexpected happened while optimizing "${req.url}"<h1>` +
-              `<p>The current page should have reloaded by now</p>`
-          )
-        }, NEW_DEPENDENCY_BUILD_TIMEOUT)
-      )
-      return
-    }
-
-    let url = decodeURI(removeTimestampQuery(req.url!)).replace(
-      NULL_BYTE_PLACEHOLDER,
-      '\0'
-    )
-
-    const withoutQuery = cleanUrl(url)
-
-    try {
-      const isSourceMap = withoutQuery.endsWith('.map')
-      // since we generate source map references, handle those requests here
-      if (isSourceMap) {
-        const originalUrl = url.replace(/\.map($|\?)/, '$1')
-        const map = (await moduleGraph.getModuleByUrl(originalUrl))
-          ?.transformResult?.map
-        if (map) {
-          return send(req, res, JSON.stringify(map), 'json')
-        } else {
-          return next()
-        }
-      }
-
-      // check if public dir is inside root dir
-      const publicDir = normalizePath(server.config.publicDir)
-      const rootDir = normalizePath(server.config.root)
-      if (publicDir.startsWith(rootDir)) {
-        const publicPath = `${publicDir.slice(rootDir.length)}/`
-        // warn explicit public paths
-        if (url.startsWith(publicPath)) {
-          logger.warn(
-            chalk.yellow(
-              `files in the public directory are served at the root path.\n` +
-                `Instead of ${chalk.cyan(url)}, use ${chalk.cyan(
-                  url.replace(publicPath, '/')
-                )}.`
-            )
-          )
-        }
-      }
-
-      if (
-        isJSRequest(url) ||
-        isImportRequest(url) ||
-        isCSSRequest(url) ||
-        isHTMLProxy(url)
-      ) {
-        // strip ?import
-        url = removeImportQuery(url)
-        // Strip valid id prefix. This is prepended to resolved Ids that are
-        // not valid browser import specifiers by the importAnalysis plugin.
-        url = unwrapId(url)
-
-        // for CSS, we need to differentiate between normal CSS requests and
-        // imports
-        if (
-          isCSSRequest(url) &&
-          !isDirectRequest(url) &&
-          req.headers.accept?.includes('text/css')
-        ) {
-          url = injectQuery(url, 'direct')
-        }
-
-        // check if we can return 304 early
-        const ifNoneMatch = req.headers['if-none-match']
-        if (
-          ifNoneMatch &&
-          (await moduleGraph.getModuleByUrl(url))?.transformResult?.etag ===
-            ifNoneMatch
-        ) {
-          isDebug && debugCache(`[304] ${prettifyUrl(url, root)}`)
-          res.statusCode = 304
-          return res.end()
-        }
-
-        // resolve, load and transform using the plugin container
-        const result = await transformRequest(url, server, {
-          html: req.headers.accept?.includes('text/html')
-        })
-        if (result) {
-          const type = isDirectCSSRequest(url) ? 'css' : 'js'
-          const isDep =
-            DEP_VERSION_RE.test(url) ||
-            (cacheDirPrefix && url.startsWith(cacheDirPrefix))
-          return send(
-            req,
-            res,
-            result.code,
-            type,
-            result.etag,
-            // allow browser to cache npm deps!
-            isDep ? 'max-age=31536000,immutable' : 'no-cache',
-            result.map
-          )
-        }
-      }
-    } catch (e) {
-      return next(e)
-    }
-
-    next()
-  }
-}

package/src/node/server/moduleGraph.ts

@@ -1,200 +0,0 @@
-import { extname } from 'path'
-import { isDirectCSSRequest } from '../plugins/css'
-import {
-  cleanUrl,
-  normalizePath,
-  removeImportQuery,
-  removeTimestampQuery
-} from '../utils'
-import { FS_PREFIX } from '../constants'
-import { TransformResult } from './transformRequest'
-import { PluginContainer } from './pluginContainer'
-import { parse as parseUrl } from 'url'
-
-export class ModuleNode {
-  /**
-   * Public served url path, starts with /
-   */
-  url: string
-  /**
-   * Resolved file system path + query
-   */
-  id: string | null = null
-  file: string | null = null
-  type: 'js' | 'css'
-  importers = new Set<ModuleNode>()
-  importedModules = new Set<ModuleNode>()
-  acceptedHmrDeps = new Set<ModuleNode>()
-  isSelfAccepting = false
-  transformResult: TransformResult | null = null
-  ssrTransformResult: TransformResult | null = null
-  ssrModule: Record<string, any> | null = null
-  lastHMRTimestamp = 0
-
-  constructor(url: string) {
-    this.url = url
-    this.type = isDirectCSSRequest(url) ? 'css' : 'js'
-  }
-}
-
-function invalidateSSRModule(mod: ModuleNode, seen: Set<ModuleNode>) {
-  if (seen.has(mod)) {
-    return
-  }
-  seen.add(mod)
-  mod.ssrModule = null
-  mod.importers.forEach((importer) => invalidateSSRModule(importer, seen))
-}
-export class ModuleGraph {
-  urlToModuleMap = new Map<string, ModuleNode>()
-  idToModuleMap = new Map<string, ModuleNode>()
-  // a single file may corresponds to multiple modules with different queries
-  fileToModulesMap = new Map<string, Set<ModuleNode>>()
-  safeModulesPath = new Set<string>()
-  container: PluginContainer
-
-  constructor(container: PluginContainer) {
-    this.container = container
-  }
-
-  async getModuleByUrl(rawUrl: string): Promise<ModuleNode | undefined> {
-    const [url] = await this.resolveUrl(rawUrl)
-    return this.urlToModuleMap.get(url)
-  }
-
-  getModuleById(id: string): ModuleNode | undefined {
-    return this.idToModuleMap.get(removeTimestampQuery(id))
-  }
-
-  getModulesByFile(file: string): Set<ModuleNode> | undefined {
-    return this.fileToModulesMap.get(file)
-  }
-
-  onFileChange(file: string): void {
-    const mods = this.getModulesByFile(file)
-    if (mods) {
-      const seen = new Set<ModuleNode>()
-      mods.forEach((mod) => {
-        this.invalidateModule(mod, seen)
-      })
-    }
-  }
-
-  invalidateModule(mod: ModuleNode, seen: Set<ModuleNode> = new Set()): void {
-    mod.transformResult = null
-    mod.ssrTransformResult = null
-    invalidateSSRModule(mod, seen)
-  }
-
-  invalidateAll(): void {
-    const seen = new Set<ModuleNode>()
-    this.idToModuleMap.forEach((mod) => {
-      this.invalidateModule(mod, seen)
-    })
-  }
-
-  /**
-   * Update the module graph based on a module's updated imports information
-   * If there are dependencies that no longer have any importers, they are
-   * returned as a Set.
-   */
-  async updateModuleInfo(
-    mod: ModuleNode,
-    importedModules: Set<string | ModuleNode>,
-    acceptedModules: Set<string | ModuleNode>,
-    isSelfAccepting: boolean
-  ): Promise<Set<ModuleNode> | undefined> {
-    mod.isSelfAccepting = isSelfAccepting
-    const prevImports = mod.importedModules
-    const nextImports = (mod.importedModules = new Set())
-    let noLongerImported: Set<ModuleNode> | undefined
-    // update import graph
-    for (const imported of importedModules) {
-      const dep =
-        typeof imported === 'string'
-          ? await this.ensureEntryFromUrl(imported)
-          : imported
-      dep.importers.add(mod)
-      nextImports.add(dep)
-    }
-    // remove the importer from deps that were imported but no longer are.
-    prevImports.forEach((dep) => {
-      if (!nextImports.has(dep)) {
-        dep.importers.delete(mod)
-        if (!dep.importers.size) {
-          // dependency no longer imported
-          ;(noLongerImported || (noLongerImported = new Set())).add(dep)
-        }
-      }
-    })
-    // update accepted hmr deps
-    const deps = (mod.acceptedHmrDeps = new Set())
-    for (const accepted of acceptedModules) {
-      const dep =
-        typeof accepted === 'string'
-          ? await this.ensureEntryFromUrl(accepted)
-          : accepted
-      deps.add(dep)
-    }
-    return noLongerImported
-  }
-
-  async ensureEntryFromUrl(rawUrl: string): Promise<ModuleNode> {
-    const [url, resolvedId] = await this.resolveUrl(rawUrl)
-    let mod = this.urlToModuleMap.get(url)
-    if (!mod) {
-      mod = new ModuleNode(url)
-      this.urlToModuleMap.set(url, mod)
-      mod.id = resolvedId
-      this.idToModuleMap.set(resolvedId, mod)
-      const file = (mod.file = cleanUrl(resolvedId))
-      let fileMappedModules = this.fileToModulesMap.get(file)
-      if (!fileMappedModules) {
-        fileMappedModules = new Set()
-        this.fileToModulesMap.set(file, fileMappedModules)
-      }
-      fileMappedModules.add(mod)
-    }
-    return mod
-  }
-
-  // some deps, like a css file referenced via @import, don't have its own
-  // url because they are inlined into the main css import. But they still
-  // need to be represented in the module graph so that they can trigger
-  // hmr in the importing css file.
-  createFileOnlyEntry(file: string): ModuleNode {
-    file = normalizePath(file)
-    let fileMappedModules = this.fileToModulesMap.get(file)
-    if (!fileMappedModules) {
-      fileMappedModules = new Set()
-      this.fileToModulesMap.set(file, fileMappedModules)
-    }
-
-    const url = `${FS_PREFIX}${file}`
-    for (const m of fileMappedModules) {
-      if (m.url === url || m.id === file) {
-        return m
-      }
-    }
-
-    const mod = new ModuleNode(url)
-    mod.file = file
-    fileMappedModules.add(mod)
-    return mod
-  }
-
-  // for incoming urls, it is important to:
-  // 1. remove the HMR timestamp query (?t=xxxx)
-  // 2. resolve its extension so that urls with or without extension all map to
-  // the same module
-  async resolveUrl(url: string): Promise<[string, string]> {
-    url = removeImportQuery(removeTimestampQuery(url))
-    const resolvedId = (await this.container.resolveId(url))?.id || url
-    const ext = extname(cleanUrl(resolvedId))
-    const { pathname, search, hash } = parseUrl(url)
-    if (ext && !pathname!.endsWith(ext)) {
-      url = pathname + ext + (search || '') + (hash || '')
-    }
-    return [url, resolvedId]
-  }
-}

package/src/node/server/openBrowser.ts

@@ -1,101 +0,0 @@
-/**
- * The following is modified based on source found in
- * https://github.com/facebook/create-react-app
- *
- * MIT Licensed
- * Copyright (c) 2015-present, Facebook, Inc.
- * https://github.com/facebook/create-react-app/blob/master/LICENSE
- *
- */
-
-import path from 'path'
-import open from 'open'
-import execa from 'execa'
-import chalk from 'chalk'
-import { execSync } from 'child_process'
-import { Logger } from '../logger'
-
-// https://github.com/sindresorhus/open#app
-const OSX_CHROME = 'google chrome'
-
-/**
- * Reads the BROWSER environment variable and decides what to do with it.
- * Returns true if it opened a browser or ran a node.js script, otherwise false.
- */
-export function openBrowser(
-  url: string,
-  opt: string | true,
-  logger: Logger
-): boolean {
-  // The browser executable to open.
-  // See https://github.com/sindresorhus/open#app for documentation.
-  const browser = typeof opt === 'string' ? opt : process.env.BROWSER || ''
-  if (browser.toLowerCase().endsWith('.js')) {
-    return executeNodeScript(browser, url, logger)
-  } else if (browser.toLowerCase() !== 'none') {
-    return startBrowserProcess(browser, url)
-  }
-  return false
-}
-
-function executeNodeScript(scriptPath: string, url: string, logger: Logger) {
-  const extraArgs = process.argv.slice(2)
-  const child = execa('node', [scriptPath, ...extraArgs, url], {
-    stdio: 'inherit'
-  })
-  child.on('close', (code) => {
-    if (code !== 0) {
-      logger.error(
-        chalk.red(
-          `\nThe script specified as BROWSER environment variable failed.\n\n${chalk.cyan(
-            scriptPath
-          )} exited with code ${code}.`
-        ),
-        { error: null }
-      )
-    }
-  })
-  return true
-}
-
-function startBrowserProcess(browser: string | undefined, url: string) {
-  // If we're on OS X, the user hasn't specifically
-  // requested a different browser, we can try opening
-  // Chrome with AppleScript. This lets us reuse an
-  // existing tab when possible instead of creating a new one.
-  const shouldTryOpenChromeWithAppleScript =
-    process.platform === 'darwin' && (browser === '' || browser === OSX_CHROME)
-
-  if (shouldTryOpenChromeWithAppleScript) {
-    try {
-      // Try our best to reuse existing tab
-      // on OS X Google Chrome with AppleScript
-      execSync('ps cax | grep "Google Chrome"')
-      execSync('osascript openChrome.applescript "' + encodeURI(url) + '"', {
-        cwd: path.dirname(require.resolve('vite/bin/openChrome.applescript')),
-        stdio: 'ignore'
-      })
-      return true
-    } catch (err) {
-      // Ignore errors
-    }
-  }
-
-  // Another special case: on OS X, check if BROWSER has been set to "open".
-  // In this case, instead of passing the string `open` to `open` function (which won't work),
-  // just ignore it (thus ensuring the intended behavior, i.e. opening the system browser):
-  // https://github.com/facebook/create-react-app/pull/1690#issuecomment-283518768
-  if (process.platform === 'darwin' && browser === 'open') {
-    browser = undefined
-  }
-
-  // Fallback to open
-  // (It will always open new tab)
-  try {
-    const options: open.Options = browser ? { app: { name: browser } } : {}
-    open(url, options).catch(() => {}) // Prevent `unhandledRejection` error.
-    return true
-  } catch (err) {
-    return false
-  }
-}