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

package/src/node/server/sourcemap.ts

@@ -1,54 +0,0 @@
-import path from 'path'
-import { promises as fs } from 'fs'
-import { Logger } from '../logger'
-import { createDebugger } from '../utils'
-
-const isDebug = !!process.env.DEBUG
-const debug = createDebugger('vite:sourcemap', {
-  onlyWhenFocused: true
-})
-
-interface SourceMapLike {
-  sources: string[]
-  sourcesContent?: (string | null)[]
-  sourceRoot?: string
-}
-
-export async function injectSourcesContent(
-  map: SourceMapLike,
-  file: string,
-  logger: Logger
-): Promise<void> {
-  let sourceRoot: string | undefined
-  try {
-    // The source root is undefined for virtual modules and permission errors.
-    sourceRoot = await fs.realpath(
-      path.resolve(path.dirname(file), map.sourceRoot || '')
-    )
-  } catch {}
-
-  const missingSources: string[] = []
-  map.sourcesContent = await Promise.all(
-    map.sources.map((sourcePath) => {
-      if (sourcePath) {
-        sourcePath = decodeURI(sourcePath)
-        if (sourceRoot) {
-          sourcePath = path.resolve(sourceRoot, sourcePath)
-        }
-        return fs.readFile(sourcePath, 'utf-8').catch(() => {
-          missingSources.push(sourcePath)
-          return null
-        })
-      }
-      return null
-    })
-  )
-
-  // Use this command…
-  //    DEBUG="vite:sourcemap" vite build
-  // …to log the missing sources.
-  if (missingSources.length) {
-    logger.warnOnce(`Sourcemap for "${file}" points to missing source files`)
-    isDebug && debug(`Missing sources:\n  ` + missingSources.join(`\n  `))
-  }
-}

package/src/node/server/transformRequest.ts

