fix(bun): respect loader returned from load hook + feat(bun): support plugin.bun.loader for per-plugin loader resolution (#601)

81reap · web-flow · commit a0b0bc4a174b · 2026-06-23T14:27:49.000+09:00
* fix(bun): respect loader returned from load hook

Use the loader returned by object load results before falling back to Bun's provided loader or guessed loader.

* feat(bun): support plugin.bun.loader for per-plugin loader resolution

Add `loader` to the `bun` plugin option block, accepting either a `Loader` literal or `(code, id) =&gt; Loader` function, mirroring the existing `plugin.esbuild.loader` API.

* fix(bun): remove LoadResult and use TransformResult instead
diff --git a/src/bun/index.ts b/src/bun/index.ts
@@ -4,7 +4,7 @@ import { isAbsolute } from 'node:path'
 import { version as unpluginVersion } from '../../package.json'
 import { normalizeObjectHook } from '../utils/filter'
 import { toArray } from '../utils/general'
-import { createBuildContext, createPluginContext, guessLoader } from './utils'
+import { createBuildContext, createPluginContext, guessLoader, unwrapLoader } from './utils'
 
 // Coerce plugin.name to satisfy Bun's namespace validator:
 // https://github.com/oven-sh/bun/blob/12d77d1ac561771e9fa1d0822e954273248e7f9a/src/js/builtins/BundlerPlugin.ts#L215-L217
@@ -141,6 +141,7 @@ export function getBunPlugin<UserOptions = Record<string, never>>(
         ): Promise<{ contents: string, loader: Loader } | undefined> {
           let code: string | undefined
           let hasResult = false
+          let activePlugin: typeof plugins[number] | undefined
 
           const namespaceLoadHooks = namespace === 'file'
             ? loadHooks
@@ -153,7 +154,7 @@ export function getBunPlugin<UserOptions = Record<string, never>>(
               continue
 
             const { mixedContext, errors, warnings } = createPluginContext(context)
-            const result = await handler.call(mixedContext, id)
+            const result: TransformResult = await handler.call(mixedContext, id)
 
             for (const warning of warnings) {
               console.warn('[unplugin]', typeof warning === 'string' ? warning : warning.message)
@@ -166,11 +167,13 @@ export function getBunPlugin<UserOptions = Record<string, never>>(
             if (typeof result === 'string') {
               code = result
               hasResult = true
+              activePlugin = plugin
               break
             }
             else if (typeof result === 'object' && result !== null) {
               code = result.code
               hasResult = true
+              activePlugin = plugin
               break
             }
           }
@@ -213,9 +216,12 @@ export function getBunPlugin<UserOptions = Record<string, never>>(
           }
 
           if (hasResult && code !== undefined) {
+            const pluginLoader = activePlugin?.bun?.loader
             return {
               contents: code,
-              loader: loader ?? guessLoader(id),
+              loader: (pluginLoader && unwrapLoader(pluginLoader, code, id))
+                ?? loader
+                ?? guessLoader(id),
             }
           }
         }
diff --git a/src/bun/utils.ts b/src/bun/utils.ts
@@ -26,6 +26,17 @@ export function guessLoader(id: string): Loader {
   return ExtToLoader[path.extname(id).toLowerCase()] || 'js'
 }
 
+export function unwrapLoader(
+  loader: Loader | ((code: string, id: string) => Loader),
+  code: string,
+  id: string,
+): Loader {
+  if (typeof loader === 'function')
+    return loader(code, id)
+
+  return loader
+}
+
 export function createBuildContext(build: PluginBuilder): UnpluginBuildContext {
   const watchFiles: string[] = []
 
diff --git a/src/types.ts b/src/types.ts
@@ -1,6 +1,6 @@
 import type { CompilationContext as FarmCompilationContext, JsPlugin as FarmPlugin } from '@farmfe/core'
 import type { Compilation as RspackCompilation, Compiler as RspackCompiler, LoaderContext as RspackLoaderContext, RspackPluginInstance } from '@rspack/core'
-import type { BunPlugin, PluginBuilder as BunPluginBuilder } from 'bun'
+import type { Loader as BunLoader, BunPlugin, PluginBuilder as BunPluginBuilder } from 'bun'
 import type { BuildOptions, Plugin as EsbuildPlugin, Loader, PluginBuild } from 'esbuild'
 import type { Plugin as RolldownPlugin } from 'rolldown'
 import type { EmittedAsset, PluginContextMeta as RollupContextMeta, Plugin as RollupPlugin, SourceMapInput } from 'rollup'
@@ -145,7 +145,10 @@ export interface UnpluginOptions {
     config?: ((options: BuildOptions) => void) | undefined
   } | undefined
   farm?: Partial<FarmPlugin> | undefined
-  bun?: Partial<BunPlugin> | undefined
+  bun?: {
+    loader?: BunLoader | ((code: string, id: string) => BunLoader) | undefined
+    setup?: ((build: BunPluginBuilder) => void | Promise<void>) | undefined
+  } | undefined
 }
 
 export interface ResolvedUnpluginOptions extends UnpluginOptions {
diff --git a/test/unit-tests/bun/nested.test.ts b/test/unit-tests/bun/nested.test.ts
@@ -132,6 +132,90 @@ describe.skipIf(typeof Bun === 'undefined')('bun nested plugin support', () => {
     Bun.file = originalFile
   })
 
+  it('should respect a static plugin.bun.loader', async () => {
+    const unplugin = createUnplugin(() => ({
+      name: 'tsx-loader',
+      resolveId(id: string) {
+        return id === 'virtual:component' ? id : null
+      },
+      load(id: string) {
+        if (id === 'virtual:component') {
+          return 'export default () => <h1>hi</h1>'
+        }
+        return null
+      },
+      bun: { loader: 'tsx' as const },
+    }))
+
+    const bunPlugin = unplugin.bun()
+    const onLoadCallbacks: Array<{ namespace?: string, cb: Bun.OnLoadCallback }> = []
+    const mockBuild = {
+      onResolve: vi.fn(),
+      onLoad: vi.fn((options, callback) => {
+        onLoadCallbacks.push({ namespace: options.namespace, cb: callback })
+      }),
+      onStart: vi.fn(),
+      config: { outdir: './dist' },
+    } as never as Bun.PluginBuilder
+
+    await bunPlugin.setup(mockBuild)
+
+    const virtualHandler = onLoadCallbacks.find(c => c.namespace !== 'file')?.cb
+    expect(virtualHandler).toBeDefined()
+
+    const result = await virtualHandler!({
+      path: 'virtual:component',
+      loader: 'js',
+    } as Bun.OnLoadArgs)
+
+    expect(result).toEqual({
+      contents: 'export default () => <h1>hi</h1>',
+      loader: 'tsx',
+    })
+  })
+
+  it('should call plugin.bun.loader as a function with code and id', async () => {
+    const loaderFn = vi.fn((_code: string, _id: string) => 'tsx' as const)
+    const unplugin = createUnplugin(() => ({
+      name: 'tsx-loader-fn',
+      resolveId(id: string) {
+        return id === 'virtual:component' ? id : null
+      },
+      load(id: string) {
+        if (id === 'virtual:component') {
+          return 'export default () => <h1>hi</h1>'
+        }
+        return null
+      },
+      bun: { loader: loaderFn },
+    }))
+
+    const bunPlugin = unplugin.bun()
+    const onLoadCallbacks: Array<{ namespace?: string, cb: Bun.OnLoadCallback }> = []
+    const mockBuild = {
+      onResolve: vi.fn(),
+      onLoad: vi.fn((options, callback) => {
+        onLoadCallbacks.push({ namespace: options.namespace, cb: callback })
+      }),
+      onStart: vi.fn(),
+      config: { outdir: './dist' },
+    } as never as Bun.PluginBuilder
+
+    await bunPlugin.setup(mockBuild)
+
+    const virtualHandler = onLoadCallbacks.find(c => c.namespace !== 'file')?.cb
+    const result = await virtualHandler!({
+      path: 'virtual:component',
+      loader: 'js',
+    } as Bun.OnLoadArgs)
+
+    expect(loaderFn).toHaveBeenCalledWith('export default () => <h1>hi</h1>', 'virtual:component')
+    expect(result).toEqual({
+      contents: 'export default () => <h1>hi</h1>',
+      loader: 'tsx',
+    })
+  })
+
   it('should call plugin.bun.setup with the build before standard hooks', async () => {
     const callOrder: string[] = []
     const bunSetup = vi.fn((_build: Bun.PluginBuilder) => {
