On this page

new Compilation(compiler, params): Compilation
Attributes
compiler:Compiler
the compiler which created the compilation
params:CompilationParams
the compilation parameters
Returns:Compilation

Creates an instance of Compilation.

Attributes
additionalChunkAssets:string[]
addModuleQueue:AsyncQueue<Module, string, Module>
assets:CompilationAssets
assetsInfo:Map<string, AssetInfo>
asyncEntrypoints:Entrypoint[]
bail:boolean
buildDependencies:LazySet<string>
buildQueue:AsyncQueue<Module, Module, Module>
buildTimeExecutedModules:WeakSet<Module>
builtModules:WeakSet<Module>
children:Compilation[]
childrenCounters:Record<string, number>
chunkGraph:ChunkGraph
chunkGroups:ChunkGroup[]
chunks:Set<Chunk>
chunkTemplate:ChunkTemplate
codeGeneratedModules:WeakSet<Module>
codeGenerationResults:CodeGenerationResults
comparedForEmitAssets:Set<string>
compilationDependencies:{ add: (item: string) => LazySet<string> }
compiler:Compiler
compilerPath:string
contextDependencies:LazySet<string>
creatingModuleDuringBuild:WeakMap<Module, Set<Module>>
Modules in value are building during the build of Module in key. Means value blocking key from finishing. Needed to detect build cycles.
dependencyFactories:Map<DependencyConstructor, ModuleFactory>
dependencyTemplates:DependencyTemplates
emittedAssets:Set<string>
endTime:number
entries:Map<string, EntryData>
entrypoints:Map<string, Entrypoint>
errors:Error[]
factorizeQueue:AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>
fileDependencies:LazySet<string>
fileSystemInfo:FileSystemInfo
fullHash:string
globalEntry:EntryData
hash:string
inputFileSystem:InputFileSystem
logger:WebpackLogger
logging:Map<string, LogEntry[]>
mainTemplate:MainTemplate
missingDependencies:LazySet<string>
moduleGraph:ModuleGraph
moduleMemCaches:Map<Module, WeakTupleMap<any[], any>>
moduleMemCaches2:Map<Module, WeakTupleMap<any[], any>>
modules:Set<Module>
moduleTemplates:ModuleTemplates
name:string
namedChunkGroups:Map<string, ChunkGroup>
namedChunks:Map<string, Chunk>
needAdditionalPass:boolean
options:WebpackOptionsNormalizedWithDefaults
outputOptions:OutputNormalizedWithDefaults
params:CompilationParams
processDependenciesQueue:AsyncQueue<Module, Module, Module>
profile:boolean
rebuildQueue:AsyncQueue<Module, Module, Module>
records:Records | null
requestShortener:RequestShortener
resolverFactory:ResolverFactory
runtimeTemplate:RuntimeTemplate
startTime:number
usedChunkIds:Set<number> | null
usedModuleIds:Set<number> | null
valueCacheVersions:Map<string, ValueCacheVersion>
warnings:Error[]
PROCESS_ASSETS_STAGE_ADDITIONAL:number
Add additional assets to the compilation.
PROCESS_ASSETS_STAGE_ADDITIONS:number
Add additional sections to existing assets, like a banner or initialization code.
PROCESS_ASSETS_STAGE_ANALYSE:number
Analyse existing assets.
PROCESS_ASSETS_STAGE_DERIVED:number
Derive new assets from existing assets. Existing assets should not be treated as complete.
PROCESS_ASSETS_STAGE_DEV_TOOLING:number
Add development tooling to assets, e. g. by extracting a SourceMap.
PROCESS_ASSETS_STAGE_OPTIMIZE:number
Optimize existing assets in a general way.
PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY:number
Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT:number
Optimize the count of existing assets, e. g. by merging them. Only assets of the same type should be merged. For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
PROCESS_ASSETS_STAGE_OPTIMIZE_HASH:number
Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE:number
Optimize the count of existing assets, e. g. by inlining assets of into other assets. Only assets of different types should be inlined. For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE:number
Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER:number
Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
PROCESS_ASSETS_STAGE_PRE_PROCESS:number
Basic preprocessing of assets.
PROCESS_ASSETS_STAGE_REPORT:number
Creating assets for reporting purposes.
PROCESS_ASSETS_STAGE_SUMMARIZE:number
Summarize the list of existing assets e. g. creating an assets manifest of Service Workers.
addAsyncEntrypoint(options, module, loc, request): Entrypoint
Attributes
options:EntryOptions
options for the entrypoint
module:Module
the module the references the chunk group
loc:DependencyLocation
the location from with the chunk group is referenced (inside of module)
request:string
the request from which the chunk group is referenced
Returns:Entrypoint
the new or existing entrypoint

