Struct NodeJsChunkingContext 

pub struct NodeJsChunkingContext { /* private fields */ }

A chunking context for build mode.

Implementations

impl NodeJsChunkingContext

pub fn builder( root_path: FileSystemPath, output_root: FileSystemPath, output_root_to_root_path: RcStr, client_root: FileSystemPath, chunk_root_path: FileSystemPath, asset_root_path: FileSystemPath, environment: ResolvedVc<Environment>, runtime_type: RuntimeType, ) -> NodeJsChunkingContextBuilder

Creates a new chunking context builder.

impl NodeJsChunkingContext

pub fn runtime_type(self: Vc<Self>) -> Vc<RuntimeType>

Returns the kind of runtime to include in output chunks.

This is defined directly on NodeJsChunkingContext so it is zero-cost when RuntimeType has a single variant.

pub fn minify_type(self: Vc<Self>) -> Vc<MinifyType>

Returns the minify type.

pub fn hash_salt(self: Vc<Self>) -> Vc<RcStr>

pub fn asset_prefix(self: Vc<Self>) -> Vc<Option<RcStr>>

pub fn server_hmr_chunk_list( self: Vc<Self>, path: FileSystemPath, chunks: Vc<OutputAssets>, ) -> Vc<Box<dyn OutputAsset>>

Creates a standalone server-HMR tracking anchor at path covering chunks, without producing an evaluate chunk.

Unlike the browser’s hmr_chunk_list, the caller supplies an explicit output path so the anchor can be placed alongside the App Router entries it belongs to (under server/app/). This is what lets the aggregate server-HMR subscription scope tracking to App Router: the anchor for client-component SSR chunks (which are physically emitted under the shared server/chunks/ssr/) is registered under the app entry’s directory so it rides the same App Router scope.

pub fn shared_runtime_chunk(self: Vc<Self>) -> Vc<bool>

Whether the runtime chunk is shared with other module graphs using this context, meaning no single graph may decide which optional runtime features to omit. See NodeJsChunkingContextBuilder::shared_runtime_chunk.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for NodeJsChunkingContext

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl ChunkingContext for NodeJsChunkingContext

fn name(self: Vc<Self>) -> Vc<RcStr>

fn root_path(self: Vc<Self>) -> Vc<FileSystemPath>

The root path of the project

fn output_root(self: Vc<Self>) -> Vc<FileSystemPath>

The output root path in the output filesystem

fn output_root_to_root_path(self: Vc<Self>) -> Vc<RcStr>

A relative path how to reach the root path from the output root. This is used to compute original paths at runtime relative to the output files. e. g. import.meta.url needs that.

fn environment(self: Vc<Self>) -> Vc<Environment>

fn is_nested_async_availability_enabled(self: Vc<Self>) -> Vc<bool>

Whether async modules should create an new availability boundary and therefore nested async modules include less modules. Enabling this will lead to better optimized async chunks, but it will require to compute all possible paths in the application, which might lead to many combinations.

fn is_module_merging_enabled(self: Vc<Self>) -> Vc<bool>

Whether to use MergeableModule to merge modules if possible.

fn is_dynamic_chunk_content_loading_enabled(self: Vc<Self>) -> Vc<bool>

Whether to include information about the content of the chunk into the runtime, to allow more incremental loading of individual chunk items.

fn minify_type(self: Vc<Self>) -> Vc<MinifyType>

fn asset_url( self: Vc<Self>, ident: FileSystemPath, tag: Option<RcStr>, ) -> Vc<RcStr>

Returns a URL (relative or absolute, depending on the asset prefix) to the static asset based on its ident. The tag is an arbitrary string that can be used to distinguish different usages of the same asset (e.g. different base paths).

fn chunk_root_path(self: Vc<Self>) -> Vc<FileSystemPath>

The path to the folder where all chunks are placed. This can be used to compute relative paths.

fn chunk_path( self: Vc<Self>, _asset: Option<Vc<Box<dyn Asset>>>, ident: Vc<AssetIdent>, prefix: Option<RcStr>, extension: RcStr, ) -> Vc<FileSystemPath>

fn reference_chunk_source_maps( self: Vc<Self>, _chunk: Vc<Box<dyn OutputAsset>>, ) -> Vc<bool>

Reference Source Map Assets for chunks

fn reference_module_source_maps( self: Vc<Self>, _module: Vc<Box<dyn Module>>, ) -> Vc<bool>

Include Source Maps for modules

fn source_map_source_type(self: Vc<Self>) -> Vc<SourceMapSourceType>

fn chunking_configs(self: Vc<Self>) -> Vc<ChunkingConfigs>

fn asset_path( self: Vc<Self>, content: Vc<AssetContent>, original_asset_ident: Vc<AssetIdent>, tag: Option<RcStr>, ) -> Vc<FileSystemPath>

fn url_behavior(self: Vc<Self>, tag: Option<RcStr>) -> Vc<UrlBehavior>

Returns the URL behavior for a given tag. This determines how asset URLs are suffixed (e.g., for deployment IDs).

fn chunk_group( self: Vc<Self>, ident: Vc<AssetIdent>, chunk_group: ChunkGroup, module_graph: Vc<ModuleGraph>, availability_info: AvailabilityInfo, ) -> Vc<ChunkGroupResult>

