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

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

@@ -1,52 +0,0 @@
-import { parse as parseUrl } from 'url'
-import { ViteDevServer } from '..'
-import { Connect } from 'types/connect'
-
-// this middleware is only active when (config.base !== '/')
-
-export function baseMiddleware({
-  config
-}: ViteDevServer): Connect.NextHandleFunction {
-  const base = config.base
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteBaseMiddleware(req, res, next) {
-    const url = req.url!
-    const parsed = parseUrl(url)
-    const path = parsed.pathname || '/'
-
-    if (path.startsWith(base)) {
-      // rewrite url to remove base.. this ensures that other middleware does
-      // not need to consider base being prepended or not
-      req.url = url.replace(base, '/')
-      return next()
-    }
-
-    // skip redirect and error fallback on middleware mode, #4057
-    if (config.server.middlewareMode) {
-      return next()
-    }
-
-    if (path === '/' || path === '/index.html') {
-      // redirect root visit to based url
-      res.writeHead(302, {
-        Location: base
-      })
-      res.end()
-      return
-    } else if (req.headers.accept?.includes('text/html')) {
-      // non-based page visit
-      const redirectPath = base + url.slice(1)
-      res.writeHead(404, {
-        'Content-Type': 'text/html'
-      })
-      res.end(
-        `The server is configured with a public base URL of ${base} - ` +
-          `did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`
-      )
-      return
-    }
-
-    next()
-  }
-}

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

@@ -1,98 +0,0 @@
-import chalk from 'chalk'
-import { RollupError } from 'rollup'
-import { ViteDevServer } from '../..'
-import { Connect } from 'types/connect'
-import { pad } from '../../utils'
-import strip from 'strip-ansi'
-import { ErrorPayload } from 'types/hmrPayload'
-
-export function prepareError(err: Error | RollupError): ErrorPayload['err'] {
-  // only copy the information we need and avoid serializing unnecessary
-  // properties, since some errors may attach full objects (e.g. PostCSS)
-  return {
-    message: strip(err.message),
-    stack: strip(cleanStack(err.stack || '')),
-    id: (err as RollupError).id,
-    frame: strip((err as RollupError).frame || ''),
-    plugin: (err as RollupError).plugin,
-    pluginCode: (err as RollupError).pluginCode,
-    loc: (err as RollupError).loc
-  }
-}
-
-export function buildErrorMessage(
-  err: RollupError,
-  args: string[] = [],
-  includeStack = true
-): string {
-  if (err.plugin) args.push(`  Plugin: ${chalk.magenta(err.plugin)}`)
-  if (err.id) args.push(`  File: ${chalk.cyan(err.id)}`)
-  if (err.frame) args.push(chalk.yellow(pad(err.frame)))
-  if (includeStack && err.stack) args.push(pad(cleanStack(err.stack)))
-  return args.join('\n')
-}
-
-function cleanStack(stack: string) {
-  return stack
-    .split(/\n/g)
-    .filter((l) => /^\s*at/.test(l))
-    .join('\n')
-}
-
-export function errorMiddleware(
-  server: ViteDevServer,
-  allowNext = false
-): Connect.ErrorHandleFunction {
-  // note the 4 args must be kept for connect to treat this as error middleware
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteErrorMiddleware(err: RollupError, _req, res, next) {
-    const msg = buildErrorMessage(err, [
-      chalk.red(`Internal server error: ${err.message}`)
-    ])
-
-    server.config.logger.error(msg, {
-      clear: true,
-      timestamp: true,
-      error: err
-    })
-
-    server.ws.send({
-      type: 'error',
-      err: prepareError(err)
-    })
-
-    if (allowNext) {
-      next()
-    } else {
-      if (err instanceof AccessRestrictedError) {
-        res.statusCode = 403
-        res.write(renderErrorHTML(err.message))
-        res.end()
-      }
-      res.statusCode = 500
-      res.end()
-    }
-  }
-}
-
-export class AccessRestrictedError extends Error {
-  constructor(msg: string) {
-    super(msg)
-  }
-}
-
-export function renderErrorHTML(msg: string): string {
-  // to have syntax highlighting and autocompletion in IDE
-  const html = String.raw
-  return html`
-    <body>
-      <h1>403 Restricted</h1>
-      <p>${msg.replace(/\n/g, '<br/>')}</p>
-      <style>
-        body {
-          padding: 1em 2em;
-        }
-      </style>
-    </body>
-  `
-}

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