Adds the provided async entrypoint to this chunk group.

addChunk(name?): Chunk
Attributes
name:string | null
optional chunk name to be provided
Returns:Chunk
create a chunk (invoked during seal event)

This method first looks to see if a name is provided for a new chunk, and first looks to see if any named chunks already exist and reuse that chunk instead.

addChunkInGroup(groupOptions, module?, loc?, request?): ChunkGroup
Attributes
groupOptions:string | ChunkGroupOptions
options for the chunk group
module:Module
the module the references the chunk group
loc:SyntheticDependencyLocation | RealDependencyLocation
the location from with the chunk group is referenced (inside of module)
request:string
the request from which the chunk group is referenced
Returns:ChunkGroup
the new or existing chunk group

If module is passed, loc and request must also be passed.

addEntry(context, entry, optionsOrName, callback): void
Attributes
context:string
context path for entry
entry:Dependency
entry dependency that should be followed
optionsOrName:string | EntryOptions
options or deprecated name of entry
callback:(err?: WebpackError | null, result?: Module | null) => void
callback function
Returns:void
returns

Adds the provided string to the compilation.

addInclude(context, dependency, options, callback): void
Attributes
context:string
context path for entry
dependency:Dependency
dependency that should be followed
options:EntryOptions
options
callback:(err?: WebpackError | null, result?: Module | null) => void
callback function
Returns:void
returns

Adds the provided string to the compilation.

addModule(module, callback): void
Attributes
module:Module
module to be added that was created
callback:(err?: WebpackError | null, result?: Module | null) => void
returns the module in the compilation, it could be the passed one (if new), or an already existing in the compilation
Returns:void

Adds the provided module to the compilation.

addModuleChain(context, dependency, callback): void
Attributes
context:string
context string path
dependency:Dependency
dependency used to create Module chain
callback:(err?: WebpackError | null, result?: Module | null) => void
callback for when module chain is complete
Returns:void
will throw if dependency instance is not a valid Dependency

Adds the provided string to the compilation.

addModuleTree({ context, dependency, contextInfo }, callback): void
Attributes
context:string
context string path
contextInfo:Partial<ModuleFactoryCreateDataContextInfo>
additional context info for the root module
dependency:Dependency
dependency used to create Module chain
callback:(err?: WebpackError | null, result?: Module | null) => void
callback for when module chain is complete
Returns:void
will throw if dependency instance is not a valid Dependency

Adds the provided object to the compilation.

addRuntimeModule(chunk, module, chunkGraph?): void
Attributes
chunk:Chunk
target chunk
module:RuntimeModule
runtime module
chunkGraph:ChunkGraph
the chunk graph
Returns:void

Adds runtime module.

assignDepth(module): void
Attributes
module:Module
module to assign depth
Returns:void

Processes the provided module.

assignDepths(modules): void
Attributes
modules:Module[] | Set<Module>
modules to assign depth
Returns:void

Assigns depth values to the provided modules.

assignRuntimeIds(): void
Returns:void
buildModule(module, callback): void
Attributes
module:Module
module to be built
callback:(err?: WebpackError | null, result?: Module | null) => void
the callback
Returns:void

Schedules a build of the module object

checkConstraints(): void
Returns:void
clearAssets(): void
Returns:void
codeGeneration(callback): void
Attributes
callback:(err?: WebpackError | null) => void
callback
Returns:void

Generates code and runtime requirements for this module.

createChildCompiler(name, outputOptions?, plugins?): Compiler
Attributes
name:string
name of the child compiler
outputOptions:Partial<OutputNormalized>
// Need to convert config schema to types for this
plugins:(false | "" | 0 | ((this: Compiler, compiler: Compiler) => void) | WebpackPluginInstance | null | undefined)[]
webpack plugins that will be applied
Returns:Compiler
creates a child Compiler instance

This function allows you to run another instance of webpack inside of webpack however as a child with different settings and configurations (if desired) applied. It copies all hooks, plugins from parent (or top level compiler) and creates a child Compilation

