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

package/src/node/constants.ts

@@ -1,87 +0,0 @@
-import path from 'path'
-
-export const DEFAULT_MAIN_FIELDS = [
-  'module',
-  'jsnext:main', // moment still uses this...
-  'jsnext'
-]
-
-export const DEFAULT_EXTENSIONS = [
-  '.mjs',
-  '.js',
-  '.ts',
-  '.jsx',
-  '.tsx',
-  '.json'
-]
-
-export const JS_TYPES_RE = /\.(?:j|t)sx?$|\.mjs$/
-
-export const OPTIMIZABLE_ENTRY_RE = /\.(?:m?js|ts)$/
-
-export const SPECIAL_QUERY_RE = /[\?&](?:worker|sharedworker|raw|url)\b/
-
-/**
- * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
- */
-export const FS_PREFIX = `/@fs/`
-
-/**
- * Prefix for resolved Ids that are not valid browser import specifiers
- */
-export const VALID_ID_PREFIX = `/@id/`
-
-/**
- * Some Rollup plugins use ids that starts with the null byte \0 to avoid
- * collisions, but it is not permitted in import URLs so we have to replace
- * them.
- */
-export const NULL_BYTE_PLACEHOLDER = `__x00__`
-
-export const CLIENT_PUBLIC_PATH = `/@vite/client`
-export const ENV_PUBLIC_PATH = `/@vite/env`
-// eslint-disable-next-line node/no-missing-require
-export const CLIENT_ENTRY = require.resolve('vite/dist/client/client.mjs')
-// eslint-disable-next-line node/no-missing-require
-export const ENV_ENTRY = require.resolve('vite/dist/client/env.mjs')
-export const CLIENT_DIR = path.dirname(CLIENT_ENTRY)
-
-// ** READ THIS ** before editing `KNOWN_ASSET_TYPES`.
-//   If you add an asset to `KNOWN_ASSET_TYPES`, make sure to also add it
-//   to the TypeScript declaration file `packages/vite/client.d.ts`.
-export const KNOWN_ASSET_TYPES = [
-  // images
-  'png',
-  'jpe?g',
-  'gif',
-  'svg',
-  'ico',
-  'webp',
-  'avif',
-
-  // media
-  'mp4',
-  'webm',
-  'ogg',
-  'mp3',
-  'wav',
-  'flac',
-  'aac',
-
-  // fonts
-  'woff2?',
-  'eot',
-  'ttf',
-  'otf',
-
-  // other
-  'wasm',
-  'webmanifest',
-  'pdf'
-]
-
-export const DEFAULT_ASSETS_RE = new RegExp(
-  `\\.(` + KNOWN_ASSET_TYPES.join('|') + `)(\\?.*)?$`
-)
-
-export const DEP_VERSION_RE = /[\?&](v=[\w\.-]+)\b/

package/src/node/importGlob.ts