@@ -1,170 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import MagicString from 'magic-string'
-import { AttributeNode, NodeTypes } from '@vue/compiler-dom'
-import { Connect } from 'types/connect'
-import {
-  applyHtmlTransforms,
-  getScriptInfo,
-  IndexHtmlTransformHook,
-  resolveHtmlTransforms,
-  traverseHtml
-} from '../../plugins/html'
-import { ResolvedConfig, ViteDevServer } from '../..'
-import { send } from '../send'
-import { CLIENT_PUBLIC_PATH, FS_PREFIX } from '../../constants'
-import { cleanUrl, fsPathFromId } from '../../utils'
-import { assetAttrsConfig } from '../../plugins/html'
-
-export function createDevHtmlTransformFn(
-  server: ViteDevServer
-): (url: string, html: string, originalUrl: string) => Promise<string> {
-  const [preHooks, postHooks] = resolveHtmlTransforms(server.config.plugins)
-
-  return (url: string, html: string, originalUrl: string): Promise<string> => {
-    return applyHtmlTransforms(html, [...preHooks, devHtmlHook, ...postHooks], {
-      path: url,
-      filename: getHtmlFilename(url, server),
-      server,
-      originalUrl
-    })
-  }
-}
-
-function getHtmlFilename(url: string, server: ViteDevServer) {
-  if (url.startsWith(FS_PREFIX)) {
-    return fsPathFromId(url)
-  } else {
-    return path.join(server.config.root, url.slice(1))
-  }
-}
-
-const startsWithSingleSlashRE = /^\/(?!\/)/
-const processNodeUrl = (
-  node: AttributeNode,
-  s: MagicString,
-  config: ResolvedConfig,
-  htmlPath: string,
-  originalUrl?: string
-) => {
-  const url = node.value?.content || ''
-  if (startsWithSingleSlashRE.test(url)) {
-    // prefix with base
-    s.overwrite(
-      node.value!.loc.start.offset,
-      node.value!.loc.end.offset,
-      `"${config.base + url.slice(1)}"`
-    )
-  } else if (
-    url.startsWith('.') &&
-    originalUrl &&
-    originalUrl !== '/' &&
-    htmlPath === '/index.html'
-  ) {
-    // #3230 if some request url (localhost:3000/a/b) return to fallback html, the relative assets
-    // path will add `/a/` prefix, it will caused 404.
-    // rewrite before `./index.js` -> `localhost:3000/a/index.js`.
-    // rewrite after `../index.js` -> `localhost:3000/index.js`.
-    s.overwrite(
-      node.value!.loc.start.offset,
-      node.value!.loc.end.offset,
-      `"${path.posix.join(
-        path.posix.relative(originalUrl, '/'),
-        url.slice(1)
-      )}"`
-    )
-  }
-}
-const devHtmlHook: IndexHtmlTransformHook = async (
-  html,
-  { path: htmlPath, server, originalUrl }
-) => {
-  // TODO: solve this design issue
-  // Optional chain expressions can return undefined by design
-  // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-  const config = server?.config!
-  const base = config.base || '/'
-
-  const s = new MagicString(html)
-  let scriptModuleIndex = -1
-
-  await traverseHtml(html, htmlPath, (node) => {
-    if (node.type !== NodeTypes.ELEMENT) {
-      return
-    }
-
-    // script tags
-    if (node.tag === 'script') {
-      const { src, isModule } = getScriptInfo(node)
-      if (isModule) {
-        scriptModuleIndex++
-      }
-
-      if (src) {
-        processNodeUrl(src, s, config, htmlPath, originalUrl)
-      } else if (isModule) {
-        // inline js module. convert to src="proxy"
-        s.overwrite(
-          node.loc.start.offset,
-          node.loc.end.offset,
-          `<script type="module" src="${
-            config.base + htmlPath.slice(1)
-          }?html-proxy&index=${scriptModuleIndex}.js"></script>`
-        )
-      }
-    }
-
-    // elements with [href/src] attrs
-    const assetAttrs = assetAttrsConfig[node.tag]
-    if (assetAttrs) {
-      for (const p of node.props) {
-        if (
-          p.type === NodeTypes.ATTRIBUTE &&
-          p.value &&
-          assetAttrs.includes(p.name)
-        ) {
-          processNodeUrl(p, s, config, htmlPath, originalUrl)
-        }
-      }
-    }
-  })
-
-  html = s.toString()
-
-  return {
-    html,
-    tags: [
-      {
-        tag: 'script',
-        attrs: {
-          type: 'module',
-          src: path.posix.join(base, CLIENT_PUBLIC_PATH)
-        },
-        injectTo: 'head-prepend'
-      }
-    ]
-  }
-}
-
-export function indexHtmlMiddleware(
-  server: ViteDevServer
-): Connect.NextHandleFunction {
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return async function viteIndexHtmlMiddleware(req, res, next) {
-    const url = req.url && cleanUrl(req.url)
-    // spa-fallback always redirects to /index.html
-    if (url?.endsWith('.html') && req.headers['sec-fetch-dest'] !== 'script') {
-      const filename = getHtmlFilename(url, server)
-      if (fs.existsSync(filename)) {
-        try {
-          let html = fs.readFileSync(filename, 'utf-8')
-          html = await server.transformIndexHtml(url, html, req.originalUrl)
-          return send(req, res, html, 'html')
-        } catch (e) {
-          return next(e)
-        }
-      }
-    }
-    next()
-  }
-}

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

