Enum NormalModule 

pub enum NormalModule {
    Owned(Box<NormalModuleInner>),
    Transferred,
}

Variants

Owned(Box<NormalModuleInner>)

Transferred

Implementations

impl NormalModule

pub fn new( request: String, user_request: String, raw_request: String, module_type: impl Into<ModuleType>, layer: Option<ModuleLayer>, parser_and_generator: Box<dyn ParserAndGenerator>, parser_options: Option<ParserOptions>, generator_options: Option<GeneratorOptions>, match_resource: Option<ResourceData>, resource_data: Arc<ResourceData>, resolve_options: Option<Arc<Resolve>>, loaders: Vec<BoxLoader>, context: Option<Context>, extract_source_map: Option<bool>, ) -> Self

pub fn id(&self) -> ModuleIdentifier

pub fn match_resource(&self) -> Option<&ResourceData>

pub fn match_resource_mut(&mut self) -> &mut Option<ResourceData>

pub fn resource_resolved_data(&self) -> &Arc<ResourceData>

pub fn request(&self) -> &str

pub fn user_request(&self) -> &str

pub fn user_request_mut(&mut self) -> &mut String

pub fn raw_request(&self) -> &str

pub fn loaders(&self) -> &[BoxLoader]

pub fn parser_and_generator(&self) -> &dyn ParserAndGenerator

pub fn parser_and_generator_mut(&mut self) -> &mut Box<dyn ParserAndGenerator>

pub fn code_generation_dependencies(&self) -> &Option<Vec<BoxModuleDependency>>

pub fn code_generation_dependencies_mut( &mut self, ) -> &mut Option<Vec<BoxModuleDependency>>

pub fn presentational_dependencies(&self) -> &Option<Vec<BoxDependencyTemplate>>

pub fn presentational_dependencies_mut( &mut self, ) -> &mut Option<Vec<BoxDependencyTemplate>>

pub fn get_parser_options(&self) -> Option<&ParserOptions>

pub fn get_generator_options(&self) -> Option<&GeneratorOptions>

Trait Implementations

impl Archive for NormalModule

where Box<NormalModuleInner>: Archive,

type Archived = ArchivedNormalModule

The archived representation of this type.

type Resolver = NormalModuleResolver

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.

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.

impl Debug for NormalModule

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

Formats the value using the given formatter.

impl DependenciesBlock for NormalModule

fn add_block_id(&mut self, block: AsyncDependenciesBlockIdentifier)

fn get_blocks(&self) -> &[AsyncDependenciesBlockIdentifier]

fn add_dependency_id(&mut self, dependency: DependencyId)

fn remove_dependency_id(&mut self, dependency: DependencyId)

fn get_dependencies(&self) -> &[DependencyId]

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

where Box<NormalModuleInner>: Archive, <Box<NormalModuleInner> as Archive>::Archived: Deserialize<Box<NormalModuleInner>, __D>,

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

Deserializes using the given deserializer

impl Diagnosable for NormalModule

fn add_diagnostic(&mut self, diagnostic: Diagnostic)

fn add_diagnostics(&mut self, diagnostics: Vec<Diagnostic>)

fn diagnostics(&self) -> Cow<'_, [Diagnostic]>

fn first_error(&self) -> Option<Cow<'_, Diagnostic>>

impl Identifiable for NormalModule

fn identifier(&self) -> ModuleIdentifier

impl Module for NormalModule

fn module_type(&self) -> &ModuleType

Defines what kind of module this is.

