On this page

Attributes
<RuntimeModule>
new GetChunkFilenameRuntimeModule(contentType, name, global, getFilenameForChunk, allChunks): GetChunkFilenameRuntimeModule
Attributes
contentType:<string>
the contentType to use the content hash for
name:<string>
kind of filename
global:<string>
function name to be assigned
getFilenameForChunk:<object>
functor to get the filename or function
allChunks:<boolean>
when false, only async chunks are included
Returns:<GetChunkFilenameRuntimeModule>
Attributes
allChunks:<boolean>
blocks:<AsyncDependenciesBlock[]>
buildInfo:
{BuildInfo}
buildMeta:
{BuildMeta}
chunk:<Chunk>
chunkGraph:<ChunkGraph>
chunksIterable:
{Iterable }
codeGenerationDependencies:<Dependency[]>
compilation:<Compilation>
contentType:<string>
context:<string>
debugId:<number>
dependencies:<Dependency[]>
dependentHash:<boolean>
depth:<number>
errors:<any>
exportsArgument:<string>
factoryMeta:
{FactoryMeta}
fullHash:<boolean>
getFilenameForChunk:<object>
global:<string>
hasEqualsChunks:<any>
hash:<string>
hot:<boolean>
id:<string> | <number>
index:<number>
index2:<number>
issuer:<Module>
isUsed:<any>
layer:<string>
moduleArgument:<string>
name:<string>
needId:<boolean>
optimizationBailout:<string> | <object[]>
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
webpack.runtime.GetChunkFilenameRuntimeModule.addBlock(block): void
Attributes
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.runtime.GetChunkFilenameRuntimeModule.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.runtime.GetChunkFilenameRuntimeModule.addChunk(chunk): boolean
Attributes
chunk:<Chunk>
Returns:<boolean>
webpack.runtime.GetChunkFilenameRuntimeModule.addCodeGenerationDependency(codeGenerationDependency): void
Attributes
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.runtime.GetChunkFilenameRuntimeModule.addDependency(dependency): void
Attributes
dependency:<Dependency>
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.addError(error): void
Attributes
error:<WebpackError>
the error
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.addPresentationalDependency(presentationalDependency): void
Attributes
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.runtime.GetChunkFilenameRuntimeModule.addWarning(warning): void
Attributes
warning:<WebpackError>
the warning
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.attach(compilation, chunk, chunkGraph?): void
Attributes
compilation:<Compilation>
the compilation
chunk:<Chunk>
the chunk
chunkGraph:<ChunkGraph>
the chunk graph
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.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.runtime.GetChunkFilenameRuntimeModule.chunkCondition(chunk, compilation): boolean
Attributes
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.runtime.GetChunkFilenameRuntimeModule.cleanupForCache(): void
Returns:
{void}

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

webpack.runtime.GetChunkFilenameRuntimeModule.clearDependenciesAndBlocks(): void
Returns:
{void}

Removes all dependencies and blocks

webpack.runtime.GetChunkFilenameRuntimeModule.clearWarningsAndErrors(): void
Returns:
{void}

removes all warnings and errors

webpack.runtime.GetChunkFilenameRuntimeModule.codeGeneration(context): void
  • context {CodeGenerationContext} context for code generation
  • Returns: {CodeGenerationResult} result
webpack.runtime.GetChunkFilenameRuntimeModule.deserialize(__namedParameters): void
Attributes
__namedParameters:<ObjectDeserializerContext>
context
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.generate(): string
Returns:<string>
runtime code
webpack.runtime.GetChunkFilenameRuntimeModule.getChunks(): Chunk[]
Returns:<Chunk[]>
webpack.runtime.GetChunkFilenameRuntimeModule.getConcatenationBailoutReason(context): void
  • context {ConcatenationBailoutReasonContext} context
  • Returns: <string> reason why this module can't be concatenated, undefined when it can be concatenated