@@ -1,124 +0,0 @@
-import * as http from 'http'
-import { createDebugger, isObject } from '../../utils'
-import httpProxy from 'http-proxy'
-import { HMR_HEADER } from '../ws'
-import { Connect } from 'types/connect'
-import { HttpProxy } from 'types/http-proxy'
-import chalk from 'chalk'
-import { ResolvedConfig } from '../..'
-
-const debug = createDebugger('vite:proxy')
-
-export interface ProxyOptions extends HttpProxy.ServerOptions {
-  /**
-   * rewrite path
-   */
-  rewrite?: (path: string) => string
-  /**
-   * configure the proxy server (e.g. listen to events)
-   */
-  configure?: (proxy: HttpProxy.Server, options: ProxyOptions) => void
-  /**
-   * webpack-dev-server style bypass function
-   */
-  bypass?: (
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    options: ProxyOptions
-  ) => void | null | undefined | false | string
-}
-
-export function proxyMiddleware(
-  httpServer: http.Server | null,
-  config: ResolvedConfig
-): Connect.NextHandleFunction {
-  const options = config.server.proxy!
-
-  // lazy require only when proxy is used
-  const proxies: Record<string, [HttpProxy.Server, ProxyOptions]> = {}
-
-  Object.keys(options).forEach((context) => {
-    let opts = options[context]
-    if (typeof opts === 'string') {
-      opts = { target: opts, changeOrigin: true } as ProxyOptions
-    }
-    const proxy = httpProxy.createProxyServer(opts) as HttpProxy.Server
-
-    proxy.on('error', (err) => {
-      config.logger.error(`${chalk.red(`http proxy error:`)}\n${err.stack}`, {
-        timestamp: true,
-        error: err
-      })
-    })
-
-    if (opts.configure) {
-      opts.configure(proxy, opts)
-    }
-    // clone before saving because http-proxy mutates the options
-    proxies[context] = [proxy, { ...opts }]
-  })
-
-  if (httpServer) {
-    httpServer.on('upgrade', (req, socket, head) => {
-      const url = req.url!
-      for (const context in proxies) {
-        if (doesProxyContextMatchUrl(context, url)) {
-          const [proxy, opts] = proxies[context]
-          if (
-            (opts.ws || opts.target?.toString().startsWith('ws:')) &&
-            req.headers['sec-websocket-protocol'] !== HMR_HEADER
-          ) {
-            if (opts.rewrite) {
-              req.url = opts.rewrite(url)
-            }
-            debug(`${req.url} -> ws ${opts.target}`)
-            proxy.ws(req, socket, head)
-            return
-          }
-        }
-      }
-    })
-  }
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteProxyMiddleware(req, res, next) {
-    const url = req.url!
-    for (const context in proxies) {
-      if (doesProxyContextMatchUrl(context, url)) {
-        const [proxy, opts] = proxies[context]
-        const options: HttpProxy.ServerOptions = {}
-
-        if (opts.bypass) {
-          const bypassResult = opts.bypass(req, res, opts)
-          if (typeof bypassResult === 'string') {
-            req.url = bypassResult
-            debug(`bypass: ${req.url} -> ${bypassResult}`)
-            return next()
-          } else if (isObject(bypassResult)) {
-            Object.assign(options, bypassResult)
-            debug(`bypass: ${req.url} use modified options: %O`, options)
-            return next()
-          } else if (bypassResult === false) {
-            debug(`bypass: ${req.url} -> 404`)
-            return res.end(404)
-          }
-        }
-
-        debug(`${req.url} -> ${opts.target || opts.forward}`)
-        if (opts.rewrite) {
-          req.url = opts.rewrite(req.url!)
-        }
-        proxy.web(req, res, options)
-        return
-      }
-    }
-    next()
-  }
-}
-
-function doesProxyContextMatchUrl(context: string, url: string): boolean {
-  return (
-    (context.startsWith('^') && new RegExp(context).test(url)) ||
-    url.startsWith(context)
-  )
-}

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

