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

package/src/node/plugins/terser.ts

@@ -1,40 +0,0 @@
-import { Plugin } from '../plugin'
-import { Worker } from 'okie'
-import { Terser } from 'types/terser'
-
-export function terserPlugin(options: Terser.MinifyOptions): Plugin {
-  const worker = new Worker(
-    (basedir: string, code: string, options: Terser.MinifyOptions) => {
-      // when vite is linked, the worker thread won't share the same resolve
-      // root with vite itself, so we have to pass in the basedir and resolve
-      // terser first.
-      // eslint-disable-next-line node/no-restricted-require
-      const terserPath = require.resolve('terser', {
-        paths: [basedir]
-      })
-      return require(terserPath).minify(code, options) as Terser.MinifyOutput
-    }
-  )
-
-  return {
-    name: 'vite:terser',
-
-    async renderChunk(code, _chunk, outputOptions) {
-      const res = await worker.run(__dirname, code, {
-        safari10: true,
-        ...options,
-        sourceMap: !!outputOptions.sourcemap,
-        module: outputOptions.format.startsWith('es'),
-        toplevel: outputOptions.format === 'cjs'
-      })
-      return {
-        code: res.code!,
-        map: res.map as any
-      }
-    },
-
-    closeBundle() {
-      worker.stop()
-    }
-  }
-}

package/src/node/plugins/wasm.ts

@@ -1,72 +0,0 @@
-import { ResolvedConfig } from '../config'
-import { Plugin } from '../plugin'
-import { fileToUrl } from './asset'
-
-const wasmHelperId = '/__vite-wasm-helper'
-
-const wasmHelper = async (opts = {}, url: string) => {
-  let result
-  if (url.startsWith('data:')) {
-    // @ts-ignore
-    const binaryString = atob(url.replace(/^data:.*?base64,/, ''))
-    const bytes = new Uint8Array(binaryString.length)
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i)
-    }
-    // @ts-ignore
-    result = await WebAssembly.instantiate(bytes, opts)
-  } else {
-    // https://github.com/mdn/webassembly-examples/issues/5
-    // WebAssembly.instantiateStreaming requires the server to provide the
-    // correct MIME type for .wasm files, which unfortunately doesn't work for
-    // a lot of static file servers, so we just work around it by getting the
-    // raw buffer.
-    // @ts-ignore
-    const response = await fetch(url)
-    const contentType = response.headers.get('Content-Type') || ''
-    if (
-      // @ts-ignore
-      'instantiateStreaming' in WebAssembly &&
-      contentType.startsWith('application/wasm')
-    ) {
-      // @ts-ignore
-      result = await WebAssembly.instantiateStreaming(response, opts)
-    } else {
-      const buffer = await response.arrayBuffer()
-      // @ts-ignore
-      result = await WebAssembly.instantiate(buffer, opts)
-    }
-  }
-  return result.instance.exports
-}
-
-const wasmHelperCode = wasmHelper.toString()
-
-export const wasmPlugin = (config: ResolvedConfig): Plugin => {
-  return {
-    name: 'vite:wasm',
-
-    resolveId(id) {
-      if (id === wasmHelperId) {
-        return id
-      }
-    },
-
-    async load(id) {
-      if (id === wasmHelperId) {
-        return `export default ${wasmHelperCode}`
-      }
-
-      if (!id.endsWith('.wasm')) {
-        return
-      }
-
-      const url = await fileToUrl(id, config, this)
-
-      return `
-import initWasm from "${wasmHelperId}"
-export default opts => initWasm(opts, ${JSON.stringify(url)})
-`
-    }
-  }
-}

package/src/node/plugins/worker.ts

