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

package/src/node/optimizer/esbuildDepPlugin.ts

@@ -1,216 +0,0 @@
-import path from 'path'
-import { Loader, Plugin, ImportKind } from 'esbuild'
-import { KNOWN_ASSET_TYPES } from '../constants'
-import { ResolvedConfig } from '..'
-import {
-  isRunningWithYarnPnp,
-  flattenId,
-  normalizePath,
-  isExternalUrl,
-  isBuiltin
-} from '../utils'
-import { browserExternalId } from '../plugins/resolve'
-import { ExportsData } from '.'
-
-const externalTypes = [
-  'css',
-  // supported pre-processor types
-  'less',
-  'sass',
-  'scss',
-  'styl',
-  'stylus',
-  'pcss',
-  'postcss',
-  // known SFC types
-  'vue',
-  'svelte',
-  'marko',
-  // JSX/TSX may be configured to be compiled differently from how esbuild
-  // handles it by default, so exclude them as well
-  'jsx',
-  'tsx',
-  ...KNOWN_ASSET_TYPES
-]
-
-export function esbuildDepPlugin(
-  qualified: Record<string, string>,
-  exportsData: Record<string, ExportsData>,
-  config: ResolvedConfig,
-  ssr?: boolean
-): Plugin {
-  // default resolver which prefers ESM
-  const _resolve = config.createResolver({ asSrc: false })
-
-  // cjs resolver that prefers Node
-  const _resolveRequire = config.createResolver({
-    asSrc: false,
-    isRequire: true
-  })
-
-  const resolve = (
-    id: string,
-    importer: string,
-    kind: ImportKind,
-    resolveDir?: string
-  ): Promise<string | undefined> => {
-    let _importer: string
-    // explicit resolveDir - this is passed only during yarn pnp resolve for
-    // entries
-    if (resolveDir) {
-      _importer = normalizePath(path.join(resolveDir, '*'))
-    } else {
-      // map importer ids to file paths for correct resolution
-      _importer = importer in qualified ? qualified[importer] : importer
-    }
-    const resolver = kind.startsWith('require') ? _resolveRequire : _resolve
-    return resolver(id, _importer, undefined, ssr)
-  }
-
-  return {
-    name: 'vite:dep-pre-bundle',
-    setup(build) {
-      // externalize assets and commonly known non-js file types
-      build.onResolve(
-        {
-          filter: new RegExp(`\\.(` + externalTypes.join('|') + `)(\\?.*)?$`)
-        },
-        async ({ path: id, importer, kind }) => {
-          const resolved = await resolve(id, importer, kind)
-          if (resolved) {
-            return {
-              path: resolved,
-              external: true
-            }
-          }
-        }
-      )
-
-      function resolveEntry(id: string) {
-        const flatId = flattenId(id)
-        if (flatId in qualified) {
-          return {
-            path: flatId,
-            namespace: 'dep'
-          }
-        }
-      }
-
-      build.onResolve(
-        { filter: /^[\w@][^:]/ },
-        async ({ path: id, importer, kind }) => {
-          // ensure esbuild uses our resolved entries
-          let entry: { path: string; namespace: string } | undefined
-          // if this is an entry, return entry namespace resolve result
-          if (!importer) {
-            if ((entry = resolveEntry(id))) return entry
-            // check if this is aliased to an entry - also return entry namespace
-            const aliased = await _resolve(id, undefined, true)
-            if (aliased && (entry = resolveEntry(aliased))) {
-              return entry
-            }
-          }
-
-          // use vite's own resolver
-          const resolved = await resolve(id, importer, kind)
-          if (resolved) {
-            if (resolved.startsWith(browserExternalId)) {
-              return {
-                path: id,
-                namespace: 'browser-external'
-              }
-            }
-            if (isExternalUrl(resolved) || (ssr && isBuiltin(id))) {
-              return {
-                path: resolved,
-                external: true
-              }
-            }
-            return {
-              path: path.resolve(resolved)
-            }
-          }
-        }
-      )
-
-      // For entry files, we'll read it ourselves and construct a proxy module
-      // to retain the entry's raw id instead of file path so that esbuild
-      // outputs desired output file structure.
-      // It is necessary to do the re-exporting to separate the virtual proxy
-      // module from the actual module since the actual module may get
-      // referenced via relative imports - if we don't separate the proxy and
-      // the actual module, esbuild will create duplicated copies of the same
-      // module!
-      const root = path.resolve(config.root)
-      build.onLoad({ filter: /.*/, namespace: 'dep' }, ({ path: id }) => {
-        const entryFile = qualified[id]
-
-        let relativePath = normalizePath(path.relative(root, entryFile))
-        if (
-          !relativePath.startsWith('./') &&
-          !relativePath.startsWith('../') &&
-          relativePath !== '.'
-        ) {
-          relativePath = `./${relativePath}`
-        }
-
-        let contents = ''
-        const data = exportsData[id]
-        const [imports, exports] = data
-        if (!imports.length && !exports.length) {
-          // cjs
-          contents += `export default require("${relativePath}");`
-        } else {
-          if (exports.includes('default')) {
-            contents += `import d from "${relativePath}";export default d;`
-          }
-          if (
-            data.hasReExports ||
-            exports.length > 1 ||
-            exports[0] !== 'default'
-          ) {
-            contents += `\nexport * from "${relativePath}"`
-          }
-        }
-
-        let ext = path.extname(entryFile).slice(1)
-        if (ext === 'mjs') ext = 'js'
-        return {
-          loader: ext as Loader,
-          contents,
-          resolveDir: root
-        }
-      })
-
-      build.onLoad(
-        { filter: /.*/, namespace: 'browser-external' },
-        ({ path: id }) => {
-          return {
-            contents:
-              `export default new Proxy({}, {
-  get() {
-    throw new Error('Module "${id}" has been externalized for ` +
-              `browser compatibility and cannot be accessed in client code.')
-  }
-})`
-          }
-        }
-      )
-
-      // yarn 2 pnp compat
-      if (isRunningWithYarnPnp) {
-        build.onResolve(
-          { filter: /.*/ },
-          async ({ path, importer, kind, resolveDir }) => ({
-            // pass along resolveDir for entries
-            path: await resolve(path, importer, kind, resolveDir)
-          })
-        )
-        build.onLoad({ filter: /.*/ }, async (args) => ({
-          contents: await require('fs').promises.readFile(args.path),
-          loader: 'default'
-        }))
-      }
-    }
-  }
-}