createChunkAssets(callback): void
Attributes
callback:(err?: WebpackError | null) => void
signals when the call finishes
Returns:void

Creates a chunk assets.

createHash(): CodeGenerationJob[]
Returns:CodeGenerationJob[]
createModuleAssets(): void
Returns:void
createModuleHashes(): void
Returns:void
createStatsFactory(options): StatsFactory
Attributes
options:NormalizedStatsOptions
options
Returns:StatsFactory
the stats factory

Creates a stats factory.

createStatsOptions(optionsOrPreset?, context?): NormalizedStatsOptions
Attributes
optionsOrPreset:string | boolean | StatsOptions
stats option value
context:CreateStatsOptionsContext
context
Returns:NormalizedStatsOptions
normalized options

Creates a stats options.

createStatsPrinter(options): StatsPrinter
Attributes
options:NormalizedStatsOptions
options
Returns:StatsPrinter
the stats printer

Creates a stats printer.

deleteAsset(file): void
Attributes
file:string
file name
Returns:void

Processes the provided file.

emitAsset(file, source, assetInfo?): void
Attributes
file:string
file name
source:Source
asset source
assetInfo:AssetInfo
extra asset information
Returns:void

Processes the provided file.

executeModule(module, options, callback): void
Attributes
module:Module
the module
options:ExecuteModuleOptions
options
callback:(err?: WebpackError | null, result?: ExecuteModuleResult | null) => void
callback
Returns:void

Processes the provided module.

factorizeModule(options, callback): void
Attributes
options:FactorizeModuleOptions & { factoryResult?: false }
options
callback:(err?: WebpackError | null, result?: Module | null) => void
callback
Returns:void

Processes the provided |.

Attributes
options:FactorizeModuleOptions & { factoryResult: true }
options
callback:(err?: WebpackError | null, result?: ModuleFactoryResult | null) => void
callback
Returns:void

Processes the provided |.

findModule(identifier): Module | undefined
Attributes
identifier:string
identifier (usually path) for module
Returns:Module | undefined
attempt to search for module and return it, else undefined

Attempts to search for a module by its identifier

finish(callback): void
Attributes
callback:(err?: WebpackError | null) => void
callback
Returns:void

Processes the provided callback.

getAsset(name): Readonly<Asset> | undefined
Attributes
name:string
the name of the asset
Returns:Readonly<Asset> | undefined
the asset or undefined when not found

Returns the asset or undefined when not found.

getAssetPath(filename, data): string
Attributes
filename:string | TemplatePathFn<T>
used to get asset path with hash
data:T
context data
Returns:string
interpolated path

Returns interpolated path.

getAssetPathWithInfo(filename, data): InterpolatedPathAndAssetInfo
Attributes
filename:string | TemplatePathFn<T>
used to get asset path with hash
data:T
context data
Returns:InterpolatedPathAndAssetInfo
interpolated path and asset info

Gets asset path with info.

getAssets(): Readonly<Asset>[]
Returns:Readonly<Asset>[]
getCache(name): CacheFacade
Attributes
name:string
cache name
Returns:CacheFacade
the cache facade instance

Returns the cache facade instance.

getDependencyReferencedExports(dependency, runtime): (string[] | ReferencedExport)[]
Attributes
dependency:Dependency
the dependency
runtime:RuntimeSpec
the runtime
Returns:(string[] | ReferencedExport)[]
referenced exports

Gets dependency referenced exports.

getErrors(): Error[]
Returns:Error[]
getLogger(name): WebpackLogger
Attributes
name:string | (() => string)
name of the logger, or function called once to get the logger name
Returns:WebpackLogger
a logger with that name

Returns a logger with that name.

getModule(module): Module
Attributes
module:Module
the module provided
Returns:Module
the module requested

Fetches a module from a compilation by its identifier

getPath(filename, data?): string
Attributes
filename:string | TemplatePathFn<T>
used to get asset path with hash
data:T
context data
Returns:string
interpolated path

Returns interpolated path.

getPathWithInfo(filename, data?): InterpolatedPathAndAssetInfo
Attributes
filename:string | TemplatePathFn<T>
used to get asset path with hash
data:T
context data
Returns:InterpolatedPathAndAssetInfo
interpolated path and asset info

Gets path with info.

