Attributes
new ModuleChunkLoadingRuntimeModule(runtimeRequirements): voidruntimeRequirements{ReadonlySet} runtime requirements - Returns:
<ModuleChunkLoadingRuntimeModule>
Attributes
blocks:
<AsyncDependenciesBlock[]>buildInfo:
{BuildInfo}
buildMeta:
{BuildMeta}
chunk:
<Chunk>chunkGraph:
<ChunkGraph>chunksIterable:
{Iterable
}
codeGenerationDependencies:
<Dependency[]>compilation:
<Compilation>context:
<string>debugId:
<number>dependencies:
<Dependency[]>dependentHash:
<boolean>depth:
<number>errors:
<any>exportsArgument:
<string>factoryMeta:
{FactoryMeta}
fullHash:
<boolean>hasEqualsChunks:
<any>hash:
<string>hot:
<boolean>index:
<number>index2:
<number>issuer:
<Module>isUsed:
<any>layer:
<string>moduleArgument:
<string>name:
<string>needId:
<boolean>optimizationBailout:
<string>
|
<object[]>optional:
<boolean>parent:
{DependenciesBlock}
presentationalDependencies:
<Dependency[]>profile:
{ModuleProfile}
renderedHash:
<string>resolveOptions:
<ResolveOptions>stage:
<number>type:
<string>used:
<any>usedExports:
{boolean|SortableSet
}
useSimpleSourceMap:
<boolean>useSourceMap:
<boolean>warnings:
<any>STAGE_ATTACH:
<number>Runtime modules which attach to handlers of other runtime modules
STAGE_BASIC:
<number>Runtime modules with simple dependencies on other runtime modules
STAGE_NORMAL:
<number>Runtime modules without any dependencies to other runtime modules
STAGE_TRIGGER:
<number>Runtime modules which trigger actions on bootstrap
webpack.esm.ModuleChunkLoadingRuntimeModule.addBlock(block): voidAttributes
block:
<AsyncDependenciesBlock>Returns:
{void}
Adds a DependencyBlock to DependencyBlock relationship. This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
webpack.esm.ModuleChunkLoadingRuntimeModule.addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies): voidfileDependencies{LazySet} set where file dependencies are added to contextDependencies{LazySet} set where context dependencies are added to missingDependencies{LazySet} set where missing dependencies are added to buildDependencies{LazySet} set where build dependencies are added to - Returns: {void}
webpack.esm.ModuleChunkLoadingRuntimeModule.addChunk(chunk): booleanAttributes
chunk:
<Chunk>the chunk
Returns:
<boolean>true, when the module was added
webpack.esm.ModuleChunkLoadingRuntimeModule.addCodeGenerationDependency(codeGenerationDependency): voidAttributes
codeGenerationDependency:
<Dependency>dependency being tied to module.
This is a Dependency where the code generation result of the referenced module is needed during code generation.
The Dependency should also be added to normal dependencies via addDependency.
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.addDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.addError(error): voidAttributes
error:
<WebpackError>the error
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.addPresentationalDependency(presentationalDependency): voidAttributes
presentationalDependency:
<Dependency>dependency being tied to module.
This is a Dependency without edge in the module graph. It's only for presentation.
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.addWarning(warning): voidAttributes
warning:
<WebpackError>the warning
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.attach(compilation, chunk, chunkGraph?): voidAttributes
compilation:
<Compilation>the compilation
chunk:
<Chunk>the chunk
chunkGraph:
<ChunkGraph>the chunk graph
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.build(options, compilation, resolver, fs, callback): voidoptions{WebpackOptionsNormalizedWithDefaults} webpack optionscompilation<Compilation>the compilationresolver{ResolverWithOptions} the resolverfs<InputFileSystem>the file systemcallback<object>callback function- Returns: {void}
webpack.esm.ModuleChunkLoadingRuntimeModule.chunkCondition(chunk, compilation): booleanAttributes
chunk:
<Chunk>the chunk which condition should be checked
compilation:
<Compilation>the compilation
Returns:
<boolean>true if the module can be placed in the chunk
webpack.esm.ModuleChunkLoadingRuntimeModule.cleanupForCache(): voidReturns:
{void}
Assuming this module is in the cache. Remove internal references to allow freeing some memory.
webpack.esm.ModuleChunkLoadingRuntimeModule.clearDependenciesAndBlocks(): voidReturns:
{void}
Removes all dependencies and blocks
webpack.esm.ModuleChunkLoadingRuntimeModule.clearWarningsAndErrors(): voidReturns:
{void}
removes all warnings and errors
webpack.esm.ModuleChunkLoadingRuntimeModule.codeGeneration(context): voidcontext{CodeGenerationContext} context for code generation- Returns: {CodeGenerationResult} result
webpack.esm.ModuleChunkLoadingRuntimeModule.deserialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectDeserializerContext>context
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.generate(): stringReturns:
<string>runtime code
webpack.esm.ModuleChunkLoadingRuntimeModule.getChunks(): Chunk[]Returns:
<Chunk[]>webpack.esm.ModuleChunkLoadingRuntimeModule.getConcatenationBailoutReason(context): voidcontext{ConcatenationBailoutReasonContext} context- Returns:
<string>reason why this module can't be concatenated, undefined when it can be concatenated
webpack.esm.ModuleChunkLoadingRuntimeModule.getErrors(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>} list of errors if any
webpack.esm.ModuleChunkLoadingRuntimeModule.getExportsType(moduleGraph, strict?): ExportsTypeAttributes
moduleGraph:
<ModuleGraph>the module graph
strict:
<boolean>the importing module is strict
Returns:
{ExportsType} export type
"namespace": Exports is already a namespace object. namespace = exports.
"dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
"default-only": Provide a namespace object with only default export. namespace = { default: exports }
"default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
webpack.esm.ModuleChunkLoadingRuntimeModule.getGeneratedCode(): stringReturns:
<string>runtime code
webpack.esm.ModuleChunkLoadingRuntimeModule.getNumberOfChunks(): numberReturns:
<number>webpack.esm.ModuleChunkLoadingRuntimeModule.getNumberOfErrors(): numberReturns:
<number>number of errors
webpack.esm.ModuleChunkLoadingRuntimeModule.getNumberOfWarnings(): numberReturns:
<number>number of warnings
webpack.esm.ModuleChunkLoadingRuntimeModule.getRootBlock(): DependenciesBlockReturns:
{DependenciesBlock}
webpack.esm.ModuleChunkLoadingRuntimeModule.getSideEffectsConnectionState(moduleGraph): ConnectionStateAttributes
moduleGraph:
<ModuleGraph>the module graph
Returns:
{ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
webpack.esm.ModuleChunkLoadingRuntimeModule.getSourceBasicTypes(): ReadonlySet<string>Returns:
{ReadonlySet
}
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.
webpack.esm.ModuleChunkLoadingRuntimeModule.getSourceTypes(): ReadonlySet<string>Returns:
{ReadonlySet
} types available (do not mutate)
webpack.esm.ModuleChunkLoadingRuntimeModule.getUnsafeCacheData(): UnsafeCacheDataReturns:
{UnsafeCacheData}
Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.
webpack.esm.ModuleChunkLoadingRuntimeModule.getWarnings(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>} list of warnings if any
webpack.esm.ModuleChunkLoadingRuntimeModule.hasChunkCondition(): booleanReturns:
<boolean>webpack.esm.ModuleChunkLoadingRuntimeModule.hasReasonForChunk(chunk, moduleGraph, chunkGraph): booleanAttributes
Returns:
<boolean>true, if the module has any reason why "chunk" should be included
webpack.esm.ModuleChunkLoadingRuntimeModule.hasReasons(moduleGraph, runtime): booleanAttributes
moduleGraph:
<ModuleGraph>the module graph
runtime:
{RuntimeSpec} the runtime
Returns:
<boolean>true if at least one other module depends on this module
webpack.esm.ModuleChunkLoadingRuntimeModule.identifier(): stringReturns:
<string>a unique identifier of the module
webpack.esm.ModuleChunkLoadingRuntimeModule.invalidateBuild(): voidReturns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): booleanAttributes
Returns:
<boolean>true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
webpack.esm.ModuleChunkLoadingRuntimeModule.isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): booleanAttributes
chunkGraph:
<ChunkGraph>the chunk graph
chunkGroup:
<ChunkGroup>a chunk group
ignoreChunk:
<Chunk>chunk to be ignored
Returns:
<boolean>true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
webpack.esm.ModuleChunkLoadingRuntimeModule.isEntryModule(): booleanReturns:
<boolean>webpack.esm.ModuleChunkLoadingRuntimeModule.isInChunk(chunk): booleanAttributes
chunk:
<Chunk>the chunk
Returns:
<boolean>true, when the module is in the chunk
webpack.esm.ModuleChunkLoadingRuntimeModule.isOptional(moduleGraph): booleanAttributes
moduleGraph:
<ModuleGraph>the module graph
Returns:
<boolean>true, if the module is optional
webpack.esm.ModuleChunkLoadingRuntimeModule.isProvided(exportName): booleanAttributes
exportName:
<string>a name of an export
Returns:
<boolean>true, if the export is provided why the module.
null, if it's unknown.
false, if it's not provided.
webpack.esm.ModuleChunkLoadingRuntimeModule.libIdent(options): voidoptions{LibIdentOptions} options- Returns:
<string>an identifier for library inclusion
webpack.esm.ModuleChunkLoadingRuntimeModule.nameForCondition(): stringReturns:
<string>absolute path which should be used for condition matching (usually the resource path)
webpack.esm.ModuleChunkLoadingRuntimeModule.needBuild(context, callback): voidcontext{NeedBuildContext} context infocallback<object>callback function, returns true, if the module needs a rebuild- Returns: {void}
webpack.esm.ModuleChunkLoadingRuntimeModule.needRebuild(fileTimestamps, contextTimestamps): voidStability: 0Deprecated
fileTimestamps{Map<string, number>}contextTimestamps{Map<string, number>}- Returns:
<boolean>
Use needBuild instead
webpack.esm.ModuleChunkLoadingRuntimeModule.originalSource(): SourceReturns:
<Source>the original source for the module before webpack transformation
webpack.esm.ModuleChunkLoadingRuntimeModule.readableIdentifier(requestShortener): voidrequestShortener{RequestShortener} the request shortener- Returns:
<string>a user readable identifier of the module
webpack.esm.ModuleChunkLoadingRuntimeModule.removeChunk(chunk): voidAttributes
chunk:
<Chunk>the chunk
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.removeDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.serialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectSerializerContext>context
Returns:
{void}
webpack.esm.ModuleChunkLoadingRuntimeModule.shouldIsolate(): booleanReturns:
<boolean>true, if the runtime module should get it's own scope
webpack.esm.ModuleChunkLoadingRuntimeModule.size(type?): numberAttributes
type:
<string>the source type for which the size should be estimated
Returns:
<number>the estimated size of the module (must be non-zero)
webpack.esm.ModuleChunkLoadingRuntimeModule.source(dependencyTemplates, runtimeTemplate, type?): voidStability: 0Deprecated
dependencyTemplates{DependencyTemplates}runtimeTemplate{RuntimeTemplate}type<string>- Returns:
<Source>
Use codeGeneration() instead
webpack.esm.ModuleChunkLoadingRuntimeModule.updateCacheModule(module): voidAttributes
module:
<Module>Returns:
{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.
webpack.esm.ModuleChunkLoadingRuntimeModule.updateHash(hash, context): voidhash{Hash} the hash used to track dependenciescontext{UpdateHashContextDependency} context- Returns: {void}
webpack.esm.ModuleChunkLoadingRuntimeModule.getCompilationHooks(compilation): JsonpCompilationPluginHooksAttributes
compilation:
<Compilation>the compilation
Returns:
{JsonpCompilationPluginHooks} hooks
webpack.esm.ModuleChunkLoadingRuntimeModule.getSourceBasicTypes(module): ReadonlySet<string>Stability: 0Deprecated
Attributes
module:
<Module>Returns:
{ReadonlySet
}
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.