Struct AssetParserAndGenerator 

pub struct AssetParserAndGenerator {
    pub parsed_asset_config: Option<CanonicalizedDataUrlOption>,
    /* private fields */
}

Fields

parsed_asset_config: Option<CanonicalizedDataUrlOption>

Implementations

impl AssetParserAndGenerator

pub fn with_auto(option: Option<AssetParserDataUrl>, emit: bool) -> Self

pub fn with_inline() -> Self

pub fn with_resource(emit: bool) -> Self

pub fn with_source() -> Self

pub fn with_bytes() -> Self

pub fn get_import_mode( &self, module_generator_options: Option<&GeneratorOptions>, ) -> Result<AssetGeneratorImportMode>

Trait Implementations

impl Archive for AssetParserAndGenerator

where bool: Archive, DataUrlOptions: Archive, Option<CanonicalizedDataUrlOption>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedAssetParserAndGenerator

The archived representation of this type.

type Resolver = AssetParserAndGeneratorResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for AssetParserAndGenerator

fn clone(&self) -> AssetParserAndGenerator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssetParserAndGenerator

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<AssetParserAndGenerator, __D> for Archived<AssetParserAndGenerator>

where bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, DataUrlOptions: Archive, <DataUrlOptions as Archive>::Archived: Deserialize<DataUrlOptions, __D>, Option<CanonicalizedDataUrlOption>: Archive, <Option<CanonicalizedDataUrlOption> as Archive>::Archived: Deserialize<Option<CanonicalizedDataUrlOption>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<AssetParserAndGenerator, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl ParserAndGenerator for AssetParserAndGenerator

fn source_types( &self, module: &dyn Module, module_graph: &ModuleGraph, ) -> &[SourceType]

The source types that the generator can generate (the source types you can make requests for)

fn size(&self, module: &dyn Module, source_type: Option<&SourceType>) -> f64

Size of the original source

fn parse<'a, 'life0, 'async_trait>( &'life0 mut self, parse_context: ParseContext<'a>, ) -> Pin<Box<dyn Future<Output = Result<TWithDiagnosticArray<ParseResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait,

Parse the source and return the dependencies and the ast or source

fn generate<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, source: &'life1 BoxSource, module: &'life2 dyn Module, generate_context: &'life3 mut GenerateContext<'_>, ) -> Pin<Box<dyn Future<Output = Result<BoxSource>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Generate source or AST based on the built source or AST

fn get_concatenation_bailout_reason( &self, _module: &dyn Module, _mg: &ModuleGraph, _cg: &ChunkGraph, ) -> Option<Cow<'static, str>>

fn get_runtime_hash<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, module: &'life1 NormalModule, compilation: &'life2 Compilation, _runtime: Option<&'life3 RuntimeSpec>, ) -> Pin<Box<dyn Future<Output = Result<RspackHashDigest>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

impl<__S: Fallible + ?Sized> Serialize<__S> for AssetParserAndGenerator

where bool: Serialize<__S>, DataUrlOptions: Serialize<__S>, Option<CanonicalizedDataUrlOption>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.