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

package/src/node/optimizer/registerMissing.ts

@@ -1,102 +0,0 @@
-import chalk from 'chalk'
-import { optimizeDeps } from '.'
-import { ViteDevServer } from '..'
-import { resolveSSRExternal } from '../ssr/ssrExternal'
-
-/**
- * The amount to wait for requests to register newly found dependencies before triggering
- * a re-bundle + page reload
- */
-const debounceMs = 100
-
-export function createMissingImporterRegisterFn(
-  server: ViteDevServer
-): (id: string, resolved: string, ssr?: boolean) => void {
-  const { logger } = server.config
-  let knownOptimized = server._optimizeDepsMetadata!.optimized
-  let currentMissing: Record<string, string> = {}
-  let handle: NodeJS.Timeout
-
-  let pendingResolve: (() => void) | null = null
-
-  async function rerun(ssr: boolean | undefined) {
-    const newDeps = currentMissing
-    currentMissing = {}
-
-    logger.info(
-      chalk.yellow(
-        `new dependencies found: ${Object.keys(newDeps).join(
-          ', '
-        )}, updating...`
-      ),
-      {
-        timestamp: true
-      }
-    )
-
-    for (const id in knownOptimized) {
-      newDeps[id] = knownOptimized[id].src
-    }
-
-    try {
-      // Nullify previous metadata so that the resolver won't
-      // resolve to optimized files during the optimizer re-run
-      server._isRunningOptimizer = true
-      server._optimizeDepsMetadata = null
-
-      const newData = (server._optimizeDepsMetadata = await optimizeDeps(
-        server.config,
-        true,
-        false,
-        newDeps,
-        ssr
-      ))
-      knownOptimized = newData!.optimized
-
-      // update ssr externals
-      server._ssrExternals = resolveSSRExternal(
-        server.config,
-        Object.keys(knownOptimized)
-      )
-
-      logger.info(
-        chalk.greenBright(`✨ dependencies updated, reloading page...`),
-        { timestamp: true }
-      )
-    } catch (e) {
-      logger.error(
-        chalk.red(`error while updating dependencies:\n${e.stack}`),
-        { timestamp: true, error: e }
-      )
-    } finally {
-      server._isRunningOptimizer = false
-      pendingResolve && pendingResolve()
-      server._pendingReload = pendingResolve = null
-    }
-
-    // Cached transform results have stale imports (resolved to
-    // old locations) so they need to be invalidated before the page is
-    // reloaded.
-    server.moduleGraph.invalidateAll()
-
-    server.ws.send({
-      type: 'full-reload',
-      path: '*'
-    })
-  }
-
-  return function registerMissingImport(
-    id: string,
-    resolved: string,
-    ssr?: boolean
-  ) {
-    if (!knownOptimized[id]) {
-      currentMissing[id] = resolved
-      if (handle) clearTimeout(handle)
-      handle = setTimeout(() => rerun(ssr), debounceMs)
-      server._pendingReload = new Promise((r) => {
-        pendingResolve = r
-      })
-    }
-  }
-}

package/src/node/optimizer/scan.ts