@@ -1,168 +0,0 @@
-import { promises as fs } from 'fs'
-import path from 'path'
-import getEtag from 'etag'
-import * as convertSourceMap from 'convert-source-map'
-import { SourceDescription, SourceMap } from 'rollup'
-import { ViteDevServer } from '..'
-import chalk from 'chalk'
-import {
-  createDebugger,
-  cleanUrl,
-  prettifyUrl,
-  removeTimestampQuery,
-  timeFrom,
-  ensureWatchedFile,
-  isObject
-} from '../utils'
-import { checkPublicFile } from '../plugins/asset'
-import { ssrTransform } from '../ssr/ssrTransform'
-import { injectSourcesContent } from './sourcemap'
-import { isFileServingAllowed } from './middlewares/static'
-
-const debugLoad = createDebugger('vite:load')
-const debugTransform = createDebugger('vite:transform')
-const debugCache = createDebugger('vite:cache')
-const isDebug = !!process.env.DEBUG
-
-export interface TransformResult {
-  code: string
-  map: SourceMap | null
-  etag?: string
-  deps?: string[]
-  dynamicDeps?: string[]
-}
-
-export interface TransformOptions {
-  ssr?: boolean
-  html?: boolean
-}
-
-export async function transformRequest(
-  url: string,
-  server: ViteDevServer,
-  options: TransformOptions = {}
-): Promise<TransformResult | null> {
-  const { config, pluginContainer, moduleGraph, watcher } = server
-
-  url = removeTimestampQuery(url)
-  const { root, logger } = config
-  const prettyUrl = isDebug ? prettifyUrl(url, root) : ''
-  const ssr = !!options.ssr
-
-  // check if we have a fresh cache
-  const module = await moduleGraph.getModuleByUrl(url)
-  const cached =
-    module && (ssr ? module.ssrTransformResult : module.transformResult)
-  if (cached) {
-    isDebug && debugCache(`[memory] ${prettyUrl}`)
-    return cached
-  }
-
-  // resolve
-  const id = (await pluginContainer.resolveId(url))?.id || url
-  const file = cleanUrl(id)
-
-  let code: string | null = null
-  let map: SourceDescription['map'] = null
-
-  // load
-  const loadStart = isDebug ? Date.now() : 0
-  const loadResult = await pluginContainer.load(id, ssr)
-  if (loadResult == null) {
-    // if this is an html request and there is no load result, skip ahead to
-    // SPA fallback.
-    if (options.html && !id.endsWith('.html')) {
-      return null
-    }
-    // try fallback loading it from fs as string
-    // if the file is a binary, there should be a plugin that already loaded it
-    // as string
-    // only try the fallback if access is allowed, skip for out of root url
-    // like /service-worker.js or /api/users
-    if (options.ssr || isFileServingAllowed(file, server)) {
-      try {
-        code = await fs.readFile(file, 'utf-8')
-        isDebug && debugLoad(`${timeFrom(loadStart)} [fs] ${prettyUrl}`)
-      } catch (e) {
-        if (e.code !== 'ENOENT') {
-          throw e
-        }
-      }
-    }
-    if (code) {
-      try {
-        map = (
-          convertSourceMap.fromSource(code) ||
-          convertSourceMap.fromMapFileSource(code, path.dirname(file))
-        )?.toObject()
-      } catch (e) {
-        logger.warn(`Failed to load source map for ${url}.`, {
-          timestamp: true
-        })
-      }
-    }
-  } else {
-    isDebug && debugLoad(`${timeFrom(loadStart)} [plugin] ${prettyUrl}`)
-    if (isObject(loadResult)) {
-      code = loadResult.code
-      map = loadResult.map
-    } else {
-      code = loadResult
-    }
-  }
-  if (code == null) {
-    if (checkPublicFile(url, config)) {
-      throw new Error(
-        `Failed to load url ${url} (resolved id: ${id}). ` +
-          `This file is in /public and will be copied as-is during build without ` +
-          `going through the plugin transforms, and therefore should not be ` +
-          `imported from source code. It can only be referenced via HTML tags.`
-      )
-    } else {
-      return null
-    }
-  }
-
-  // ensure module in graph after successful load
-  const mod = await moduleGraph.ensureEntryFromUrl(url)
-  ensureWatchedFile(watcher, mod.file, root)
-
-  // transform
-  const transformStart = isDebug ? Date.now() : 0
-  const transformResult = await pluginContainer.transform(code, id, map, ssr)
-  if (
-    transformResult == null ||
-    (isObject(transformResult) && transformResult.code == null)
-  ) {
-    // no transform applied, keep code as-is
-    isDebug &&
-      debugTransform(
-        timeFrom(transformStart) + chalk.dim(` [skipped] ${prettyUrl}`)
-      )
-  } else {
-    isDebug && debugTransform(`${timeFrom(transformStart)} ${prettyUrl}`)
-    code = transformResult.code!
-    map = transformResult.map
-  }
-
-  if (map && mod.file) {
-    map = (typeof map === 'string' ? JSON.parse(map) : map) as SourceMap
-    if (map.mappings && !map.sourcesContent) {
-      await injectSourcesContent(map, mod.file, logger)
-    }
-  }
-
-  if (ssr) {
-    return (mod.ssrTransformResult = await ssrTransform(
-      code,
-      map as SourceMap,
-      url
-    ))
-  } else {
-    return (mod.transformResult = {
-      code,
-      map,
-      etag: getEtag(code, { weak: true })
-    } as TransformResult)
-  }
-}

package/src/node/server/ws.ts