getRenderManifest(options): RenderManifestEntry[]
Attributes
options:RenderManifestOptions
options object
Returns:RenderManifestEntry[]
manifest entries

Gets render manifest.

getStats(): Stats
Returns:Stats
getWarnings(): Error[]
Returns:Error[]
handleModuleCreation(handleModuleCreationOptions, callback): void
Attributes
handleModuleCreationOptions:HandleModuleCreationOptions
callback:(err?: WebpackError | null, result?: Module | null) => void
callback
Returns:void

Handle module creation.

patchChunksAfterReasonRemoval(module, chunk): void
Attributes
module:Module
module to patch tie
chunk:Chunk
chunk to patch tie
Returns:void

Patch chunks after reason removal.

processModuleDependencies(module, callback): void
Attributes
module:Module
to be processed for deps
callback:(err?: WebpackError | null, result?: Module | null) => void
callback to be triggered
Returns:void

Process module dependencies.

processModuleDependenciesNonRecursive(module): void
Attributes
module:Module
to be processed for deps
Returns:void

Process module dependencies non recursive.

processRuntimeRequirements({ chunkGraph?, modules?, chunks?, codeGenerationResults?, chunkGraphEntries }?): void
Attributes
chunkGraph:ChunkGraph
the chunk graph
chunkGraphEntries:Iterable<Chunk, any, any>
chunkGraphEntries
chunks:Iterable<Chunk, any, any>
chunks
codeGenerationResults:CodeGenerationResults
codeGenerationResults
modules:Iterable<Module, any, any>
modules
Returns:void

Process runtime requirements.

rebuildModule(module, callback): void
Attributes
module:Module
module to be rebuilt
callback:(err?: WebpackError | null, result?: Module | null) => void
callback when module finishes rebuilding
Returns:void

Processes the provided module.

removeChunkFromDependencies(block, chunk): void
Attributes
block:DependenciesBlock
block tie for Chunk
chunk:Chunk
chunk to remove from dep
Returns:void

Removes chunk from dependencies.

removeReasonsOfDependencyBlock(module, block): void
Attributes
module:Module
module relationship for removal
block:DependenciesBlockLike
dependencies block
Returns:void

Removes reasons of dependency block.

renameAsset(file, newFile): void
Attributes
file:string
file name
newFile:string
the new name of file
Returns:void

Processes the provided file.

reportDependencyErrorsAndWarnings(module, blocks): boolean
Attributes
module:Module
module to report from
blocks:DependenciesBlock[]
blocks to report from
Returns:boolean
true, when it has warnings or errors

Report dependency errors and warnings.

seal(callback): void
Attributes
callback:(err?: WebpackError | null) => void
signals when the call finishes
Returns:void

Processes the provided callback.

sortItemsWithChunkIds(): void
Returns:void
summarizeDependencies(): void
Returns:void
unseal(): void
Returns:void
updateAsset(file, newSourceOrFunction, assetInfoUpdateOrFunction?): void
Attributes
file:string
file name
newSourceOrFunction:Source | ((source: Source) => Source)
new asset source or function converting old to new
assetInfoUpdateOrFunction:AssetInfo | ((assetInfo?: AssetInfo) => AssetInfo | undefined)
new asset info or function converting old to new
Returns:void

Updates asset using the provided file.

addEntry(dependency, entryOptions): void
Attributes
dependency:Dependency
entryOptions:EntryOptions
Returns:void
Stability: 0Deprecated
Returns:void
Stability: 0Deprecated
Returns:void
additionalChunkRuntimeRequirements(chunk, set, runtimeRequirementsContext): void
Attributes
chunk:Chunk
set:Set<string>
runtimeRequirementsContext:RuntimeRequirementsContext
Returns:void
additionalModuleRuntimeRequirements(module, set, runtimeRequirementsContext): void
Attributes
module:Module
set:Set<string>
runtimeRequirementsContext:RuntimeRequirementsContext
Returns:void
additionalTreeRuntimeRequirements(chunk, set, runtimeRequirementsContext): void
Attributes
chunk:Chunk
set:Set<string>
runtimeRequirementsContext:RuntimeRequirementsContext
Returns:void
afterChunks(iterable): void
Attributes
iterable:Iterable<Chunk>
Returns:void

