Struct RuntimeModuleFromJs 

pub struct RuntimeModuleFromJs {
    pub name: String,
    pub generator: Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>,
    pub full_hash: bool,
    pub dependent_hash: bool,
    pub isolate: bool,
    pub stage: RuntimeModuleStage,
    pub source_map_kind: SourceMapKind,
    pub custom_source: Option<String>,
    pub cached_generated_code: Arc<OnceCell<BoxSource>>,
}

Fields

name: String

generator: Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>

full_hash: bool

dependent_hash: bool

isolate: bool

stage: RuntimeModuleStage

source_map_kind: SourceMapKind

custom_source: Option<String>

cached_generated_code: Arc<OnceCell<BoxSource>>

Trait Implementations

impl Archive for RuntimeModuleFromJs

where String: Archive, Unsupported: ArchiveWith<Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>>, bool: Archive, RuntimeModuleStage: Archive, SourceMapKind: Archive, Option<String>: Archive, Skip: ArchiveWith<Arc<OnceCell<BoxSource>>>,

type Archived = ArchivedRuntimeModuleFromJs

The archived representation of this type.

type Resolver = RuntimeModuleFromJsResolver

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 CustomSourceRuntimeModule for RuntimeModuleFromJs

fn set_custom_source(&mut self, source: String)

fn get_custom_source(&self) -> Option<String>

fn get_constructor_name(&self) -> String

impl Debug for RuntimeModuleFromJs

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

Formats the value using the given formatter.

impl DependenciesBlock for RuntimeModuleFromJs

fn add_block_id(&mut self, _: AsyncDependenciesBlockIdentifier)

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

fn add_dependency_id(&mut self, _: DependencyId)

fn remove_dependency_id(&mut self, _: DependencyId)

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

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

where String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Unsupported: ArchiveWith<Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>> + DeserializeWith<<Unsupported as ArchiveWith<Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>>>::Archived, Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, RuntimeModuleStage: Archive, <RuntimeModuleStage as Archive>::Archived: Deserialize<RuntimeModuleStage, __D>, SourceMapKind: Archive, <SourceMapKind as Archive>::Archived: Deserialize<SourceMapKind, __D>, Option<String>: Archive, <Option<String> as Archive>::Archived: Deserialize<Option<String>, __D>, Skip: ArchiveWith<Arc<OnceCell<BoxSource>>> + DeserializeWith<<Skip as ArchiveWith<Arc<OnceCell<BoxSource>>>>::Archived, Arc<OnceCell<BoxSource>>, __D>,

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

Deserializes using the given deserializer

impl Diagnosable for RuntimeModuleFromJs

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 RuntimeModuleFromJs

fn identifier(&self) -> Identifier

impl Module for RuntimeModuleFromJs

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 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 readable_identifier(&self, _context: &Context) -> Cow<'_, str>

User readable identifier of the module.

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 factory_meta(&self) -> Option<&FactoryMeta>

fn set_factory_meta(&mut self, v: 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 code_generation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, compilation: &'life1 Compilation, _runtime: Option<&'life2 RuntimeSpec>, __arg3: 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 build<'life0, 'life1, 'async_trait>( &'life0 mut self, _build_context: BuildContext, _compilation: Option<&'life1 Compilation>, ) -> Pin<Box<dyn Future<Output = Result<BuildResult, Report>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: '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 get_exports_argument(&self) -> ExportsArgument

fn get_module_argument(&self) -> ModuleArgument

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

fn get_strict_esm_module(&self) -> bool

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_code_generation_dependencies( &self, ) -> Option<&[Box<dyn ModuleDependency>]>

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<&[Box<dyn DependencyCodeGeneration>]>

fn get_concatenation_bailout_reason( &self, _mg: &ModuleGraph<'_>, _cg: &ChunkGraph, ) -> Option<Cow<'static, 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_context(&self) -> Option<Box<Context>>

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

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

fn get_side_effects_connection_state( &self, _module_graph: &ModuleGraph<'_>, _module_graph_cache: &Arc<ModuleGraphCacheArtifactInner>, _module_chain: &mut HashSet<Identifier, BuildHasherDefault<IdentityHasher>>, _connection_state_cache: &mut HashMap<Identifier, ConnectionState, BuildHasherDefault<IdentityHasher>>, ) -> ConnectionState

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

fn depends_on(&self, modified_file: &HashSet<ArcPath, FxBuildHasher>) -> bool

fn need_id(&self) -> bool

impl ModuleSourceMapConfig for RuntimeModuleFromJs

fn get_source_map_kind(&self) -> &SourceMapKind

fn set_source_map_kind(&mut self, source_map_kind: SourceMapKind)

impl RuntimeModule for RuntimeModuleFromJs

fn name(&self) -> Identifier

fn generate<'life0, 'life1, 'async_trait>( &'life0 self, _: &'life1 Compilation, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

fn full_hash(&self) -> bool

fn dependent_hash(&self) -> bool

fn should_isolate(&self) -> bool

fn stage(&self) -> RuntimeModuleStage

fn attach(&mut self, _chunk: ChunkUkey)

fn template(&self) -> Vec<(String, String)>

fn generate_with_custom<'life0, 'life1, 'async_trait>( &'life0 self, compilation: &'life1 Compilation, ) -> Pin<Box<dyn Future<Output = Result<String, Report>> + Send + 'async_trait>>

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

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

where String: Serialize<__S>, Unsupported: SerializeWith<Arc<dyn Fn() -> BoxFuture<'static, Result<String>> + Send + Sync>, __S>, bool: Serialize<__S>, RuntimeModuleStage: Serialize<__S>, SourceMapKind: Serialize<__S>, Option<String>: Serialize<__S>, Skip: SerializeWith<Arc<OnceCell<BoxSource>>, __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.