@@ -1,117 +0,0 @@
-import { ResolvedConfig } from '../config'
-import { Plugin } from '../plugin'
-import { resolvePlugins } from '../plugins'
-import { parse as parseUrl, URLSearchParams } from 'url'
-import { fileToUrl, getAssetHash } from './asset'
-import { cleanUrl, injectQuery } from '../utils'
-import Rollup from 'rollup'
-import { ENV_PUBLIC_PATH } from '../constants'
-import path from 'path'
-import { onRollupWarning } from '../build'
-
-function parseWorkerRequest(id: string): Record<string, string> | null {
-  const { search } = parseUrl(id)
-  if (!search) {
-    return null
-  }
-  return Object.fromEntries(new URLSearchParams(search.slice(1)))
-}
-
-const WorkerFileId = 'worker_file'
-
-export function webWorkerPlugin(config: ResolvedConfig): Plugin {
-  const isBuild = config.command === 'build'
-
-  return {
-    name: 'vite:worker',
-
-    load(id) {
-      if (isBuild) {
-        const parsedQuery = parseWorkerRequest(id)
-        if (
-          parsedQuery &&
-          (parsedQuery.worker ?? parsedQuery.sharedworker) != null
-        ) {
-          return ''
-        }
-      }
-    },
-
-    async transform(_, id) {
-      const query = parseWorkerRequest(id)
-      if (query && query[WorkerFileId] != null) {
-        return {
-          code: `import '${ENV_PUBLIC_PATH}'\n` + _
-        }
-      }
-      if (
-        query == null ||
-        (query && (query.worker ?? query.sharedworker) == null)
-      ) {
-        return
-      }
-
-      let url: string
-      if (isBuild) {
-        // bundle the file as entry to support imports
-        const rollup = require('rollup') as typeof Rollup
-        const bundle = await rollup.rollup({
-          input: cleanUrl(id),
-          plugins: await resolvePlugins({ ...config }, [], [], []),
-          onwarn(warning, warn) {
-            onRollupWarning(warning, warn, config)
-          }
-        })
-        let code: string
-        try {
-          const { output } = await bundle.generate({
-            format: 'iife',
-            sourcemap: config.build.sourcemap
-          })
-          code = output[0].code
-        } finally {
-          await bundle.close()
-        }
-        const content = Buffer.from(code)
-        if (query.inline != null) {
-          // inline as blob data url
-          return `const encodedJs = "${content.toString('base64')}";
-            const blob = typeof window !== "undefined" && window.Blob && new Blob([atob(encodedJs)], { type: "text/javascript;charset=utf-8" });
-            export default function WorkerWrapper() {
-              const objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
-              try {
-                return objURL ? new Worker(objURL) : new Worker("data:application/javascript;base64," + encodedJs, {type: "module"});
-              } finally {
-                objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
-              }
-            }`
-        } else {
-          const basename = path.parse(cleanUrl(id)).name
-          const contentHash = getAssetHash(content)
-          const fileName = path.posix.join(
-            config.build.assetsDir,
-            `${basename}.${contentHash}.js`
-          )
-          url = `__VITE_ASSET__${this.emitFile({
-            fileName,
-            type: 'asset',
-            source: code
-          })}__`
-        }
-      } else {
-        url = await fileToUrl(cleanUrl(id), config, this)
-        url = injectQuery(url, WorkerFileId)
-      }
-
-      const workerConstructor =
-        query.sharedworker != null ? 'SharedWorker' : 'Worker'
-      const workerOptions = { type: 'module' }
-
-      return `export default function WorkerWrapper() {
-        return new ${workerConstructor}(${JSON.stringify(
-        url
-      )}, ${JSON.stringify(workerOptions, null, 2)})
-      }`
-    }
-  }
-}

package/src/node/preview.ts