The afterChunks hook is called directly after the chunks and module graph have been created and before the chunks and modules have been optimized. This hook is useful to inspect, analyze, and/or modify the chunk graph.

afterCodeGeneration(): void
Returns:void
afterHash(): void
Returns:void
afterModuleHash(): void
Returns:void
afterOptimizeAssets(compilationAssets): void
Stability: 0Deprecated
Attributes
compilationAssets:CompilationAssets
Returns:void
Stability: 0Deprecated
Returns:void
afterOptimizeChunkIds(iterable): void
Attributes
iterable:Iterable<Chunk>
Returns:void
afterOptimizeChunkModules(iterable, iterable): void
Attributes
iterable:Iterable<Chunk>
iterable:Iterable<Module>
Returns:void
afterOptimizeChunks(iterable, arg1): void
Attributes
iterable:Iterable<Chunk>
arg1:ChunkGroup[]
Returns:void
afterOptimizeDependencies(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
afterOptimizeModuleIds(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
afterOptimizeModules(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
afterOptimizeTree(iterable, iterable): void
Attributes
iterable:Iterable<Chunk>
iterable:Iterable<Module>
Returns:void
afterProcessAssets(compilationAssets): void
Attributes
compilationAssets:CompilationAssets
Returns:void
afterRuntimeRequirements(): void
Returns:void
afterSeal(): void
Returns:void
assetPath(string, pathData, arg2): string
Attributes
string:string
pathData:PathData
arg2:undefined | AssetInfo
Returns:string
beforeChunkAssets(): void
Returns:void
beforeChunkIds(iterable): void
Attributes
iterable:Iterable<Chunk>
Returns:void
beforeChunks(): void
Returns:void
beforeCodeGeneration(): void
Returns:void
beforeHash(): void
Returns:void
beforeModuleAssets(): void
Returns:void
beforeModuleHash(): void
Returns:void
beforeModuleIds(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
beforeRuntimeRequirements(): void
Returns:void
buildModule(module): void
Attributes
module:Module
Returns:void
childCompiler(compiler, string, number): void
Attributes
compiler:Compiler
string:string
number:number
Returns:void
chunkAsset(chunk, string): void
Attributes
chunk:Chunk
string:string
Returns:void
chunkHash(chunk, hash, chunkHashContext): void
Attributes
chunk:Chunk
hash:Hash
chunkHashContext:ChunkHashContext
Returns:void
chunkIds(iterable): void
Attributes
iterable:Iterable<Chunk>
Returns:void
contentHash(chunk): void
Attributes
chunk:Chunk
Returns:void
dependencyReferencedExports(arg0, dependency, runtimeSpec): (string[] | ReferencedExport)[]
Attributes
arg0:(string[] | ReferencedExport)[]
dependency:Dependency
runtimeSpec:RuntimeSpec
Returns:(string[] | ReferencedExport)[]
executeModule(executeModuleArgument, executeModuleContext): void
Attributes
executeModuleArgument:ExecuteModuleArgument
executeModuleContext:ExecuteModuleContext
Returns:void
failedEntry(dependency, entryOptions, error): void
Attributes
dependency:Dependency
entryOptions:EntryOptions
error:Error
Returns:void
failedModule(module, webpackError): void
Attributes
module:Module
webpackError:WebpackError
Returns:void
finishModules(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
finishRebuildingModule(module): void
Attributes
module:Module
Returns:void
fullHash(hash): void
Attributes
hash:Hash
Returns:void
log(string, logEntry): boolean | void
Attributes
string:string
logEntry:LogEntry
Returns:boolean | void
moduleAsset(module, string): void
Attributes
module:Module
string:string
Returns:void
moduleIds(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
needAdditionalPass(): boolean | void
Returns:boolean | void
needAdditionalSeal(): boolean | void
Returns:boolean | void
normalModuleLoader(anyLoaderContext, normalModule): void
Stability: 0Deprecated
Attributes
anyLoaderContext:AnyLoaderContext
normalModule:NormalModule
Returns:void

Gets normal module loader.

optimize(): void
Returns:void
optimizeAssets(compilationAssets): void
Stability: 0Deprecated
Attributes
compilationAssets:CompilationAssets
Returns:void
Stability: 0Deprecated
Returns:void
optimizeChunkIds(iterable): void
Attributes
iterable:Iterable<Chunk>
Returns:void
optimizeChunkModules(iterable, iterable): void
Attributes
iterable:Iterable<Chunk>
iterable:Iterable<Module>
Returns:void
optimizeChunks(iterable, arg1): boolean | void
Attributes
iterable:Iterable<Chunk>
arg1:ChunkGroup[]
Returns:boolean | void
optimizeCodeGeneration(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
optimizeDependencies(iterable): boolean | void
Attributes
iterable:Iterable<Module>
Returns:boolean | void
optimizeModuleIds(iterable): void
Attributes
iterable:Iterable<Module>
Returns:void
optimizeModules(iterable): boolean | void
Attributes
iterable:Iterable<Module>
Returns:boolean | void
optimizeTree(iterable, iterable): void
Attributes
iterable:Iterable<Chunk>
iterable:Iterable<Module>
Returns:void
prepareModuleExecution(executeModuleArgument, executeModuleContext): void
Attributes
executeModuleArgument:ExecuteModuleArgument
executeModuleContext:ExecuteModuleContext
Returns:void
processAdditionalAssets(compilationAssets): void
Attributes
compilationAssets:CompilationAssets
Returns:void
processAssets(compilationAssets): void
Attributes
compilationAssets:CompilationAssets
Returns:void
processErrors(arg0): Error[]
Attributes
arg0:Error[]
Returns:Error[]
processWarnings(arg0): Error[]
Attributes
arg0:Error[]
Returns:Error[]
rebuildModule(module): void
Attributes
module:Module
Returns:void
record(compilation, records): void
Attributes
compilation:Compilation
records:Records
Returns:void
recordChunks(iterable, records): void
Attributes
iterable:Iterable<Chunk>
records:Records
Returns:void
recordHash(records): void
Attributes
records:Records
Returns:void
recordModules(iterable, records): void
Attributes
iterable:Iterable<Module>
records:Records
Returns:void
renderManifest(arg0, renderManifestOptions): RenderManifestEntry[]
Attributes
arg0:RenderManifestEntry[]
renderManifestOptions:RenderManifestOptions
Returns:RenderManifestEntry[]
reviveChunks(iterable, records): void
Attributes
iterable:Iterable<Chunk>
records:Records
Returns:void
reviveModules(iterable, records): void
Attributes
iterable:Iterable<Module>
records:Records
Returns:void
runtimeModule(runtimeModule, chunk): void
Attributes
runtimeModule:RuntimeModule
chunk:Chunk
Returns:void
Returns:void
Returns:void
Returns:void
seal(): void
Returns:void
shouldGenerateChunkAssets(): boolean | void
Returns:boolean | void
shouldRecord(): boolean | void
Returns:boolean | void
statsFactory(statsFactory, normalizedStatsOptions): void
Attributes
statsFactory:StatsFactory
normalizedStatsOptions:NormalizedStatsOptions
Returns:void
statsNormalize(partial, createStatsOptionsContext): void
Attributes
partial:Partial<NormalizedStatsOptions>
createStatsOptionsContext:CreateStatsOptionsContext
Returns:void
Returns:void
statsPrinter(statsPrinter, normalizedStatsOptions): void
Attributes
statsPrinter:StatsPrinter
normalizedStatsOptions:NormalizedStatsOptions
Returns:void
stillValidModule(module): void
Attributes
module:Module
Returns:void
succeedEntry(dependency, entryOptions, module): void
Attributes
dependency:Dependency
entryOptions:EntryOptions
module:Module
Returns:void
succeedModule(module): void
Attributes
module:Module
Returns:void
unseal(): void
Returns:void
Attributes
hash:string
module:Module
runtime:RuntimeSpec
runtimes:RuntimeSpec[]
Type:KnownCreateStatsOptionsContext & Record<string, any>
Attributes
blocks:AsyncDependenciesBlock[]
dependencies:Dependency[]
Attributes
dependencies:Dependency[]
dependencies of the entrypoint that should be evaluated at startup
includeDependencies:Dependency[]
dependencies of the entrypoint that should be included but not evaluated
options:EntryOptions
options of the entrypoint
Type:"module" | "chunk" | "root-of-chunk" | "nested"
Attributes
codeGenerationResult:CodeGenerationResult
module:Module
moduleObject:ExecuteModuleObject
Attributes
__webpack_require__:WebpackRequire
assets:Map<string, { info?: AssetInfo; source: Source }>
chunk:Chunk
chunkGraph:ChunkGraph
Attributes
error:Error
error
exports:any
exports
id:string
module id
loaded:boolean
is loaded
Attributes
entryOptions:EntryOptions
Attributes
assets:Map<string, { info?: AssetInfo; source: Source }>
buildDependencies:LazySet<string>
cacheable:boolean
contextDependencies:LazySet<string>
exports:any
fileDependencies:LazySet<string>
missingDependencies:LazySet<string>
notCacheableReasons:string[]
reasons why the executed modules are not cacheable
Attributes
id:string
module id
module:ExecuteModuleObject
module
require:WebpackRequire
require function

Processes the provided factorize module option.

Attributes
context:string
contextInfo:Partial<ModuleFactoryCreateDataContextInfo>
currentProfile:ModuleProfile
dependencies:Dependency[]
factory:ModuleFactory
factoryResult:boolean
return full ModuleFactoryResult instead of only module
originModule:Module | null
Attributes
checkCycle:boolean
check the cycle dependencies of the created module
connectOrigin:boolean
connect the resolved module with the origin module
context:string
contextInfo:Partial<ModuleFactoryCreateDataContextInfo>
dependencies:Dependency[]
factory:ModuleFactory
originModule:Module | null
recursive:boolean
recurse into dependencies of the created module
Attributes
forToString:boolean
Attributes
assetsSort:string | false
assetsSpace:number
cachedAssets:boolean
cachedModules:boolean
chunkGroupAuxiliary:boolean
chunkGroupChildren:boolean
chunkGroupMaxAssets:number
chunkGroups:boolean
chunkModulesSort:string | false
chunkModulesSpace:number
chunksSort:string | false
context:string
dependentModules:boolean
entrypoints:boolean | "auto"
excludeAssets:((value: string, asset: StatsAsset) => boolean)[]
excludeModules:((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]
groupAssetsByEmitStatus:boolean
groupAssetsByExtension:boolean
groupAssetsByPath:boolean
groupModulesByAttributes:boolean
groupModulesByCacheStatus:boolean
groupModulesByExtension:boolean
groupModulesByLayer:boolean
groupModulesByPath:boolean
groupModulesByType:boolean
ids:boolean
logging:false | "error" | "warn" | "info" | "log" | "none" | "verbose"
loggingDebug:((value: string) => boolean)[]
loggingTrace:boolean
modulesSort:string | false
modulesSpace:number
nestedModulesSort:string | false
nestedModulesSpace:number
orphanModules:boolean
requestShortener:RequestShortener
runtimeModules:boolean
warningsFilter:((warning: StatsError, textValue: string) => boolean)[]
Attributes
args:any[]
time:number
trace:string[]
type:"error" | "warn" | "info" | "log" | "debug" | "trace" | "group" | "groupCollapsed" | "groupEnd" | "profile" | "profileEnd" | "time" | "clear" | "status"
Attributes
javascript:ModuleTemplate
Type:KnownNormalizedStatsOptions & Omit<StatsOptions, "context" | "chunkGroups" | "requestShortener" | "chunksSort" | "modulesSort" | "chunkModulesSort" | "nestedModulesSort" | "assetsSort" | "ids" | "cachedAssets" | "groupAssetsByEmitStatus" | "groupAssetsByPath" | "groupAssetsByExtension" | "assetsSpace" | "excludeAssets" | "excludeModules" | "warningsFilter" | "cachedModules" | "orphanModules" | "dependentModules" | "runtimeModules" | "groupModulesByCacheStatus" | "groupModulesByLayer" | "groupModulesByAttributes" | "groupModulesByPath" | "groupModulesByExtension" | "groupModulesByType" | "entrypoints" | "chunkGroupAuxiliary" | "chunkGroupChildren" | "chunkGroupMaxAssets" | "modulesSpace" | "chunkModulesSpace" | "nestedModulesSpace" | "logging" | "loggingDebug" | "loggingTrace" | "_env"> & Record<string, any>
Attributes
additionalAssets:boolean | ((assets: CompilationAssets) => void)
Attributes
chunkGraph:ChunkGraph
the chunk graph
codeGenerationResults:CodeGenerationResults
the code generation results
Attributes
id:string
Returns:any
Attributes
c:Record<string, ExecuteModuleObject>
i:((options: ExecuteOptions) => void)[]