new Compilation(compiler, params): CompilationAttributes
compiler:
<Compiler>params:
{CompilationParams}
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:
<object>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
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:
<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): EntrypointAttributes
Returns:
<Entrypoint>Adds the provided async entrypoint to this chunk group.
addChunk(name?): ChunkAttributes
Returns:
<Chunk>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?): ChunkGroupAttributes
Returns:
<ChunkGroup>If module is passed, loc and request must also be passed.
addEntry(context, entry, optionsOrName, callback): voidAttributes
Returns:
{void}
Adds the provided string to the compilation.
addInclude(context, dependency, options, callback): voidAttributes
Returns:
{void}
Adds the provided string to the compilation.
addModule(module, callback): voidAttributes
Returns:
{void}
Adds the provided module to the compilation.
addModuleChain(context, dependency, callback): voidAttributes
Returns:
{void}
Adds the provided string to the compilation.
addModuleTree(__namedParameters, callback): voidAttributes
Returns:
{void}
Adds the provided object to the compilation.
addRuntimeModule(chunk, module, chunkGraph?): voidAttributes
Returns:
{void}
Adds runtime module.
assignDepth(module): voidStability: 0Deprecated
Attributes
module:
<Module>Returns:
{void}
Processes the provided module.
assignDepths(modules): voidmodules{Module[]|Set} - Returns: {void}
Assigns depth values to the provided modules.
assignRuntimeIds(): voidReturns:
{void}
buildModule(module, callback): voidAttributes
Returns:
{void}
Schedules a build of the module object
checkConstraints(): voidReturns:
{void}
clearAssets(): voidReturns:
{void}
codeGeneration(callback): voidAttributes
callback:
<object>Returns:
{void}
Generates code and runtime requirements for this module.
createChildCompiler(name, outputOptions?, plugins?): CompilerAttributes
name:
<string>outputOptions:
{Partial
}
plugins:
<object>
|
<WebpackPluginInstance>
|
<null>
|
<undefined[]>Returns:
<Compiler>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): voidAttributes
callback:
<object>Returns:
{void}
Creates a chunk assets.
createHash(): CodeGenerationJob[]Returns:
{CodeGenerationJob[]}
createModuleAssets(): voidReturns:
{void}
createModuleHashes(): voidReturns:
{void}
createStatsFactory(options): voidoptions{NormalizedStatsOptions}- Returns: {StatsFactory}
Creates a stats factory.
createStatsOptions(optionsOrPreset?, context?): NormalizedStatsOptionsAttributes
optionsOrPreset:
<string>
|
<boolean>
|
<StatsOptions>context:
{CreateStatsOptionsContext}
Returns:
{NormalizedStatsOptions}
Creates a stats options.
createStatsPrinter(options): voidoptions{NormalizedStatsOptions}- Returns: {StatsPrinter}
Creates a stats printer.
deleteAsset(file): voidAttributes
file:
<string>Returns:
{void}
Processes the provided file.
emitAsset(file, source, assetInfo?): voidAttributes
Returns:
{void}
Processes the provided file.
executeModule(module, options, callback): voidAttributes
Returns:
{void}
Processes the provided module.
factorizeModule(options, callback): voidAttributes
Returns:
{void}
Processes the provided module callback.
Attributes
Returns:
{void}
Processes the provided module factory result callback.
findModule(identifier): Module | undefinedAttributes
identifier:
<string>Returns:
<Module>
|
<undefined>Attempts to search for a module by its identifier
finish(callback): voidAttributes
callback:
<object>Returns:
{void}
Processes the provided callback.
getAsset(name): Readonly<Asset> | undefinedAttributes
name:
<string>Returns:
{Readonly
|undefined}
Returns the asset or undefined when not found.
getAssetPath(filename, data): voidfilename{string|TemplatePathFn} data{T}- Returns:
<string>
Returns interpolated path.
getAssetPathWithInfo(filename, data): voidfilename{string|TemplatePathFn} data{T}- Returns: {InterpolatedPathAndAssetInfo}
Gets asset path with info.
getAssets(): Readonly<Asset>[]Returns:
{Readonly
[]}
getCache(name): CacheFacadeAttributes
name:
<string>Returns:
{CacheFacade}
Returns the cache facade instance.
getDependencyReferencedExports(dependency, runtime): string[]Attributes
dependency:
<Dependency>runtime:
{RuntimeSpec}
Returns:
<string[]>Gets dependency referenced exports.
getErrors(): Error[]Returns:
<Error[]>getLogger(name): WebpackLoggerAttributes
Returns:
{WebpackLogger}
Returns a logger with that name.
getModule(module): ModuleAttributes
module:
<Module>Returns:
<Module>Fetches a module from a compilation by its identifier
getPath(filename, data?): voidfilename{string|TemplatePathFn} data{T}- Returns:
<string>
Returns interpolated path.
getPathWithInfo(filename, data?): voidfilename{string|TemplatePathFn} data{T}- Returns: {InterpolatedPathAndAssetInfo}
Gets path with info.
getRenderManifest(options): RenderManifestEntry[]Attributes
options:
<RenderManifestOptions>Returns:
<RenderManifestEntry[]>Gets render manifest.
getStats(): StatsReturns:
<Stats>getWarnings(): Error[]Returns:
<Error[]>handleModuleCreation(__namedParameters, callback): void__namedParameters{HandleModuleCreationOptions}callback<object>- Returns: {void}
Handle module creation.
patchChunksAfterReasonRemoval(module, chunk): voidAttributes
Returns:
{void}
Patch chunks after reason removal.
processModuleDependencies(module, callback): voidAttributes
Returns:
{void}
Process module dependencies.
processModuleDependenciesNonRecursive(module): voidAttributes
module:
<Module>Returns:
{void}
Process module dependencies non recursive.
processRuntimeRequirements(__namedParameters?): voidAttributes
__namedParameters:
<object>Returns:
{void}
Process runtime requirements.
rebuildModule(module, callback): voidAttributes
Returns:
{void}
Processes the provided module.
removeChunkFromDependencies(block, chunk): voidblock{DependenciesBlock}chunk<Chunk>- Returns: {void}
Removes chunk from dependencies.
removeReasonsOfDependencyBlock(module, block): voidAttributes
module:
<Module>block:
{DependenciesBlockLike}
Returns:
{void}
Removes reasons of dependency block.
renameAsset(file, newFile): voidAttributes
Returns:
{void}
Processes the provided file.
reportDependencyErrorsAndWarnings(module, blocks): booleanAttributes
module:
<Module>blocks:
{DependenciesBlock[]}
Returns:
<boolean>Report dependency errors and warnings.
M
seal
seal(callback): voidAttributes
callback:
<object>Returns:
{void}
Processes the provided callback.
sortItemsWithChunkIds(): voidReturns:
{void}
summarizeDependencies(): voidReturns:
{void}
unseal(): voidReturns:
{void}
updateAsset(file, newSourceOrFunction, assetInfoUpdateOrFunction?): voidAttributes
file:
<string>assetInfoUpdateOrFunction:
<AssetInfo>
|
<object>Returns:
{void}
Updates asset using the provided file.