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

package/src/node/ssr/ssrExternal.ts

@@ -1,161 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { tryNodeResolve, InternalResolveOptions } from '../plugins/resolve'
-import {
-  createDebugger,
-  isDefined,
-  lookupFile,
-  normalizePath,
-  resolveFrom,
-  unique
-} from '../utils'
-import { ResolvedConfig } from '..'
-import { createFilter } from '@rollup/pluginutils'
-
-const debug = createDebugger('vite:ssr-external')
-
-/**
- * Heuristics for determining whether a dependency should be externalized for
- * server-side rendering.
- *
- * TODO right now externals are imported using require(), we probably need to
- * rework this when more libraries ship native ESM distributions for Node.
- */
-export function resolveSSRExternal(
-  config: ResolvedConfig,
-  knownImports: string[],
-  ssrExternals: Set<string> = new Set(),
-  seen: Set<string> = new Set()
-): string[] {
-  if (config.ssr?.noExternal === true) {
-    return []
-  }
-
-  const { root } = config
-  const pkgContent = lookupFile(root, ['package.json'])
-  if (!pkgContent) {
-    return []
-  }
-  const pkg = JSON.parse(pkgContent)
-  const importedDeps = knownImports.map(getNpmPackageName).filter(isDefined)
-  const deps = unique([
-    ...importedDeps,
-    ...Object.keys(pkg.devDependencies || {}),
-    ...Object.keys(pkg.dependencies || {})
-  ])
-
-  const resolveOptions: InternalResolveOptions = {
-    root,
-    isProduction: false,
-    isBuild: true
-  }
-
-  const depsToTrace = new Set<string>()
-
-  for (const id of deps) {
-    if (seen.has(id)) {
-      continue
-    }
-    seen.add(id)
-
-    let entry: string | undefined
-    let requireEntry: string
-    try {
-      entry = tryNodeResolve(
-        id,
-        undefined,
-        resolveOptions,
-        true,
-        undefined,
-        true
-      )?.id
-      // normalizePath required for windows. tryNodeResolve uses normalizePath
-      // which returns with '/', require.resolve returns with '\\'
-      requireEntry = normalizePath(require.resolve(id, { paths: [root] }))
-    } catch (e) {
-      // resolve failed, assume include
-      debug(`Failed to resolve entries for package "${id}"\n`, e)
-      continue
-    }
-    if (!entry) {
-      // no esm entry but has require entry (is this even possible?)
-      ssrExternals.add(id)
-      continue
-    }
-    if (!entry.includes('node_modules')) {
-      // entry is not a node dep, possibly linked - don't externalize
-      // instead, trace its dependencies.
-      depsToTrace.add(id)
-      continue
-    }
-    if (entry !== requireEntry) {
-      // has separate esm/require entry, assume require entry is cjs
-      ssrExternals.add(id)
-    } else {
-      // node resolve and esm resolve resolves to the same file.
-      if (!/\.m?js$/.test(entry)) {
-        // entry is not js, cannot externalize
-        continue
-      }
-      // check if the entry is cjs
-      const content = fs.readFileSync(entry, 'utf-8')
-      if (/\bmodule\.exports\b|\bexports[.\[]|\brequire\s*\(/.test(content)) {
-        ssrExternals.add(id)
-      }
-    }
-  }
-
-  for (const id of depsToTrace) {
-    const depRoot = path.dirname(
-      resolveFrom(`${id}/package.json`, root, !!config.resolve.preserveSymlinks)
-    )
-    resolveSSRExternal(
-      {
-        ...config,
-        root: depRoot
-      },
-      knownImports,
-      ssrExternals,
-      seen
-    )
-  }
-
-  if (config.ssr?.external) {
-    config.ssr.external.forEach((id) => ssrExternals.add(id))
-  }
-  let externals = [...ssrExternals]
-  if (config.ssr?.noExternal) {
-    const filter = createFilter(undefined, config.ssr.noExternal, {
-      resolve: false
-    })
-    externals = externals.filter((id) => filter(id))
-  }
-  return externals.filter((id) => id !== 'vite')
-}
-
-export function shouldExternalizeForSSR(
-  id: string,
-  externals: string[]
-): boolean {
-  const should = externals.some((e) => {
-    if (id === e) {
-      return true
-    }
-    // deep imports, check ext before externalizing - only externalize
-    // extension-less imports and explicit .js imports
-    if (id.startsWith(e + '/') && (!path.extname(id) || id.endsWith('.js'))) {
-      return true
-    }
-  })
-  return should
-}
-
-function getNpmPackageName(importPath: string): string | null {
-  const parts = importPath.split('/')
-  if (parts[0].startsWith('@')) {
-    if (!parts[1]) return null
-    return `${parts[0]}/${parts[1]}`
-  } else {
-    return parts[0]
-  }
-}

package/src/node/ssr/ssrManifestPlugin.ts

@@ -1,53 +0,0 @@
-import { relative } from 'path'
-import { normalizePath } from '@rollup/pluginutils'
-import { ResolvedConfig } from '..'
-import { Plugin } from '../plugin'
-import { chunkToEmittedCssFileMap } from '../plugins/css'
-import { chunkToEmittedAssetsMap } from '../plugins/asset'
-
-export function ssrManifestPlugin(config: ResolvedConfig): Plugin {
-  // module id => preload assets mapping
-  const ssrManifest: Record<string, string[]> = {}
-  const base = config.base
-
-  return {
-    name: 'vite:ssr-manifest',
-    generateBundle(_options, bundle) {
-      for (const file in bundle) {
-        const chunk = bundle[file]
-        if (chunk.type === 'chunk') {
-          // links for certain entry chunks are already generated in static HTML
-          // in those cases we only need to record info for non-entry chunks
-          const cssFiles = chunk.isEntry
-            ? null
-            : chunkToEmittedCssFileMap.get(chunk)
-          const assetFiles = chunkToEmittedAssetsMap.get(chunk)
-          for (const id in chunk.modules) {
-            const normalizedId = normalizePath(relative(config.root, id))
-            const mappedChunks =
-              ssrManifest[normalizedId] || (ssrManifest[normalizedId] = [])
-            if (!chunk.isEntry) {
-              mappedChunks.push(base + chunk.fileName)
-            }
-            if (cssFiles) {
-              cssFiles.forEach((file) => {
-                mappedChunks.push(base + file)
-              })
-            }
-            if (assetFiles) {
-              assetFiles.forEach((file) => {
-                mappedChunks.push(base + file)
-              })
-            }
-          }
-        }
-      }
-
-      this.emitFile({
-        fileName: 'ssr-manifest.json',
-        type: 'asset',
-        source: JSON.stringify(ssrManifest, null, 2)
-      })
-    }
-  }
-}

package/src/node/ssr/ssrModuleLoader.ts

@@ -1,214 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { ViteDevServer } from '..'
-import { cleanUrl, resolveFrom, unwrapId } from '../utils'
-import { rebindErrorStacktrace, ssrRewriteStacktrace } from './ssrStacktrace'
-import {
-  ssrExportAllKey,
-  ssrModuleExportsKey,
-  ssrImportKey,
-  ssrImportMetaKey,
-  ssrDynamicImportKey
-} from './ssrTransform'
-import { transformRequest } from '../server/transformRequest'
-
-interface SSRContext {
-  global: NodeJS.Global
-}
-
-type SSRModule = Record<string, any>
-
-const pendingModules = new Map<string, Promise<SSRModule>>()
-const pendingImports = new Map<string, string[]>()
-
-export async function ssrLoadModule(
-  url: string,
-  server: ViteDevServer,
-  context: SSRContext = { global },
-  urlStack: string[] = []
-): Promise<SSRModule> {
-  url = unwrapId(url)
-
-  // when we instantiate multiple dependency modules in parallel, they may
-  // point to shared modules. We need to avoid duplicate instantiation attempts
-  // by register every module as pending synchronously so that all subsequent
-  // request to that module are simply waiting on the same promise.
-  const pending = pendingModules.get(url)
-  if (pending) {
-    return pending
-  }
-
-  const modulePromise = instantiateModule(url, server, context, urlStack)
-  pendingModules.set(url, modulePromise)
-  modulePromise
-    .catch(() => {
-      pendingImports.delete(url)
-    })
-    .finally(() => {
-      pendingModules.delete(url)
-    })
-  return modulePromise
-}
-
-async function instantiateModule(
-  url: string,
-  server: ViteDevServer,
-  context: SSRContext = { global },
-  urlStack: string[] = []
-): Promise<SSRModule> {
-  const { moduleGraph } = server
-  const mod = await moduleGraph.ensureEntryFromUrl(url)
-
-  if (mod.ssrModule) {
-    return mod.ssrModule
-  }
-
-  const result =
-    mod.ssrTransformResult ||
-    (await transformRequest(url, server, { ssr: true }))
-  if (!result) {
-    // TODO more info? is this even necessary?
-    throw new Error(`failed to load module for ssr: ${url}`)
-  }
-
-  const ssrModule = {
-    [Symbol.toStringTag]: 'Module'
-  }
-  Object.defineProperty(ssrModule, '__esModule', { value: true })
-
-  // Tolerate circular imports by ensuring the module can be
-  // referenced before it's been instantiated.
-  mod.ssrModule = ssrModule
-
-  const ssrImportMeta = { url }
-
-  urlStack = urlStack.concat(url)
-  const isCircular = (url: string) => urlStack.includes(url)
-
-  // Since dynamic imports can happen in parallel, we need to
-  // account for multiple pending deps and duplicate imports.
-  const pendingDeps: string[] = []
-
-  const ssrImport = async (dep: string) => {
-    if (dep[0] !== '.' && dep[0] !== '/') {
-      return nodeRequire(
-        dep,
-        mod.file,
-        server.config.root,
-        !!server.config.resolve.preserveSymlinks
-      )
-    }
-    dep = unwrapId(dep)
-    if (!isCircular(dep) && !pendingImports.get(dep)?.some(isCircular)) {
-      pendingDeps.push(dep)
-      if (pendingDeps.length === 1) {
-        pendingImports.set(url, pendingDeps)
-      }
-      await ssrLoadModule(dep, server, context, urlStack)
-      if (pendingDeps.length === 1) {
-        pendingImports.delete(url)
-      } else {
-        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
-      }
-    }
-    return moduleGraph.urlToModuleMap.get(dep)?.ssrModule
-  }
-
-  const ssrDynamicImport = (dep: string) => {
-    // #3087 dynamic import vars is ignored at rewrite import path,
-    // so here need process relative path
-    if (dep[0] === '.') {
-      dep = path.posix.resolve(path.dirname(url), dep)
-    }
-    return ssrImport(dep)
-  }
-
-  function ssrExportAll(sourceModule: any) {
-    for (const key in sourceModule) {
-      if (key !== 'default') {
-        Object.defineProperty(ssrModule, key, {
-          enumerable: true,
-          configurable: true,
-          get() {
-            return sourceModule[key]
-          }
-        })
-      }
-    }
-  }
-
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    const AsyncFunction = async function () {}.constructor as typeof Function
-    const initModule = new AsyncFunction(
-      `global`,
-      ssrModuleExportsKey,
-      ssrImportMetaKey,
-      ssrImportKey,
-      ssrDynamicImportKey,
-      ssrExportAllKey,
-      result.code + `\n//# sourceURL=${mod.url}`
-    )
-    await initModule(
-      context.global,
-      ssrModule,
-      ssrImportMeta,
-      ssrImport,
-      ssrDynamicImport,
-      ssrExportAll
-    )
-  } catch (e) {
-    const stacktrace = ssrRewriteStacktrace(e.stack, moduleGraph)
-    rebindErrorStacktrace(e, stacktrace)
-    server.config.logger.error(
-      `Error when evaluating SSR module ${url}:\n${stacktrace}`,
-      {
-        timestamp: true,
-        clear: server.config.clearScreen,
-        error: e
-      }
-    )
-    throw e
-  }
-
-  return Object.freeze(ssrModule)
-}
-
-function nodeRequire(
-  id: string,
-  importer: string | null,
-  root: string,
-  preserveSymlinks: boolean
-) {
-  const mod = require(resolve(id, importer, root, preserveSymlinks))
-  const defaultExport = mod.__esModule ? mod.default : mod
-  // rollup-style default import interop for cjs
-  return new Proxy(mod, {
-    get(mod, prop) {
-      if (prop === 'default') return defaultExport
-      return mod[prop]
-    }
-  })
-}
-
-const resolveCache = new Map<string, string>()
-
-function resolve(
-  id: string,
-  importer: string | null,
-  root: string,
-  preserveSymlinks: boolean
-) {
-  const key = id + importer + root
-  const cached = resolveCache.get(key)
-  if (cached) {
-    return cached
-  }
-  const resolveDir =
-    importer && fs.existsSync(cleanUrl(importer))
-      ? path.dirname(importer)
-      : root
-  const resolved = resolveFrom(id, resolveDir, preserveSymlinks, true)
-  resolveCache.set(key, resolved)
-  return resolved
-}

package/src/node/ssr/ssrStacktrace.ts

@@ -1,75 +0,0 @@
-import { SourceMapConsumer, RawSourceMap } from 'source-map'
-import { ModuleGraph } from '../server/moduleGraph'
-
-let offset: number
-try {
-  new Function('throw new Error(1)')()
-} catch (e) {
-  // in Node 12, stack traces account for the function wrapper.
-  // in Node 13 and later, the function wrapper adds two lines,
-  // which must be subtracted to generate a valid mapping
-  const match = /:(\d+):\d+\)$/.exec(e.stack.split('\n')[1])
-  offset = match ? +match[1] - 1 : 0
-}
-
-export function ssrRewriteStacktrace(
-  stack: string,
-  moduleGraph: ModuleGraph
-): string {
-  return stack
-    .split('\n')
-    .map((line) => {
-      return line.replace(
-        /^ {4}at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?)\)?/,
-        (input, varName, url, line, column) => {
-          if (!url) return input
-
-          const mod = moduleGraph.urlToModuleMap.get(url)
-          const rawSourceMap = mod?.ssrTransformResult?.map
-
-          if (!rawSourceMap) {
-            return input
-          }
-
-          const consumer = new SourceMapConsumer(
-            rawSourceMap as unknown as RawSourceMap
-          )
-
-          const pos = consumer.originalPositionFor({
-            line: Number(line) - offset,
-            column: Number(column),
-            bias: SourceMapConsumer.LEAST_UPPER_BOUND
-          })
-
-          if (!pos.source) {
-            return input
-          }
-
-          const source = `${pos.source}:${pos.line || 0}:${pos.column || 0}`
-          if (!varName || varName === 'eval') {
-            return `    at ${source}`
-          } else {
-            return `    at ${varName} (${source})`
-          }
-        }
-      )
-    })
-    .join('\n')
-}
-
-export function rebindErrorStacktrace(e: Error, stacktrace: string): void {
-  const { configurable, writable } = Object.getOwnPropertyDescriptor(
-    e,
-    'stack'
-  )!
-  if (configurable) {
-    Object.defineProperty(e, 'stack', {
-      value: stacktrace,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    })
-  } else if (writable) {
-    e.stack = stacktrace
-  }
-}