wassname/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/wassname/DefinitelyTyped.git synced 2026-09-09 11:13:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7445 from tkqubo/webpack-add-definition

Browse Source 
Webpack more definition and comment
This commit is contained in:
Horiuchi_H
2016-01-05 11:23:15 +09:00
parent bdaf2f0eb1 25c3427fd8
commit a892c9d31c
1 changed files with 192 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
webpack/webpack.d.ts
Vendored
+192 -4
View File
@@ -1,4 +1,4 @@
// Type definitions for webpack 1.12.2
// Type definitions for webpack 1.12.9
// Project: https://github.com/webpack/webpack
// Definitions by: Qubo <https://github.com/tkqubo>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -6,10 +6,58 @@
declare module "webpack" {
namespace webpack {
interface Configuration {
context?: string;
entry?: string|string[]|Entry;
/** Choose a developer tool to enhance debugging. */
devtool?: string;
/** Options affecting the output. */
output?: Output;
/** Options affecting the normal modules (NormalModuleFactory) */
module?: Module;
/** Options affecting the resolving of modules. */
resolve?: Resolve;
/** Like resolve but for loaders. */
resolveLoader?: ResolveLoader;
/**
* Specify dependencies that shouldn’t be resolved by webpack, but should become dependencies of the resulting bundle.
* The kind of the dependency depends on output.libraryTarget.
*/
externals?: ExternalsElement|ExternalsElement[];
/**
* <ul>
* <li>"web" Compile for usage in a browser-like environment (default)</li>
* <li>"webworker" Compile as WebWorker</li>
* <li>"node" Compile for usage in a node.js-like environment (use require to load chunks)</li>
* <li>"async-node" Compile for usage in a node.js-like environment (use fs and vm to load chunks async)</li>
* <li>"node-webkit" Compile for usage in webkit, uses jsonp chunk loading but also supports builtin node.js modules plus require(“nw.gui”) (experimental)</li>
* <li>"atom" Compile for usage in electron (formerly known as atom-shell), supports require for modules necessary to run Electron.</li>
* <ul>
*/
target?: string;
/** Report the first error as a hard error instead of tolerating it. */
bail?: boolean;
/** Capture timing information for each module. */
profile?: boolean;
/** Cache generated modules and chunks to improve performance for multiple incremental builds. */
cache?: boolean|any;
/** Enter watch mode, which rebuilds on file change. */
watch?: boolean;
watchOptions?: WatchOptions;
/** Switch loaders to debug mode. */
debug?: boolean;
/** Can be used to configure the behaviour of webpack-dev-server when the webpack config is passed to webpack-dev-server CLI. */
devServer?: any; // TODO: Type this
/** Include polyfills or mocks for various node stuff */
node?: Node;
/** Set the value of require.amd and define.amd. */
amd?: { [moduleName: string]: boolean };
/** Used for recordsInputPath and recordsOutputPath */
recordsPath?: string;
/** Load compiler state from a json file. */
recordsInputPath?: string;
/** Store compiler state to a json file. */
recordsOutputPath?: string;
/** Add additional plugins to the compiler. */
plugins?: (Plugin|Function)[];
}
@@ -18,21 +66,161 @@ declare module "webpack" {
}
interface Output {
/** The output directory as absolute path (required). */
path?: string;
/** The filename of the entry chunk as relative path inside the output.path directory. */
filename?: string;
/** The filename of non-entry chunks as relative path inside the output.path directory. */
chunkFilename?: string;
/** The filename of the SourceMaps for the JavaScript files. They are inside the output.path directory. */
sourceMapFilename?: string;
/** Filename template string of function for the sources array in a generated SourceMap. */
devtoolModuleFilenameTemplate?: string;
/** Similar to output.devtoolModuleFilenameTemplate, but used in the case of duplicate module identifiers. */
devtoolFallbackModuleFilenameTemplate?: string;
/**
* Enable line to line mapped mode for all/specified modules.
* Line to line mapped mode uses a simple SourceMap where each line of the generated source is mapped to the same line of the original source.
* It’s a performance optimization. Only use it if your performance need to be better and you are sure that input lines match which generated lines.
* true enables it for all modules (not recommended)
*/
devtoolLineToLine?: boolean;
/** The filename of the Hot Update Chunks. They are inside the output.path directory. */
hotUpdateChunkFilename?: string;
/** The filename of the Hot Update Main File. It is inside the output.path directory. */
hotUpdateMainFilename?: string;
/** The output.path from the view of the Javascript / HTML page. */
publicPath?: string;
/** The JSONP function used by webpack for asnyc loading of chunks. */
jsonpFunction?: string;
/** The JSONP function used by webpack for async loading of hot update chunks. */
hotUpdateFunction?: string;
/** Include comments with information about the modules. */
pathinfo?: boolean;
/** If set, export the bundle as library. output.library is the name. */
library?: boolean;
/**
* Which format to export the library:
* <ul>
* <li>"var" - Export by setting a variable: var Library = xxx (default)</li>
* <li>"this" - Export by setting a property of this: this["Library"] = xxx</li>
* <li>"commonjs" - Export by setting a property of exports: exports["Library"] = xxx</li>
* <li>"commonjs2" - Export by setting module.exports: module.exports = xxx</li>
* <li>"amd" - Export to AMD (optionally named)</li>
* <li>"umd" - Export to AMD, CommonJS2 or as property in root</li>
* </ul>
*/
libraryTarget?: string;
/** If output.libraryTarget is set to umd and output.library is set, setting this to true will name the AMD module. */
umdNamedDefine?: boolean;
/** Prefixes every line of the source in the bundle with this string. */
sourcePrefix?: string;
/** This option enables cross-origin loading of chunks. */
crossOriginLoading?: string|boolean;
}
interface Module {
/** A array of automatically applied loaders. */
loaders?: Loader[];
/** A array of applied pre loaders. */
preLoaders?: Loader[];
/** A array of applied post loaders. */
postLoaders?: Loader[];
/** A RegExp or an array of RegExps. Don’t parse files matching. */
noParse?: RegExp|RegExp[];
unknownContextRequest?: string;
unknownContextRecursive?: boolean;
unknownContextRegExp?: RegExp;
unknownContextCritical?: boolean;
exprContextRequest?: string;
exprContextRegExp?: RegExp;
exprContextRecursive?: boolean;
exprContextCritical?: boolean;
wrappedContextRegExp?: RegExp;
wrappedContextRecursive?: boolean;
wrappedContextCritical?: boolean;
}
interface Resolve {
/** Replace modules by other modules or paths. */
alias: { [key: string]: string; };
/**
* The directory (absolute path) that contains your modules.
* May also be an array of directories.
* This setting should be used to add individual directories to the search path. */
root?: string|string[];
/**
* An array of directory names to be resolved to the current directory as well as its ancestors, and searched for modules.
* This functions similarly to how node finds “node_modules” directories.
* For example, if the value is ["mydir"], webpack will look in “./mydir”, “../mydir”, “../../mydir”, etc.
*/
modulesDirectories?: string[];
/**
* A directory (or array of directories absolute paths),
* in which webpack should look for modules that weren’t found in resolve.root or resolve.modulesDirectories.
*/
fallback?: string|string[];
/**
* An array of extensions that should be used to resolve modules.
* For example, in order to discover CoffeeScript files, your array should contain the string ".coffee".
*/
extensions?: string[];
/** Check these fields in the package.json for suitable files. */
packageMains?: (string|string[])[];
/** Check this field in the package.json for an object. Key-value-pairs are threaded as aliasing according to this spec */
packageAlias?: (string|string[])[];
/**
* Enable aggressive but unsafe caching for the resolving of a part of your files.
* Changes to cached paths may cause failure (in rare cases). An array of RegExps, only a RegExp or true (all files) is expected.
* If the resolved path matches, it’ll be cached.
*/
unsafeCache?: RegExp|RegExp[]|boolean;
}
interface ResolveLoader extends Resolve {
/** It describes alternatives for the module name that are tried. */
moduleTemplates?: string[];
}
type ExternalsElement = string|RegExp|ExternalsObjectElement|ExternalsFunctionElement;
interface ExternalsObjectElement {
[key: string]: boolean|string;
}
interface ExternalsFunctionElement {
(context: any, request: any, callback: (error: any, result: any) => void): any;
}
interface WatchOptions {
/** Delay the rebuilt after the first change. Value is a time in ms. */
aggregateTimeout?: number;
/** true: use polling, number: use polling with specified interval */
poll?: boolean|number;
}
interface Node {
console?: boolean;
global?: boolean;
process?: boolean;
Buffer?: boolean;
__filename?: boolean|string;
__dirname?: boolean|string;
[nodeBuiltin: string]: boolean|string;
}
type LoaderCondition = string|RegExp|((absPath: string) => boolean);
interface Loader {
exclude?: string[];
include?: string[];
test: RegExp;
/** A condition that must not be met */
exclude?: LoaderCondition|LoaderCondition[];
/** A condition that must be met */
include?: LoaderCondition|LoaderCondition[];
/** A condition that must be met */
test: LoaderCondition|LoaderCondition[];
/** A string of “!” separated loaders */
loader?: string;
/** A array of loaders as string */
loaders?: string[];
query?: {
[name: string]: any;