@@ -1,82 +0,0 @@
-import path from 'path'
-import sirv from 'sirv'
-import chalk from 'chalk'
-import connect from 'connect'
-import compression from 'compression'
-import { ResolvedConfig, ServerOptions } from '.'
-import { Connect } from 'types/connect'
-import {
-  resolveHttpsConfig,
-  resolveHttpServer,
-  httpServerStart
-} from './server/http'
-import { openBrowser } from './server/openBrowser'
-import corsMiddleware from 'cors'
-import { proxyMiddleware } from './server/middlewares/proxy'
-import { printServerUrls } from './logger'
-import { resolveHostname } from './utils'
-
-export async function preview(
-  config: ResolvedConfig,
-  serverOptions: Pick<ServerOptions, 'port' | 'host'>
-): Promise<void> {
-  const app = connect() as Connect.Server
-  const httpServer = await resolveHttpServer(
-    config.server,
-    app,
-    await resolveHttpsConfig(config)
-  )
-
-  // cors
-  const { cors } = config.server
-  if (cors !== false) {
-    app.use(corsMiddleware(typeof cors === 'boolean' ? {} : cors))
-  }
-
-  // proxy
-  if (config.server.proxy) {
-    app.use(proxyMiddleware(httpServer, config))
-  }
-
-  app.use(compression())
-
-  const distDir = path.resolve(config.root, config.build.outDir)
-  app.use(
-    config.base,
-    sirv(distDir, {
-      etag: true,
-      dev: true,
-      single: true
-    })
-  )
-
-  const options = config.server
-  const hostname = resolveHostname(serverOptions.host ?? options.host)
-  const port = serverOptions.port ?? 5000
-  const protocol = options.https ? 'https' : 'http'
-  const logger = config.logger
-  const base = config.base
-
-  const serverPort = await httpServerStart(httpServer, {
-    port,
-    strictPort: options.strictPort,
-    host: hostname.host,
-    logger
-  })
-
-  logger.info(
-    chalk.cyan(`\n  vite v${require('vite/package.json').version}`) +
-      chalk.green(` build preview server running at:\n`)
-  )
-
-  printServerUrls(hostname, protocol, serverPort, base, logger.info)
-
-  if (options.open) {
-    const path = typeof options.open === 'string' ? options.open : base
-    openBrowser(
-      `${protocol}://${hostname.name}:${serverPort}${path}`,
-      true,
-      logger
-    )
-  }
-}

package/src/node/server/__tests__/fixtures/none/nested/package.json

@@ -1,3 +0,0 @@
-{
-  "private": true
-}

package/src/node/server/__tests__/fixtures/pnpm/nested/package.json

@@ -1,3 +0,0 @@
-{
-  "private": true
-}

package/src/node/server/__tests__/fixtures/pnpm/package.json

@@ -1,3 +0,0 @@
-{
-  "private": true
-}

package/src/node/server/__tests__/fixtures/yarn/nested/package.json

@@ -1,3 +0,0 @@
-{
-  "private": true
-}

package/src/node/server/__tests__/fixtures/yarn/package.json

@@ -1,6 +0,0 @@
-{
-  "private": true,
-  "workspaces": [
-    "nested"
-  ]
-}

package/src/node/server/__tests__/search-root.spec.ts

@@ -1,31 +0,0 @@
-import { searchForWorkspaceRoot } from '../searchRoot'
-import { resolve } from 'path'
-
-describe('searchForWorkspaceRoot', () => {
-  test('pnpm', () => {
-    const resolved = searchForWorkspaceRoot(
-      resolve(__dirname, 'fixtures/pnpm/nested')
-    )
-    expect(resolved).toBe(resolve(__dirname, 'fixtures/pnpm'))
-  })
-
-  test('yarn', () => {
-    const resolved = searchForWorkspaceRoot(
-      resolve(__dirname, 'fixtures/yarn/nested')
-    )
-    expect(resolved).toBe(resolve(__dirname, 'fixtures/yarn'))
-  })
-
-  test('yarn at root', () => {
-    const resolved = searchForWorkspaceRoot(resolve(__dirname, 'fixtures/yarn'))
-    expect(resolved).toBe(resolve(__dirname, 'fixtures/yarn'))
-  })
-
-  test('none', () => {
-    const resolved = searchForWorkspaceRoot(
-      resolve(__dirname, 'fixtures/none/nested')
-    )
-    // resolved to vite repo's root
-    expect(resolved).toBe(resolve(__dirname, '../../../../../..'))
-  })
-})