webpack.NormalModule

• {Module}

new NormalModule(__namedParameters): void

• __namedParameters {NormalModuleCreateData} options object
• Returns: {NormalModule}

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

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

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

• dependency {Dependency}
• Returns: {void}

webpack.NormalModule.addError(error): void

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

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

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

webpack.NormalModule.applyNoParseRule(rule, content): boolean

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

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

webpack.NormalModule.clearDependenciesAndBlocks(): void

Removes all dependencies and blocks

webpack.NormalModule.clearWarningsAndErrors(): void

removes all warnings and errors

webpack.NormalModule.codeGeneration(context): void

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

webpack.NormalModule.createSource(context, content, sourceMap?, associatedObjectForCache?): Source

webpack.NormalModule.createSourceForAsset(context, name, content, sourceMap?, associatedObjectForCache?): Source

webpack.NormalModule.deserialize(__namedParameters): void

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

webpack.NormalModule.getChunks(): Chunk[]

webpack.NormalModule.getConcatenationBailoutReason(context): void

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

webpack.NormalModule.getCurrentLoader(loaderContext, index?): void

• loaderContext {AnyLoaderContext} loader context
• index <number> index
• Returns: {LoaderItem} loader

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

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

webpack.NormalModule.getNumberOfErrors(): number

webpack.NormalModule.getNumberOfWarnings(): number

webpack.NormalModule.getResource(): string

webpack.NormalModule.getRootBlock(): DependenciesBlock

webpack.NormalModule.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.NormalModule.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.NormalModule.getSourceTypes(): ReadonlySet<string>

webpack.NormalModule.getUnsafeCacheData(): UnsafeCacheData

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

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

webpack.NormalModule.hasChunkCondition(): boolean

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

webpack.NormalModule.invalidateBuild(): void

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

webpack.NormalModule.isInChunk(chunk): void

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

webpack.NormalModule.isOptional(moduleGraph): void

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

webpack.NormalModule.isProvided(exportName): boolean

webpack.NormalModule.libIdent(options): void

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

webpack.NormalModule.markModuleAsErrored(error): void

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

webpack.NormalModule.nameForCondition(): string

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

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

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

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

Use needBuild instead

webpack.NormalModule.originalSource(): Source

webpack.NormalModule.readableIdentifier(requestShortener): void

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

webpack.NormalModule.removeChunk(chunk): void

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

webpack.NormalModule.removeDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.NormalModule.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.NormalModule.serialize(__namedParameters): void

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

webpack.NormalModule.shouldPreventParsing(noParseRule, request): boolean

webpack.NormalModule.size(type?): number

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

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

Use codeGeneration() instead

webpack.NormalModule.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.NormalModule.updateHash(hash, context): void

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

webpack.NormalModule.deserialize(context): void

• context {ObjectDeserializerContext} context
• Returns: {NormalModule}

webpack.NormalModule.getCompilationHooks(compilation): void

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

webpack.NormalModule.getSourceBasicTypes(module): void

• module {Module}
• Returns: {ReadonlySet}

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