feat(build): add vite-plus support

packages/build-info/src/build-systems/index.ts

@@ -10,6 +10,7 @@ import { NPM, PNPM, Yarn } from './package-managers.js'
 import { Pants } from './pants.js'
 import { Rush } from './rush.js'
 import { Turbo } from './turbo.js'
+import { VitePlus } from './vite-plus.js'
 
 export const buildSystems = [
   Bazel,
@@ -23,6 +24,7 @@ export const buildSystems = [
   Pants,
   Rush,
   Turbo,
+  VitePlus,
 
   // JavaScript Package managers that offer building from a workspace
   PNPM,

packages/build-info/src/build-systems/vite-plus.test.ts

@@ -0,0 +1,61 @@
+import { beforeEach, expect, test } from 'vitest'
+
+import { mockFileSystem } from '../../tests/mock-file-system.js'
+import { NodeFS } from '../node/file-system.js'
+import { Project } from '../project.js'
+
+beforeEach((ctx) => {
+  ctx.fs = new NodeFS()
+})
+
+test('detects Vite+ when vite-plus is in devDependencies', async ({ fs }) => {
+  const cwd = mockFileSystem({
+    'package.json': JSON.stringify({ devDependencies: { 'vite-plus': '^1.0.0' } }),
+  })
+  const detected = await new Project(fs, cwd).detectBuildSystem()
+
+  expect(detected[0]?.name).toBe('Vite+')
+  expect(detected[0]?.version).toBe('^1.0.0')
+})
+
+test('detects Vite+ when vite-plus is in dependencies', async ({ fs }) => {
+  const cwd = mockFileSystem({
+    'package.json': JSON.stringify({ dependencies: { 'vite-plus': '^2.0.0' } }),
+  })
+  const detected = await new Project(fs, cwd).detectBuildSystem()
+
+  expect(detected[0]?.name).toBe('Vite+')
+  expect(detected[0]?.version).toBe('^2.0.0')
+})
+
+test('does not detect Vite+ when vite-plus is absent', async ({ fs }) => {
+  const cwd = mockFileSystem({
+    'package.json': JSON.stringify({ devDependencies: { vite: '^5.0.0' } }),
+  })
+  const detected = await new Project(fs, cwd).detectBuildSystem()
+
+  expect(detected.find((b) => b.name === 'Vite+')).toBeUndefined()
+})
+
+test('generates vp run commands from package.json scripts', async ({ fs }) => {
+  const cwd = mockFileSystem({
+    'package.json': JSON.stringify({
+      devDependencies: { 'vite-plus': '^1.0.0' },
+      scripts: {
+        build: 'vite build',
+        dev: 'vite dev',
+        test: 'vitest',
+      },
+    }),
+  })
+  const project = new Project(fs, cwd)
+  const detected = await project.detectBuildSystem()
+  const vitePlus = detected.find((b) => b.name === 'Vite+')
+
+  const commands = await vitePlus!.getCommands!('')
+  expect(commands).toEqual([
+    { type: 'build', command: 'vp run build' },
+    { type: 'dev', command: 'vp run dev' },
+    { type: 'unknown', command: 'vp run test' },
+  ])
+})

packages/build-info/src/build-systems/vite-plus.ts

@@ -0,0 +1,36 @@
+import { isNpmBuildScript, isNpmDevScript } from '../get-commands.js'
+
+import { BaseBuildTool, type Command } from './build-system.js'
+
+export class VitePlus extends BaseBuildTool {
+  id = 'vite-plus'
+  name = 'Vite+'
+
+  async detect(): Promise<this | undefined> {
+    const pkgJsonPath = await this.project.fs.findUp('package.json', {
+      cwd: this.project.baseDirectory,
+      stopAt: this.project.root,
+    })
+    if (pkgJsonPath) {
+      const pkg = await this.project.fs.readJSON<Record<string, Record<string, string>>>(pkgJsonPath)
+      if (pkg.dependencies?.['vite-plus'] || pkg.devDependencies?.['vite-plus']) {
+        this.version = pkg.devDependencies?.['vite-plus'] || pkg.dependencies?.['vite-plus']
+        return this
+      }
+    }
+  }
+
+  async getCommands(packagePath: string): Promise<Command[]> {
+    const { scripts } = await this.project.fs.readJSON<Record<string, Record<string, string>>>(
+      this.project.resolveFromPackage(packagePath, 'package.json'),
+    )
+
+    if (scripts && Object.keys(scripts).length > 0) {
+      return Object.entries(scripts).map(([scriptName, value]) => ({
+        type: isNpmDevScript(scriptName, value) ? 'dev' : isNpmBuildScript(scriptName, value) ? 'build' : 'unknown',
+        command: `vp run ${scriptName}`,
+      }))
+    }
+    return []
+  }
+}

packages/build/src/plugins_core/vite_plus_setup/index.test.ts

@@ -0,0 +1,128 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { describe, expect, test, vi, beforeEach } from 'vitest'
+
+import { hasVitePlusPackage, getVitePlusVersion, installVitePlusCli } from './index.js'
+
+vi.mock('execa', () => ({
+  execa: vi.fn().mockResolvedValue({ exitCode: 0 }),
+}))
+
+vi.mock('../../utils/package.js', () => ({
+  getPackageJson: vi.fn().mockResolvedValue({ packageJson: {} }),
+}))
+
+import { execa } from 'execa'
+import { getPackageJson } from '../../utils/package.js'
+
+const mockedExeca = vi.mocked(execa)
+const mockedGetPackageJson = vi.mocked(getPackageJson)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('hasVitePlusPackage', () => {
+  test('returns true when vite-plus is in dependencies', () => {
+    expect(hasVitePlusPackage({ dependencies: { 'vite-plus': '^1.0.0' } })).toBe(true)
+  })
+
+  test('returns true when vite-plus is in devDependencies', () => {
+    expect(hasVitePlusPackage({ devDependencies: { 'vite-plus': '^1.0.0' } })).toBe(true)
+  })
+
+  test('returns false when vite-plus is not present', () => {
+    expect(hasVitePlusPackage({ dependencies: { vue: '^3.0.0' } })).toBe(false)
+  })
+
+  test('returns false for empty package.json', () => {
+    expect(hasVitePlusPackage({})).toBe(false)
+  })
+})
+
+describe('getVitePlusVersion', () => {
+  test('returns version from root devDependencies', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({
+      packageJson: { devDependencies: { 'vite-plus': '^2.0.0' } },
+    })
+
+    expect(await getVitePlusVersion('/project')).toBe('^2.0.0')
+  })
+
+  test('returns version from root dependencies', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({
+      packageJson: { dependencies: { 'vite-plus': '1.5.0' } },
+    })
+
+    expect(await getVitePlusVersion('/project')).toBe('1.5.0')
+  })
+
+  test('prefers devDependencies over dependencies', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({
+      packageJson: {
+        dependencies: { 'vite-plus': '1.0.0' },
+        devDependencies: { 'vite-plus': '2.0.0' },
+      },
+    })
+
+    expect(await getVitePlusVersion('/project')).toBe('2.0.0')
+  })
+
+  test('falls back to workspace package.json', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({ packageJson: {} })
+    mockedGetPackageJson.mockResolvedValueOnce({
+      packageJson: { devDependencies: { 'vite-plus': '3.0.0' } },
+    })
+
+    expect(await getVitePlusVersion('/project', 'packages/app')).toBe('3.0.0')
+  })
+
+  test('returns latest when not found anywhere', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({ packageJson: {} })
+
+    expect(await getVitePlusVersion('/project')).toBe('latest')
+  })
+
+  test('returns latest when not found in workspace either', async () => {
+    mockedGetPackageJson.mockResolvedValueOnce({ packageJson: {} })
+    mockedGetPackageJson.mockResolvedValueOnce({ packageJson: {} })
+
+    expect(await getVitePlusVersion('/project', 'packages/app')).toBe('latest')
+  })
+})
+
+describe('installVitePlusCli', () => {
+  test('calls curl with the install script', async () => {
+    await installVitePlusCli('1.0.0')
+
+    expect(mockedExeca).toHaveBeenCalledWith('bash', ['-c', 'curl -fsSL https://vite.plus | bash'], {
+      env: expect.objectContaining({
+        VP_VERSION: '1.0.0',
+        VITE_PLUS_VERSION: '1.0.0',
+      }),
+      stdio: 'pipe',
+    })
+  })
+
+  test('passes latest as version env vars', async () => {
+    await installVitePlusCli('latest')
+
+    expect(mockedExeca).toHaveBeenCalledWith(
+      'bash',
+      expect.any(Array),
+      expect.objectContaining({
+        env: expect.objectContaining({
+          VP_VERSION: 'latest',
+          VITE_PLUS_VERSION: 'latest',
+        }),
+      }),
+    )
+  })
+
+  test('returns the vite-plus bin directory', async () => {
+    const binDir = await installVitePlusCli('1.0.0')
+
+    expect(binDir).toBe(join(homedir(), '.vite-plus', 'bin'))
+  })
+})