webpack.runtime.GetChunkFilenameRuntimeModule.getErrors(): Iterable<WebpackError, any, any>
Returns:
{Iterable<WebpackError, any, any>} list of errors if any
webpack.runtime.GetChunkFilenameRuntimeModule.getExportsType(moduleGraph, strict?): ExportsType
Attributes
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.runtime.GetChunkFilenameRuntimeModule.getGeneratedCode(): string
Returns:<string>
runtime code
webpack.runtime.GetChunkFilenameRuntimeModule.getNumberOfChunks(): number
Returns:<number>
webpack.runtime.GetChunkFilenameRuntimeModule.getNumberOfErrors(): number
Returns:<number>
number of errors
webpack.runtime.GetChunkFilenameRuntimeModule.getNumberOfWarnings(): number
Returns:<number>
number of warnings
webpack.runtime.GetChunkFilenameRuntimeModule.getRootBlock(): DependenciesBlock
Returns:
{DependenciesBlock}
webpack.runtime.GetChunkFilenameRuntimeModule.getSideEffectsConnectionState(moduleGraph): ConnectionState
Attributes
moduleGraph:<ModuleGraph>
the module graph
Returns:
{ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
webpack.runtime.GetChunkFilenameRuntimeModule.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.runtime.GetChunkFilenameRuntimeModule.getSourceTypes(): ReadonlySet<string>
Returns:
{ReadonlySet } types available (do not mutate)
webpack.runtime.GetChunkFilenameRuntimeModule.getUnsafeCacheData(): UnsafeCacheData
Returns:
{UnsafeCacheData}

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

webpack.runtime.GetChunkFilenameRuntimeModule.getWarnings(): Iterable<WebpackError, any, any>
Returns:
{Iterable<WebpackError, any, any>} list of warnings if any
webpack.runtime.GetChunkFilenameRuntimeModule.hasChunkCondition(): boolean
Returns:<boolean>
webpack.runtime.GetChunkFilenameRuntimeModule.hasReasonForChunk(chunk, moduleGraph, chunkGraph): boolean
Attributes
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.runtime.GetChunkFilenameRuntimeModule.hasReasons(moduleGraph, runtime): boolean
Attributes
moduleGraph:<ModuleGraph>
the module graph
runtime:
{RuntimeSpec} the runtime
Returns:<boolean>
true if at least one other module depends on this module
webpack.runtime.GetChunkFilenameRuntimeModule.identifier(): string
Returns:<string>
a unique identifier of the module
webpack.runtime.GetChunkFilenameRuntimeModule.invalidateBuild(): void
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): boolean
Attributes
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.runtime.GetChunkFilenameRuntimeModule.isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): boolean
Attributes
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.runtime.GetChunkFilenameRuntimeModule.isEntryModule(): boolean
Returns:<boolean>
webpack.runtime.GetChunkFilenameRuntimeModule.isInChunk(chunk): boolean
Attributes
chunk:<Chunk>
the chunk
Returns:<boolean>
true, when the module is in the chunk
webpack.runtime.GetChunkFilenameRuntimeModule.isOptional(moduleGraph): boolean
Attributes
moduleGraph:<ModuleGraph>
the module graph
Returns:<boolean>
true, if the module is optional
webpack.runtime.GetChunkFilenameRuntimeModule.isProvided(exportName): boolean
Attributes
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.runtime.GetChunkFilenameRuntimeModule.libIdent(options): void
  • options {LibIdentOptions} options
  • Returns: <string> an identifier for library inclusion
webpack.runtime.GetChunkFilenameRuntimeModule.nameForCondition(): string
Returns:<string>
absolute path which should be used for condition matching (usually the resource path)
webpack.runtime.GetChunkFilenameRuntimeModule.needBuild(context, callback): void
  • context {NeedBuildContext} context info
  • callback <object> callback function, returns true, if the module needs a rebuild
  • Returns: {void}
webpack.runtime.GetChunkFilenameRuntimeModule.needRebuild(fileTimestamps, contextTimestamps): void
Stability: 0Deprecated
  • fileTimestamps {Map<string, number>}
  • contextTimestamps {Map<string, number>}
  • Returns: <boolean>

Use needBuild instead

webpack.runtime.GetChunkFilenameRuntimeModule.originalSource(): Source
Returns:<Source>
the original source for the module before webpack transformation
webpack.runtime.GetChunkFilenameRuntimeModule.readableIdentifier(requestShortener): void
  • requestShortener {RequestShortener} the request shortener
  • Returns: <string> a user readable identifier of the module
webpack.runtime.GetChunkFilenameRuntimeModule.removeChunk(chunk): void
Attributes
chunk:<Chunk>
the chunk
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.removeDependency(dependency): void
Attributes
dependency:<Dependency>
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.serialize(__namedParameters): void
Attributes
__namedParameters:<ObjectSerializerContext>
context
Returns:
{void}
webpack.runtime.GetChunkFilenameRuntimeModule.shouldIsolate(): boolean
Returns:<boolean>
true, if the runtime module should get it's own scope
webpack.runtime.GetChunkFilenameRuntimeModule.size(type?): number
Attributes
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.runtime.GetChunkFilenameRuntimeModule.source(dependencyTemplates, runtimeTemplate, type?): void
Stability: 0Deprecated
  • dependencyTemplates {DependencyTemplates}
  • runtimeTemplate {RuntimeTemplate}
  • type <string>
  • Returns: <Source>

Use codeGeneration() instead

webpack.runtime.GetChunkFilenameRuntimeModule.updateCacheModule(module): void
Attributes
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.runtime.GetChunkFilenameRuntimeModule.updateHash(hash, context): void
  • hash {Hash} the hash used to track dependencies
  • context {UpdateHashContextDependency} context
  • Returns: {void}
webpack.runtime.GetChunkFilenameRuntimeModule.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.