feat: support object style hooks (#9634)

Author: antfu

package.json

@@ -77,7 +77,7 @@
     "prettier": "2.7.1",
     "prompts": "^2.4.2",
     "rimraf": "^3.0.2",
-    "rollup": ">=2.75.6 <2.77.0 || ~2.77.0",
+    "rollup": "~2.78.0",
     "semver": "^7.3.7",
     "simple-git-hooks": "^2.8.0",
     "tslib": "^2.4.0",

packages/plugin-vue/package.json

@@ -42,7 +42,7 @@
     "@jridgewell/gen-mapping": "^0.3.2",
     "@jridgewell/trace-mapping": "^0.3.15",
     "debug": "^4.3.4",
-    "rollup": ">=2.75.6 <2.77.0 || ~2.77.0",
+    "rollup": "~2.78.0",
     "slash": "^4.0.0",
     "source-map": "^0.6.1",
     "vite": "workspace:*",

packages/vite/package.json

@@ -61,7 +61,7 @@
     "esbuild": "^0.14.47",
     "postcss": "^8.4.16",
     "resolve": "^1.22.1",
-    "rollup": ">=2.75.6 <2.77.0 || ~2.77.0"
+    "rollup": "~2.78.0"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"

packages/vite/src/node/build.ts

@@ -16,7 +16,6 @@ import type {
   WarningHandler,
   WatcherOptions
 } from 'rollup'
-import type Rollup from 'rollup'
 import type { Terser } from 'types/terser'
 import commonjsPlugin from '@rollup/plugin-commonjs'
 import type { RollupCommonJSOptions } from 'types/commonjs'
@@ -788,34 +787,60 @@ function injectSsrFlagToHooks(plugin: Plugin): Plugin {
   }
 }
 