package/src/node/optimizer/index.ts

@@ -1,410 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import chalk from 'chalk'
-import { createHash } from 'crypto'
-import { build, BuildOptions as EsbuildBuildOptions } from 'esbuild'
-import { ResolvedConfig } from '../config'
-import {
-  createDebugger,
-  emptyDir,
-  lookupFile,
-  normalizePath,
-  writeFile,
-  flattenId,
-  normalizeId
-} from '../utils'
-import { esbuildDepPlugin } from './esbuildDepPlugin'
-import { ImportSpecifier, init, parse } from 'es-module-lexer'
-import { scanImports } from './scan'
-import { transformWithEsbuild } from '../plugins/esbuild'
-
-const debug = createDebugger('vite:deps')
-
-export type ExportsData = [ImportSpecifier[], string[]] & {
-  // es-module-lexer has a facade detection but isn't always accurate for our
-  // use case when the module has default export
-  hasReExports?: true
-}
-
-export interface DepOptimizationOptions {
-  /**
-   * By default, Vite will crawl your index.html to detect dependencies that
-   * need to be pre-bundled. If build.rollupOptions.input is specified, Vite
-   * will crawl those entry points instead.
-   *
-   * If neither of these fit your needs, you can specify custom entries using
-   * this option - the value should be a fast-glob pattern or array of patterns
-   * (https://github.com/mrmlnc/fast-glob#basic-syntax) that are relative from
-   * vite project root. This will overwrite default entries inference.
-   */
-  entries?: string | string[]
-  /**
-   * Force optimize listed dependencies (must be resolvable import paths,
-   * cannot be globs).
-   */
-  include?: string[]
-  /**
-   * Do not optimize these dependencies (must be resolvable import paths,
-   * cannot be globs).
-   */
-  exclude?: string[]
-  /**
-   * Options to pass to esbuild during the dep scanning and optimization
-   *
-   * Certain options are omitted since changing them would not be compatible
-   * with Vite's dep optimization.
-   *
-   * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
-   * - `plugins` are merged with Vite's dep plugin
-   * - `keepNames` takes precedence over the deprecated `optimizeDeps.keepNames`
-   *
-   * https://esbuild.github.io/api
-   */
-  esbuildOptions?: Omit<
-    EsbuildBuildOptions,
-    | 'bundle'
-    | 'entryPoints'
-    | 'external'
-    | 'write'
-    | 'watch'
-    | 'outdir'
-    | 'outfile'
-    | 'outbase'
-    | 'outExtension'
-    | 'metafile'
-  >
-  /**
-   * @deprecated use `esbuildOptions.keepNames`
-   */
-  keepNames?: boolean
-}
-
-export interface DepOptimizationMetadata {
-  /**
-   * The main hash is determined by user config and dependency lockfiles.
-   * This is checked on server startup to avoid unnecessary re-bundles.
-   */
-  hash: string
-  /**
-   * The browser hash is determined by the main hash plus additional dependencies
-   * discovered at runtime. This is used to invalidate browser requests to
-   * optimized deps.
-   */
-  browserHash: string
-  optimized: Record<
-    string,
-    {
-      file: string
-      src: string
-      needsInterop: boolean
-    }
-  >
-}
-
-export async function optimizeDeps(
-  config: ResolvedConfig,
-  force = config.server.force,
-  asCommand = false,
-  newDeps?: Record<string, string>, // missing imports encountered after server has started
-  ssr?: boolean
-): Promise<DepOptimizationMetadata | null> {
-  config = {
-    ...config,
-    command: 'build'
-  }
-
-  const { root, logger, cacheDir } = config
-  const log = asCommand ? logger.info : debug
-
-  if (!cacheDir) {
-    log(`No cache directory. Skipping.`)
-    return null
-  }
-
-  const dataPath = path.join(cacheDir, '_metadata.json')
-  const mainHash = getDepHash(root, config)
-  const data: DepOptimizationMetadata = {
-    hash: mainHash,
-    browserHash: mainHash,
-    optimized: {}
-  }
-
-  if (!force) {
-    let prevData: DepOptimizationMetadata | undefined
-    try {
-      prevData = JSON.parse(fs.readFileSync(dataPath, 'utf-8'))
-    } catch (e) {}
-    // hash is consistent, no need to re-bundle
-    if (prevData && prevData.hash === data.hash) {
-      log('Hash is consistent. Skipping. Use --force to override.')
-      return prevData
-    }
-  }
-
-  if (fs.existsSync(cacheDir)) {
-    emptyDir(cacheDir)
-  } else {
-    fs.mkdirSync(cacheDir, { recursive: true })
-  }
-  // a hint for Node.js
-  // all files in the cache directory should be recognized as ES modules
-  writeFile(
-    path.resolve(cacheDir, 'package.json'),
-    JSON.stringify({ type: 'module' })
-  )
-
-  let deps: Record<string, string>, missing: Record<string, string>
-  if (!newDeps) {
-    ;({ deps, missing } = await scanImports(config))
-  } else {
-    deps = newDeps
-    missing = {}
-  }
-
-  // update browser hash
-  data.browserHash = createHash('sha256')
-    .update(data.hash + JSON.stringify(deps))
-    .digest('hex')
-    .substr(0, 8)
-
-  const missingIds = Object.keys(missing)
-  if (missingIds.length) {
-    throw new Error(
-      `The following dependencies are imported but could not be resolved:\n\n  ${missingIds
-        .map(
-          (id) =>
-            `${chalk.cyan(id)} ${chalk.white.dim(
-              `(imported by ${missing[id]})`
-            )}`
-        )
-        .join(`\n  `)}\n\nAre they installed?`
-    )
-  }
-
-  const include = config.optimizeDeps?.include
-  if (include) {
-    const resolve = config.createResolver({ asSrc: false })
-    for (const id of include) {
-      // normalize 'foo   >bar` as 'foo > bar' to prevent same id being added
-      // and for pretty printing
-      const normalizedId = normalizeId(id)
-      if (!deps[normalizedId]) {
-        const entry = await resolve(id)
-        if (entry) {
-          deps[normalizedId] = entry
-        } else {
-          throw new Error(
-            `Failed to resolve force included dependency: ${chalk.cyan(id)}`
-          )
-        }
-      }
-    }
-  }
-
-  const qualifiedIds = Object.keys(deps)
-
-  if (!qualifiedIds.length) {
-    writeFile(dataPath, JSON.stringify(data, null, 2))
-    log(`No dependencies to bundle. Skipping.\n\n\n`)
-    return data
-  }
-
-  const total = qualifiedIds.length
-  const maxListed = 5
-  const listed = Math.min(total, maxListed)
-  const extra = Math.max(0, total - maxListed)
-  const depsString = chalk.yellow(
-    qualifiedIds.slice(0, listed).join(`\n  `) +
-      (extra > 0 ? `\n  (...and ${extra} more)` : ``)
-  )
-  if (!asCommand) {
-    if (!newDeps) {
-      // This is auto run on server start - let the user know that we are
-      // pre-optimizing deps
-      logger.info(
-        chalk.greenBright(`Pre-bundling dependencies:\n  ${depsString}`)
-      )
-      logger.info(
-        `(this will be run only when your dependencies or config have changed)`
-      )
-    }
-  } else {
-    logger.info(chalk.greenBright(`Optimizing dependencies:\n  ${depsString}`))
-  }
-
-  // esbuild generates nested directory output with lowest common ancestor base
-  // this is unpredictable and makes it difficult to analyze entry / output
-  // mapping. So what we do here is:
-  // 1. flatten all ids to eliminate slash
-  // 2. in the plugin, read the entry ourselves as virtual files to retain the
-  //    path.
-  const flatIdDeps: Record<string, string> = {}
-  const idToExports: Record<string, ExportsData> = {}
-  const flatIdToExports: Record<string, ExportsData> = {}
-
-  const { plugins = [], ...esbuildOptions } =
-    config.optimizeDeps?.esbuildOptions ?? {}
-
-  await init
-  for (const id in deps) {
-    const flatId = flattenId(id)
-    const filePath = (flatIdDeps[flatId] = deps[id])
-    const entryContent = fs.readFileSync(filePath, 'utf-8')
-    let exportsData: ExportsData
-    try {
-      exportsData = parse(entryContent) as ExportsData
-    } catch {
-      debug(
-        `Unable to parse dependency: ${id}. Trying again with a JSX transform.`
-      )
-      const transformed = await transformWithEsbuild(entryContent, filePath, {
-        loader: 'jsx'
-      })
-      // Ensure that optimization won't fail by defaulting '.js' to the JSX parser.
-      // This is useful for packages such as Gatsby.
-      esbuildOptions.loader = {
-        '.js': 'jsx',
-        ...esbuildOptions.loader
-      }
-      exportsData = parse(transformed.code) as ExportsData
-    }
-    for (const { ss, se } of exportsData[0]) {
-      const exp = entryContent.slice(ss, se)
-      if (/export\s+\*\s+from/.test(exp)) {
-        exportsData.hasReExports = true
-      }
-    }
-    idToExports[id] = exportsData
-    flatIdToExports[flatId] = exportsData
-  }
-
-  const define: Record<string, string> = {
-    'process.env.NODE_ENV': JSON.stringify(config.mode)
-  }
-  for (const key in config.define) {
-    const value = config.define[key]
-    define[key] = typeof value === 'string' ? value : JSON.stringify(value)
-  }
-
-  const start = Date.now()
-
-  const result = await build({
-    absWorkingDir: process.cwd(),
-    entryPoints: Object.keys(flatIdDeps),
-    bundle: true,
-    format: 'esm',
-    external: config.optimizeDeps?.exclude,
-    logLevel: 'error',
-    splitting: true,
-    sourcemap: true,
-    outdir: cacheDir,
-    treeShaking: 'ignore-annotations',
-    metafile: true,
-    define,
-    plugins: [
-      ...plugins,
-      esbuildDepPlugin(flatIdDeps, flatIdToExports, config, ssr)
-    ],
-    ...esbuildOptions
-  })
-
-  const meta = result.metafile!
-
-  // the paths in `meta.outputs` are relative to `process.cwd()`
-  const cacheDirOutputPath = path.relative(process.cwd(), cacheDir)
-
-  for (const id in deps) {
-    const entry = deps[id]
-    data.optimized[id] = {
-      file: normalizePath(path.resolve(cacheDir, flattenId(id) + '.js')),
-      src: entry,
-      needsInterop: needsInterop(
-        id,
-        idToExports[id],
-        meta.outputs,
-        cacheDirOutputPath
-      )
-    }
-  }
-
-  writeFile(dataPath, JSON.stringify(data, null, 2))
-
-  debug(`deps bundled in ${Date.now() - start}ms`)
-  return data
-}
-
-// https://github.com/vitejs/vite/issues/1724#issuecomment-767619642
-// a list of modules that pretends to be ESM but still uses `require`.
-// this causes esbuild to wrap them as CJS even when its entry appears to be ESM.
-const KNOWN_INTEROP_IDS = new Set(['moment'])
-
-function needsInterop(
-  id: string,
-  exportsData: ExportsData,
-  outputs: Record<string, any>,
-  cacheDirOutputPath: string
-): boolean {
-  if (KNOWN_INTEROP_IDS.has(id)) {
-    return true
-  }
-  const [imports, exports] = exportsData
-  // entry has no ESM syntax - likely CJS or UMD
-  if (!exports.length && !imports.length) {
-    return true
-  }
-
-  // if a peer dependency used require() on a ESM dependency, esbuild turns the
-  // ESM dependency's entry chunk into a single default export... detect
-  // such cases by checking exports mismatch, and force interop.
-  const flatId = flattenId(id) + '.js'
-  let generatedExports: string[] | undefined
-  for (const output in outputs) {
-    if (
-      normalizePath(output) ===
-      normalizePath(path.join(cacheDirOutputPath, flatId))
-    ) {
-      generatedExports = outputs[output].exports
-      break
-    }
-  }
-
-  if (
-    !generatedExports ||
-    (isSingleDefaultExport(generatedExports) && !isSingleDefaultExport(exports))
-  ) {
-    return true
-  }
-  return false
-}
-
-function isSingleDefaultExport(exports: string[]) {
-  return exports.length === 1 && exports[0] === 'default'
-}
-
-const lockfileFormats = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml']
-
-function getDepHash(root: string, config: ResolvedConfig): string {
-  let content = lookupFile(root, lockfileFormats) || ''
-  // also take config into account
-  // only a subset of config options that can affect dep optimization
-  content += JSON.stringify(
-    {
-      mode: config.mode,
-      root: config.root,
-      resolve: config.resolve,
-      assetsInclude: config.assetsInclude,
-      plugins: config.plugins.map((p) => p.name),
-      optimizeDeps: {
-        include: config.optimizeDeps?.include,
-        exclude: config.optimizeDeps?.exclude
-      }
-    },
-    (_, value) => {
-      if (typeof value === 'function' || value instanceof RegExp) {
-        return value.toString()
-      }
-      return value
-    }
-  )
-  return createHash('sha256').update(content).digest('hex').substr(0, 8)
-}