Attributes
new ExternalModule(request, type, userRequest, dependencyMeta?): voidrequest{ExternalModuleRequest} requesttype{ExternalsType} typeuserRequest<string>user requestdependencyMeta{ImportDependencyMeta|CssImportDependencyMeta|AssetDependencyMeta} dependency meta- Returns:
<ExternalModule>
Attributes
blocks:
<AsyncDependenciesBlock[]>buildInfo:
{BuildInfo}
buildMeta:
{BuildMeta}
chunksIterable:
{Iterable
}
codeGenerationDependencies:
<Dependency[]>context:
<string>debugId:
<number>dependencies:
<Dependency[]>dependencyMeta:
{ImportDependencyMeta|CssImportDependencyMeta|AssetDependencyMeta}
depth:
<number>errors:
<any>exportsArgument:
<string>externalType:
{ExternalsType}
factoryMeta:
{FactoryMeta}
hasEqualsChunks:
<any>hash:
<string>hot:
<boolean>index:
<number>index2:
<number>issuer:
<Module>isUsed:
<any>layer:
<string>moduleArgument:
<string>needId:
<boolean>optimizationBailout:
<string>
|
<object[]>optional:
<boolean>parent:
{DependenciesBlock}
presentationalDependencies:
<Dependency[]>profile:
{ModuleProfile}
renderedHash:
<string>request:
{ExternalModuleRequest}
resolveOptions:
<ResolveOptions>type:
<string>used:
<any>usedExports:
{boolean|SortableSet
}
userRequest:
<string>useSimpleSourceMap:
<boolean>useSourceMap:
<boolean>warnings:
<any>getExternalModuleNodeCommonjsInitFragment:
<object>ModuleExternalInitFragment:
{ModuleExternalInitFragment}
webpack.ExternalModule.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.ExternalModule.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.ExternalModule.addChunk(chunk): booleanAttributes
chunk:
<Chunk>the chunk
Returns:
<boolean>true, when the module was added
webpack.ExternalModule.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.ExternalModule.addDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
webpack.ExternalModule.addError(error): voidAttributes
error:
<WebpackError>the error
Returns:
{void}
webpack.ExternalModule.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.ExternalModule.addWarning(warning): voidAttributes
warning:
<WebpackError>the warning
Returns:
{void}
webpack.ExternalModule.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.ExternalModule.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.ExternalModule.cleanupForCache(): voidReturns:
{void}
Assuming this module is in the cache. Remove internal references to allow freeing some memory.
webpack.ExternalModule.clearDependenciesAndBlocks(): voidReturns:
{void}
Removes all dependencies and blocks
webpack.ExternalModule.clearWarningsAndErrors(): voidReturns:
{void}
removes all warnings and errors
webpack.ExternalModule.codeGeneration(context): voidcontext{CodeGenerationContext} context for code generation- Returns: {CodeGenerationResult} result
webpack.ExternalModule.deserialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectDeserializerContext>context
Returns:
{void}
webpack.ExternalModule.getChunks(): Chunk[]Returns:
<Chunk[]>webpack.ExternalModule.getConcatenationBailoutReason(context): voidcontext{ConcatenationBailoutReasonContext} context- Returns:
<string>reason why this module can't be concatenated, undefined when it can be concatenated
webpack.ExternalModule.getErrors(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>} list of errors if any
webpack.ExternalModule.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.ExternalModule.getNumberOfChunks(): numberReturns:
<number>webpack.ExternalModule.getNumberOfErrors(): numberReturns:
<number>number of errors
webpack.ExternalModule.getNumberOfWarnings(): numberReturns:
<number>number of warnings
webpack.ExternalModule.getRootBlock(): DependenciesBlockReturns:
{DependenciesBlock}
webpack.ExternalModule.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.ExternalModule.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.ExternalModule.getSourceTypes(): ReadonlySet<string>Returns:
{ReadonlySet
} types available (do not mutate)
webpack.ExternalModule.getUnsafeCacheData(): UnsafeCacheDataReturns:
{UnsafeCacheData}
Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.
webpack.ExternalModule.getWarnings(): Iterable<WebpackError, any, any>Returns:
{Iterable<WebpackError, any, any>} list of warnings if any
webpack.ExternalModule.hasChunkCondition(): booleanReturns:
<boolean>webpack.ExternalModule.hasReasonForChunk(chunk, moduleGraph, chunkGraph): booleanAttributes
Returns:
<boolean>true, if the module has any reason why "chunk" should be included
webpack.ExternalModule.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.ExternalModule.identifier(): stringReturns:
<string>a unique identifier of the module
webpack.ExternalModule.invalidateBuild(): voidReturns:
{void}
webpack.ExternalModule.isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): booleanAttributes
Returns:
<boolean>true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
webpack.ExternalModule.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.ExternalModule.isEntryModule(): booleanReturns:
<boolean>webpack.ExternalModule.isInChunk(chunk): booleanAttributes
chunk:
<Chunk>the chunk
Returns:
<boolean>true, when the module is in the chunk
webpack.ExternalModule.isOptional(moduleGraph): booleanAttributes
moduleGraph:
<ModuleGraph>the module graph
Returns:
<boolean>true, if the module is optional
webpack.ExternalModule.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.ExternalModule.libIdent(options): voidoptions{LibIdentOptions} options- Returns:
<string>an identifier for library inclusion
webpack.ExternalModule.nameForCondition(): stringReturns:
<string>absolute path which should be used for condition matching (usually the resource path)
webpack.ExternalModule.needBuild(context, callback): voidcontext{NeedBuildContext} context infocallback<object>callback function, returns true, if the module needs a rebuild- Returns: {void}
webpack.ExternalModule.needRebuild(fileTimestamps, contextTimestamps): voidStability: 0Deprecated
fileTimestamps{Map<string, number>}contextTimestamps{Map<string, number>}- Returns:
<boolean>
Use needBuild instead
webpack.ExternalModule.originalSource(): SourceReturns:
<Source>the original source for the module before webpack transformation
webpack.ExternalModule.readableIdentifier(requestShortener): voidrequestShortener{RequestShortener} the request shortener- Returns:
<string>a user readable identifier of the module
webpack.ExternalModule.removeChunk(chunk): voidAttributes
chunk:
<Chunk>the chunk
Returns:
{void}
webpack.ExternalModule.removeDependency(dependency): voidAttributes
dependency:
<Dependency>Returns:
{void}
webpack.ExternalModule.restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory): voidunsafeCacheData{UnsafeCacheData} data from getUnsafeCacheDatanormalModuleFactory{NormalModuleFactory} the normal module factory handling the unsafe caching- Returns: {void}
restore unsafe cache data
webpack.ExternalModule.serialize(__namedParameters): voidAttributes
__namedParameters:
<ObjectSerializerContext>context
Returns:
{void}
webpack.ExternalModule.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.ExternalModule.source(dependencyTemplates, runtimeTemplate, type?): voidStability: 0Deprecated
dependencyTemplates{DependencyTemplates}runtimeTemplate{RuntimeTemplate}type<string>- Returns:
<Source>
Use codeGeneration() instead
webpack.ExternalModule.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.ExternalModule.updateHash(hash, context): voidhash{Hash} the hash used to track dependenciescontext{UpdateHashContextDependency} context- Returns: {void}
webpack.ExternalModule.getCompilationHooks(compilation): ExternalModuleHooksAttributes
compilation:
<Compilation>the compilation
Returns:
{ExternalModuleHooks} the attached hooks
webpack.ExternalModule.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.