@@ -1,173 +0,0 @@
-import path from 'path'
-import glob from 'fast-glob'
-import {
-  isModernFlag,
-  preloadMethod,
-  preloadMarker
-} from './plugins/importAnalysisBuild'
-import { cleanUrl } from './utils'
-import { RollupError } from 'rollup'
-
-export async function transformImportGlob(
-  source: string,
-  pos: number,
-  importer: string,
-  importIndex: number,
-  root: string,
-  normalizeUrl?: (url: string, pos: number) => Promise<[string, string]>,
-  preload = true
-): Promise<{
-  importsString: string
-  imports: string[]
-  exp: string
-  endIndex: number
-  isEager: boolean
-  pattern: string
-  base: string
-}> {
-  const isEager = source.slice(pos, pos + 21) === 'import.meta.globEager'
-  const isEagerDefault =
-    isEager && source.slice(pos + 21, pos + 28) === 'Default'
-
-  const err = (msg: string) => {
-    const e = new Error(`Invalid glob import syntax: ${msg}`)
-    ;(e as any).pos = pos
-    return e
-  }
-
-  importer = cleanUrl(importer)
-  const importerBasename = path.basename(importer)
-
-  let [pattern, endIndex] = lexGlobPattern(source, pos)
-  if (!pattern.startsWith('.') && !pattern.startsWith('/')) {
-    throw err(`pattern must start with "." or "/" (relative to project root)`)
-  }
-  let base: string
-  let parentDepth = 0
-  const isAbsolute = pattern.startsWith('/')
-  if (isAbsolute) {
-    base = path.resolve(root)
-    pattern = pattern.slice(1)
-  } else {
-    base = path.dirname(importer)
-    while (pattern.startsWith('../')) {
-      pattern = pattern.slice(3)
-      base = path.resolve(base, '../')
-      parentDepth++
-    }
-    if (pattern.startsWith('./')) {
-      pattern = pattern.slice(2)
-    }
-  }
-  const files = glob.sync(pattern, {
-    cwd: base,
-    ignore: ['**/node_modules/**']
-  })
-  const imports: string[] = []
-  let importsString = ``
-  let entries = ``
-  for (let i = 0; i < files.length; i++) {
-    // skip importer itself
-    if (files[i] === importerBasename) continue
-    const file = isAbsolute
-      ? `/${files[i]}`
-      : parentDepth
-      ? `${'../'.repeat(parentDepth)}${files[i]}`
-      : `./${files[i]}`
-    let importee = file
-    if (normalizeUrl) {
-      ;[importee] = await normalizeUrl(file, pos)
-    }
-    imports.push(importee)
-    const identifier = `__glob_${importIndex}_${i}`
-    if (isEager) {
-      importsString += `import ${
-        isEagerDefault ? `` : `* as `
-      }${identifier} from ${JSON.stringify(importee)};`
-      entries += ` ${JSON.stringify(file)}: ${identifier},`
-    } else {
-      let imp = `import(${JSON.stringify(importee)})`
-      if (!normalizeUrl && preload) {
-        imp =
-          `(${isModernFlag}` +
-          `? ${preloadMethod}(()=>${imp},"${preloadMarker}")` +
-          `: ${imp})`
-      }
-      entries += ` ${JSON.stringify(file)}: () => ${imp},`
-    }
-  }
-
-  return {
-    imports,
-    importsString,
-    exp: `{${entries}}`,
-    endIndex,
-    isEager,
-    pattern,
-    base
-  }
-}
-
-const enum LexerState {
-  inCall,
-  inSingleQuoteString,
-  inDoubleQuoteString,
-  inTemplateString
-}
-
-function lexGlobPattern(code: string, pos: number): [string, number] {
-  let state = LexerState.inCall
-  let pattern = ''
-
-  let i = code.indexOf(`(`, pos) + 1
-  outer: for (; i < code.length; i++) {
-    const char = code.charAt(i)
-    switch (state) {
-      case LexerState.inCall:
-        if (char === `'`) {
-          state = LexerState.inSingleQuoteString
-        } else if (char === `"`) {
-          state = LexerState.inDoubleQuoteString
-        } else if (char === '`') {
-          state = LexerState.inTemplateString
-        } else if (/\s/.test(char)) {
-          continue
-        } else {
-          error(i)
-        }
-        break
-      case LexerState.inSingleQuoteString:
-        if (char === `'`) {
-          break outer
-        } else {
-          pattern += char
-        }
-        break
-      case LexerState.inDoubleQuoteString:
-        if (char === `"`) {
-          break outer
-        } else {
-          pattern += char
-        }
-        break
-      case LexerState.inTemplateString:
-        if (char === '`') {
-          break outer
-        } else {
-          pattern += char
-        }
-        break
-      default:
-        throw new Error('unknown import.meta.glob lexer state')
-    }
-  }
-  return [pattern, code.indexOf(`)`, i) + 1]
-}
-
-function error(pos: number) {
-  const err = new Error(
-    `import.meta.glob() can only accept string literals.`
-  ) as RollupError
-  err.pos = pos
-  throw err
-}

package/src/node/index.ts