fn entry_chunk_group( self: Vc<Self>, path: FileSystemPath, chunk_group: ChunkGroup, module_graph: Vc<ModuleGraph>, extra_chunks: Vc<OutputAssets>, extra_referenced_assets: Vc<OutputAssets>, availability_info: AvailabilityInfo, ) -> Vc<EntryChunkGroupResult>

Generates an output chunk that:

fn evaluated_chunk_group( self: Vc<Self>, _ident: Vc<AssetIdent>, _chunk_group: ChunkGroup, _module_graph: Vc<ModuleGraph>, _extra_chunks: Vc<OutputAssets>, _availability_info: AvailabilityInfo, ) -> Vc<ChunkGroupResult>

Like [Self::chunk_group], but additionally produces an evaluate chunk (and, in dev, a chunk-list register chunk) that bootstraps and runs chunk_group’s entries.

fn chunk_item_id_strategy(self: Vc<Self>) -> Vc<ModuleIdStrategy>

fn async_loader_chunk_item( self: Vc<Self>, module: Vc<Box<dyn ChunkableModule>>, module_graph: Vc<ModuleGraph>, availability_info: AvailabilityInfo, ) -> Vc<Box<dyn ChunkItem>>

fn async_loader_chunk_item_ident( self: Vc<Self>, module: Vc<Box<dyn ChunkableModule>>, ) -> Vc<AssetIdent>

fn module_export_usage( self: Vc<Self>, module: Vc<Box<dyn Module>>, ) -> Vc<ModuleExportUsage>

fn unused_references(self: Vc<Self>) -> Vc<UnusedReferences>

fn debug_ids_enabled(self: Vc<Self>) -> Vc<bool>

Returns whether debug IDs are enabled for this chunking context.

fn worker_configuration_options( self: Vc<Self>, ) -> Vc<WorkerConfigurationOptions>

Returns the worker-related configuration: the base-path override and the list of globals to forward to workers.

fn chunk_loading(self: Vc<Self>) -> Vc<ChunkLoading>

where Self: Sized,

fn service_worker_scope_base_path(self: Vc<Self>) -> Vc<RcStr>

where Self: Sized,

fn batching_config(self: Vc<Self>) -> Vc<BatchingConfig>

where Self: Sized,

fn should_use_absolute_url_references(self: Vc<Self>) -> Vc<bool>

where Self: Sized,

fn hmr_chunk_list( self: Vc<Self>, _ident: Vc<AssetIdent>, _chunks: Vc<OutputAssets>, ) -> Vc<OutputAssets>

where Self: Sized,

In development, produces a standalone HMR chunk-list register chunk that tracks chunks for hot-module-replacement without producing an evaluate chunk. Returns None (empty vec) outside dev or when HMR is disabled. Used to register a page-specific chunk list that covers client-reference chunks built outside the shared module graph.

fn worker_entrypoint(self: Vc<Self>) -> Vc<Box<dyn OutputAsset>>

where Self: Sized,

Returns the worker entrypoint for this chunking context.

impl Clone for NodeJsChunkingContext

fn clone(&self) -> NodeJsChunkingContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeJsChunkingContext

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for NodeJsChunkingContext

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Encode for NodeJsChunkingContext

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl Eq for NodeJsChunkingContext

impl NonLocalValue for NodeJsChunkingContext

impl PartialEq for NodeJsChunkingContext

fn eq(&self, other: &NodeJsChunkingContext) -> bool

Equality operator ==.

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

Inequality operator !=.

impl ShrinkToFit for NodeJsChunkingContext

fn shrink_to_fit(&mut self)

impl StructuralPartialEq for NodeJsChunkingContext

impl TraceRawVcs for NodeJsChunkingContext

fn trace_raw_vcs(&self, __context__: &mut TraceRawVcsContext)

fn get_raw_vcs(&self) -> Vec<RawVc>

impl Upcast<Box<dyn ChunkingContext>> for NodeJsChunkingContext

impl Upcast<Box<dyn ValueDebug>> for NodeJsChunkingContext

impl UpcastStrict<Box<dyn ChunkingContext>> for NodeJsChunkingContext

impl UpcastStrict<Box<dyn ValueDebug>> for NodeJsChunkingContext

impl ValueDebug for NodeJsChunkingContext

fn dbg_depth<'a>( &'a self, depth: usize, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'a>>

Like dbg, but with a depth limit.

fn dbg( &self, ) -> Pin<Box<dyn Future<Output = Result<String, Error>> + Send + '_>>

impl ValueDebugFormat for NodeJsChunkingContext

Available on debug-assertions enabled only.

fn value_debug_format<'a>(&'a self, depth: usize) -> ValueDebugFormatString<'a>

impl VcValueType for NodeJsChunkingContext

type Read = VcDefaultRead<NodeJsChunkingContext>

How to read the value.

type CellMode = VcCellCompareMode<NodeJsChunkingContext>

How to update cells of this value type.

fn get_value_type_id() -> ValueTypeId

Returns the type id of the value type.

fn has_serialization() -> bool