Attributes
new ModuleChunkLoadingRuntimeModule(runtimeRequirements): voidruntimeRequirements{ReadonlySet} - 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>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
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)
addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies): voidfileDependencies{LazySet} contextDependencies{LazySet} missingDependencies{LazySet} buildDependencies{LazySet} - Returns: {void}
addChunk(chunk): booleanAttributes
chunk:
<Chunk>Returns:
<boolean>addCodeGenerationDependency(codeGenerationDependency): voidAttributes
codeGenerationDependency:
<Dependency>Returns:
{void}
addDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
addError(error): voidAttributes
error:
<WebpackError>Returns:
{void}
addPresentationalDependency(presentationalDependency): voidAttributes
presentationalDependency:
<Dependency>Returns:
{void}
addWarning(warning): voidAttributes
warning:
<WebpackError>Returns:
{void}
attach(compilation, chunk, chunkGraph?): voidAttributes
Returns:
{void}
build(options, compilation, resolver, fs, callback): voidoptions{WebpackOptionsNormalizedWithDefaults}compilation<Compilation>resolver{ResolverWithOptions}fs<InputFileSystem>callback{object}- Returns: {void}
chunkCondition(chunk, compilation): booleanAttributes
chunk:
<Chunk>compilation:
<Compilation>Returns:
<boolean>cleanupForCache(): voidReturns:
{void}
Assuming this module is in the cache. Remove internal references to allow freeing some memory.
clearDependenciesAndBlocks(): voidReturns:
{void}
Removes all dependencies and blocks
clearWarningsAndErrors(): voidReturns:
{void}
removes all warnings and errors
codeGeneration(context): voidcontext{CodeGenerationContext}- Returns: {CodeGenerationResult}
deserialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectDeserializerContext>Returns:
{void}
generate(): stringReturns:
<string>getChunks(): Chunk[]Returns:
<Chunk[]>getConcatenationBailoutReason(context): voidcontext{ConcatenationBailoutReasonContext}- Returns:
<string>
getErrors(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>}
getExportsType(moduleGraph, strict?): ExportsTypeAttributes
moduleGraph:
<ModuleGraph>strict:
<boolean>Returns:
{ExportsType}
getGeneratedCode(): stringReturns:
<string>getNumberOfChunks(): numberReturns:
<number>getNumberOfErrors(): numberReturns:
<number>getNumberOfWarnings(): numberReturns:
<number>getRootBlock(): DependenciesBlockReturns:
{DependenciesBlock}
getSideEffectsConnectionState(moduleGraph): ConnectionStateAttributes
moduleGraph:
<ModuleGraph>Returns:
{ConnectionState}
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.
getSourceTypes(): ReadonlySet<string>Returns:
{ReadonlySet
}
getUnsafeCacheData(): UnsafeCacheDataReturns:
{UnsafeCacheData}
Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.
getWarnings(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>}
hasChunkCondition(): booleanReturns:
<boolean>hasReasonForChunk(chunk, moduleGraph, chunkGraph): booleanAttributes
Returns:
<boolean>hasReasons(moduleGraph, runtime): booleanAttributes
moduleGraph:
<ModuleGraph>runtime:
{RuntimeSpec}
Returns:
<boolean>identifier(): stringReturns:
<string>invalidateBuild(): voidReturns:
{void}
isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): booleanAttributes
Returns:
<boolean>isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): booleanAttributes
Returns:
<boolean>isEntryModule(): booleanReturns:
<boolean>isInChunk(chunk): booleanAttributes
chunk:
<Chunk>Returns:
<boolean>isOptional(moduleGraph): booleanAttributes
moduleGraph:
<ModuleGraph>Returns:
<boolean>isProvided(exportName): booleanAttributes
exportName:
<string>Returns:
<boolean>libIdent(options): voidoptions{LibIdentOptions}- Returns:
<string>
nameForCondition(): stringReturns:
<string>needBuild(context, callback): voidcontext{NeedBuildContext}callback{object}- Returns: {void}
needRebuild(fileTimestamps, contextTimestamps): voidStability: 0Deprecated
fileTimestamps{Map<string, number>}contextTimestamps{Map<string, number>}- Returns:
<boolean>
Use needBuild instead
originalSource(): SourceReturns:
{Source}
readableIdentifier(requestShortener): voidrequestShortener{RequestShortener}- Returns:
<string>
removeChunk(chunk): voidAttributes
chunk:
<Chunk>Returns:
{void}
removeDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
serialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectSerializerContext>Returns:
{void}
shouldIsolate(): booleanReturns:
<boolean>M
size
size(type?): numberAttributes
type:
<string>Returns:
<number>source(dependencyTemplates, runtimeTemplate, type?): voidStability: 0Deprecated
dependencyTemplates{DependencyTemplates}runtimeTemplate{RuntimeTemplate}type<string>- Returns: {Source}
Use codeGeneration() instead
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.
updateHash(hash, context): voidhash{Hash}context{UpdateHashContextDependency}- Returns: {void}
Attributes
compilation:
<Compilation>Returns:
{JsonpCompilationPluginHooks}
Stability: 0Deprecated
Attributes
module:
<Module>Returns:
{ReadonlySet
}
In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.