API JavaScript #

function asynchrone createServer(inlineConfig? : InlineConfig) : Promise<ViteDevServer> : 1.

import { fileURLToPath } from 'url' (en anglais)
import { createServer } from 'vite' (en anglais)

const __dirname = fileURLToPath(new URL('.', import.meta.url))

;(async () => {
  const server = await createServer({
    // toutes les options valides de configuration de l'utilisateur, plus `mode` et `configFile`.
    configFile : false,
    root : __dirname,
    server : {
      port : 1337
    }
  })
  attendez que server.listen()

  server.printUrls()
})()

interface ViteDevServer {
  /**
   * L'objet de configuration Vite résolu.
   */
  config : ResolvedConfig
  /**
   * Une instance d'application de connexion
   * - Peut être utilisée pour attacher des middlewares personnalisés au serveur de développement.
   * Peut également être utilisée comme fonction de gestion d'un serveur http personnalisé.
   * ou en tant qu'intergiciel dans tout cadre Node.js de type connect.
   *
   * https://github.com/senchalabs/connect#use-middleware
   */
  middlewares : Connect.Server
  /**
   * Instance de serveur http native de Node.
   * Sera nulle en mode middleware.
   */
  httpServer : http.Server | null
  /**
   * Instance de l'observateur de Chokidar.
   * https://github.com/paulmillr/chokidar#api
   */
  watcher : FSWatcher
  /**
   * Serveur de socket Web avec la méthode `send(payload)`.
   */
  ws : WebSocketServer
  /**
   * Conteneur de plugin Rollup qui peut exécuter les hooks de plugin sur un fichier donné.
   */
  pluginContainer : PluginContainer
  /**
   * Graphique de module qui suit les relations d'importation, le mappage url/fichier et l'état de l'hmr.
   * et l'état de l'hmr.
   */
  moduleGraph : ModuleGraph
  /**
   * Les urls résolues que Vite imprime sur la CLI. null en mode middleware ou
   * avant que `server.listen` ne soit appelé.
   */
  resolvedUrls : ResolvedServerUrls | null
  /**
   * Résoudre, charger et transformer une URL de manière programmée et obtenir le résultat sans passer par le pipeline de requêtes http.
   * sans passer par le pipeline de requête http.
   */
  transformRequest(
    url : string,
    options ? TransformOptions
  ) : Promise<TransformResult | null>
  /**
   * Applique les transformations HTML intégrées de Vite et les transformations HTML des plugins.
   */
  transformIndexHtml(url : string, html : string) : Promise<string>
  /**
   * Charge une URL donnée en tant que module instancié pour SSR.
   */
  ssrLoadModule(
    url : string,
    options ? { fixStacktrace? : boolean }
  ) : Promise<Record<string, any>>
  /**
   * Fixe le stacktrace de l'erreur ssr.
   */
  ssrFixStacktrace(e : Error) : void
  /**
   * Déclenche HMR pour un module dans le graphe des modules. Vous pouvez utiliser l'API `server.moduleGraph' * pour récupérer le module à utiliser.
   * pour récupérer le module à recharger. Si `hmr` est false, c'est un no-op.
   */
  reloadModule(module : ModuleNode) : Promise<void>
  /**
   * Démarre le serveur.
   */
  listen(port? : nombre, isRestart? : booléen) : Promise<ViteDevServer> : boolean
  /**
   * Redémarrer le serveur.
   *
   * @param forceOptimize - Force l'optimiseur à re-bundle, comme le drapeau cli --force.
   */
  restart(forceOptimize? : booléen) : Promise<void>
  /**
   * Arrête le serveur.
   */
  close() : Promise<void>
}

function asynchrone build(
  inlineConfig ? InlineConfig
) : Promise<RollupOutput|RollupOutput[]>

import path from 'path'
import { fileURLToPath } from 'url'
import { build } from 'vite'

const __dirname = fileURLToPath(new URL('.', import.meta.url))

;(async () => {
  await build({
    root : path.resolve(__dirname, './project'),
    base : '/foo/',
    build : {
      rollupOptions : {
        // ...
      }
    }
  })
})()

funciton asynchrone preview(inlineConfig? : InlineConfig) : Promise<PreviewServer>

import { preview } from 'vite'
;(async () => {
  const previewServer = await preview({
    // toute option de configuration utilisateur valide, plus `mode` et `configFile`.
    aperçu : {
      port : 8080,
      open : true
    }
  })

  previewServer.printUrls()
})()

function asynchrone resolveConfig(
  inlineConfig : InlineConfig,
  command : 'build' | 'serve',
  defaultMode = 'development'
) : Promise<ResolvedConfig>

function mergeConfig(
  par défaut : Record<string, any>,
  dérogations : Record<string, any>,
  isRoot = true
) : Record<string, any>

fonction searchForWorkspaceRoot(
  current : chaîne,
  root = searchForPackageRoot(current)
) : chaîne

fonction loadEnv(
  mode : string,
  envDir : string,
  préfixes : chaîne de caractères | chaîne de caractères[] = 'VITE_'
) : Record<string, string>

fonction normalizePath(id : string) : string

fonction asynchrone transformWithEsbuild(
  code : chaîne,
  filename : string,
  options ? EsbuildTransformOptions,
  inMap? : objet
) : Promise<ESBuildTransformResult> (Promesse)

Fonction asynchrone loadConfigFromFile(
  configEnv : ConfigEnv,
  configFile : string,
  configRoot : string = process.cwd(),
  logLevel ? LogLevel
) : Promise<{
  path : string
  config : UserConfig
  dépendances : string[]
} | null>