These types are not exported by webpack, but they are available to TypeScript consumers.
Attributes
chunkGraph:
<ChunkGraph>moduleGraph:
<ModuleGraph>[index: {string}]<ResolveRequest>|<ResolveRequest>[] |<undefined>
Attributes
Attributes
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.
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
} Sets the template for the filename for created chunks.
idHint:
<string>Sets the hint for chunk id.
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.
| (module:
<Module>
, context:
<CacheGroupsContext>
) =>
<boolean>
Assign modules to a cache group by module name.usedExports:
<boolean>Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
Type:
Type:
{string | Set
}