fn source_types(&self, module_graph: &ModuleGraph<'_>) -> &[SourceType]

Defines what kind of code generation results this module can generate.

fn source(&self) -> Option<&BoxSource>

The source of the module. This could be optional, modules like the NormalModule can have the corresponding source. However, modules that is created from “nowhere” (e.g. ExternalModule and MissingModule) does not have its source.

fn readable_identifier(&self, context: &Context) -> Cow<'_, str>

User readable identifier of the module.

fn size( &self, source_type: Option<&SourceType>, _compilation: Option<&Compilation>, ) -> f64

The size of the original source, which will used as a parameter for code-splitting. Only when calculating the size of the RuntimeModule is the Compilation depended on

fn build<'life0, 'life1, 'async_trait>( &'life0 mut self, build_context: BuildContext, _compilation: Option<&'life1 Compilation>, ) -> Pin<Box<dyn Future<Output = Result<BuildResult>> + Send + 'async_trait>>

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

The actual build of the module, which will be called by the Compilation. Build can also returns the dependencies of the module, which will be used by the Compilation to build the dependency graph.

fn code_generation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, compilation: &'life1 Compilation, runtime: Option<&'life2 RuntimeSpec>, concatenation_scope: Option<ConcatenationScope>, ) -> Pin<Box<dyn Future<Output = Result<CodeGenerationResult>> + Send + 'async_trait>>

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

The actual code generation of the module, which will be called by the Compilation. The code generation result should not be cached as it is implemented elsewhere to provide a universal cache mechanism (time to invalidate cache, etc.)

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

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

Update hash for cgm.hash (chunk graph module hash) Different cgm code generation result should have different cgm.hash, so this also accept compilation (mainly chunk graph) and runtime as args. (Difference with impl Hash for Module: this is just a part for calculating cgm.hash, not for Module itself)

fn name_for_condition(&self) -> Option<Box<str>>

Name matched against bundle-splitting conditions.

fn lib_ident(&self, options: LibIdentOptions<'_>) -> Option<Cow<'_, str>>

fn get_resolve_options(&self) -> Option<Arc<Resolve>>

Resolve options matched by module rules. e.g javascript/esm may have special resolving options like fullySpecified. css and css/module may have special resolving options like preferRelative.

fn get_code_generation_dependencies(&self) -> Option<&[BoxModuleDependency]>

Code generation dependencies of the module, which means the code generation of this module depends on the code generation results of dependencies which are returned by this function. e.g Css module may rely on the code generation result of CssUrlDependency to re-direct the url of the referenced assets.

fn get_presentational_dependencies(&self) -> Option<&[BoxDependencyTemplate]>

fn get_context(&self) -> Option<Box<Context>>

fn get_layer(&self) -> Option<&ModuleLayer>

fn get_side_effects_connection_state( &self, module_graph: &ModuleGraph<'_>, module_graph_cache: &ModuleGraphCacheArtifact, module_chain: &mut IdentifierSet, connection_state_cache: &mut IdentifierMap<ConnectionState>, ) -> ConnectionState

fn get_concatenation_bailout_reason( &self, mg: &ModuleGraph<'_>, cg: &ChunkGraph, ) -> Option<Cow<'static, str>>

fn factory_meta(&self) -> Option<&FactoryMeta>

fn set_factory_meta(&mut self, factory_meta: FactoryMeta)

fn build_info(&self) -> &BuildInfo

fn build_info_mut(&mut self) -> &mut BuildInfo

fn build_meta(&self) -> &BuildMeta

fn build_meta_mut(&mut self) -> &mut BuildMeta

fn get_exports_argument(&self) -> ExportsArgument

fn get_module_argument(&self) -> ModuleArgument

fn get_exports_type( &self, module_graph: &ModuleGraph<'_>, module_graph_cache: &ModuleGraphCacheArtifact, strict: bool, ) -> ExportsType

fn get_strict_esm_module(&self) -> bool

fn chunk_condition( &self, _chunk_key: &ChunkUkey, _compilation: &Compilation, ) -> Option<bool>

fn need_build(&self, value_cache_version: &ValueCacheVersions) -> bool

fn need_id(&self) -> bool

impl ModuleSourceMapConfig for NormalModule

fn get_source_map_kind(&self) -> &SourceMapKind

fn set_source_map_kind(&mut self, source_map_kind: SourceMapKind)

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

where Box<NormalModuleInner>: 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.