@@ -1,32 +0,0 @@
-import fs from 'fs'
-import history from 'connect-history-api-fallback'
-import path from 'path'
-import { Connect } from 'types/connect'
-import { createDebugger } from '../../utils'
-
-export function spaFallbackMiddleware(
-  root: string
-): Connect.NextHandleFunction {
-  const historySpaFallbackMiddleware = history({
-    logger: createDebugger('vite:spa-fallback'),
-    // support /dir/ without explicit index.html
-    rewrites: [
-      {
-        from: /\/$/,
-        to({ parsedUrl }: any) {
-          const rewritten = parsedUrl.pathname + 'index.html'
-          if (fs.existsSync(path.join(root, rewritten))) {
-            return rewritten
-          } else {
-            return `/index.html`
-          }
-        }
-      }
-    ]
-  })
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteSpaFallbackMiddleware(req, res, next) {
-    return historySpaFallbackMiddleware(req, res, next)
-  }
-}

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

@@ -1,153 +0,0 @@
-import path from 'path'
-import sirv, { Options } from 'sirv'
-import { Connect } from 'types/connect'
-import { normalizePath, ResolvedConfig, ViteDevServer } from '../..'
-import { FS_PREFIX } from '../../constants'
-import {
-  cleanUrl,
-  ensureLeadingSlash,
-  fsPathFromId,
-  isImportRequest,
-  isInternalRequest,
-  isWindows,
-  slash
-} from '../../utils'
-import { AccessRestrictedError } from './error'
-
-const sirvOptions: Options = {
-  dev: true,
-  etag: true,
-  extensions: [],
-  setHeaders(res, pathname) {
-    // Matches js, jsx, ts, tsx.
-    // The reason this is done, is that the .ts file extension is reserved
-    // for the MIME type video/mp2t. In almost all cases, we can expect
-    // these files to be TypeScript files, and for Vite to serve them with
-    // this Content-Type.
-    if (/\.[tj]sx?$/.test(pathname)) {
-      res.setHeader('Content-Type', 'application/javascript')
-    }
-  }
-}
-
-export function servePublicMiddleware(dir: string): Connect.NextHandleFunction {
-  const serve = sirv(dir, sirvOptions)
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteServePublicMiddleware(req, res, next) {
-    // skip import request and internal requests `/@fs/ /@vite-client` etc...
-    if (isImportRequest(req.url!) || isInternalRequest(req.url!)) {
-      return next()
-    }
-    serve(req, res, next)
-  }
-}
-
-export function serveStaticMiddleware(
-  dir: string,
-  config: ResolvedConfig
-): Connect.NextHandleFunction {
-  const serve = sirv(dir, sirvOptions)
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteServeStaticMiddleware(req, res, next) {
-    // only serve the file if it's not an html request
-    // so that html requests can fallthrough to our html middleware for
-    // special processing
-    // also skip internal requests `/@fs/ /@vite-client` etc...
-    if (
-      path.extname(cleanUrl(req.url!)) === '.html' ||
-      isInternalRequest(req.url!)
-    ) {
-      return next()
-    }
-
-    const url = decodeURI(req.url!)
-
-    // apply aliases to static requests as well
-    let redirected: string | undefined
-    for (const { find, replacement } of config.resolve.alias) {
-      const matches =
-        typeof find === 'string' ? url.startsWith(find) : find.test(url)
-      if (matches) {
-        redirected = url.replace(find, replacement)
-        break
-      }
-    }
-    if (redirected) {
-      // dir is pre-normalized to posix style
-      if (redirected.startsWith(dir)) {
-        redirected = redirected.slice(dir.length)
-      }
-      req.url = redirected
-    }
-
-    serve(req, res, next)
-  }
-}
-
-export function serveRawFsMiddleware(
-  server: ViteDevServer
-): Connect.NextHandleFunction {
-  const serveFromRoot = sirv('/', sirvOptions)
-
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteServeRawFsMiddleware(req, res, next) {
-    let url = req.url!
-    // In some cases (e.g. linked monorepos) files outside of root will
-    // reference assets that are also out of served root. In such cases
-    // the paths are rewritten to `/@fs/` prefixed paths and must be served by
-    // searching based from fs root.
-    if (url.startsWith(FS_PREFIX)) {
-      // restrict files outside of `fs.allow`
-      ensureServingAccess(slash(path.resolve(fsPathFromId(url))), server)
-      url = url.slice(FS_PREFIX.length)
-      if (isWindows) url = url.replace(/^[A-Z]:/i, '')
-
-      req.url = url
-      serveFromRoot(req, res, next)
-    } else {
-      next()
-    }
-  }
-}
-
-export function isFileServingAllowed(
-  url: string,
-  server: ViteDevServer
-): boolean {
-  // explicitly disabled
-  if (server.config.server.fs.strict === false) return true
-
-  const file = ensureLeadingSlash(normalizePath(cleanUrl(url)))
-
-  if (server.moduleGraph.safeModulesPath.has(file)) return true
-
-  if (server.config.server.fs.allow.some((i) => file.startsWith(i + '/')))
-    return true
-
-  if (!server.config.server.fs.strict) {
-    server.config.logger.warnOnce(`Unrestricted file system access to "${url}"`)
-    server.config.logger.warnOnce(
-      `For security concerns, accessing files outside of serving allow list will ` +
-        `be restricted by default in the future version of Vite. ` +
-        `Refer to https://vitejs.dev/config/#server-fs-allow for more details.`
-    )
-    return true
-  }
-
-  return false
-}
-
-export function ensureServingAccess(url: string, server: ViteDevServer): void {
-  if (!isFileServingAllowed(url, server)) {
-    const allow = server.config.server.fs.allow
-    throw new AccessRestrictedError(
-      `The request url "${url}" is outside of Vite serving allow list:
-
-${allow.map((i) => `- ${i}`).join('\n')}
-
-Refer to docs https://vitejs.dev/config/#server-fs-allow for configurations and more details.`
-    )
-  }
-}

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

@@ -1,18 +0,0 @@
-import { Connect } from 'types/connect'
-import { createDebugger, prettifyUrl, timeFrom } from '../../utils'
-
-const logTime = createDebugger('vite:time')
-
-export function timeMiddleware(root: string): Connect.NextHandleFunction {
-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
-  return function viteTimeMiddleware(req, res, next) {
-    const start = Date.now()
-    const end = res.end
-    res.end = (...args: any[]) => {
-      logTime(`${timeFrom(start)} ${prettifyUrl(req.url!, root)}`)
-      // @ts-ignore
-      return end.call(res, ...args)
-    }
-    next()
-  }
-}