@@ -1,131 +0,0 @@
-import chalk from 'chalk'
-import { Server, STATUS_CODES } from 'http'
-import {
-  createServer as createHttpsServer,
-  ServerOptions as HttpsServerOptions
-} from 'https'
-import WebSocket from 'ws'
-import { ErrorPayload, HMRPayload } from 'types/hmrPayload'
-import { ResolvedConfig } from '..'
-import { isObject } from '../utils'
-import { Socket } from 'net'
-export const HMR_HEADER = 'vite-hmr'
-
-export interface WebSocketServer {
-  send(payload: HMRPayload): void
-  close(): Promise<void>
-}
-
-export function createWebSocketServer(
-  server: Server | null,
-  config: ResolvedConfig,
-  httpsOptions?: HttpsServerOptions
-): WebSocketServer {
-  let wss: WebSocket.Server
-  let httpsServer: Server | undefined = undefined
-
-  const hmr = isObject(config.server.hmr) && config.server.hmr
-  const wsServer = (hmr && hmr.server) || server
-
-  if (wsServer) {
-    wss = new WebSocket.Server({ noServer: true })
-    wsServer.on('upgrade', (req, socket, head) => {
-      if (req.headers['sec-websocket-protocol'] === HMR_HEADER) {
-        wss.handleUpgrade(req, socket as Socket, head, (ws) => {
-          wss.emit('connection', ws, req)
-        })
-      }
-    })
-  } else {
-    const websocketServerOptions: WebSocket.ServerOptions = {}
-    const port = (hmr && hmr.port) || 24678
-    if (httpsOptions) {
-      // if we're serving the middlewares over https, the ws library doesn't support automatically creating an https server, so we need to do it ourselves
-      // create an inline https server and mount the websocket server to it
-      httpsServer = createHttpsServer(httpsOptions, (req, res) => {
-        const statusCode = 426
-        const body = STATUS_CODES[statusCode]
-        if (!body)
-          throw new Error(
-            `No body text found for the ${statusCode} status code`
-          )
-
-        res.writeHead(statusCode, {
-          'Content-Length': body.length,
-          'Content-Type': 'text/plain'
-        })
-        res.end(body)
-      })
-
-      httpsServer.listen(port)
-      websocketServerOptions.server = httpsServer
-    } else {
-      // we don't need to serve over https, just let ws handle its own server
-      websocketServerOptions.port = port
-    }
-
-    // vite dev server in middleware mode
-    wss = new WebSocket.Server(websocketServerOptions)
-  }
-
-  wss.on('connection', (socket) => {
-    socket.send(JSON.stringify({ type: 'connected' }))
-    if (bufferedError) {
-      socket.send(JSON.stringify(bufferedError))
-      bufferedError = null
-    }
-  })
-
-  wss.on('error', (e: Error & { code: string }) => {
-    if (e.code !== 'EADDRINUSE') {
-      config.logger.error(
-        chalk.red(`WebSocket server error:\n${e.stack || e.message}`),
-        { error: e }
-      )
-    }
-  })
-
-  // On page reloads, if a file fails to compile and returns 500, the server
-  // sends the error payload before the client connection is established.
-  // If we have no open clients, buffer the error and send it to the next
-  // connected client.
-  let bufferedError: ErrorPayload | null = null
-
-  return {
-    send(payload: HMRPayload) {
-      if (payload.type === 'error' && !wss.clients.size) {
-        bufferedError = payload
-        return
-      }
-
-      const stringified = JSON.stringify(payload)
-      wss.clients.forEach((client) => {
-        if (client.readyState === WebSocket.OPEN) {
-          client.send(stringified)
-        }
-      })
-    },
-
-    close() {
-      return new Promise((resolve, reject) => {
-        wss.close((err) => {
-          if (err) {
-            reject(err)
-          } else {
-            if (httpsServer) {
-              httpsServer.close((err) => {
-                if (err) {
-                  reject(err)
-                } else {
-                  resolve()
-                }
-              })
-            } else {
-              resolve()
-            }
-          }
-        })
-      })
-    }
-  }
-}

package/src/node/ssr/__tests__/ssrTransform.spec.ts