-function wrapSsrResolveId(
-  fn?: Rollup.ResolveIdHook
-): Rollup.ResolveIdHook | undefined {
-  if (!fn) return
+function wrapSsrResolveId(hook?: Plugin['resolveId']): Plugin['resolveId'] {
+  if (!hook) return
 
-  return function (id, importer, options) {
+  const fn = 'handler' in hook ? hook.handler : hook
+  const handler: Plugin['resolveId'] = function (id, importer, options) {
     return fn.call(this, id, importer, injectSsrFlag(options))
   }
+
+  if ('handler' in hook) {
+    return {
+      ...hook,
+      handler
+    } as Plugin['resolveId']
+  } else {
+    return handler
+  }
 }
 
-function wrapSsrLoad(fn?: Rollup.LoadHook): Rollup.LoadHook | undefined {
-  if (!fn) return
+function wrapSsrLoad(hook?: Plugin['load']): Plugin['load'] {
+  if (!hook) return
 
-  return function (id, ...args) {
+  const fn = 'handler' in hook ? hook.handler : hook
+  const handler: Plugin['load'] = function (id, ...args) {
     // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
     return fn.call(this, id, injectSsrFlag(args[0]))
   }
+
+  if ('handler' in hook) {
+    return {
+      ...hook,
+      handler
+    } as Plugin['load']
+  } else {
+    return handler
+  }
 }
 
-function wrapSsrTransform(
-  fn?: Rollup.TransformHook
-): Rollup.TransformHook | undefined {
-  if (!fn) return
+function wrapSsrTransform(hook?: Plugin['transform']): Plugin['transform'] {
+  if (!hook) return
 
-  return function (code, importer, ...args) {
+  const fn = 'handler' in hook ? hook.handler : hook
+  const handler: Plugin['transform'] = function (code, importer, ...args) {
     // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
     return fn.call(this, code, importer, injectSsrFlag(args[0]))
   }
+
+  if ('handler' in hook) {
+    return {
+      ...hook,
+      handler
+    } as Plugin['transform']
+  } else {
+    return handler
+  }
 }
 
 function injectSsrFlag<T extends Record<string, any>>(

packages/vite/src/node/config.ts

@@ -8,7 +8,7 @@ import type { Alias, AliasOptions } from 'types/alias'
 import aliasPlugin from '@rollup/plugin-alias'
 import { build } from 'esbuild'
 import type { RollupOptions } from 'rollup'
-import type { Plugin } from './plugin'
+import type { HookHandler, Plugin } from './plugin'
 import type {
   BuildOptions,
   RenderBuiltAssetUrl,
@@ -33,7 +33,11 @@ import {
   normalizeAlias,
   normalizePath
 } from './utils'
-import { resolvePlugins } from './plugins'
+import {
+  createPluginHookUtils,
+  getSortedPluginsByHook,
+  resolvePlugins
+} from './plugins'
 import type { ESBuildOptions } from './plugins/esbuild'
 import {
   CLIENT_ENTRY,
@@ -289,7 +293,7 @@ export interface LegacyOptions {
   buildSsrCjsExternalHeuristics?: boolean
 }
 
-export interface ResolveWorkerOptions {
+export interface ResolveWorkerOptions extends PluginHookUtils {
   format: 'es' | 'iife'
   plugins: Plugin[]
   rollupOptions: RollupOptions
@@ -334,9 +338,16 @@ export type ResolvedConfig = Readonly<
     worker: ResolveWorkerOptions
     appType: AppType
     experimental: ExperimentalOptions
-  }
+  } & PluginHookUtils
 >
 
+export interface PluginHookUtils {
+  getSortedPlugins: (hookName: keyof Plugin) => Plugin[]
+  getSortedPluginHooks: <K extends keyof Plugin>(
+    hookName: K
+  ) => NonNullable<HookHandler<Plugin[K]>>[]
+}
+
 export type ResolveFn = (
   id: string,
   importer?: string,
@@ -431,9 +442,11 @@ export async function resolveConfig(
 
   // run config hooks
   const userPlugins = [...prePlugins, ...normalPlugins, ...postPlugins]
-  for (const p of userPlugins) {
-    if (p.config) {
-      const res = await p.config(config, configEnv)
+  for (const p of getSortedPluginsByHook('config', userPlugins)) {
+    const hook = p.config
+    const handler = hook && 'handler' in hook ? hook.handler : hook
+    if (handler) {
+      const res = await handler(config, configEnv)
       if (res) {
         config = mergeConfig(config, res)
       }
@@ -598,9 +611,11 @@ export async function resolveConfig(
     ...workerNormalPlugins,
     ...workerPostPlugins
   ]
-  for (const p of workerUserPlugins) {
-    if (p.config) {
-      const res = await p.config(workerConfig, configEnv)
+  for (const p of getSortedPluginsByHook('config', workerUserPlugins)) {
+    const hook = p.config
+    const handler = hook && 'handler' in hook ? hook.handler : hook
+    if (handler) {
+      const res = await handler(workerConfig, configEnv)
       if (res) {
         workerConfig = mergeConfig(workerConfig, res)
       }
@@ -609,7 +624,9 @@ export async function resolveConfig(
   const resolvedWorkerOptions: ResolveWorkerOptions = {
     format: workerConfig.worker?.format || 'iife',
     plugins: [],
-    rollupOptions: workerConfig.worker?.rollupOptions || {}
+    rollupOptions: workerConfig.worker?.rollupOptions || {},
+    getSortedPlugins: undefined!,
+    getSortedPluginHooks: undefined!
   }
 
   const resolvedConfig: ResolvedConfig = {
@@ -660,7 +677,9 @@ export async function resolveConfig(
       importGlobRestoreExtension: false,
       hmrPartialAccept: false,
       ...config.experimental
-    }
+    },
+    getSortedPlugins: undefined!,
+    getSortedPluginHooks: undefined!
   }
   const resolved: ResolvedConfig = {
     ...config,
@@ -673,31 +692,34 @@ export async function resolveConfig(
     normalPlugins,
     postPlugins
   )
+  Object.assign(resolved, createPluginHookUtils(resolved.plugins))
 
   const workerResolved: ResolvedConfig = {
     ...workerConfig,
     ...resolvedConfig,
     isWorker: true,
     mainConfig: resolved
   }
-
   resolvedConfig.worker.plugins = await resolvePlugins(
     workerResolved,
     workerPrePlugins,
     workerNormalPlugins,
     workerPostPlugins
   )
+  Object.assign(
+    resolvedConfig.worker,
+    createPluginHookUtils(resolvedConfig.worker.plugins)
+  )
 
   // call configResolved hooks
-  await Promise.all(
-    userPlugins
-      .map((p) => p.configResolved?.(resolved))
-      .concat(
-        resolvedConfig.worker.plugins.map((p) =>
-          p.configResolved?.(workerResolved)
-        )
-      )
-  )
+  await Promise.all([
+    ...resolved
+      .getSortedPluginHooks('configResolved')
+      .map((hook) => hook(resolved)),
+    ...resolvedConfig.worker
+      .getSortedPluginHooks('configResolved')
+      .map((hook) => hook(workerResolved))
+  ])
 
   // validate config
 

packages/vite/src/node/index.ts

@@ -50,7 +50,7 @@ export type {
   SSRFormat,
   SSRTarget
 } from './ssr'
-export type { Plugin } from './plugin'
+export type { Plugin, HookHandler } from './plugin'
 export type { PackageCache, PackageData } from './packages'
 export type {
   Logger,

packages/vite/src/node/plugin.ts

@@ -1,6 +1,7 @@
 import type {
   CustomPluginOptions,
   LoadResult,
+  ObjectHook,
   PluginContext,
   ResolveIdResult,
   Plugin as RollupPlugin,
@@ -63,14 +64,16 @@ export interface Plugin extends RollupPlugin {
    * 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>
+  config?: ObjectHook<
+    (
+      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>
+  configResolved?: ObjectHook<(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
@@ -80,7 +83,7 @@ export interface Plugin extends RollupPlugin {
    * 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
+  configureServer?: ObjectHook<ServerHook>
   /**
    * Configure the preview server. The hook receives the connect server and
    * its underlying http server.
@@ -89,7 +92,7 @@ export interface Plugin extends RollupPlugin {
    * return a post hook that will be called after other middlewares are
    * applied. Hooks can be async functions and will be called in series.
    */
-  configurePreviewServer?: PreviewServerHook
+  configurePreviewServer?: ObjectHook<PreviewServerHook>
   /**
    * Transform index.html.
    * The hook receives the following arguments:
@@ -121,36 +124,46 @@ export interface Plugin extends RollupPlugin {
    * - 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>
+  handleHotUpdate?: ObjectHook<
+    (
+      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
-      /**
-       * @internal
-       */
-      scan?: boolean
-      isEntry: boolean
-    }
-  ) => Promise<ResolveIdResult> | ResolveIdResult
-  load?: (
-    this: PluginContext,
-    id: string,
-    options?: { ssr?: boolean }
-  ) => Promise<LoadResult> | LoadResult
-  transform?: (
-    this: TransformPluginContext,
-    code: string,
-    id: string,
-    options?: { ssr?: boolean }
-  ) => Promise<TransformResult> | TransformResult
+  resolveId?: ObjectHook<
+    (
+      this: PluginContext,
+      source: string,
+      importer: string | undefined,
+      options: {
+        custom?: CustomPluginOptions
+        ssr?: boolean
+        /**
+         * @internal
+         */
+        scan?: boolean
+        isEntry: boolean
+      }
+    ) => Promise<ResolveIdResult> | ResolveIdResult
+  >
+  load?: ObjectHook<
+    (
+      this: PluginContext,
+      id: string,
+      options?: { ssr?: boolean }
+    ) => Promise<LoadResult> | LoadResult
+  >
+  transform?: ObjectHook<
+    (
+      this: TransformPluginContext,
+      code: string,
+      id: string,
+      options?: { ssr?: boolean }
+    ) => Promise<TransformResult> | TransformResult
+  >
 }
+
+export type HookHandler<T> = T extends ObjectHook<infer H> ? H : T

packages/vite/src/node/plugins/index.ts

@@ -1,7 +1,7 @@
 import aliasPlugin from '@rollup/plugin-alias'
-import type { ResolvedConfig } from '../config'
+import type { PluginHookUtils, ResolvedConfig } from '../config'
 import { isDepsOptimizerEnabled } from '../config'
-import type { Plugin } from '../plugin'
+import type { HookHandler, Plugin } from '../plugin'
 import { getDepsOptimizer } from '../optimizer'
 import { shouldExternalizeForSSR } from '../ssr/ssrExternal'
 import { jsonPlugin } from './json'
@@ -99,3 +99,60 @@ export async function resolvePlugins(
       : [clientInjectionsPlugin(config), importAnalysisPlugin(config)])
   ].filter(Boolean) as Plugin[]
 }
+
+export function createPluginHookUtils(
+  plugins: readonly Plugin[]
+): PluginHookUtils {
+  // sort plugins per hook
+  const sortedPluginsCache = new Map<keyof Plugin, Plugin[]>()
+  function getSortedPlugins(hookName: keyof Plugin): Plugin[] {
+    if (sortedPluginsCache.has(hookName))
+      return sortedPluginsCache.get(hookName)!
+    const sorted = getSortedPluginsByHook(hookName, plugins)
+    sortedPluginsCache.set(hookName, sorted)
+    return sorted
+  }
+  function getSortedPluginHooks<K extends keyof Plugin>(
+    hookName: K
+  ): NonNullable<HookHandler<Plugin[K]>>[] {
+    const plugins = getSortedPlugins(hookName)
+    return plugins
+      .map((p) => {
+        const hook = p[hookName]!
+        // @ts-expect-error cast
+        return 'handler' in hook ? hook.handler : hook
+      })
+      .filter(Boolean)
+  }
+
+  return {
+    getSortedPlugins,
+    getSortedPluginHooks
+  }
+}
+
+export function getSortedPluginsByHook(
+  hookName: keyof Plugin,
+  plugins: readonly Plugin[]
+): Plugin[] {
+  const pre: Plugin[] = []
+  const normal: Plugin[] = []
+  const post: Plugin[] = []
+  for (const plugin of plugins) {
+    const hook = plugin[hookName]
+    if (hook) {
+      if (typeof hook === 'object') {
+        if (hook.order === 'pre') {
+          pre.push(plugin)
+          continue
+        }
+        if (hook.order === 'post') {
+          post.push(plugin)
+          continue
+        }
+      }
+      normal.push(plugin)
+    }
+  }
+  return [...pre, ...normal, ...post]
+}

packages/vite/src/node/plugins/worker.ts

@@ -237,7 +237,6 @@ export function webWorkerPlugin(config: ResolvedConfig): Plugin {
             injectEnv = module?.transformResult?.code || ''
           }
         }
-
         return {
           code: injectEnv + raw
         }

packages/vite/src/node/preview.ts

@@ -87,12 +87,8 @@ export async function preview(
 
   // apply server hooks from plugins
   const postHooks: ((() => void) | void)[] = []
-  for (const plugin of config.plugins) {
-    if (plugin.configurePreviewServer) {
-      postHooks.push(
-        await plugin.configurePreviewServer({ middlewares: app, httpServer })
-      )
-    }
+  for (const hook of config.getSortedPluginHooks('configurePreviewServer')) {
+    postHooks.push(await hook({ middlewares: app, httpServer }))
   }
 
   // cors

packages/vite/src/node/server/hmr.ts

@@ -93,12 +93,10 @@ export async function handleHMRUpdate(
     server
   }
 
-  for (const plugin of config.plugins) {
-    if (plugin.handleHotUpdate) {
-      const filteredModules = await plugin.handleHotUpdate(hmrContext)
-      if (filteredModules) {
-        hmrContext.modules = filteredModules
-      }
+  for (const hook of config.getSortedPluginHooks('handleHotUpdate')) {
+    const filteredModules = await hook(hmrContext)
+    if (filteredModules) {
+      hmrContext.modules = filteredModules
     }
   }
 

packages/vite/src/node/server/index.ts

@@ -493,10 +493,8 @@ export async function createServer(
 
   // apply server configuration hooks from plugins
   const postHooks: ((() => void) | void)[] = []
-  for (const plugin of config.plugins) {
-    if (plugin.configureServer) {
-      postHooks.push(await plugin.configureServer(server))
-    }
+  for (const hook of config.getSortedPluginHooks('configureServer')) {
+    postHooks.push(await hook(server))
   }
 
   // Internal middlewares ------------------------------------------------------

packages/vite/src/node/server/pluginContainer.ts

@@ -34,14 +34,17 @@ import { join, resolve } from 'node:path'
 import { performance } from 'node:perf_hooks'
 import { createRequire } from 'node:module'
 import type {
+  AsyncPluginHooks,
   CustomPluginOptions,
   EmittedFile,
+  FunctionPluginHooks,
   InputOptions,
   LoadResult,
   MinimalPluginContext,
   ModuleInfo,
   NormalizedInputOptions,
   OutputOptions,
+  ParallelPluginHooks,
   PartialResolvedId,
   ResolvedId,
   RollupError,
@@ -74,6 +77,7 @@ import {
 } from '../utils'
 import { FS_PREFIX } from '../constants'
 import type { ResolvedConfig } from '../config'
+import { createPluginHookUtils } from '../plugins'
 import { buildErrorMessage } from './middlewares/error'
 import type { ModuleGraph } from './moduleGraph'
 
@@ -137,11 +141,19 @@ type PluginContext = Omit<
 export let parser = acorn.Parser
 
 export async function createPluginContainer(
-  { plugins, logger, root, build: { rollupOptions } }: ResolvedConfig,
+  config: ResolvedConfig,
   moduleGraph?: ModuleGraph,
   watcher?: FSWatcher
 ): Promise<PluginContainer> {
   const isDebug = process.env.DEBUG
+  const {
+    plugins,
+    logger,
+    root,
+    build: { rollupOptions }
+  } = config
+  const { getSortedPluginHooks, getSortedPlugins } =
+    createPluginHookUtils(plugins)
 
   const seenResolves: Record<string, true | undefined> = {}
   const debugResolve = createDebugger('vite:resolve')
@@ -192,6 +204,28 @@ export async function createPluginContainer(
     )
   }
 
+  // parallel, ignores returns
+  async function hookParallel<H extends AsyncPluginHooks & ParallelPluginHooks>(
+    hookName: H,
+    context: (plugin: Plugin) => ThisType<FunctionPluginHooks[H]>,
+    args: (plugin: Plugin) => Parameters<FunctionPluginHooks[H]>
+  ): Promise<void> {
+    const parallelPromises: Promise<unknown>[] = []
+    for (const plugin of getSortedPlugins(hookName)) {
+      const hook = plugin[hookName]
+      if (!hook) continue
+      const handler: Function = 'handler' in hook ? hook.handler : hook
+      if ((hook as { sequential?: boolean }).sequential) {
+        await Promise.all(parallelPromises)
+        parallelPromises.length = 0
+        await handler.apply(context(plugin), args(plugin))
+      } else {
+        parallelPromises.push(handler.apply(context(plugin), args(plugin)))
+      }
+    }
+    await Promise.all(parallelPromises)
+  }
+
   // throw when an unsupported ModuleInfo property is accessed,
   // so that incompatible plugins fail in a non-cryptic way.
   const ModuleInfoProxy: ProxyHandler<ModuleInfo> = {
@@ -500,10 +534,8 @@ export async function createPluginContainer(
   const container: PluginContainer = {
     options: await (async () => {
       let options = rollupOptions
-      for (const plugin of plugins) {
-        if (!plugin.options) continue
-        options =
-          (await plugin.options.call(minimalContext, options)) || options
+      for (const optionsHook of getSortedPluginHooks('options')) {
+        options = (await optionsHook.call(minimalContext, options)) || options
       }
       if (options.acornInjectPlugins) {
         parser = acorn.Parser.extend(
@@ -520,15 +552,10 @@ export async function createPluginContainer(
     getModuleInfo,
 
     async buildStart() {
-      await Promise.all(
-        plugins.map((plugin) => {
-          if (plugin.buildStart) {
-            return plugin.buildStart.call(
-              new Context(plugin) as any,
-              container.options as NormalizedInputOptions
-            )
-          }
-        })
+      await hookParallel(
+        'buildStart',
+        (plugin) => new Context(plugin),
+        () => [container.options as NormalizedInputOptions]
       )
     },
 
@@ -544,24 +571,23 @@ export async function createPluginContainer(
 
       let id: string | null = null
       const partial: Partial<PartialResolvedId> = {}
-      for (const plugin of plugins) {
+      for (const plugin of getSortedPlugins('resolveId')) {
         if (!plugin.resolveId) continue
         if (skip?.has(plugin)) continue
 
         ctx._activePlugin = plugin
 
         const pluginResolveStart = isDebug ? performance.now() : 0
-        const result = await plugin.resolveId.call(
-          ctx as any,
-          rawId,
-          importer,
-          {
-            custom: options?.custom,
-            isEntry: !!options?.isEntry,
-            ssr,
-            scan
-          }
-        )
+        const handler =
+          'handler' in plugin.resolveId
+            ? plugin.resolveId.handler
+            : plugin.resolveId
+        const result = await handler.call(ctx as any, rawId, importer, {
+          custom: options?.custom,
+          isEntry: !!options?.isEntry,
+          ssr,
+          scan
+        })
         if (!result) continue
 
         if (typeof result === 'string') {
@@ -607,10 +633,12 @@ export async function createPluginContainer(
       const ssr = options?.ssr
       const ctx = new Context()
       ctx.ssr = !!ssr
-      for (const plugin of plugins) {
+      for (const plugin of getSortedPlugins('load')) {
         if (!plugin.load) continue
         ctx._activePlugin = plugin
-        const result = await plugin.load.call(ctx as any, id, { ssr })
+        const handler =
+          'handler' in plugin.load ? plugin.load.handler : plugin.load
+        const result = await handler.call(ctx as any, id, { ssr })
         if (result != null) {
           if (isObject(result)) {
             updateModuleInfo(id, result)
@@ -626,15 +654,19 @@ export async function createPluginContainer(
       const ssr = options?.ssr
       const ctx = new TransformContext(id, code, inMap as SourceMap)
       ctx.ssr = !!ssr
-      for (const plugin of plugins) {
+      for (const plugin of getSortedPlugins('transform')) {
         if (!plugin.transform) continue
         ctx._activePlugin = plugin
         ctx._activeId = id
         ctx._activeCode = code
         const start = isDebug ? performance.now() : 0
         let result: TransformResult | string | undefined
+        const handler =
+          'handler' in plugin.transform
+            ? plugin.transform.handler
+            : plugin.transform
         try {
-          result = await plugin.transform.call(ctx as any, code, id, { ssr })
+          result = await handler.call(ctx as any, code, id, { ssr })
         } catch (e) {
           ctx.error(e)
         }
@@ -670,11 +702,15 @@ export async function createPluginContainer(
     async close() {
       if (closed) return
       const ctx = new Context()
-      await Promise.all(
-        plugins.map((p) => p.buildEnd && p.buildEnd.call(ctx as any))
+      await hookParallel(
+        'buildEnd',
+        () => ctx,
+        () => []
       )
-      await Promise.all(
-        plugins.map((p) => p.closeBundle && p.closeBundle.call(ctx as any))
+      await hookParallel(
+        'closeBundle',
+        () => ctx,
+        () => []
       )
       closed = true
     }

playground/lib/__tests__/lib.spec.ts

@@ -24,7 +24,7 @@ describe.runIf(isBuild)('build', () => {
     expect(await page.textContent('.iife')).toBe('It works')
     const code = readFile('dist/my-lib-custom-filename.iife.js')
     // esbuild helpers are injected inside of the IIFE wrapper
-    expect(code).toMatch(/^const MyLib=function\(\){"use strict";/)
+    expect(code).toMatch(/^var MyLib=function\(\){"use strict";/)
   })
 
   test('Library mode does not include `preload`', async () => {

playground/object-hooks/__tests__/object-hooks.spec.ts

@@ -0,0 +1,6 @@
+import { expect, test } from 'vitest'
+import { page } from '~utils'
+
+test('object hooks', async () => {
+  expect(await page.textContent('#transform')).toMatch('ok')
+})

playground/object-hooks/index.html

@@ -0,0 +1,4 @@
+<h3>Transform Hook order</h3>
+<div id="transform"></div>
+
+<script type="module" src="./main.ts"></script>

playground/object-hooks/main.ts

@@ -0,0 +1,2 @@
+const app = document.getElementById('transform')
+app.innerText = '__TRANSFORM__'

playground/object-hooks/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "test-extensions",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "debug": "node --inspect-brk ../../packages/vite/bin/vite",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.2.37"
+  }
+}

playground/object-hooks/vite.config.ts

@@ -0,0 +1,69 @@
+/* eslint-disable import/no-nodejs-modules */
+import assert from 'assert'
+import { defineConfig } from 'vite'
+
+let count = 0
+export default defineConfig({
+  plugins: [
+    {
+      name: 'plugin1',
+      buildStart: {
+        async handler() {
+          await new Promise((r) => setTimeout(r, 100))
+          count += 1
+        }
+      },
+      transform: {
+        order: 'post',
+        handler(code) {
+          return code.replace('__TRANSFORM3__', 'ok')
+        }
+      }
+    },
+    {
+      name: 'plugin2',
+      buildStart: {
+        sequential: true,
+        async handler() {
+          assert(count === 1)
+          await new Promise((r) => setTimeout(r, 100))
+          count += 1
+        }
+      },
+      transform: {
+        handler(code) {
+          return code.replace('__TRANSFORM1__', '__TRANSFORM2__')
+        }
+      }
+    },
+    {
+      name: 'plugin3',
+      buildStart: {
+        async handler() {
+          assert(count === 2)
+          await new Promise((r) => setTimeout(r, 100))
+          count += 1
+        }
+      },
+      transform: {
+        order: 'pre',
+        handler(code) {
+          return code.replace('__TRANSFORM__', '__TRANSFORM1__')
+        }
+      }
+    },
+    {
+      name: 'plugin4',
+      buildStart: {
+        async handler() {
+          assert(count === 2)
+        }
+      },
+      transform: {
+        handler(code) {
+          return code.replace('__TRANSFORM2__', '__TRANSFORM3__')
+        }
+      }
+    }
+  ]
+})