Struct ManifestChunk 

pub struct ManifestChunk<S = String, Vs = Vec<S>, Vu8 = Vec<u8>> {

    pub key: S,
    pub contents: Vu8,
    pub hash: S,
    pub mime_type: S,
    pub src: Option<S>,
    pub file: S,
    pub css: Vs,
    pub assets: Vs,
    pub is_entry: bool,
    pub name: Option<S>,
    pub is_dynamic_entry: bool,
    pub imports: Vs,
    pub dynamic_imports: Vs,
}

Vite manifest chunk.

Where possible, use StaticManifestChunk and DynamicManifestChunk instead.

See Vite documentation

Generics

• Generic S can be used to change type of strings in struct.
• Generic Vs can be used to change type of array of strings.
• Generic Vu8 can be used to change type of byte arrays (f.e. Vec<u8> or &[u8]).

Fields

key: S

The key of this chunk in manifest.

This field is added by vite-static and skipped during (de)serialization.

contents: Vu8

The contents of manifest chunk.

This field is added by vite-static and skipped during (de)serialization.

hash: S

Hash of this chunk. Derive macro uses BLAKE3 as hashing algorithm.

This field is added by vite-static and skipped during (de)serialization.

mime_type: S

Mime type of this chunk.

This field is added by vite-static and skipped during (de)serialization.

src: Option<S>

The input file name of this chunk/asset if known.

file: S

The output file name of this chunk/asset.

css: Vs

The list of CSS files imported by this chunk.

assets: Vs

The list of asset files imported by this chunk, excluding CSS files.

is_entry: bool

Whether this chunk or asset is an entry point

name: Option<S>

The name of this chunk/asset if known.

is_dynamic_entry: bool

Whether this chunk is a dynamic entry point

This field is only present in JS chunks.

imports: Vs

The list of statically imported chunks by this chunk

The values are the keys of the manifest. This field is only present in JS chunks.

dynamic_imports: Vs

The list of dynamically imported chunks by this chunk

The values are the keys of the manifest. This field is only present in JS chunks.

Trait Implementations

impl<S, Vs, Vu8> Clone for ManifestChunk<S, Vs, Vu8>

where S: Clone, Vs: Clone, Vu8: Clone,

fn clone(&self) -> ManifestChunk<S, Vs, Vu8>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, Vs, Vu8> Copy for ManifestChunk<S, Vs, Vu8>

where S: Copy, Vs: Copy, Vu8: Copy,

impl<S, Vs, Vu8> Debug for ManifestChunk<S, Vs, Vu8>

where S: Debug, Vs: Debug, Vu8: Debug,

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

Formats the value using the given formatter.

impl<S, Vs, Vu8> Default for ManifestChunk<S, Vs, Vu8>

where S: Default, Vs: Default, Vu8: Default,

fn default() -> ManifestChunk<S, Vs, Vu8>

Returns the “default value” for a type.

impl<'de, S, Vs, Vu8> Deserialize<'de> for ManifestChunk<S, Vs, Vu8>

where S: Deserialize<'de> + Default, Vs: Deserialize<'de> + Default, Vu8: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ManifestChunk<S, Vs, Vu8>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, Vs, Vu8> Eq for ManifestChunk<S, Vs, Vu8>

where S: Eq, Vs: Eq, Vu8: Eq,

impl<S, Vs, Vu8> Hash for ManifestChunk<S, Vs, Vu8>

where S: Hash, Vs: Hash, Vu8: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S, Vs, Vu8> PartialEq for ManifestChunk<S, Vs, Vu8>

where S: PartialEq, Vs: PartialEq, Vu8: PartialEq,

fn eq(&self, other: &ManifestChunk<S, Vs, Vu8>) -> 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<S, Vs, Vu8> Serialize for ManifestChunk<S, Vs, Vu8>

where S: Serialize, Vs: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S, Vs, Vu8> StructuralPartialEq for ManifestChunk<S, Vs, Vu8>

where S: PartialEq, Vs: PartialEq, Vu8: PartialEq,