@@ -1,309 +0,0 @@
-import { traverseHtml } from '../../plugins/html'
-import { ssrTransform } from '../ssrTransform'
-
-test('default import', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import foo from 'vue';console.log(foo.bar)`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    console.log(__vite_ssr_import_0__.default.bar)"
-  `)
-})
-
-test('named import', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import { ref } from 'vue';function foo() { return ref(0) }`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    function foo() { return __vite_ssr_import_0__.ref(0) }"
-  `)
-})
-
-test('namespace import', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import * as vue from 'vue';function foo() { return vue.ref(0) }`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    function foo() { return __vite_ssr_import_0__.ref(0) }"
-  `)
-})
-
-test('export function declaration', async () => {
-  expect((await ssrTransform(`export function foo() {}`, null, null)).code)
-    .toMatchInlineSnapshot(`
-    "function foo() {}
-    Object.defineProperty(__vite_ssr_exports__, \\"foo\\", { enumerable: true, configurable: true, get(){ return foo }});"
-  `)
-})
-
-test('export class declaration', async () => {
-  expect((await ssrTransform(`export class foo {}`, null, null)).code)
-    .toMatchInlineSnapshot(`
-    "class foo {}
-    Object.defineProperty(__vite_ssr_exports__, \\"foo\\", { enumerable: true, configurable: true, get(){ return foo }});"
-  `)
-})
-
-test('export var declaration', async () => {
-  expect((await ssrTransform(`export const a = 1, b = 2`, null, null)).code)
-    .toMatchInlineSnapshot(`
-    "const a = 1, b = 2
-    Object.defineProperty(__vite_ssr_exports__, \\"a\\", { enumerable: true, configurable: true, get(){ return a }});
-    Object.defineProperty(__vite_ssr_exports__, \\"b\\", { enumerable: true, configurable: true, get(){ return b }});"
-  `)
-})
-
-test('export named', async () => {
-  expect(
-    (await ssrTransform(`const a = 1, b = 2; export { a, b as c }`, null, null))
-      .code
-  ).toMatchInlineSnapshot(`
-    "const a = 1, b = 2; 
-    Object.defineProperty(__vite_ssr_exports__, \\"a\\", { enumerable: true, configurable: true, get(){ return a }});
-    Object.defineProperty(__vite_ssr_exports__, \\"c\\", { enumerable: true, configurable: true, get(){ return b }});"
-  `)
-})
-
-test('export named from', async () => {
-  expect(
-    (await ssrTransform(`export { ref, computed as c } from 'vue'`, null, null))
-      .code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-
-    Object.defineProperty(__vite_ssr_exports__, \\"ref\\", { enumerable: true, configurable: true, get(){ return __vite_ssr_import_0__.ref }});
-    Object.defineProperty(__vite_ssr_exports__, \\"c\\", { enumerable: true, configurable: true, get(){ return __vite_ssr_import_0__.computed }});"
-  `)
-})
-
-test('named exports of imported binding', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import {createApp} from 'vue';export {createApp}`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-
-    Object.defineProperty(__vite_ssr_exports__, \\"createApp\\", { enumerable: true, configurable: true, get(){ return __vite_ssr_import_0__.createApp }});"
-  `)
-})
-
-test('export * from', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `export * from 'vue'\n` + `export * from 'react'`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    __vite_ssr_exportAll__(__vite_ssr_import_0__);
-    const __vite_ssr_import_1__ = await __vite_ssr_import__(\\"react\\");
-    __vite_ssr_exportAll__(__vite_ssr_import_1__);"
-  `)
-})
-
-test('export * as from', async () => {
-  expect((await ssrTransform(`export * as foo from 'vue'`, null, null)).code)
-    .toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-
-    Object.defineProperty(__vite_ssr_exports__, \\"foo\\", { enumerable: true, configurable: true, get(){ return __vite_ssr_import_0__ }});"
-  `)
-})
-
-test('export default', async () => {
-  expect(
-    (await ssrTransform(`export default {}`, null, null)).code
-  ).toMatchInlineSnapshot(`"__vite_ssr_exports__.default = {}"`)
-})
-
-test('import.meta', async () => {
-  expect(
-    (await ssrTransform(`console.log(import.meta.url)`, null, null)).code
-  ).toMatchInlineSnapshot(`"console.log(__vite_ssr_import_meta__.url)"`)
-})
-
-test('dynamic import', async () => {
-  const result = await ssrTransform(
-    `export const i = () => import('./foo')`,
-    null,
-    null
-  )
-  expect(result.code).toMatchInlineSnapshot(`
-    "const i = () => __vite_ssr_dynamic_import__('./foo')
-    Object.defineProperty(__vite_ssr_exports__, \\"i\\", { enumerable: true, configurable: true, get(){ return i }});"
-  `)
-  expect(result.deps).toEqual([])
-  expect(result.dynamicDeps).toEqual(['./foo'])
-})
-
-test('do not rewrite method definition', async () => {
-  const result = await ssrTransform(
-    `import { fn } from 'vue';class A { fn() { fn() } }`,
-    null,
-    null
-  )
-  expect(result.code).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    class A { fn() { __vite_ssr_import_0__.fn() } }"
-  `)
-  expect(result.deps).toEqual(['vue'])
-})
-
-test('do not rewrite catch clause', async () => {
-  const result = await ssrTransform(
-    `import {error} from './dependency';try {} catch(error) {}`,
-    null,
-    null
-  )
-  expect(result.code).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"./dependency\\");
-    try {} catch(error) {}"
-  `)
-  expect(result.deps).toEqual(['./dependency'])
-})
-
-// #2221
-test('should declare variable for imported super class', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import { Foo } from './dependency';` + `class A extends Foo {}`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"./dependency\\");
-    const Foo = __vite_ssr_import_0__.Foo;
-    class A extends Foo {}"
-  `)
-
-  // exported classes: should prepend the declaration at root level, before the
-  // first class that uses the binding
-  expect(
-    (
-      await ssrTransform(
-        `import { Foo } from './dependency';` +
-          `export default class A extends Foo {}\n` +
-          `export class B extends Foo {}`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"./dependency\\");
-    const Foo = __vite_ssr_import_0__.Foo;
-    class A extends Foo {}
-    class B extends Foo {}
-    Object.defineProperty(__vite_ssr_exports__, \\"default\\", { enumerable: true, value: A });
-    Object.defineProperty(__vite_ssr_exports__, \\"B\\", { enumerable: true, configurable: true, get(){ return B }});"
-  `)
-})
-
-// #4049
-test('should handle default export variants', async () => {
-  // default anonymous functions
-  expect(
-    (await ssrTransform(`export default function() {}\n`, null, null)).code
-  ).toMatchInlineSnapshot(`
-    "__vite_ssr_exports__.default = function() {}
-    "
-  `)
-  // default anonymous class
-  expect((await ssrTransform(`export default class {}\n`, null, null)).code)
-    .toMatchInlineSnapshot(`
-    "__vite_ssr_exports__.default = class {}
-    "
-  `)
-  // default named functions
-  expect(
-    (
-      await ssrTransform(
-        `export default function foo() {}\n` +
-          `foo.prototype = Object.prototype;`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "function foo() {}
-    foo.prototype = Object.prototype;
-    Object.defineProperty(__vite_ssr_exports__, \\"default\\", { enumerable: true, value: foo });"
-  `)
-  // default named classes
-  expect(
-    (
-      await ssrTransform(
-        `export default class A {}\n` + `export class B extends A {}`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "class A {}
-    class B extends A {}
-    Object.defineProperty(__vite_ssr_exports__, \\"default\\", { enumerable: true, value: A });
-    Object.defineProperty(__vite_ssr_exports__, \\"B\\", { enumerable: true, configurable: true, get(){ return B }});"
-  `)
-})
-
-test('sourcemap source', async () => {
-  expect(
-    (await ssrTransform(`export const a = 1`, null, 'input.js')).map.sources
-  ).toStrictEqual(['input.js'])
-})
-
-test('overwrite bindings', async () => {
-  expect(
-    (
-      await ssrTransform(
-        `import { inject } from 'vue';` +
-          `const a = { inject }\n` +
-          `const b = { test: inject }\n` +
-          `function c() { const { test: inject } = { test: true }; console.log(inject) }\n` +
-          `const d = inject \n` +
-          `function f() {  console.log(inject) }\n` +
-          `function e() { const { inject } = { inject: true } }\n` +
-          `function g() { const f = () => { const inject = true }; console.log(inject) }\n`,
-        null,
-        null
-      )
-    ).code
-  ).toMatchInlineSnapshot(`
-    "const __vite_ssr_import_0__ = await __vite_ssr_import__(\\"vue\\");
-    const a = { inject: __vite_ssr_import_0__.inject }
-    const b = { test: __vite_ssr_import_0__.inject }
-    function c() { const { test: inject } = { test: true }; console.log(inject) }
-    const d = __vite_ssr_import_0__.inject 
-    function f() {  console.log(__vite_ssr_import_0__.inject) }
-    function e() { const { inject } = { inject: true } }
-    function g() { const f = () => { const inject = true }; console.log(__vite_ssr_import_0__.inject) }
-    "
-  `)
-})