@@ -1,88 +0,0 @@
-export * from './config'
-export { createServer } from './server'
-export { build } from './build'
-export { optimizeDeps } from './optimizer'
-export { send } from './server/send'
-export { createLogger } from './logger'
-export { transformWithEsbuild } from './plugins/esbuild'
-export { resolvePackageData, resolvePackageEntry } from './plugins/resolve'
-export { normalizePath } from './utils'
-
-// additional types
-export type {
-  ViteDevServer,
-  ServerOptions,
-  CorsOptions,
-  FileSystemServeOptions,
-  CorsOrigin,
-  ServerHook,
-  ResolvedServerOptions
-} from './server'
-export type {
-  BuildOptions,
-  LibraryOptions,
-  LibraryFormats,
-  ResolvedBuildOptions
-} from './build'
-export type {
-  DepOptimizationMetadata,
-  DepOptimizationOptions
-} from './optimizer'
-export type { Plugin } from './plugin'
-export type {
-  Logger,
-  LogOptions,
-  LogErrorOptions,
-  LogLevel,
-  LogType,
-  LoggerOptions
-} from './logger'
-export type {
-  AliasOptions,
-  ResolverFunction,
-  ResolverObject,
-  Alias
-} from 'types/alias'
-export type {
-  IndexHtmlTransform,
-  IndexHtmlTransformHook,
-  IndexHtmlTransformContext,
-  IndexHtmlTransformResult,
-  HtmlTagDescriptor
-} from './plugins/html'
-export type { CSSOptions, CSSModulesOptions } from './plugins/css'
-export type { JsonOptions } from './plugins/json'
-export type { TransformOptions as EsbuildTransformOptions } from 'esbuild'
-export type { ESBuildOptions, ESBuildTransformResult } from './plugins/esbuild'
-export type { Manifest, ManifestChunk } from './plugins/manifest'
-export type {
-  PackageData,
-  ResolveOptions,
-  InternalResolveOptions
-} from './plugins/resolve'
-export type { WebSocketServer } from './server/ws'
-export type { PluginContainer } from './server/pluginContainer'
-export type { ModuleGraph, ModuleNode } from './server/moduleGraph'
-export type { ProxyOptions } from './server/middlewares/proxy'
-export type {
-  TransformOptions,
-  TransformResult
-} from './server/transformRequest'
-export type { HmrOptions, HmrContext } from './server/hmr'
-export type {
-  HMRPayload,
-  ConnectedPayload,
-  UpdatePayload,
-  Update,
-  FullReloadPayload,
-  CustomPayload,
-  PrunePayload,
-  ErrorPayload
-} from 'types/hmrPayload'
-export type { Connect } from 'types/connect'
-export type { HttpProxy } from 'types/http-proxy'
-export type { FSWatcher, WatchOptions } from 'types/chokidar'
-export type { Terser } from 'types/terser'
-export type { RollupCommonJSOptions } from 'types/commonjs'
-export type { RollupDynamicImportVarsOptions } from 'types/dynamicImportVars'
-export type { Matcher, AnymatchPattern, AnymatchFn } from 'types/anymatch'

package/src/node/logger.ts

