On this page

These types are not exported by webpack, but they are available to TypeScript consumers.

Attributes
chunkGraph:ChunkGraph
moduleGraph:ModuleGraph
Attributes
err:Error | null
result:T | null
Returns:void
Attributes
err:Error | null
result:T
Returns:void
Attributes
maps:boolean
drop cached source maps (default true )
parsedMap:boolean
drop the parsed object form of cached source maps on SourceMapSource instances (default false — re-parsing JSON is significantly more expensive than toString ). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
source:boolean
drop cached source/buffer copies (default true )

Creates a callback wrapper that waits for a fixed number of completions and forwards the first error immediately.

Attributes
toString:() => string

Options object for persistent file-based caching.

Attributes
allowCollectingMemory:boolean
Allows to collect unused memory allocated during deserialization. This requires copying data into smaller buffers and has a performance cost.
buildDependencies:{ [index: string]: string[] }
Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack').
cacheDirectory:string
Base directory for the cache (defaults to node_modules/.cache/webpack).
cacheLocation:string
Locations for the cache (defaults to cacheDirectory / name).
compression:false | "gzip" | "brotli"
Compression type used for the cache files.
hashAlgorithm:string
Algorithm used for generation the hash (see node.js crypto package).
idleTimeout:number
Time in ms after which idle period the cache storing should happen.
idleTimeoutAfterLargeChanges:number
Time in ms after which idle period the cache storing should happen when larger changes has been detected (cumulative build time > 2 x avg cache store time).
idleTimeoutForInitialStore:number
Time in ms after which idle period the initial cache storing should happen.
immutablePaths:(string | RegExp)[]
List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.
managedPaths:(string | RegExp)[]
List of paths that are managed by a package manager and can be trusted to not be modified otherwise.
maxAge:number
Time for which unused cache entries stay in the filesystem cache at minimum (in milliseconds).
maxMemoryGenerations:number
Number of generations unused cache entries stay in memory cache at minimum (0 = no memory cache used, 1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Cache entries will be deserialized from disk when removed from memory cache.
memoryCacheUnaffected:boolean
Additionally cache computation of modules that are unchanged and reference only unchanged modules in memory.
name:string
Name for the cache. Different names will lead to different coexisting caches.
profile:boolean
Track and log detailed timing information for individual cache items.
readonly:boolean
Enable/disable readonly mode.
store:"pack"
When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).
type:"filesystem"
Filesystem caching.
version:string
Version of the cache data. Different versions won't allow to reuse the cache and override existing content. Update the version when config changed in a way which doesn't allow to reuse cache. This will invalidate the cache.
Attributes
factoryMeta:FactoryMeta
factory meta
generatorOptions:GeneratorOptions
parserOptions:ParserOptions
resolveOptions:ResolveOptions
resolve options

Options object for in-memory caching.

Attributes
cacheUnaffected:boolean
Additionally cache computation of modules that are unchanged and reference only unchanged modules.
maxGenerations:number
Number of generations unused cache entries stay in memory cache at minimum (1 = may be removed after unused for a single compilation, ..., Infinity: kept forever).
type:"memory"
In memory caching.

Options object for describing behavior of a cache group selecting modules that should be cached together.

Attributes
automaticNameDelimiter:string
Sets the name delimiter for created chunks.
chunks:RegExp | "all" | "initial" | "async" | ((chunk: Chunk) => boolean | undefined)
Select chunks for determining cache group content (defaults to "initial", "initial" and "all" requires adding these chunks to the HTML).
enforce:boolean
Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group.
enforceSizeThreshold:number | { [index: string]: number }
Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
filename:string | TemplatePathFn<PathDataChunk>
Sets the template for the filename for created chunks.
idHint:string
Sets the hint for chunk id.
layer:string | RegExp | ((layer: string | null) => boolean)
Assign modules to a cache group by module layer.
maxAsyncRequests:number
Maximum number of requests which are accepted for on-demand loading.
maxAsyncSize:number | { [index: string]: number }
Maximal size hint for the on-demand chunks.
maxInitialRequests:number
Maximum number of initial chunks which are accepted for an entry point.
maxInitialSize:number | { [index: string]: number }
Maximal size hint for the initial chunks.
maxSize:number | { [index: string]: number }
Maximal size hint for the created chunks.
minChunks:number
Minimum number of times a module has to be duplicated until it's considered for splitting.
minRemainingSize:number | { [index: string]: number }
Minimal size for the chunks the stay after moving the modules to a new chunk.
minSize:number | { [index: string]: number }
Minimal size for the created chunk.
minSizeReduction:number | { [index: string]: number }
Minimum size reduction due to the created chunk.
name:string | false | ((module: Module, chunks: Chunk[], key: string) => string | undefined)
Give chunks for this cache group a name (chunks with equal name are merged).
priority:number
Priority of this cache group.
reuseExistingChunk:boolean
Try to reuse existing chunk (with name) when it has matching modules.
test:string | RegExp | ((module: Module, context: CacheGroupsContext) => boolean)
Assign modules to a cache group by module name.
type:string | RegExp | ((type: string) => boolean)
Assign modules to a cache group by module type.
usedExports:boolean
Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
Type:false | FileCacheOptions | MemoryCacheOptions
Type:KnownUnsafeCacheData & Record<string, any>
Type:string | Set<string>