SWC Compiler

Copyexport declare function getTargetTriple(): string

Copyexport function getBinaryMetadata() {
  return {
    target: loadedBindings?.getTargetTriple?.(),
  }
}

Copyasync function loadWasmRawBindings(importPath = ''): Promise<RawWasmBindings> {
  let attempts = []
 
  // Used by `run-tests` to force use of a locally-built wasm binary. This environment variable is
  // unstable and subject to change.
  const testWasmDir = process.env.NEXT_TEST_WASM_DIR
 
  if (testWasmDir) {
    // assume these are node.js bindings and don't need a call to `.default()`
    const rawBindings = await import(
      pathToFileURL(path.join(testWasmDir, 'wasm.js')).toString()
    )
    infoLog(`next-swc build: wasm build ${testWasmDir}`)
    return rawBindings
  } else {
    for (let pkg of ['@next/swc-wasm-nodejs', '@next/swc-wasm-web']) {

Copy> [!NOTE]
> The WebAssembly initialization path distinguishes between Node.js and browser or web environments. When loading `@next/swc-wasm-web`, the loader explicitly invokes the exported `default()` initialization method to set up memory instances before binding execution.

Copy} catch (e: any) {
  // Only log attempts for loading wasm when loading as fallback
  if (importPath) {
    if (e?.code === 'ERR_MODULE_NOT_FOUND') {
      attempts.push(`Attempted to load ${pkg}, but it was not installed`)
    } else {
      attempts.push(
        `Attempted to load ${pkg}, but an error occurred: ${e.message ?? e}`
      )
    }

Copyconst cacheDirectory = getCacheDirectory(
  'next-swc',
  process.env['NEXT_SWC_PATH']
)
 
const extractFromTar = () =>
  x({
    file: path.join(cacheDirectory, tarFileName),
    cwd: outputDirectory,
    strip: 1,
  })
 
if (!fs.existsSync(path.join(cacheDirectory, tarFileName))) {
  Log.info(`Downloading swc package ${pkgName}... to ${cacheDirectory}`)
  await fs.promises.mkdir(cacheDirectory, { recursive: true })
  const tempFile = path.join(
    cacheDirectory,
    `${tarFileName}.temp-${Date.now()}`
  )
 
  const registry = getRegistry()
 
  const downloadUrl = `${registry}${pkgName}/-/${tarFileName}`
 
  await fetch(downloadUrl).then((res) => {

Copyconst MAX_VERSIONS_TO_CACHE = 8

Copyconst cacheFiles = await fs.promises.readdir(cacheDirectory)
 
if (cacheFiles.length > MAX_VERSIONS_TO_CACHE) {
  cacheFiles.sort((a, b) => {
    if (a.length < b.length) return -1
    return a.localeCompare(b)
  })
 
  // prune oldest versions in cache
  for (let i = 0; i++; i < cacheFiles.length - MAX_VERSIONS_TO_CACHE) {
    await fs.promises
      .unlink(path.join(cacheDirectory, cacheFiles[i]))
      .catch(() => {})
  }
}

Copy/**
 * This module provides a way to install SWC bindings without eagerly loading the entire swc/index module.
 *
 * The swc/index module can transitively load other modules (like webpack-config) that import React,
 * and React's entry point checks process.env.NODE_ENV at require time to decide whether to load
 * the development or production bundle. By deferring the require of swc/index until this function
 * is called, we ensure NODE_ENV is set before React is loaded.
 */
 
/**
 * Loads and caches the native bindings. This is idempotent and should be called early so bindings
 * can be accessed synchronously later.
 *
 * @param useWasmBinary - Whether to use WASM bindings instead of native bindings
 */
export async function installBindings(
  useWasmBinary: boolean = false
): Promise<void> {
  // Lazy require to avoid loading swc/index (and transitively webpack-config/React)
  // before NODE_ENV is set
  const { loadBindings } = require('./index') as typeof import('./index')
  await loadBindings(useWasmBinary)
}

Copyif (!fs.existsSync(path.join(cacheDirectory, tarFileName))) {
  Log.info(`Downloading swc package ${pkgName}... to ${cacheDirectory}`)
  await fs.promises.mkdir(cacheDirectory, { recursive: true })
  const tempFile = path.join(
    cacheDirectory,
    `${tarFileName}.temp-${Date.now()}`
  )
 
  const registry = getRegistry()
 
  const downloadUrl = `${registry}${pkgName}/-/${tarFileName}`
 
  await fetch(downloadUrl).then((res) => {
    const { ok, body } = res
    if (!ok || !body) {
      Log.error(`Failed to download swc package from ${downloadUrl}`)
    }
 
    if (!ok) {
      throw new Error(`request failed with status ${res.status}`)
    }
    if (!body) {
      throw new Error('request failed with empty body')
    }
    const cacheWriteStream = fs.createWriteStream(tempFile)
    return body.pipeTo(
      new WritableStream({
        write(chunk) {
          return new Promise<void>((resolve, reject) =>
            cacheWriteStream.write(chunk, (error) => {
              if (error) {
                reject(error)
                return
              }
 
              resolve()
            })
          )
        },
        close() {
          return new Promise<void>((resolve, reject) =>
            cacheWriteStream.close((error) => {
              if (error) {
                reject(error)
                return
              }
 
              resolve()
            })
          )
        },
      })
    )
  })
 
  await fs.promises.access(tempFile) // ensure the temp file existed
  await fs.promises.rename(tempFile, path.join(cacheDirectory, tarFileName))
} else {
  Log.info(`Using cached swc package ${pkgName}...`)
}

Copyconst cacheFiles = await fs.promises.readdir(cacheDirectory)
 
if (cacheFiles.length > MAX_VERSIONS_TO_CACHE) {
  cacheFiles.sort((a, b) => {
    if (a.length < b.length) return -1
    return a.localeCompare(b)
  })
 
  // prune oldest versions in cache
  for (let i = 0; i++; i < cacheFiles.length - MAX_VERSIONS_TO_CACHE) {
    await fs.promises
      .unlink(path.join(cacheDirectory, cacheFiles[i]))
      .catch(() => {})
  }
}

Copyexport function getParserOptions({ filename, jsConfig, ...rest }: any) {
  const isTSFile = filename.endsWith('.ts')
  const hasTsSyntax = isTypeScriptFile(filename)
  const enableDecorators = Boolean(
    jsConfig?.compilerOptions?.experimentalDecorators
  )
  return {
    ...rest,
    syntax: hasTsSyntax ? 'typescript' : 'ecmascript',
    dynamicImport: true,
    decorators: enableDecorators,
    // Exclude regular TypeScript files from React transformation to prevent e.g. generic parameters and angle-bracket type assertion from being interpreted as JSX tags.
    [hasTsSyntax ? 'tsx' : 'jsx']: !isTSFile,
    importAssertions: true,
  }
}

Copyreact: {
  importSource:
    jsConfig?.compilerOptions?.jsxImportSource ??
    (compilerOptions?.emotion && !isReactServerLayer
      ? '@emotion/react'
      : 'react'),
  runtime: 'automatic',
  pragmaFrag: 'React.Fragment',
  throwIfNamespace: true,
  development: !!development,
  useBuiltins: true,
  refresh: !!hasReactRefresh,
},

Copy// Disable css-in-js libs (without client-only integration) transform on server layer for server components
...(!isReactServerLayer && {
  emotion: getEmotionOptions(compilerOptions?.emotion, development),
  styledComponents: getStyledComponentsOptions(
    compilerOptions?.styledComponents,
    development
  ),
}),

Copyfunction getPoolId(cwd: string, filename: string) {
  return `${cwd}:${filename}`
}
 
export async function runLoaderWorkerPool(
  bindings: typeof import('./generated-native'),
  bindingPath: string
) {
  bindings.registerWorkerScheduler(
    (creation) => {
      const {
        options: { filename, cwd },
      } = creation
 
      const poolId = getPoolId(cwd, filename)
 
      const worker = new Worker(/* turbopackIgnore: true*/ filename, {
        workerData: {
          bindingPath,
          cwd,
        },
      })
 
      // This will cause handing when run in jest worker, but not as a first level thread of nodejs thread
      // worker.unref()
 
      const workers =
        loaderWorkers[poolId] || (loaderWorkers[poolId] = new Map())
 
      workers.set(worker.threadId, worker)
    },
    (termination) => {
      const {
        options: { filename, cwd },
        workerId,
      } = termination
 
      const poolId = getPoolId(cwd, filename)
      const workers = loaderWorkers[poolId]
      workers.get(workerId)?.terminate()
      workers.delete(workerId)
    }
  )

Copyconst worker = new Worker(workerPath, {
  maxRetries: 0,
  numWorkers: 1,
  // Always worker-threads, regardless of `experimental.workerThreads`.
  // Unlike the `'use cache'` probe (which follows the flag), validation has
  // no reason to prefer a child process: it doesn't need process-level
  // isolation (a worker thread already has its own V8 heap and module
  // registry, so the reloaded route is isolated from the main thread), and
  // threads let a superseded validation be aborted mid-run through a shared
  // `SharedArrayBuffer`, which a separate process can't receive. Threads
  // also carry the transported Flight bytes as typed arrays via structured
  // clone, with no JSON round-trip to corrupt them.
  enableWorkerThreads: true,
  // Listing the method explicitly tells jest-worker to skip the discovery
  // `require()` it would otherwise do in the parent process to enumerate
  // the module's exports. This worker's top-level imports (`require-hook`,
  // `node-environment`) run runtime setup meant only for the isolated
  // worker thread, so they must not be evaluated in the parent.
  exposedMethods: [
    'runDevValidation',
    'applyHmrUpdate',
    'invalidateCaches',
  ],
  forkOptions: {
    env: {
      ...process.env,
      NODE_OPTIONS: workerNodeOptions,
    },
  },
}) as Worker & ValidationPool

Copyfunction resolveSWCOptions(
  cwd: string,
  compilerOptions: RelevantCompilerOptions
): SWCOptions {
  return {
    jsc: {
      parser: {
        syntax: 'typescript',
      },
      ...(compilerOptions.paths ? { paths: compilerOptions.paths } : {}),
      ...(compilerOptions.baseUrl
        ? // Needs to be an absolute path.
          { baseUrl: path.resolve(cwd, compilerOptions.baseUrl) }
        : compilerOptions.paths
          ? // If paths is given, baseUrl is required.
            { baseUrl: compilerOptions.pathsBasePath ?? cwd }
          : {}),
    },
    module: {
      type: 'commonjs',
    },
    isModule: 'unknown',
    env: {
      targets: {
        // Setting the Node.js version can reduce unnecessary code generation.
        node: process?.versions?.node ?? '20.19.0',
      },
    },
  } satisfies SWCOptions
}

Copy// register require hook only if require exists
if (code.includes('require(')) {
  registerHook(swcOptions)
  hasRequire = true
}
 

Copyfor (const ext of extensions) {
  const oldHook = require.extensions[ext] ?? oldJSHook
  require.extensions[ext] = function (mod: any, oldFilename) {
    const _compile = mod._compile
 
    mod._compile = function (code: string, filename: string) {
      const swc = transformSync(code, swcOptions)
      return _compile.call(this, swc.code, filename)
    }
 
    return oldHook(mod, oldFilename)
  }
}

Copyconst createTransformer: TransformerCreator<
  SyncTransformer<JestTransformerConfig>,
  JestTransformerConfig
> = (inputOptions) => ({
  process(src, filename, jestOptions) {
    const jestConfig = getJestConfig(jestOptions)
 
    const swcTransformOpts = getJestSWCOptions({
      isServer:
        jestConfig.testEnvironment === 'node' ||
        jestConfig.testEnvironment.includes('jest-environment-node'),
      filename,
      configDir: inputOptions?.configDir,
      jsConfig: inputOptions?.jsConfig,
      resolvedBaseUrl: inputOptions?.resolvedBaseUrl,
      pagesDir: inputOptions?.pagesDir,
      serverComponents: inputOptions?.serverComponents,
      modularizeImports: inputOptions?.modularizeImports,
      swcPlugins: inputOptions?.swcPlugins,
      compilerOptions: inputOptions?.compilerOptions,
      imageConfig: inputOptions?.imageConfig,
      serverReferenceHashSalt: '',
      esm:
        isSupportEsm &&
        isEsm(Boolean(inputOptions?.isEsmProject), filename, jestConfig),
    })
 
    return transformSync(src, { ...swcTransformOpts, filename })
  },
})

Copyfunction isEsm(
  isEsmProject: boolean,
  filename: string,
  jestConfig: Config.ProjectConfig
): boolean {
  return (
    (/\.jsx?$/.test(filename) && isEsmProject) ||
    jestConfig.extensionsToTreatAsEsm?.some((ext: any) =>
      filename.endsWith(ext)
    )
  )
}

Copyasync function loadWasmRawBindings(importPath = ''): Promise<RawWasmBindings> {
  let attempts = []
 
  // Used by `run-tests` to force use of a locally-built wasm binary. This environment variable is
  // unstable and subject to change.
  const testWasmDir = process.env.NEXT_TEST_WASM_DIR
 
  if (testWasmDir) {
    // assume these are node.js bindings and don't need a call to `.default()`
    const rawBindings = await import(
      pathToFileURL(path.join(testWasmDir, 'wasm.js')).toString()
    )
    infoLog(`next-swc build: wasm build ${testWasmDir}`)
    return rawBindings
  } else {
    for (let pkg of ['@next/swc-wasm-nodejs', '@next/swc-wasm-web']) {
      try {
        let pkgPath = pkg
 
        if (importPath) {
          // the import path must be exact when not in node_modules
          pkgPath = path.join(importPath, pkg, 'wasm.js')
        }
        const importedRawBindings = await import(
          pathToFileURL(pkgPath).toString()
        )
        let rawBindings
        if (pkg === '@next/swc-wasm-web') {
          // https://rustwasm.github.io/docs/wasm-bindgen/examples/without-a-bundler.html
          // `default` must be called to initialize the module
          rawBindings = await importedRawBindings.default!()
        } else {
          rawBindings = importedRawBindings
        }
        infoLog(`next-swc build: wasm build ${pkg}`)
        return rawBindings
      } catch (e: any) {
        // Only log attempts for loading wasm when loading as fallback
        if (importPath) {
          if (e?.code === 'ERR_MODULE_NOT_FOUND') {
            attempts.push(`Attempted to load ${pkg}, but it was not installed`)
          } else {
            attempts.push(
              `Attempted to load ${pkg}, but an error occurred: ${e.message ?? e}`
            )
          }
        }
      }
    }
  }
 
  throw attempts
}
 
// helper for tryLoadWasmWithFallback / loadBindings.
async function loadWasm(importPath = '') {
  const rawBindings = await loadWasmRawBindings(importPath)
 
  function removeUndefined(obj: any): any {
    // serde-wasm-bindgen expect that `undefined` values map to `()` in rust, but we want to treat
    // those fields as non-existent, so remove them before passing them to rust.
    //
    // The native (non-wasm) bindings use `JSON.stringify`, which strips undefined values.
    if (typeof obj !== 'object' || obj === null) {
      return obj
    }
    if (Array.isArray(obj)) {
      return obj.map(removeUndefined)
    }
    const newObj: { [key: string]: any } = {}
    for (const [k, v] of Object.entries(obj)) {
      if (typeof v !== 'undefined') {
        newObj[k] = removeUndefined(v)
      }
    }
    return newObj
  }
 
  // Note wasm binary does not support async intefaces yet, all async
  // interface coereces to sync interfaces.

Copyrspack: {
  getModuleNamedExports: function (
    resourcePath: string
  ): Promise<string[]> {
    return bindings.getModuleNamedExports(resourcePath)
  },
  warnForEdgeRuntime: function (
    source: string,
    isProduction: boolean
  ): Promise<NapiSourceDiagnostic[]> {
    return bindings.warnForEdgeRuntime(source, isProduction)
  },
},
expandNextJsTemplate(
  content: Buffer,
  templatePath: string,
  nextPackageDirPath: string,
  replacements: Record<`VAR_${string}`, string>,
  injections: Record<string, string>,
  imports: Record<string, string | null>
): string {
  return bindings.expandNextJsTemplate(
    content,
    templatePath,
    nextPackageDirPath,
    replacements,
    injections,
    imports
  )
},
lockfileTryAcquire(filePath: string, content?: string | null) {
  return bindings.lockfileTryAcquire(filePath, content)
},
lockfileTryAcquireSync(filePath: string, content?: string | null) {
  return bindings.lockfileTryAcquireSync(filePath, content)
},
lockfileUnlock(lockfile: Lockfile) {
  return bindings.lockfileUnlock(lockfile)
},
lockfileUnlockSync(lockfile: Lockfile) {
  return bindings.lockfileUnlockSync(lockfile)
},