feat!: add workspace support

README.md

@@ -41,11 +41,12 @@ A blazing fast unit test framework powered by Vite.
 - Components testing ([Vue](./examples/vue), [React](./examples/react), [Svelte](./examples/svelte), [Lit](./examples/lit), [Vitesse](./examples/vitesse))
 - Workers multi-threading via [Tinypool](https://github.com/tinylibs/tinypool) (a lightweight fork of [Piscina](https://github.com/piscinajs/piscina))
 - Benchmarking support with [Tinybench](https://github.com/tinylibs/tinybench)
+- Workspaces support
 - ESM first, top level await
 - Out-of-box TypeScript / JSX support
 - Filtering, timeouts, concurrent for suite and tests
 
-> Vitest requires Vite >=v3.0.0 and Node >=v14
+> Vitest requires Vite >=v3.0.0 and Node >=v14.18
 
 
 ```ts

docs/.vitepress/components/FeaturesList.vue

@@ -13,6 +13,7 @@
     <ListItem>Workers multi-threading via <a target="_blank" href="https://github.com/tinylibs/tinypool" rel="noopener noreferrer">Tinypool</a></ListItem>
     <ListItem>Benchmarking support with <a target="_blank" href="https://github.com/tinylibs/tinybench" rel="noopener noreferrer">Tinybench</a></ListItem>
     <ListItem>Filtering, timeouts, concurrent for suite and tests</ListItem>
+    <ListItem>Workspaces support</ListItem>
     <ListItem>
       <a href="/guide/snapshot">
         Jest-compatible Snapshot

docs/guide/index.md

@@ -32,7 +32,7 @@ pnpm add -D vitest
 ```
 
 :::tip
-Vitest requires Vite >=v3.0.0 and Node >=v14
+Vitest requires Vite >=v3.0.0 and Node >=v14.18
 :::
 
 It is recommended that you install a copy of `vitest` in your `package.json`, using one of the methods listed above. However, if you would prefer to run `vitest` directly, you can use `npx vitest` (the `npx` command comes with npm and Node.js).

packages/browser/src/client/main.ts

@@ -66,6 +66,10 @@ ws.addEventListener('open', async () => {
     moduleCache: new Map(),
     rpc: client.rpc,
     safeRpc,
+    durations: {
+      environment: 0,
+      prepare: 0,
+    },
   }
 
   const paths = getQueryPaths()

packages/coverage-c8/rollup.config.js

@@ -17,6 +17,7 @@ const external = [
   ...builtinModules,
   ...Object.keys(pkg.dependencies || {}),
   ...Object.keys(pkg.peerDependencies || {}),
+  'node:inspector',
   'c8/lib/report.js',
   'c8/lib/commands/check-coverage.js',
   'vitest',

packages/runner/src/collect.ts

@@ -18,7 +18,7 @@ export async function collectTests(paths: string[], runner: VitestRunner): Promi
   for (const filepath of paths) {
     const path = relative(config.root, filepath)
     const file: File = {
-      id: generateHash(path),
+      id: generateHash(`${path}${config.name || ''}`),
       name: path,
       type: 'suite',
       mode: 'run',

packages/vitest/src/api/setup.ts

@@ -10,10 +10,13 @@ import { API_PATH } from '../constants'
 import type { Vitest } from '../node'
 import type { File, ModuleGraphData, Reporter, TaskResultPack, UserConsoleLog } from '../types'
 import { getModuleGraph, isPrimitive } from '../utils'
+import type { VitestWorkspace } from '../node/workspace'
 import { parseErrorStacktrace } from '../utils/source-map'
 import type { TransformResultWithSource, WebSocketEvents, WebSocketHandlers } from './types'
 
-export function setup(ctx: Vitest, server?: ViteDevServer) {
+export function setup(vitestOrWorkspace: Vitest | VitestWorkspace, server?: ViteDevServer) {
+  const ctx = 'ctx' in vitestOrWorkspace ? vitestOrWorkspace.ctx : vitestOrWorkspace
+
   const wss = new WebSocketServer({ noServer: true })
 
   const clients = new Map<WebSocket, BirpcReturn<WebSocketEvents>>()

packages/vitest/src/config.ts

@@ -1,9 +1,15 @@
 import type { ConfigEnv, UserConfig as ViteUserConfig } from 'vite'
+import type { WorkspaceConfig } from './types'
 
 export interface UserConfig extends ViteUserConfig {
   test?: ViteUserConfig['test']
 }
 
+export interface UserWorkspaceConfig extends ViteUserConfig {
+  extends?: string
+  test?: WorkspaceConfig
+}
+
 // will import vitest declare test in module 'vite'
 export { configDefaults, defaultInclude, defaultExclude, coverageConfigDefaults } from './defaults'
 export { mergeConfig } from 'vite'
@@ -12,6 +18,17 @@ export type { ConfigEnv }
 export type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>
 export type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFn
 
+export type UserWorkspaceConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>
+export type UserWorkspaceConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserWorkspaceConfigFn
+
 export function defineConfig(config: UserConfigExport) {
   return config
 }
+
+export function defineWorkspace(config: UserWorkspaceConfigExport) {
+  return config
+}
+
+export function defineWorkspaces(config: (string | UserWorkspaceConfigExport)[]) {
+  return config
+}

packages/vitest/src/constants.ts

@@ -1,25 +1,43 @@
 // if changed, update also jsdocs and docs
 export const defaultPort = 51204
+export const defaultBrowserPort = 63315
 
 export const EXIT_CODE_RESTART = 43
 
 export const API_PATH = '/__vitest_api__'
 
-export const configFiles = [
-  'vitest.config.ts',
-  'vitest.config.mts',
-  'vitest.config.cts',
-  'vitest.config.js',
-  'vitest.config.mjs',
-  'vitest.config.cjs',
-  'vite.config.ts',
-  'vite.config.mts',
-  'vite.config.cts',
-  'vite.config.js',
-  'vite.config.mjs',
-  'vite.config.cjs',
+export const CONFIG_NAMES = [
+  'vitest.config',
+  'vite.config',
 ]
 
+const WORKSPACES_NAMES = [
+  'vitest.workspaces',
+  'vitest.projects',
+]
+
+const CONFIG_EXTENSIONS = [
+  '.ts',
+  '.mts',
+  '.cts',
+  '.js',
+  '.mjs',
+  '.cjs',
+]
+
+export const configFiles = CONFIG_NAMES.flatMap(name =>
+  CONFIG_EXTENSIONS.map(ext => name + ext),
+)
+
+const WORKSPACES_EXTENSIONS = [
+  ...CONFIG_EXTENSIONS,
+  '.json',
+]
+
+export const workspacesFiles = WORKSPACES_NAMES.flatMap(name =>
+  WORKSPACES_EXTENSIONS.map(ext => name + ext),
+)
+
 export const globalApis = [
   // suite
   'suite',

packages/vitest/src/integrations/browser/server.ts

@@ -1,15 +1,15 @@
 import { createServer } from 'vite'
 import { resolve } from 'pathe'
 import { findUp } from 'find-up'
-import { configFiles } from '../../constants'
-import type { Vitest } from '../../node'
+import { configFiles, defaultBrowserPort } from '../../constants'
 import type { UserConfig } from '../../types/config'
 import { ensurePackageInstalled } from '../../node/pkg'
 import { resolveApiServerConfig } from '../../node/config'
 import { CoverageTransform } from '../../node/plugins/coverageTransform'
+import type { VitestWorkspace } from '../../node/workspace'
 
-export async function createBrowserServer(ctx: Vitest, options: UserConfig) {
-  const root = ctx.config.root
+export async function createBrowserServer(workspace: VitestWorkspace, options: UserConfig) {
+  const root = workspace.config.root
 
   await ensurePackageInstalled('@vitest/browser', root)
 
@@ -21,7 +21,7 @@ export async function createBrowserServer(ctx: Vitest, options: UserConfig) {
 
   const server = await createServer({
     logLevel: 'error',
-    mode: ctx.config.mode,
+    mode: workspace.config.mode,
     configFile: configPath,
     // watch is handled by Vitest
     server: {
@@ -32,29 +32,18 @@ export async function createBrowserServer(ctx: Vitest, options: UserConfig) {
     },
     plugins: [
       (await import('@vitest/browser')).default('/'),
-      CoverageTransform(ctx),
+      CoverageTransform(workspace.ctx),
       {
         enforce: 'post',
         name: 'vitest:browser:config',
         async config(config) {
           const server = resolveApiServerConfig(config.test?.browser || {}) || {
-            port: 63315,
+            port: defaultBrowserPort,
           }
 
           config.server = server
           config.server.fs = { strict: false }
 
-          config.optimizeDeps ??= {}
-          config.optimizeDeps.entries ??= []
-
-          const [...entries] = await ctx.globAllTestFiles(ctx.config, ctx.config.dir || root)
-          entries.push(...ctx.config.setupFiles)
-
-          if (typeof config.optimizeDeps.entries === 'string')
-            config.optimizeDeps.entries = [config.optimizeDeps.entries]
-
-          config.optimizeDeps.entries.push(...entries)
-
           return {
             resolve: {
               alias: config.test?.alias,
@@ -68,7 +57,7 @@ export async function createBrowserServer(ctx: Vitest, options: UserConfig) {
   await server.listen()
   await server.watcher.close()
 
-  ;(await import('../../api/setup')).setup(ctx, server)
+  ;(await import('../../api/setup')).setup(workspace, server)
 
   return server
 }

packages/vitest/src/node/browser/playwright.ts

@@ -1,7 +1,7 @@
 import type { Page } from 'playwright'
 import type { BrowserProvider, BrowserProviderOptions } from '../../types/browser'
 import { ensurePackageInstalled } from '../pkg'
-import type { Vitest } from '../core'
+import type { VitestWorkspace } from '../workspace'
 
 export const playwrightBrowsers = ['firefox', 'webkit', 'chromium'] as const
 export type PlaywrightBrowser = typeof playwrightBrowsers[number]
@@ -15,13 +15,13 @@ export class PlaywrightBrowserProvider implements BrowserProvider {
 
   private cachedBrowser: Page | null = null
   private browser!: PlaywrightBrowser
-  private ctx!: Vitest
+  private ctx!: VitestWorkspace
 
   getSupportedBrowsers() {
     return playwrightBrowsers
   }
 
-  async initialize(ctx: Vitest, { browser }: PlaywrightProviderOptions) {
+  async initialize(ctx: VitestWorkspace, { browser }: PlaywrightProviderOptions) {
     this.ctx = ctx
     this.browser = browser
 

packages/vitest/src/node/browser/webdriver.ts

@@ -1,7 +1,7 @@
 import type { Browser } from 'webdriverio'
 import type { BrowserProvider, BrowserProviderOptions } from '../../types/browser'
 import { ensurePackageInstalled } from '../pkg'
-import type { Vitest } from '../core'
+import type { VitestWorkspace } from '../workspace'
 
 export const webdriverBrowsers = ['firefox', 'chrome', 'edge', 'safari'] as const
 export type WebdriverBrowser = typeof webdriverBrowsers[number]
@@ -16,13 +16,13 @@ export class WebdriverBrowserProvider implements BrowserProvider {
   private cachedBrowser: Browser | null = null
   private stopSafari: () => void = () => {}
   private browser!: WebdriverBrowser
-  private ctx!: Vitest
+  private ctx!: VitestWorkspace
 
   getSupportedBrowsers() {
     return webdriverBrowsers
   }
 
-  async initialize(ctx: Vitest, { browser }: WebdriverProviderOptions) {
+  async initialize(ctx: VitestWorkspace, { browser }: WebdriverProviderOptions) {
     this.ctx = ctx
     this.browser = browser
 

packages/vitest/src/node/cache/files.ts

@@ -1,23 +1,36 @@
 import fs from 'node:fs'
 import type { Stats } from 'node:fs'
+import { relative } from 'pathe'
+import type { WorkspaceSpec } from '../pool'
 
 type FileStatsCache = Pick<Stats, 'size'>
 
 export class FilesStatsCache {
   public cache = new Map<string, FileStatsCache>()
 
-  public getStats(fsPath: string): FileStatsCache | undefined {
-    return this.cache.get(fsPath)
+  public getStats(key: string): FileStatsCache | undefined {
+    return this.cache.get(key)
   }
 
-  public async updateStats(fsPath: string) {
+  public async populateStats(root: string, specs: WorkspaceSpec[]) {
+    const promises = specs.map((spec) => {
+      const key = `${spec[0].getName()}:${relative(root, spec[1])}`
+      return this.updateStats(spec[1], key)
+    })
+    await Promise.all(promises)
+  }
+
+  public async updateStats(fsPath: string, key: string) {
     if (!fs.existsSync(fsPath))
       return
     const stats = await fs.promises.stat(fsPath)
-    this.cache.set(fsPath, { size: stats.size })
+    this.cache.set(key, { size: stats.size })
   }
 
   public removeStats(fsPath: string) {
-    this.cache.delete(fsPath)
+    this.cache.forEach((_, key) => {
+      if (key.endsWith(fsPath))
+        this.cache.delete(key)
+    })
   }
 }

packages/vitest/src/node/cache/index.ts

@@ -12,12 +12,12 @@ export class VitestCache {
   results = new ResultsCache()
   stats = new FilesStatsCache()
 
-  getFileTestResults(id: string) {
-    return this.results.getResults(id)
+  getFileTestResults(key: string) {
+    return this.results.getResults(key)
   }
 
-  getFileStats(id: string) {
-    return this.stats.getStats(id)
+  getFileStats(key: string) {
+    return this.stats.getStats(key)
   }
 
   static resolveCacheDir(root: string, dir: string | undefined) {