packages/build/src/plugins_core/vite_plus_setup/index.ts

@@ -0,0 +1,93 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { execa } from 'execa'
+
+import { log } from '../../log/logger.js'
+import { THEME } from '../../log/theme.js'
+import { getPackageJson, type PackageJson } from '../../utils/package.js'
+import { CoreStep, CoreStepCondition, CoreStepFunction } from '../types.js'
+
+const NPM_PACKAGE_NAME = 'vite-plus'
+const INSTALL_URL = 'https://vite.plus'
+
+export const hasVitePlusPackage = (packageJSON: PackageJson): boolean => {
+  const { dependencies = {}, devDependencies = {} } = packageJSON
+
+  return NPM_PACKAGE_NAME in dependencies || NPM_PACKAGE_NAME in devDependencies
+}
+
+export const getVitePlusVersion = async (buildDir: string, packagePath?: string): Promise<string> => {
+  const { packageJson } = await getPackageJson(buildDir)
+  const version = packageJson.devDependencies?.[NPM_PACKAGE_NAME] || packageJson.dependencies?.[NPM_PACKAGE_NAME]
+
+  if (version) {
+    return version
+  }
+
+  if (packagePath) {
+    const { packageJson: workspacePackageJson } = await getPackageJson(join(buildDir, packagePath))
+    return (
+      workspacePackageJson.devDependencies?.[NPM_PACKAGE_NAME] ||
+      workspacePackageJson.dependencies?.[NPM_PACKAGE_NAME] ||
+      'latest'
+    )
+  }
+
+  return 'latest'
+}
+
+export const installVitePlusCli = async (version: string): Promise<string> => {
+  await execa('bash', ['-c', `curl -fsSL ${INSTALL_URL} | bash`], {
+    env: { ...process.env, VP_VERSION: version, VITE_PLUS_VERSION: version },
+    stdio: 'pipe',
+  })
+
+  const vitePlusBinDir = join(homedir(), '.vite-plus', 'bin')
+  return vitePlusBinDir
+}
+
+const condition: CoreStepCondition = async ({ buildDir, packagePath, featureFlags }) => {
+  if (!featureFlags?.netlify_build_vite_plus_setup) {
+    return false
+  }
+
+  const { packageJson } = await getPackageJson(buildDir)
+
+  if (hasVitePlusPackage(packageJson)) {
+    return true
+  }
+
+  if (packagePath) {
+    const { packageJson: workspacePackageJson } = await getPackageJson(join(buildDir, packagePath))
+
+    if (hasVitePlusPackage(workspacePackageJson)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+const coreStep: CoreStepFunction = async ({ buildDir, packagePath, logs }) => {
+  const version = await getVitePlusVersion(buildDir, packagePath)
+
+  log(logs, `Installing Vite+ CLI${version !== 'latest' ? ` (${THEME.highlightWords(version)})` : ''}`)
+
+  const vitePlusBinDir = await installVitePlusCli(version)
+  const newPath = `${vitePlusBinDir}:${process.env.PATH}`
+  process.env.PATH = newPath
+
+  log(logs, `Vite+ CLI installed successfully`)
+
+  return { newEnvChanges: { PATH: newPath } }
+}
+
+export const vitePlusSetup: CoreStep = {
+  event: 'onPreBuild',
+  coreStep,
+  coreStepId: 'vite_plus_setup',
+  coreStepName: 'Vite+ setup',
+  coreStepDescription: () => 'Installing Vite+ CLI',
+  condition,
+}

packages/build/src/steps/get.ts

@@ -8,6 +8,7 @@ import { bundleEdgeFunctions } from '../plugins_core/edge_functions/index.js'
 import { applyDeployConfig } from '../plugins_core/frameworks_api/index.js'
 import { bundleFunctions } from '../plugins_core/functions/index.js'
 import { dbSetup } from '../plugins_core/db_setup/index.js'
+import { vitePlusSetup } from '../plugins_core/vite_plus_setup/index.js'
 import { copyDbMigrations } from '../plugins_core/db_setup/migrations.js'
 import { preCleanup } from '../plugins_core/pre_cleanup/index.js'
 import { preDevCleanup } from '../plugins_core/pre_dev_cleanup/index.js'
@@ -78,6 +79,7 @@ const getEventSteps = function (eventHandlers?: any[]) {
 const addCoreSteps = function (steps): CoreStep[] {
   return [
     preCleanup,
+    vitePlusSetup,
     dbSetup,
     buildCommandCore,
     applyDeployConfig,