Struct ViteConfig

pub struct ViteConfig<'a> {
    pub manifest_path: &'a str,
    pub entrypoints: Option<Vec<&'a str>>,
    pub force_mode: Option<ViteMode>,
    pub use_heart_beat_check: bool,
    pub enable_dev_server: bool,
    pub server_host: Option<&'a str>,
}

Fields

manifest_path: &'a str

The path/to/manifest.json file. Currently, Vite won’t resolve relative paths, so please consider your current working directory as the root of it and start the path with a root node directory directly.

Optionally and experimentally, you can use the [resolve_path] method for the manifest file resolution. However, this method might come to fail at some point, and will also panic in the many situations described on its documentation.

Example

your_project/
|-- public/
|   |-- dist/
|   |   |-- manifest.json
|-- src/
|   |-- main.rs // <-- you're here!

 
use vite_rust::{ViteConfig, utils::resolve_path};
 
let config = ViteConfig {
    manifest_path: "public/dist/manifest.json",
    // or
    manifest_path: resolve_path(file!(), "../public/dist/manifest.json"),
    // ...
};

entrypoints: Option<Vec<&'a str>>

Defines which entrypoints Vite will use to generate the html script, link and stylesheet tags.

If None is provided, Vite will scan the manifest for files with isEntry: true property and consider them the entrypoints.

force_mode: Option<ViteMode>

If None is provided, Vite will discover which one to use considering:

• any of RUST_ENV, NODE_ENV or APP_ENV environment variables exists and is set to true;
• Dev-server is running;
• Heart beat check is enabled.

By setting this option, the discovering phase will be skipped. Refer to the crate’s README.md file to understand the way it decides which mode to pick.

use_heart_beat_check: bool

Whether Vite should ping your vite dev-server to check if its running. If false, ViteMode will be set to Development if not forced by the configuration.

enable_dev_server: bool

Whether dev server should be considered or not.

If false, force_mode should be either Manifest or None, otherwise, undefined behavior might occur.

server_host: Option<&'a str>

The host in which your vite dev-server is running. Normally, it would be "http://localhost:5173".

Please, do not forget the protocol (http, https)!

Implementations

impl<'a> ViteConfig<'a>

pub fn new_with_defaults(manifest_path: &'a str) -> Self

Create a ViteConfig instance.

You can create your config by directly instantiating the struct, or by using some default options and defining only the most critical fields:

Example

use vite_rust::ViteConfig;
 
let manual_config = ViteConfig {
    manifest_path: "path/to/manifest.json",
    entrypoints: None, // Vite can discover them by itself
    force_mode: None, // Vite can discover it too
    use_heart_beat_check: true,
    enable_dev_server: true,
    server_host: Some("http://localhost:5173")
};
 
let with_defaults_config = ViteConfig::new_with_defaults("path/to/manifest.json");
 
assert_eq!(manual_config, with_defaults_config);

Trait Implementations

impl<'a> Clone for ViteConfig<'a>

fn clone(&self) -> ViteConfig<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ViteConfig<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for ViteConfig<'a>

fn eq(&self, other: &ViteConfig<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for ViteConfig<'a>

impl<'a> StructuralPartialEq for ViteConfig<'a>