webpack.ExternalModule

• {Module}

new ExternalModule(request, type, userRequest, dependencyMeta?): void

• request {ExternalModuleRequest} request
• type {ExternalsType} type
• userRequest <string> user request
• dependencyMeta {ImportDependencyMeta|CssImportDependencyMeta|AssetDependencyMeta} dependency meta
• Returns: {ExternalModule}

• 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>
• id <string> | <number>
• 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): void

• 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): void

• fileDependencies {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): void

• chunk {Chunk} the chunk
• Returns: <boolean> true, when the module was added

webpack.ExternalModule.addCodeGenerationDependency(codeGenerationDependency): void

• 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): void

• dependency {Dependency}
• Returns: {void}

webpack.ExternalModule.addError(error): void

• error {WebpackError} the error
• Returns: {void}

webpack.ExternalModule.addPresentationalDependency(presentationalDependency): void

• 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): void

• warning {WebpackError} the warning
• Returns: {void}

webpack.ExternalModule.build(options, compilation, resolver, fs, callback): void

• options {WebpackOptionsNormalizedWithDefaults} webpack options
• compilation {Compilation} the compilation
• resolver {ResolverWithOptions} the resolver
• fs {InputFileSystem} the file system
• callback <object> callback function
• Returns: {void}

webpack.ExternalModule.chunkCondition(chunk, compilation): void

• 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(): void

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

webpack.ExternalModule.clearDependenciesAndBlocks(): void

Removes all dependencies and blocks

webpack.ExternalModule.clearWarningsAndErrors(): void

removes all warnings and errors

webpack.ExternalModule.codeGeneration(context): void

• context {CodeGenerationContext} context for code generation
• Returns: {CodeGenerationResult} result

webpack.ExternalModule.deserialize(__namedParameters): void

• __namedParameters {ObjectDeserializerContext} context
• Returns: {void}

webpack.ExternalModule.getChunks(): Chunk[]

webpack.ExternalModule.getConcatenationBailoutReason(context): void

• context {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>

webpack.ExternalModule.getExportsType(moduleGraph, strict?): void

• 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(): number

webpack.ExternalModule.getNumberOfErrors(): number

webpack.ExternalModule.getNumberOfWarnings(): number

webpack.ExternalModule.getRootBlock(): DependenciesBlock

webpack.ExternalModule.getSideEffectsConnectionState(moduleGraph): void

• 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>

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>

webpack.ExternalModule.getUnsafeCacheData(): 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>

webpack.ExternalModule.hasChunkCondition(): boolean

webpack.ExternalModule.hasReasonForChunk(chunk, moduleGraph, chunkGraph): void

• chunk {Chunk} a chunk
• moduleGraph {ModuleGraph} the module graph
• chunkGraph {ChunkGraph} the chunk graph
• Returns: <boolean> true, if the module has any reason why "chunk" should be included

webpack.ExternalModule.hasReasons(moduleGraph, runtime): void

• 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(): string

webpack.ExternalModule.invalidateBuild(): void

webpack.ExternalModule.isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): void

• chunkGraph {ChunkGraph} the chunk graph
• chunk {Chunk} a chunk
• ignoreChunk {Chunk} chunk to be ignored
• Returns: <boolean> true, if the module is accessible from "chunk" when ignoring "ignoreChunk"

webpack.ExternalModule.isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): void

• 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(): boolean

webpack.ExternalModule.isInChunk(chunk): void

• chunk {Chunk} the chunk
• Returns: <boolean> true, when the module is in the chunk

webpack.ExternalModule.isOptional(moduleGraph): void

• moduleGraph {ModuleGraph} the module graph
• Returns: <boolean> true, if the module is optional

webpack.ExternalModule.isProvided(exportName): boolean

webpack.ExternalModule.libIdent(options): void

• options {LibIdentOptions} options
• Returns: <string> an identifier for library inclusion

webpack.ExternalModule.nameForCondition(): string

webpack.ExternalModule.needBuild(context, callback): void

• context {NeedBuildContext} context info
• callback <object> callback function, returns true, if the module needs a rebuild
• Returns: {void}

webpack.ExternalModule.needRebuild(fileTimestamps, contextTimestamps): void

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

Use needBuild instead

webpack.ExternalModule.originalSource(): Source

webpack.ExternalModule.readableIdentifier(requestShortener): void

• requestShortener {RequestShortener} the request shortener
• Returns: <string> a user readable identifier of the module

webpack.ExternalModule.removeChunk(chunk): void

• chunk {Chunk} the chunk
• Returns: {void}

webpack.ExternalModule.removeDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.ExternalModule.restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory): void

• unsafeCacheData {UnsafeCacheData} data from getUnsafeCacheData
• normalModuleFactory {NormalModuleFactory} the normal module factory handling the unsafe caching
• Returns: {void}

restore unsafe cache data

webpack.ExternalModule.serialize(__namedParameters): void

• __namedParameters {ObjectSerializerContext} context
• Returns: {void}

webpack.ExternalModule.size(type?): number

webpack.ExternalModule.source(dependencyTemplates, runtimeTemplate, type?): void

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

Use codeGeneration() instead

webpack.ExternalModule.updateCacheModule(module): void

• 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): void

• hash {Hash} the hash used to track dependencies
• context {UpdateHashContextDependency} context
• Returns: {void}

webpack.ExternalModule.getCompilationHooks(compilation): void

• compilation {Compilation} the compilation
• Returns: {ExternalModuleHooks} the attached hooks

webpack.ExternalModule.getSourceBasicTypes(module): void

• module {Module}
• Returns: {ReadonlySet}

In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.