@@ -1,167 +0,0 @@
-/* eslint no-console: 0 */
-
-import chalk from 'chalk'
-import readline from 'readline'
-import os from 'os'
-import { RollupError } from 'rollup'
-import { Hostname } from './utils'
-
-export type LogType = 'error' | 'warn' | 'info'
-export type LogLevel = LogType | 'silent'
-export interface Logger {
-  info(msg: string, options?: LogOptions): void
-  warn(msg: string, options?: LogOptions): void
-  warnOnce(msg: string, options?: LogOptions): void
-  error(msg: string, options?: LogErrorOptions): void
-  clearScreen(type: LogType): void
-  hasErrorLogged(error: Error | RollupError): boolean
-  hasWarned: boolean
-}
-
-export interface LogOptions {
-  clear?: boolean
-  timestamp?: boolean
-}
-
-export interface LogErrorOptions extends LogOptions {
-  error?: Error | RollupError | null
-}
-
-export const LogLevels: Record<LogLevel, number> = {
-  silent: 0,
-  error: 1,
-  warn: 2,
-  info: 3
-}
-
-let lastType: LogType | undefined
-let lastMsg: string | undefined
-let sameCount = 0
-
-function clearScreen() {
-  const repeatCount = process.stdout.rows - 2
-  const blank = repeatCount > 0 ? '\n'.repeat(repeatCount) : ''
-  console.log(blank)
-  readline.cursorTo(process.stdout, 0, 0)
-  readline.clearScreenDown(process.stdout)
-}
-
-export interface LoggerOptions {
-  prefix?: string
-  allowClearScreen?: boolean
-  customLogger?: Logger
-}
-
-export function createLogger(
-  level: LogLevel = 'info',
-  options: LoggerOptions = {}
-): Logger {
-  if (options.customLogger) {
-    return options.customLogger
-  }
-
-  const loggedErrors = new WeakSet<Error | RollupError>()
-  const { prefix = '[vite]', allowClearScreen = true } = options
-  const thresh = LogLevels[level]
-  const clear =
-    allowClearScreen && process.stdout.isTTY && !process.env.CI
-      ? clearScreen
-      : () => {}
-
-  function output(type: LogType, msg: string, options: LogErrorOptions = {}) {
-    if (thresh >= LogLevels[type]) {
-      const method = type === 'info' ? 'log' : type
-      const format = () => {
-        if (options.timestamp) {
-          const tag =
-            type === 'info'
-              ? chalk.cyan.bold(prefix)
-              : type === 'warn'
-              ? chalk.yellow.bold(prefix)
-              : chalk.red.bold(prefix)
-          return `${chalk.dim(new Date().toLocaleTimeString())} ${tag} ${msg}`
-        } else {
-          return msg
-        }
-      }
-      if (options.error) {
-        loggedErrors.add(options.error)
-      }
-      if (type === lastType && msg === lastMsg) {
-        sameCount++
-        clear()
-        console[method](format(), chalk.yellow(`(x${sameCount + 1})`))
-      } else {
-        sameCount = 0
-        lastMsg = msg
-        lastType = type
-        if (options.clear) {
-          clear()
-        }
-        console[method](format())
-      }
-    }
-  }
-
-  const warnedMessages = new Set<string>()
-
-  const logger: Logger = {
-    hasWarned: false,
-    info(msg, opts) {
-      output('info', msg, opts)
-    },
-    warn(msg, opts) {
-      logger.hasWarned = true
-      output('warn', msg, opts)
-    },
-    warnOnce(msg, opts) {
-      if (warnedMessages.has(msg)) return
-      logger.hasWarned = true
-      output('warn', msg, opts)
-      warnedMessages.add(msg)
-    },
-    error(msg, opts) {
-      logger.hasWarned = true
-      output('error', msg, opts)
-    },
-    clearScreen(type) {
-      if (thresh >= LogLevels[type]) {
-        clear()
-      }
-    },
-    hasErrorLogged(error) {
-      return loggedErrors.has(error)
-    }
-  }
-
-  return logger
-}
-
-export function printServerUrls(
-  hostname: Hostname,
-  protocol: string,
-  port: number,
-  base: string,
-  info: Logger['info']
-): void {
-  if (hostname.host === '127.0.0.1') {
-    const url = `${protocol}://${hostname.name}:${chalk.bold(port)}${base}`
-    info(`  > Local: ${chalk.cyan(url)}`)
-    if (hostname.name !== '127.0.0.1') {
-      info(`  > Network: ${chalk.dim('use `--host` to expose')}`)
-    }
-  } else {
-    Object.values(os.networkInterfaces())
-      .flatMap((nInterface) => nInterface ?? [])
-      .filter((detail) => detail.family === 'IPv4')
-      .map((detail) => {
-        const type = detail.address.includes('127.0.0.1')
-          ? 'Local:   '
-          : 'Network: '
-        const host = detail.address.replace('127.0.0.1', hostname.name)
-        const url = `${protocol}://${host}:${chalk.bold(port)}${base}`
-        return `  > ${type} ${chalk.cyan(url)}`
-      })
-      .forEach((msg) => info(msg))
-  }
-}