bundleConfigFile() — vite Function Reference

Source Code

packages/vite/src/node/config.ts lines 2351–2514

async function bundleConfigFile(
  fileName: string,
  isESM: boolean,
): Promise<{ code: string; dependencies: string[] }> {
  let importMetaResolverRegistered = false

  const root = path.dirname(fileName)
  const dirnameVarName = '__vite_injected_original_dirname'
  const filenameVarName = '__vite_injected_original_filename'
  const importMetaUrlVarName = '__vite_injected_original_import_meta_url'
  const importMetaResolveVarName =
    '__vite_injected_original_import_meta_resolve'
  const importMetaResolveRegex = /import\.meta\s*\.\s*resolve/

  const bundle = await rolldown({
    input: fileName,
    // target: [`node${process.versions.node}`],
    platform: 'node',
    resolve: {
      mainFields: ['main'],
    },
    transform: {
      define: {
        __dirname: dirnameVarName,
        __filename: filenameVarName,
        'import.meta.url': importMetaUrlVarName,
        'import.meta.dirname': dirnameVarName,
        'import.meta.filename': filenameVarName,
        'import.meta.resolve': importMetaResolveVarName,
        'import.meta.main': 'false',
      },
    },
    // disable treeshake to include files that is not sideeffectful to `moduleIds`
    treeshake: false,
    // disable tsconfig as it's confusing to respect tsconfig options in the config file
    // this also aligns with other config loader behaviors
    tsconfig: false,
    plugins: [
      {
        name: 'externalize-deps',
        resolveId: {
          filter: { id: /^[^.#].*/ },
          async handler(id, importer, { kind }) {
            if (!importer || path.isAbsolute(id) || isNodeBuiltin(id)) {
              return
            }

            // With the `isNodeBuiltin` check above, this check captures if the builtin is a
            // non-node built-in, which esbuild doesn't know how to handle. In that case, we
            // externalize it so the non-node runtime handles it instead.
            if (isNodeLikeBuiltin(id) || id.startsWith('npm:')) {
              return { id, external: true }
            }

            const isImport = isESM || kind === 'dynamic-import'
            let idFsPath: string | undefined
            try {
              idFsPath = nodeResolveWithVite(id, importer, {
                root,
                isRequire: !isImport,
              })
            } catch (e) {
              if (!isImport) {
                let canResolveWithImport = false
                try {
                  canResolveWithImport = !!nodeResolveWithVite(id, importer, {
                    root,
                  })
                } catch {}
                if (canResolveWithImport) {
                  throw new Error(
                    `Failed to resolve ${JSON.stringify(
                      id,
                    )}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`,
                  )
                }
              }
              throw e
            }
            if (!idFsPath) return
            // always no-externalize json files as rolldown does not support import attributes