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 }
buildQueue:<AsyncQueue>
< <Module> , <Module> , <Module> >
buildTimeExecutedModules:
{WeakSet }
builtModules:
{WeakSet }
children:<Compilation>
[]
childrenCounters:
<Record> < <string> , <number> >
chunkGraph:<ChunkGraph>
chunkGroups:<ChunkGroup>
[]
chunks:
{Set }
chunkTemplate:<ChunkTemplate>
codeGeneratedModules:
{WeakSet }
codeGenerationResults:<CodeGenerationResults>
comparedForEmitAssets:
{Set }
compilationDependencies:
{{ add: (item: string) => LazySet }}
compiler:<Compiler>
compilerPath:<string>
contextDependencies:
{LazySet }
creatingModuleDuringBuild:
{WeakMap<Module, Set >} 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 }
endTime:<number>
entries:<Map>
< <string> , <EntryData> >
entrypoints:<Map>
< <string> , <Entrypoint> >
errors:<Error>
[]
factorizeQueue:<AsyncQueue>
< <FactorizeModuleOptions> , <string> , <Module> | <ModuleFactoryResult> >
fileDependencies:
{LazySet }
fileSystemInfo:<FileSystemInfo>
fullHash:<string>
globalEntry:<EntryData>
hash:<string>
hooks:
{Readonly<{ addEntry: SyncHook <> < <[Dependency, EntryOptions]>; additionalAssets: FakeHook> < <Pick<AsyncSeriesHook<[]>, "name" | "tap" | "tapAsync" | "tapPromise"> >>; additionalChunkAssets: FakeHook<Pick<AsyncSeriesHook<[Set ]>, "name" | "tap" | "tapAsync" | "tapPromise">>; additionalChunkRuntimeRequirements: SyncHook<[Chunk, Set , RuntimeRequirementsContext]>; additionalModuleRuntimeRequirements: SyncHook<[Module, Set , RuntimeRequirementsContext]>; additionalTreeRuntimeRequirements: SyncHook<[Chunk, Set , RuntimeRequirementsContext]>; afterChunks: SyncHook<[Iterable ]>; afterCodeGeneration: SyncHook <> < <[]>; afterHash: SyncHook<[]>; afterModuleHash: SyncHook<[]>; afterOptimizeAssets: SyncHook<[CompilationAssets]> >; afterOptimizeChunkAssets: FakeHook<Pick<AsyncSeriesHook<[Set ]>, "name" | "tap" | "tapAsync" | "tapPromise">>; afterOptimizeChunkIds: SyncHook<[Iterable ]>; afterOptimizeChunkModules: SyncHook<[Iterable , Iterable ]>; afterOptimizeChunks: SyncHook<[Iterable , ChunkGroup[]]>; afterOptimizeDependencies: SyncHook<[Iterable ]>; afterOptimizeModuleIds: SyncHook<[Iterable ]>; afterOptimizeModules: SyncHook<[Iterable ]>; afterOptimizeTree: SyncHook<[Iterable , Iterable ]>; afterProcessAssets: SyncHook <> < <[CompilationAssets]>; afterRuntimeRequirements: SyncHook<[]>; afterSeal: AsyncSeriesHook<[]>; assetPath: SyncWaterfallHook<[string, PathData, undefined | AssetInfo]> , <string>; beforeChunkAssets: SyncHook<[]> >; beforeChunkIds: SyncHook<[Iterable ]>; beforeChunks: SyncHook <> < <[]>; beforeCodeGeneration: SyncHook<[]>; beforeHash: SyncHook<[]>; beforeModuleAssets: SyncHook<[]>; beforeModuleHash: SyncHook<[]> >; beforeModuleIds: SyncHook<[Iterable ]>; beforeRuntimeRequirements: SyncHook <> < <[]>; buildModule: SyncHook<[Module]>; childCompiler: SyncHook<[Compiler, string, number]>; chunkAsset: SyncHook<[Chunk, string]>; chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]> >; chunkIds: SyncHook<[Iterable ]>; contentHash: SyncHook <> < <[Chunk]>; dependencyReferencedExports: SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]> , <(string[] | ReferencedExport)[]>; executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>; failedEntry: SyncHook<[Dependency, EntryOptions, Error]>; failedModule: SyncHook<[Module, WebpackError]> >; finishModules: AsyncSeriesHook<[Iterable ]>; finishRebuildingModule: AsyncSeriesHook <> < <[Module]>; fullHash: SyncHook<[Hash]>; log: SyncBailHook<[string, LogEntry]> , <boolean> | <void>; moduleAsset: SyncHook<[Module, string]> >; moduleIds: SyncHook<[Iterable ]>; needAdditionalPass: SyncBailHook <> < <[]> , <boolean> | <void>; needAdditionalSeal: SyncBailHook<[]> , <boolean> | <void>; normalModuleLoader: SyncHook<[AnyLoaderContext, NormalModule]>; optimize: SyncHook<[]>; optimizeAssets: AsyncSeriesHook<[CompilationAssets]> , <ProcessAssetsAdditionalOptions> >; optimizeChunkAssets: FakeHook<Pick<AsyncSeriesHook<[Set ]>, "name" | "tap" | "tapAsync" | "tapPromise">>; optimizeChunkIds: SyncHook<[Iterable ]>; optimizeChunkModules: AsyncSeriesBailHook<[Iterable , Iterable ], void>; optimizeChunks: SyncBailHook<[Iterable , ChunkGroup[]], boolean | void>; optimizeCodeGeneration: SyncHook<[Iterable ]>; optimizeDependencies: SyncBailHook<[Iterable ], boolean | void>; optimizeModuleIds: SyncHook<[Iterable ]>; optimizeModules: SyncBailHook<[Iterable ], boolean | void>; optimizeTree: AsyncSeriesHook<[Iterable , Iterable ]>; prepareModuleExecution: AsyncParallelHook <> < <[ExecuteModuleArgument, ExecuteModuleContext]>; processAdditionalAssets: AsyncSeriesHook<[CompilationAssets]>; processAssets: AsyncSeriesHook<[CompilationAssets]> , <ProcessAssetsAdditionalOptions>; processErrors: SyncWaterfallHook<[Error[]]> , <Error[]>; processWarnings: SyncWaterfallHook<[Error[]]> , <Error[]>; rebuildModule: SyncHook<[Module]>; record: SyncHook<[Compilation, Records]> >; recordChunks: SyncHook<[Iterable , Records]>; recordHash: SyncHook <> < <[Records]> >; recordModules: SyncHook<[Iterable , Records]>; renderManifest: SyncWaterfallHook <> < <[RenderManifestEntry[], RenderManifestOptions]> , <RenderManifestEntry> []>; reviveChunks: SyncHook<[Iterable , Records]>; reviveModules: SyncHook<[Iterable , Records]>; runtimeModule: SyncHook <> < <[RuntimeModule, Chunk]> >; runtimeRequirementInChunk: HookMap<SyncBailHook<[Chunk, Set , RuntimeRequirementsContext], void>>; runtimeRequirementInModule: HookMap<SyncBailHook<[Module, Set , RuntimeRequirementsContext], void>>; runtimeRequirementInTree: HookMap<SyncBailHook<[Chunk, Set , RuntimeRequirementsContext], void>>; seal: SyncHook <> < <[]>; shouldGenerateChunkAssets: SyncBailHook<[]> , <boolean> | <void>; shouldRecord: SyncBailHook<[]> , <boolean> | <void>; statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]> >; statsNormalize: SyncHook<[Partial , CreateStatsOptionsContext]>; statsPreset: HookMap<SyncHook<[Partial , CreateStatsOptionsContext]>>; statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>; stillValidModule: SyncHook<[Module]>; succeedEntry: SyncHook<[Dependency, EntryOptions, Module]>; succeedModule: SyncHook<[Module]>; unseal: SyncHook<[]> }>}
inputFileSystem:<InputFileSystem>
logger:<WebpackLogger>
logging:<Map>
< <string> , <LogEntry> []>
mainTemplate:<MainTemplate>
missingDependencies:
{LazySet }
moduleGraph:<ModuleGraph>
moduleMemCaches:<Map>
< <Module> , <WeakTupleMap> < <any> [], <any> >>
moduleMemCaches2:<Map>
< <Module> , <WeakTupleMap> < <any> [], <any> >>
modules:
{Set }
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 | null}
usedModuleIds:
{Set | 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 } 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
  • modules {Module[] | Set} 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

Generates code and runtime requirements for this module.

createChildCompiler(name, outputOptions?, plugins?): Compiler
Attributes
name:<string>
name of the child compiler
outputOptions:
{Partial } // 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

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

Processes the provided |.

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

Processes the provided callback.

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

Returns the asset or undefined when not found.

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

Returns interpolated path.

getAssetPathWithInfo(filename, data): void
  • filename {string | TemplatePathFn} 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 []}
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?): void
  • filename {string | TemplatePathFn} used to get asset path with hash
  • data {T} context data
  • Returns: <string> interpolated path

Returns interpolated path.

getPathWithInfo(filename, data?): void
  • filename {string | TemplatePathFn} 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

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.

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>
  • assets {Map<string, { info?: AssetInfo; source: Source }>}
  • buildDependencies {LazySet}
  • cacheable <boolean>
  • contextDependencies {LazySet}
  • exports <any>
  • fileDependencies {LazySet}
  • missingDependencies {LazySet}
Attributes
id:<string>
module id
module:<ExecuteModuleObject>
module
require:<WebpackRequire>
require function

Processes the provided factorize module option.

Attributes
context:<string>
contextInfo:
{Partial }
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 }
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>