webpack.Compiler

Constructors

Compiler Constructor

new Compiler(context, options?): Compiler

Attributes

context:<string>

the compilation path

options:<WebpackOptionsNormalized>

options

Returns:<Compiler>

Properties

cache {CacheClass}
compilerPath <string>
context <string>
contextTimestamps {Map<string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null>}
fileTimestamps {Map<string, "ignore"|EntryTypesIndex|OnlySafeTimeEntry|ExistenceOnlyTimeEntryTypesIndex|null>}
fsStartTime <number>
hooks {Readonly
}
idle <boolean>

immutablePaths {Set<string|RegExp>}

infrastructureLogger <object>

inputFileSystem <InputFileSystem> | <null>

intermediateFileSystem <null>

managedPaths {Set<string|RegExp>}

modifiedFiles {ReadonlySet}

moduleMemCaches {Map<Module, ModuleMemCachesItem>}

name <string>

options <WebpackOptionsNormalized>

outputFileSystem <OutputFileSystem> | <null>

outputPath <string>

parentCompilation <Compilation>

platform {Readonly}

records {Records}

recordsInputPath <string> | <null>

recordsOutputPath <string> | <null>

removedFiles {ReadonlySet}

requestShortener <RequestShortener>

resolverFactory <ResolverFactory>

root <Compiler>

running <boolean>

unmanagedPaths {Set<string|RegExp>}

watchFileSystem <null>

watching <Watching>

watchMode <boolean>

webpack {exports}

Methods
M
close
```
close(callback): void
```
Attributes
callback:<object>
signals when the compiler closes
Returns:
{void}

M
compile
```
compile(callback): void
```
- callback {CallbackWebpackFunction_2<Compilation, void>} signals when the compilation finishes
- Returns: {void}
M
createChildCompiler
```
createChildCompiler(compilation, compilerName, compilerIndex, outputOptions?, plugins?): Compiler
```
Attributes
compilation:<Compilation>
the compilation
compilerName:<string>
the compiler's name
compilerIndex:<number>
the compiler's index
outputOptions:
{Partial } the output options
plugins:<WebpackPluginInstance> | <object> | <null> | <undefined[]>
the plugins to apply
Returns:<Compiler>
a child compiler

M
createCompilation
```
createCompilation(params): void
```
- params {CompilationParams} the compilation parameters
- Returns: <Compilation> compilation
M
createContextModuleFactory
```
createContextModuleFactory(): ContextModuleFactory
```
Returns:<ContextModuleFactory>

M
createNormalModuleFactory
```
createNormalModuleFactory(): NormalModuleFactory
```
Returns:<NormalModuleFactory>

M
emitAssets
```
emitAssets(compilation, callback): void
```
Attributes
compilation:<Compilation>
the compilation
callback:<object>
signals when the assets are emitted
Returns:
{void}

M
emitRecords
```
emitRecords(callback): void
```
Attributes
callback:<object>
signals when the call finishes
Returns:
{void}

M
getCache
```
getCache(name): CacheFacade
```
Attributes
name:<string>
cache name
Returns:<CacheFacade>
the cache facade instance

M
getInfrastructureLogger
```
getInfrastructureLogger(name): WebpackLogger
```
Attributes
name:<string> | <object>
name of the logger, or function called once to get the logger name
Returns:<WebpackLogger>
a logger with that name

M
isChild
```
isChild(): boolean
```
Returns:<boolean>

M
Compilation
```
Compilation(params): void
```
- params {CompilationParams} the compilation parameters
- Returns: <Compilation> the created compilation
M
CompilationParams
```
CompilationParams(): object
```
Returns:<object>

M
purgeInputFileSystem
```
purgeInputFileSystem(): void
```
Returns:
{void}

M
readRecords
```
readRecords(callback): void
```
Attributes
callback:<object>
signals when the call finishes
Returns:
{void}

M
run
```
run(callback): void
```
- callback {CallbackWebpackFunction_2<Stats, void>} signals when the call finishes
- Returns: {void}
M
runAsChild
```
runAsChild(callback): void
```
Attributes
callback:<object>
signals when the call finishes
Returns:
{void}

M
validate
```
validate(schema, value, options?, check?): void
```
Attributes
schema:<object>
schema
value:
{T} value
options:
{ValidationErrorConfiguration} options
check:<object>
options
Returns:
{void}

Schema validation function with optional pre-compiled check

M
watch
```
watch(watchOptions, handler): void
```
- watchOptions {WatchOptions} the watcher's options
- handler {CallbackWebpackFunction_2<Stats, void>} signals when the call finishes
- Returns: <Watching> | <undefined> a compiler watcher