webpack.Module

• {DependenciesBlock}

• {ExternalModule}
• {NormalModule}
• {RuntimeModule}

new Module(type, context?, layer?): Module

• blocks {AsyncDependenciesBlock[]}
• buildInfo {BuildInfo}
• buildMeta {BuildMeta}
• chunksIterable {Iterable}
• codeGenerationDependencies {Dependency[]}
• context <string>
• debugId <number>
• dependencies {Dependency[]}
• depth <number>
• errors <any>
• exportsArgument <string>
• 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>
• resolveOptions {ResolveOptions}
• type <string>
• used <any>
• usedExports {boolean|SortableSet}
• useSimpleSourceMap <boolean>
• useSourceMap <boolean>
• warnings <any>

webpack.Module.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.Module.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.Module.addChunk(chunk): void

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

webpack.Module.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.Module.addDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.Module.addError(error): void

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

webpack.Module.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.Module.addWarning(warning): void

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

webpack.Module.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.Module.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.Module.cleanupForCache(): void

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

webpack.Module.clearDependenciesAndBlocks(): void

Removes all dependencies and blocks

webpack.Module.clearWarningsAndErrors(): void

removes all warnings and errors

webpack.Module.codeGeneration(context): void

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

webpack.Module.deserialize(__namedParameters): void

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

webpack.Module.getChunks(): Chunk[]

webpack.Module.getConcatenationBailoutReason(context): void

• context {ConcatenationBailoutReasonContext} context
• Returns: <string> reason why this module can't be concatenated, undefined when it can be concatenated

webpack.Module.getErrors(): Iterable<WebpackError, any, any>

webpack.Module.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.Module.getNumberOfChunks(): number

webpack.Module.getNumberOfErrors(): number

webpack.Module.getNumberOfWarnings(): number

webpack.Module.getRootBlock(): DependenciesBlock

webpack.Module.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.Module.getSourceBasicTypes(): ReadonlySet<string>

webpack.Module.getSourceTypes(): ReadonlySet<string>

webpack.Module.getUnsafeCacheData(): UnsafeCacheData

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

webpack.Module.getWarnings(): Iterable<WebpackError, any, any>

webpack.Module.hasChunkCondition(): boolean

webpack.Module.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.Module.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.Module.identifier(): string

webpack.Module.invalidateBuild(): void

webpack.Module.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.Module.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.Module.isEntryModule(): boolean

webpack.Module.isInChunk(chunk): void

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

webpack.Module.isOptional(moduleGraph): void

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

webpack.Module.isProvided(exportName): boolean

webpack.Module.libIdent(options): void

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

webpack.Module.nameForCondition(): string

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

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

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

• fileTimestamps {Map<string, number>} timestamps of files
• contextTimestamps {Map<string, number>} timestamps of directories
• Returns: <boolean> true, if the module needs a rebuild

webpack.Module.originalSource(): Source

webpack.Module.readableIdentifier(requestShortener): void

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

webpack.Module.removeChunk(chunk): void

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

webpack.Module.removeDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.Module.serialize(__namedParameters): void

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

webpack.Module.size(type?): number

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

• dependencyTemplates {DependencyTemplates} the dependency templates
• runtimeTemplate {RuntimeTemplate} the runtime template
• type <string> the type of source that should be generated
• Returns: {Source} generated source

webpack.Module.updateCacheModule(module): void

• module {Module} fresh 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.Module.updateHash(hash, context): void

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

webpack.Module.getSourceBasicTypes(module): void

• module {Module} the module
• Returns: {ReadonlySet} the source types of the module