@@ -1,457 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import glob from 'fast-glob'
-import { ResolvedConfig } from '..'
-import { Loader, Plugin, build, transform } from 'esbuild'
-import {
-  KNOWN_ASSET_TYPES,
-  JS_TYPES_RE,
-  SPECIAL_QUERY_RE,
-  OPTIMIZABLE_ENTRY_RE
-} from '../constants'
-import {
-  createDebugger,
-  normalizePath,
-  isObject,
-  cleanUrl,
-  externalRE,
-  dataUrlRE,
-  multilineCommentsRE,
-  singlelineCommentsRE
-} from '../utils'
-import {
-  createPluginContainer,
-  PluginContainer
-} from '../server/pluginContainer'
-import { init, parse } from 'es-module-lexer'
-import MagicString from 'magic-string'
-import { transformImportGlob } from '../importGlob'
-
-const debug = createDebugger('vite:deps')
-
-const htmlTypesRE = /\.(html|vue|svelte)$/
-
-// A simple regex to detect import sources. This is only used on
-// <script lang="ts"> blocks in vue (setup only) or svelte files, since
-// seemingly unused imports are dropped by esbuild when transpiling TS which
-// prevents it from crawling further.
-// We can't use es-module-lexer because it can't handle TS, and don't want to
-// use Acorn because it's slow. Luckily this doesn't have to be bullet proof
-// since even missed imports can be caught at runtime, and false positives will
-// simply be ignored.
-export const importsRE =
-  /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type)(?:[\w*{}\n\r\t, ]+from\s*)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm
-
-export async function scanImports(config: ResolvedConfig): Promise<{
-  deps: Record<string, string>
-  missing: Record<string, string>
-}> {
-  const s = Date.now()
-
-  let entries: string[] = []
-
-  const explicitEntryPatterns = config.optimizeDeps?.entries
-  const buildInput = config.build.rollupOptions?.input
-
-  if (explicitEntryPatterns) {
-    entries = await globEntries(explicitEntryPatterns, config)
-  } else if (buildInput) {
-    const resolvePath = (p: string) => path.resolve(config.root, p)
-    if (typeof buildInput === 'string') {
-      entries = [resolvePath(buildInput)]
-    } else if (Array.isArray(buildInput)) {
-      entries = buildInput.map(resolvePath)
-    } else if (isObject(buildInput)) {
-      entries = Object.values(buildInput).map(resolvePath)
-    } else {
-      throw new Error('invalid rollupOptions.input value.')
-    }
-  } else {
-    entries = await globEntries('**/*.html', config)
-  }
-
-  // Non-supported entry file types and virtual files should not be scanned for
-  // dependencies.
-  entries = entries.filter(
-    (entry) =>
-      (JS_TYPES_RE.test(entry) || htmlTypesRE.test(entry)) &&
-      fs.existsSync(entry)
-  )
-
-  if (!entries.length) {
-    config.logger.warn(
-      'Could not determine entry point from rollupOptions or html files. Skipping dependency pre-bundling.'
-    )
-    return { deps: {}, missing: {} }
-  } else {
-    debug(`Crawling dependencies using entries:\n  ${entries.join('\n  ')}`)
-  }
-
-  const deps: Record<string, string> = {}
-  const missing: Record<string, string> = {}
-  const container = await createPluginContainer(config)
-  const plugin = esbuildScanPlugin(config, container, deps, missing, entries)
-
-  const { plugins = [], ...esbuildOptions } =
-    config.optimizeDeps?.esbuildOptions ?? {}
-
-  await Promise.all(
-    entries.map((entry) =>
-      build({
-        absWorkingDir: process.cwd(),
-        write: false,
-        entryPoints: [entry],
-        bundle: true,
-        format: 'esm',
-        logLevel: 'error',
-        plugins: [...plugins, plugin],
-        ...esbuildOptions
-      })
-    )
-  )
-
-  debug(`Scan completed in ${Date.now() - s}ms:`, deps)
-
-  return {
-    deps,
-    missing
-  }
-}
-
-function globEntries(pattern: string | string[], config: ResolvedConfig) {
-  return glob(pattern, {
-    cwd: config.root,
-    ignore: [
-      '**/node_modules/**',
-      `**/${config.build.outDir}/**`,
-      `**/__tests__/**`
-    ],
-    absolute: true
-  })
-}
-
-const scriptModuleRE =
-  /(<script\b[^>]*type\s*=\s*(?:"module"|'module')[^>]*>)(.*?)<\/script>/gims
-export const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims
-export const commentRE = /<!--(.|[\r\n])*?-->/
-const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im
-const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im
-const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im
-
-function esbuildScanPlugin(
-  config: ResolvedConfig,
-  container: PluginContainer,
-  depImports: Record<string, string>,
-  missing: Record<string, string>,
-  entries: string[]
-): Plugin {
-  const seen = new Map<string, string | undefined>()
-
-  const resolve = async (id: string, importer?: string) => {
-    const key = id + (importer && path.dirname(importer))
-    if (seen.has(key)) {
-      return seen.get(key)
-    }
-    const resolved = await container.resolveId(
-      id,
-      importer && normalizePath(importer)
-    )
-    const res = resolved?.id
-    seen.set(key, res)
-    return res
-  }
-
-  const include = config.optimizeDeps?.include
-  const exclude = [
-    ...(config.optimizeDeps?.exclude || []),
-    '@vite/client',
-    '@vite/env'
-  ]
-
-  const externalUnlessEntry = ({ path }: { path: string }) => ({
-    path,
-    external: !entries.includes(path)
-  })
-
-  return {
-    name: 'vite:dep-scan',
-    setup(build) {
-      // external urls
-      build.onResolve({ filter: externalRE }, ({ path }) => ({
-        path,
-        external: true
-      }))
-
-      // data urls
-      build.onResolve({ filter: dataUrlRE }, ({ path }) => ({
-        path,
-        external: true
-      }))
-
-      // html types: extract script contents -----------------------------------
-      build.onResolve({ filter: htmlTypesRE }, async ({ path, importer }) => {
-        return {
-          path: await resolve(path, importer),
-          namespace: 'html'
-        }
-      })
-
-      // extract scripts inside HTML-like files and treat it as a js module
-      build.onLoad(
-        { filter: htmlTypesRE, namespace: 'html' },
-        async ({ path }) => {
-          let raw = fs.readFileSync(path, 'utf-8')
-          // Avoid matching the content of the comment
-          raw = raw.replace(commentRE, '<!---->')
-          const isHtml = path.endsWith('.html')
-          const regex = isHtml ? scriptModuleRE : scriptRE
-          regex.lastIndex = 0
-          let js = ''
-          let loader: Loader = 'js'
-          let match: RegExpExecArray | null
-          while ((match = regex.exec(raw))) {
-            const [, openTag, content] = match
-            const srcMatch = openTag.match(srcRE)
-            const typeMatch = openTag.match(typeRE)
-            const langMatch = openTag.match(langRE)
-            const type =
-              typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3])
-            const lang =
-              langMatch && (langMatch[1] || langMatch[2] || langMatch[3])
-            // skip type="application/ld+json" and other non-JS types
-            if (
-              type &&
-              !(
-                type.includes('javascript') ||
-                type.includes('ecmascript') ||
-                type === 'module'
-              )
-            ) {
-              continue
-            }
-            if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
-              loader = lang
-            }
-            if (srcMatch) {
-              const src = srcMatch[1] || srcMatch[2] || srcMatch[3]
-              js += `import ${JSON.stringify(src)}\n`
-            } else if (content.trim()) {
-              js += content + '\n'
-            }
-          }
-          // empty singleline & multiline comments to avoid matching comments
-          const code = js
-            .replace(multilineCommentsRE, '/* */')
-            .replace(singlelineCommentsRE, '')
-
-          if (
-            loader.startsWith('ts') &&
-            (path.endsWith('.svelte') ||
-              (path.endsWith('.vue') && /<script\s+setup/.test(raw)))
-          ) {
-            // when using TS + (Vue + <script setup>) or Svelte, imports may seem
-            // unused to esbuild and dropped in the build output, which prevents
-            // esbuild from crawling further.
-            // the solution is to add `import 'x'` for every source to force
-            // esbuild to keep crawling due to potential side effects.
-            let m
-            while ((m = importsRE.exec(code)) != null) {
-              // This is necessary to avoid infinite loops with zero-width matches
-              if (m.index === importsRE.lastIndex) {
-                importsRE.lastIndex++
-              }
-              js += `\nimport ${m[1]}`
-            }
-          }
-
-          if (!code.includes(`export default`)) {
-            js += `\nexport default {}`
-          }
-
-          if (code.includes('import.meta.glob')) {
-            return {
-              // transformGlob already transforms to js
-              loader: 'js',
-              contents: await transformGlob(js, path, config.root, loader)
-            }
-          }
-
-          return {
-            loader,
-            contents: js
-          }
-        }
-      )
-
-      // bare imports: record and externalize ----------------------------------
-      build.onResolve(
-        {
-          // avoid matching windows volume
-          filter: /^[\w@][^:]/
-        },
-        async ({ path: id, importer }) => {
-          if (exclude?.some((e) => e === id || id.startsWith(e + '/'))) {
-            return externalUnlessEntry({ path: id })
-          }
-          if (depImports[id]) {
-            return externalUnlessEntry({ path: id })
-          }
-          const resolved = await resolve(id, importer)
-          if (resolved) {
-            if (shouldExternalizeDep(resolved, id)) {
-              return externalUnlessEntry({ path: id })
-            }
-            if (resolved.includes('node_modules') || include?.includes(id)) {
-              // dependency or forced included, externalize and stop crawling
-              if (OPTIMIZABLE_ENTRY_RE.test(resolved)) {
-                depImports[id] = resolved
-              }
-              return externalUnlessEntry({ path: id })
-            } else {
-              const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined
-              // linked package, keep crawling
-              return {
-                path: path.resolve(resolved),
-                namespace
-              }
-            }
-          } else {
-            missing[id] = normalizePath(importer)
-          }
-        }
-      )
-
-      // Externalized file types -----------------------------------------------
-      // these are done on raw ids using esbuild's native regex filter so it
-      // should be faster than doing it in the catch-all via js
-      // they are done after the bare import resolve because a package name
-      // may end with these extensions
-
-      // css & json
-      build.onResolve(
-        {
-          filter: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|json)$/
-        },
-        externalUnlessEntry
-      )
-
-      // known asset types
-      build.onResolve(
-        {
-          filter: new RegExp(`\\.(${KNOWN_ASSET_TYPES.join('|')})$`)
-        },
-        externalUnlessEntry
-      )
-
-      // known vite query types: ?worker, ?raw
-      build.onResolve({ filter: SPECIAL_QUERY_RE }, ({ path }) => ({
-        path,
-        external: true
-      }))
-
-      // catch all -------------------------------------------------------------
-
-      build.onResolve(
-        {
-          filter: /.*/
-        },
-        async ({ path: id, importer }) => {
-          // use vite resolver to support urls and omitted extensions
-          const resolved = await resolve(id, importer)
-          if (resolved) {
-            if (shouldExternalizeDep(resolved, id)) {
-              return externalUnlessEntry({ path: id })
-            }
-
-            const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined
-
-            return {
-              path: path.resolve(cleanUrl(resolved)),
-              namespace
-            }
-          } else {
-            // resolve failed... probably unsupported type
-            return externalUnlessEntry({ path: id })
-          }
-        }
-      )
-
-      // for jsx/tsx, we need to access the content and check for
-      // presence of import.meta.glob, since it results in import relationships
-      // but isn't crawled by esbuild.
-      build.onLoad({ filter: JS_TYPES_RE }, ({ path: id }) => {
-        let ext = path.extname(id).slice(1)
-        if (ext === 'mjs') ext = 'js'
-
-        let contents = fs.readFileSync(id, 'utf-8')
-        if (ext.endsWith('x') && config.esbuild && config.esbuild.jsxInject) {
-          contents = config.esbuild.jsxInject + `\n` + contents
-        }
-
-        if (contents.includes('import.meta.glob')) {
-          return transformGlob(contents, id, config.root, ext as Loader).then(
-            (contents) => ({
-              loader: ext as Loader,
-              contents
-            })
-          )
-        }
-        return {
-          loader: ext as Loader,
-          contents
-        }
-      })
-    }
-  }
-}
-
-async function transformGlob(
-  source: string,
-  importer: string,
-  root: string,
-  loader: Loader
-) {
-  // transform the content first since es-module-lexer can't handle non-js
-  if (loader !== 'js') {
-    source = (await transform(source, { loader })).code
-  }
-
-  await init
-  const imports = parse(source)[0]
-  const s = new MagicString(source)
-  for (let index = 0; index < imports.length; index++) {
-    const { s: start, e: end, ss: expStart } = imports[index]
-    const url = source.slice(start, end)
-    if (url !== 'import.meta') continue
-    if (source.slice(end, end + 5) !== '.glob') continue
-    const { importsString, exp, endIndex } = await transformImportGlob(
-      source,
-      start,
-      normalizePath(importer),
-      index,
-      root
-    )
-    s.prepend(importsString)
-    s.overwrite(expStart, endIndex, exp)
-  }
-  return s.toString()
-}
-
-export function shouldExternalizeDep(
-  resolvedId: string,
-  rawId: string
-): boolean {
-  // not a valid file path
-  if (!path.isAbsolute(resolvedId)) {
-    return true
-  }
-  // virtual id
-  if (resolvedId === rawId || resolvedId.includes('\0')) {
-    return true
-  }
-  // resolved is not a scannable type
-  if (!JS_TYPES_RE.test(resolvedId) && !htmlTypesRE.test(resolvedId)) {
-    return true
-  }
-  return false
-}

