webpack.esm.ModuleChunkLoadingRuntimeModule

new ModuleChunkLoadingRuntimeModule(runtimeRequirements): void

• runtimeRequirements {ReadonlySet}
• Returns: <ModuleChunkLoadingRuntimeModule>

Creates an instance of ModuleChunkLoadingRuntimeModule.

addBlock(block): void

Adds a DependencyBlock to DependencyBlock relationship. This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)

addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies): void

• fileDependencies {LazySet}
• contextDependencies {LazySet}
• missingDependencies {LazySet}
• buildDependencies {LazySet}
• Returns: {void}

Adds the provided file dependencies to the module.

addChunk(chunk): boolean

Adds the provided chunk to the module.

addCodeGenerationDependency(codeGenerationDependency): void

Adds code generation dependency.

addDependency(dependency): void

Adds the provided dependency to the dependencies block.

addError(error): void

Adds the provided error to the module.

addPresentationalDependency(presentationalDependency): void

Adds presentational dependency.

addWarning(warning): void

Adds the provided warning to the module.

attach(compilation, chunk, chunkGraph?): void

Processes the provided compilation.

build(options, compilation, resolver, fs, callback): void

• options {WebpackOptionsNormalizedWithDefaults}
• compilation <Compilation>
• resolver {ResolverWithOptions}
• fs <InputFileSystem>
• callback <object>
• Returns: {void}

Builds the module using the provided compilation context.

chunkCondition(chunk, compilation): boolean

Returns true if the module can be placed in the chunk.

cleanupForCache(): void

Assuming this module is in the cache. Remove internal references to allow freeing some memory.

clearDependenciesAndBlocks(): void

Clear dependencies and blocks.

clearWarningsAndErrors(): void

removes all warnings and errors

codeGeneration(context): void

• context {CodeGenerationContext}
• Returns: {CodeGenerationResult}

Generates code and runtime requirements for this module.

deserialize(__namedParameters): void

Restores this instance from the provided deserializer context.

generate(): string | null

Generates runtime code for this runtime module.

getChunks(): Chunk[]

getConcatenationBailoutReason(context): void

• context {ConcatenationBailoutReasonContext}
• Returns: <string> | <undefined>

Returns the reason this module cannot be concatenated, when one exists.

getErrors(): Error[] | undefined

Returns list of errors if any.

getExportsType(moduleGraph, strict?): ExportsType

Returns export type.

getGeneratedCode(): string | null

Gets generated code.

getNumberOfChunks(): number

getNumberOfErrors(): number

Gets number of errors.

getNumberOfWarnings(): number

Gets number of warnings.

getRootBlock(): DependenciesBlock

getSideEffectsConnectionState(moduleGraph): ConnectionState

Gets side effects connection state.

getSourceBasicTypes(): ReadonlySet<string>

Basic source types are high-level categories like javascript, css, webassembly, etc. We only have built-in knowledge about the javascript basic type here; other basic types may be added or changed over time by generators and do not need to be handled or detected here. Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init" from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.

getSourceTypes(): ReadonlySet<string>

Returns the source types this module can generate.

getUnsafeCacheData(): UnsafeCacheData

Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.

getWarnings(): Error[] | undefined

Returns list of warnings if any.

hasChunkCondition(): boolean

hasReasonForChunk(chunk, moduleGraph, chunkGraph): boolean

Checks whether this module contains the chunk.

hasReasons(moduleGraph, runtime): boolean

Checks whether this module contains the module graph.

identifier(): string

Returns the unique identifier used to reference this module.

invalidateBuild(): void

Invalidates the cached state associated with this value.

isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): boolean

Checks whether this module is accessible in chunk.

isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): boolean

Checks whether this module is accessible in chunk group.

isEntryModule(): boolean

isInChunk(chunk): boolean

Checks whether this module is in the provided chunk.

isOptional(moduleGraph): boolean

Checks whether this module is optional.

isProvided(exportName): boolean | null

Checks whether this module provides the specified export.

libIdent(options): void

• options {LibIdentOptions}
• Returns: <string> | <null>

Gets the library identifier.

nameForCondition(): string | null

Returns the path used when matching this module against rule conditions.

needBuild(context, callback): void

• context {NeedBuildContext}
• callback <object>
• Returns: {void}

Checks whether the module needs to be rebuilt for the current build state.

needRebuild(fileTimestamps, contextTimestamps): void

• fileTimestamps {Map<string, number|null>}
• contextTimestamps {Map<string, number|null>}
• Returns: <boolean>

Checks whether it needs rebuild.

originalSource(): Source | null

Gets the original source.

readableIdentifier(requestShortener): void

• requestShortener {RequestShortener}
• Returns: <string>

Returns a human-readable identifier for this module.

removeChunk(chunk): void

Removes the provided chunk from the module.

removeDependency(dependency): void

Removes dependency.

serialize(__namedParameters): void

Serializes this instance into the provided serializer context.

shouldIsolate(): boolean

Returns true, if the runtime module should get it's own scope.

size(type?): number

Returns the estimated size for the requested source type.

source(dependencyTemplates, runtimeTemplate, type?): void

• dependencyTemplates {DependencyTemplates}
• runtimeTemplate {RuntimeTemplate}
• type <string>
• Returns: <Source>

Returns generated source.

updateCacheModule(module): void

Assuming this module is in the cache. Update the (cached) module with the fresh module from the factory. Usually updates internal references and properties.

updateHash(hash, context): void

• hash {Hash}
• context {UpdateHashContextDependency}
• Returns: {void}

Updates the hash with the data contributed by this instance.

Returns hooks.

Gets source basic types.