package/src/node/plugin.ts

@@ -1,138 +0,0 @@
-import { UserConfig } from './config'
-import {
-  CustomPluginOptions,
-  LoadResult,
-  Plugin as RollupPlugin,
-  PluginContext,
-  ResolveIdResult,
-  TransformPluginContext,
-  TransformResult
-} from 'rollup'
-import { ServerHook } from './server'
-import { IndexHtmlTransform } from './plugins/html'
-import { ModuleNode } from './server/moduleGraph'
-import { ConfigEnv, ResolvedConfig } from './'
-import { HmrContext } from './server/hmr'
-
-/**
- * Vite plugins extends the Rollup plugin interface with a few extra
- * vite-specific options. A valid vite plugin is also a valid Rollup plugin.
- * On the contrary, a Rollup plugin may or may NOT be a valid vite universal
- * plugin, since some Rollup features do not make sense in an unbundled
- * dev server context. That said, as long as a rollup plugin doesn't have strong
- * coupling between its bundle phase and output phase hooks then it should
- * just work (that means, most of them).
- *
- * By default, the plugins are run during both serve and build. When a plugin
- * is applied during serve, it will only run **non output plugin hooks** (see
- * rollup type definition of {@link rollup#PluginHooks}). You can think of the
- * dev server as only running `const bundle = rollup.rollup()` but never calling
- * `bundle.generate()`.
- *
- * A plugin that expects to have different behavior depending on serve/build can
- * export a factory function that receives the command being run via options.
- *
- * If a plugin should be applied only for server or build, a function format
- * config file can be used to conditional determine the plugins to use.
- */
-export interface Plugin extends RollupPlugin {
-  /**
-   * Enforce plugin invocation tier similar to webpack loaders.
-   *
-   * Plugin invocation order:
-   * - alias resolution
-   * - `enforce: 'pre'` plugins
-   * - vite core plugins
-   * - normal plugins
-   * - vite build plugins
-   * - `enforce: 'post'` plugins
-   * - vite build post plugins
-   */
-  enforce?: 'pre' | 'post'
-  /**
-   * Apply the plugin only for serve or build, or on certain conditions.
-   */
-  apply?: 'serve' | 'build' | ((config: UserConfig, env: ConfigEnv) => boolean)
-  /**
-   * Modify vite config before it's resolved. The hook can either mutate the
-   * passed-in config directly, or return a partial config object that will be
-   * deeply merged into existing config.
-   *
-   * Note: User plugins are resolved before running this hook so injecting other
-   * plugins inside  the `config` hook will have no effect.
-   */
-  config?: (
-    config: UserConfig,
-    env: ConfigEnv
-  ) => UserConfig | null | void | Promise<UserConfig | null | void>
-  /**
-   * Use this hook to read and store the final resolved vite config.
-   */
-  configResolved?: (config: ResolvedConfig) => void | Promise<void>
-  /**
-   * Configure the vite server. The hook receives the {@link ViteDevServer}
-   * instance. This can also be used to store a reference to the server
-   * for use in other hooks.
-   *
-   * The hooks will be called before internal middlewares are applied. A hook
-   * can return a post hook that will be called after internal middlewares
-   * are applied. Hook can be async functions and will be called in series.
-   */
-  configureServer?: ServerHook
-  /**
-   * Transform index.html.
-   * The hook receives the following arguments:
-   *
-   * - html: string
-   * - ctx?: vite.ServerContext (only present during serve)
-   * - bundle?: rollup.OutputBundle (only present during build)
-   *
-   * It can either return a transformed string, or a list of html tag
-   * descriptors that will be injected into the <head> or <body>.
-   *
-   * By default the transform is applied **after** vite's internal html
-   * transform. If you need to apply the transform before vite, use an object:
-   * `{ enforce: 'pre', transform: hook }`
-   */
-  transformIndexHtml?: IndexHtmlTransform
-  /**
-   * Perform custom handling of HMR updates.
-   * The handler receives a context containing changed filename, timestamp, a
-   * list of modules affected by the file change, and the dev server instance.
-   *
-   * - The hook can return a filtered list of modules to narrow down the update.
-   *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
-   *   the descriptors.
-   *
-   * - The hook can also return an empty array and then perform custom updates
-   *   by sending a custom hmr payload via server.ws.send().
-   *
-   * - If the hook doesn't return a value, the hmr update will be performed as
-   *   normal.
-   */
-  handleHotUpdate?(
-    ctx: HmrContext
-  ): Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>
-
-  /**
-   * extend hooks with ssr flag
-   */
-  resolveId?(
-    this: PluginContext,
-    source: string,
-    importer: string | undefined,
-    options: { custom?: CustomPluginOptions },
-    ssr?: boolean
-  ): Promise<ResolveIdResult> | ResolveIdResult
-  load?(
-    this: PluginContext,
-    id: string,
-    ssr?: boolean
-  ): Promise<LoadResult> | LoadResult
-  transform?(
-    this: TransformPluginContext,
-    code: string,
-    id: string,
-    ssr?: boolean
-  ): Promise<TransformResult> | TransformResult
-}