From 76cfb34e13ca0edc556d3fc48096fbf4b79fe186 Mon Sep 17 00:00:00 2001 From: Dennis George Date: Tue, 27 Feb 2018 15:48:32 -0600 Subject: [PATCH] updated webpack to be 4.0 specific; added v3 subfolder for old version --- types/webpack/index.d.ts | 98 +-- types/webpack/v3/index.d.ts | 1301 +++++++++++++++++++++++++++++ types/webpack/v3/package.json | 6 + types/webpack/v3/tsconfig.json | 26 + types/webpack/v3/tslint.json | 3 + types/webpack/v3/webpack-tests.ts | 667 +++++++++++++++ 6 files changed, 2025 insertions(+), 76 deletions(-) create mode 100644 types/webpack/v3/index.d.ts create mode 100644 types/webpack/v3/package.json create mode 100644 types/webpack/v3/tsconfig.json create mode 100644 types/webpack/v3/tslint.json create mode 100644 types/webpack/v3/webpack-tests.ts diff --git a/types/webpack/index.d.ts b/types/webpack/index.d.ts index f704797f58..9b84ff7731 100644 --- a/types/webpack/index.d.ts +++ b/types/webpack/index.d.ts @@ -187,9 +187,13 @@ declare namespace webpack { sourcePrefix?: string; /** This option enables cross-origin loading of chunks. */ crossOriginLoading?: string | boolean; + /** A Constructor to a custom hash function. You can provide a non-crypto hash function for performance reasons */ + hashFunction?: (algorithm: string, options?: any) => any; + /** Allow to choose the global object reference in runtime exitCode. */ + globalObject?: any; } - interface BaseModule { + interface Module { /** A array of applied pre loaders. */ preLoaders?: Rule[]; /** A array of applied post loaders. */ @@ -208,18 +212,10 @@ declare namespace webpack { wrappedContextRecursive?: boolean; wrappedContextCritical?: boolean; strictExportPresence?: boolean; - } - interface OldModule extends BaseModule { - /** An array of automatically applied loaders. */ - loaders: Rule[]; - } - interface NewModule extends BaseModule { /** An array of rules applied for modules. */ rules: Rule[]; } - type Module = OldModule | NewModule; - interface Resolve { /** * A list of directories to resolve modules from. @@ -381,7 +377,10 @@ declare namespace webpack { options?: { [name: string]: any }; } type Loader = string | OldLoader | NewLoader; - + interface ParserOptions { + [optName: string]: any; + system?: boolean; + } /** * There are direct and delegate rules. Direct Rules need a test, Delegate rules delegate to subrules bringing their own. * Direct rules can optionally contain delegate keys (oneOf, rules). @@ -421,11 +420,17 @@ declare namespace webpack { * For each different parser options object a new parser is created and plugins can apply plugins depending on the parser options. * Many of the default plugins apply their parser plugins only if a property in the parser options is not set or true. */ - parser?: { [optName: string]: any }; + parser?: ParserOptions; /** An array of Rules that is also used when the Rule matches. */ rules?: Rule[]; /** An array of Rules from which only the first matching Rule is used when the Rule matches. */ oneOf?: Rule[]; + /** Configures module resolving. */ + resolve?: Resolve; + /** Configures the module type. */ + type?: "javascript/auto" | "javascript/esm" | "javascript/dynamic" | "json" | "webassembly/experimental"; + /** TODO: Update this when the v4 documentation is complete. */ + sideEffects?: any; } interface BaseDirectRule extends BaseRule { /** A condition that must be met */ @@ -884,6 +889,7 @@ declare namespace webpack { constructor(options: any); } + /** @deprecated use config.optimization.namedModules */ class NamedModulesPlugin extends Plugin { constructor(); } @@ -892,15 +898,12 @@ declare namespace webpack { constructor(nameResolver?: (chunk: any) => string | null); } + /** @deprecated use config.optimization.noEmitOnErrors */ class NoEmitOnErrorsPlugin extends Plugin { constructor(); } /** @deprecated use webpack.NoEmitOnErrorsPlugin */ - class NoErrorsPlugin extends Plugin { - constructor(); - } - class NormalModuleReplacementPlugin extends Plugin { constructor(resourceRegExp: any, newResource: any); } @@ -954,6 +957,7 @@ declare namespace webpack { } namespace optimize { + /** @deprecated use config.optimization.concatenateModules */ class ModuleConcatenationPlugin extends Plugin { } class AggressiveMergingPlugin extends Plugin { constructor(options?: AggressiveMergingPlugin.Options); @@ -980,62 +984,6 @@ declare namespace webpack { } } - class CommonsChunkPlugin extends Plugin { - constructor(options?: CommonsChunkPlugin.Options); - } - - namespace CommonsChunkPlugin { - type MinChunksFn = (module: any, count: number) => boolean; - - interface Options { - /** - * The chunk name of the commons chunk. An existing chunk can be selected by passing a name of an existing chunk. - * If an array of strings is passed this is equal to invoking the plugin multiple times for each chunk name. - * If omitted and `options.async` or `options.children` is set all chunks are used, - * otherwise `options.filename` is used as chunk name. - */ - name?: string; - names?: string[]; - - /** - * The filename template for the commons chunk. Can contain the same placeholders as `output.filename`. - * If omitted the original filename is not modified (usually `output.filename` or `output.chunkFilename`). - */ - filename?: string; - - /** - * The minimum number of chunks which need to contain a module before it's moved into the commons chunk. - * The number must be greater than or equal 2 and lower than or equal to the number of chunks. - * Passing `Infinity` just creates the commons chunk, but moves no modules into it. - * By providing a `function` you can add custom logic. (Defaults to the number of chunks) - */ - minChunks?: number | MinChunksFn; - - /** - * Select the source chunks by chunk names. The chunk must be a child of the commons chunk. - * If omitted all entry chunks are selected. - */ - chunks?: string[]; - - /** - * If `true` all children of the commons chunk are selected - */ - children?: boolean; - - /** - * If `true` a new async commons chunk is created as child of `options.name` and sibling of `options.chunks`. - * It is loaded in parallel with `options.chunks`. It is possible to change the name of the output file - * by providing the desired string instead of `true`. - */ - async?: boolean | string; - - /** - * Minimum size of all common module before a commons chunk is created. - */ - minSize?: number; - } - } - /** @deprecated */ class DedupePlugin extends Plugin { constructor(); @@ -1252,11 +1200,6 @@ declare namespace webpack { */ inputValue: any; - /** - * The options passed to the Compiler. - */ - options: any; - /** * A boolean flag. It is set when in debug mode. */ @@ -1311,6 +1254,9 @@ declare namespace webpack { * Hacky access to the Module object being loaded. */ _module: any; + + /** Flag if HMR is enabled */ + hot: boolean; } } diff --git a/types/webpack/v3/index.d.ts b/types/webpack/v3/index.d.ts new file mode 100644 index 0000000000..ee3a291d02 --- /dev/null +++ b/types/webpack/v3/index.d.ts @@ -0,0 +1,1301 @@ +// Type definitions for webpack 3.8 +// Project: https://github.com/webpack/webpack +// Definitions by: Qubo +// Benjamin Lim +// Boris Cherny +// Tommy Troy Lin +// Mohsen Azimi +// Jonathan Creamer +// Ahmed T. Ali +// Alan Agius +// Spencer Elliott +// Jason Cheatham +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.2 + +/// + +import Tapable = require('tapable'); +import * as UglifyJS from 'uglify-js'; +import { RawSourceMap } from 'source-map'; + +export = webpack; + +declare function webpack( + options: webpack.Configuration, + handler: webpack.Compiler.Handler +): webpack.Compiler.Watching | webpack.Compiler; +declare function webpack(options?: webpack.Configuration): webpack.Compiler; + +declare function webpack( + options: webpack.Configuration[], + handler: webpack.MultiCompiler.Handler +): webpack.MultiWatching | webpack.MultiCompiler; +declare function webpack(options: webpack.Configuration[]): webpack.MultiCompiler; + +declare namespace webpack { + interface Configuration { + /** Name of the configuration. Used when loading multiple configurations. */ + name?: string; + /** + * The base directory (absolute path!) for resolving the `entry` option. + * If `output.pathinfo` is set, the included pathinfo is shortened to this directory. + */ + context?: string; + entry?: string | string[] | Entry | EntryFunc; + /** Choose a style of source mapping to enhance the debugging process. These values can affect build and rebuild speed dramatically. */ + devtool?: Options.Devtool; + /** 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[]; + /** + *
    + *
  • "web" Compile for usage in a browser-like environment (default)
    • + *
  • "webworker" Compile as WebWorker
    • + *
  • "node" Compile for usage in a node.js-like environment (use require to load chunks)
    • + *
  • "async-node" Compile for usage in a node.js-like environment (use fs and vm to load chunks async)
    • + *
  • "node-webkit" Compile for usage in webkit, uses jsonp chunk loading but also supports builtin node.js modules plus require(“nw.gui”) (experimental)
    • + *
  • "atom" Compile for usage in electron (formerly known as atom-shell), supports require for modules necessary to run Electron.
    • + *
  • "electron-renderer" Compile for Electron for renderer process, providing a target using JsonpTemplatePlugin, FunctionModulePlugin + * for browser environments and NodeTargetPlugin and ExternalsPlugin for CommonJS and Electron built-in modules.
  • + *
  • "electron-main" Compile for Electron for main process.
    • + *
  • "atom" Alias for electron-main
    • + *
  • "electron" Alias for electron-main
    • + *
      + */ + target?: 'web' | 'webworker' | 'node' | 'async-node' | 'node-webkit' | 'atom' | 'electron' | 'electron-renderer' | 'electron-main' | ((compiler?: any) => void); + /** 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 | object; + /** Enter watch mode, which rebuilds on file change. */ + watch?: boolean; + watchOptions?: Options.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[]; + /** Stats options for logging */ + stats?: Options.Stats; + /** Performance options */ + performance?: Options.Performance; + /** Limit the number of parallel processed modules. Can be used to fine tune performance or to get more reliable profiling results */ + parallelism?: number; + } + + interface Entry { + [name: string]: string | string[]; + } + + type EntryFunc = () => (string | string[] | Promise); + + interface DevtoolModuleFilenameTemplateInfo { + identifier: string; + shortIdentifier: string; + resource: any; + resourcePath: string; + absoluteResourcePath: string; + allLoaders: any[]; + query: string; + moduleId: string; + hash: string; + } + + 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 | ((info: DevtoolModuleFilenameTemplateInfo) => string); + /** Similar to output.devtoolModuleFilenameTemplate, but used in the case of duplicate module identifiers. */ + devtoolFallbackModuleFilenameTemplate?: string | ((info: DevtoolModuleFilenameTemplateInfo) => 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?: string | string[]; + /** + * Which format to export the library: + *
        + *
      • "var" - Export by setting a variable: var Library = xxx (default)
        • + *
      • "this" - Export by setting a property of this: this["Library"] = xxx
        • + *
      • "commonjs" - Export by setting a property of exports: exports["Library"] = xxx
        • + *
      • "commonjs2" - Export by setting module.exports: module.exports = xxx
        • + *
      • "amd" - Export to AMD (optionally named)
        • + *
      • "umd" - Export to AMD, CommonJS2 or as property in root
        • + *
      • "window" - Assign to widnow
        • + *
      • "assign" - Assign to a global variable
        • + *
      • "jsonp" - Generate Webpack JSONP module
      • + *
      + */ + libraryTarget?: 'var' | 'this' | 'commonjs' | 'commonjs2' | 'amd' | 'umd' | 'window' | 'assign' | 'jsonp'; + /** Configure which module or modules will be exposed via the `libraryTarget` */ + libraryExport?: string | 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 BaseModule { + /** A array of applied pre loaders. */ + preLoaders?: Rule[]; + /** A array of applied post loaders. */ + postLoaders?: Rule[]; + /** A RegExp or an array of RegExps. Don’t parse files matching. */ + noParse?: RegExp | RegExp[] | ((content: string) => boolean); + unknownContextRequest?: string; + unknownContextRecursive?: boolean; + unknownContextRegExp?: RegExp; + unknownContextCritical?: boolean; + exprContextRequest?: string; + exprContextRegExp?: RegExp; + exprContextRecursive?: boolean; + exprContextCritical?: boolean; + wrappedContextRegExp?: RegExp; + wrappedContextRecursive?: boolean; + wrappedContextCritical?: boolean; + strictExportPresence?: boolean; + } + interface OldModule extends BaseModule { + /** An array of automatically applied loaders. */ + loaders: Rule[]; + } + interface NewModule extends BaseModule { + /** An array of rules applied for modules. */ + rules: Rule[]; + } + + type Module = OldModule | NewModule; + + interface Resolve { + /** + * A list of directories to resolve modules from. + * + * Absolute paths will be searched once. + * + * If an entry is relative, will be resolved using node's resolution algorithm + * relative to the requested file. + * + * Defaults to `["node_modules"]` + */ + modules?: string[]; + + /** + * A list of package description files to search for. + * + * Defaults to `["package.json"]` + */ + descriptionFiles?: string[]; + + /** + * A list of fields in a package description object to use for finding + * the entry point. + * + * Defaults to `["browser", "module", "main"]` or `["module", "main"]`, + * depending on the value of the `target` `Configuration` value. + */ + mainFields?: string[]; + + /** + * A list of fields in a package description object to try to parse + * in the same format as the `alias` resolve option. + * + * Defaults to `["browser"]` or `[]`, depending on the value of the + * `target` `Configuration` value. + * + * @see alias + */ + aliasFields?: string[]; + + /** + * A list of file names to search for when requiring directories that + * don't contain a package description file. + * + * Defaults to `["index"]`. + */ + mainFiles?: string[]; + + /** + * A list of file extensions to try when requesting files. + * + * An empty string is considered invalid. + */ + extensions?: string[]; + + /** + * If true, requires that all requested paths must use an extension + * from `extensions`. + */ + enforceExtension?: boolean; + + /** + * Replace the given module requests with other modules or paths. + * + * @see aliasFields + */ + alias?: { [key: string]: string; }; + + /** + * Whether to use a cache for resolving, or the specific object + * to use for caching. Sharing objects may be useful when running + * multiple webpack compilers. + * + * Defaults to `true`. + */ + unsafeCache?: {} | boolean; + + /** + * A function used to decide whether to cache the given resolve request. + * + * Defaults to `() => true`. + */ + cachePredicate?(data: { path: string, request: string }): boolean; + + /** + * A list of additional resolve plugins which should be applied. + */ + plugins?: ResolvePlugin[]; + + /** + * Whether to resolve symlinks to their symlinked location. + * + * Defaults to `true` + */ + symlinks?: boolean; + } + + interface ResolveLoader extends Resolve { + /** + * List of strings to append to a loader's name when trying to resolve it. + */ + moduleExtensions?: string[]; + + enforceModuleExtension?: boolean; + } + + type ExternalsElement = string | RegExp | ExternalsObjectElement | ExternalsFunctionElement; + + interface ExternalsObjectElement { + [key: string]: boolean | string; + } + + type ExternalsFunctionElement = (context: any, request: any, callback: (error: any, result: any) => void) => any; + + interface Node { + console?: boolean; + global?: boolean; + process?: boolean; + Buffer?: boolean; + __filename?: boolean | string; + __dirname?: boolean | string; + [nodeBuiltin: string]: boolean | string | undefined; + } + + interface BaseConditionSpec { + /** The Condition must match. The convention is the provide a string or array of strings here, but it's not enforced. */ + include?: Condition; + /** The Condition must NOT match. The convention is the provide a string or array of strings here, but it's not enforced. */ + exclude?: Condition; + } + interface TestConditionSpec extends BaseConditionSpec { + /** The Condition must match. The convention is the provide a RegExp or array of RegExps here, but it's not enforced. */ + test: Condition; + } + interface AndConditionSpec extends BaseConditionSpec { + /** All Conditions must match. */ + and: Condition[]; + } + interface OrConditionSpec extends BaseConditionSpec { + /** Any Condition must match. */ + or: Condition[]; + } + interface NotConditionSpec extends BaseConditionSpec { + /** The Condition must NOT match. */ + not: Condition; + } + type ConditionSpec = TestConditionSpec | OrConditionSpec | AndConditionSpec | NotConditionSpec; + + // tslint:disable-next-line:no-empty-interface + interface ConditionArray extends Array { } + type Condition = string | RegExp | ((absPath: string) => boolean) | ConditionSpec | ConditionArray; + + interface OldLoader { + loader: string; + query?: { [name: string]: any }; + } + interface NewLoader { + loader: string; + options?: { [name: string]: any }; + } + type Loader = string | OldLoader | NewLoader; + + /** + * There are direct and delegate rules. Direct Rules need a test, Delegate rules delegate to subrules bringing their own. + * Direct rules can optionally contain delegate keys (oneOf, rules). + * + * These types exist to enforce that a rule has the keys `((loader XOR loaders) AND test) OR oneOf OR rules` + */ + interface BaseRule { + /** + * Specifies the category of the loader. No value means normal loader. + * + * There is also an additional category "inlined loader" which are loaders applied inline of the import/require. + * + * All loaders are sorted in the order post, inline, normal, pre and used in this order. + * + * All normal loaders can be omitted (overridden) by prefixing ! in the request. + * + * All normal and pre loaders can be omitted (overridden) by prefixing -! in the request. + * + * All normal, post and pre loaders can be omitted (overridden) by prefixing !! in the request. + * + * Inline loaders and ! prefixes should not be used as they are non-standard. They may be use by loader generated code. + */ + enforce?: 'pre' | 'post'; + /** A condition that must be met */ + test?: Condition | Condition[]; + /** A condition that must not be met */ + exclude?: Condition | Condition[]; + /** A condition that must be met */ + include?: Condition | Condition[]; + /** A Condition matched with the resource. */ + resource?: Condition | Condition[]; + /** A condition matched with the issuer */ + issuer?: Condition | Condition[]; + /** + * An object with parser options. All applied parser options are merged. + * + * For each different parser options object a new parser is created and plugins can apply plugins depending on the parser options. + * Many of the default plugins apply their parser plugins only if a property in the parser options is not set or true. + */ + parser?: { [optName: string]: any }; + /** An array of Rules that is also used when the Rule matches. */ + rules?: Rule[]; + /** An array of Rules from which only the first matching Rule is used when the Rule matches. */ + oneOf?: Rule[]; + } + interface BaseDirectRule extends BaseRule { + /** A condition that must be met */ + test: Condition | Condition[]; + } + // Direct Rules + interface BaseSingleLoaderRule extends BaseDirectRule { + /** Loader name or an object with name and options */ + loader: Loader; + } + interface OldLoaderRule extends BaseSingleLoaderRule { + /** + * Loader options + * @deprecated: + */ + query?: { [name: string]: any }; + } + interface NewLoaderRule extends BaseSingleLoaderRule { + options?: { [name: string]: any }; + } + type LoaderRule = OldLoaderRule | NewLoaderRule; + interface OldUseRule extends BaseDirectRule { + /** + * A array of loaders. + * @deprecated use `use` instead + */ + loaders: string[]; + } + interface NewUseRule extends BaseDirectRule { + /** A loader or array of loaders */ + use: Loader | Loader[]; + } + type UseRule = OldUseRule | NewUseRule; + + // Delegate Rules + interface RulesRule extends BaseRule { + /** An array of Rules that is also used when the Rule matches. */ + rules: Rule[]; + } + interface OneOfRule extends BaseRule { + oneOf: Rule[]; + } + type Rule = LoaderRule | UseRule | RulesRule | OneOfRule; + + namespace Options { + // tslint:disable-next-line:max-line-length + type Devtool = 'eval' | 'inline-source-map' | 'cheap-eval-source-map' | 'cheap-source-map' | 'cheap-module-eval-source-map' | 'cheap-module-source-map' | 'eval-source-map' | 'source-map' | + 'nosources-source-map' | 'hidden-source-map' | 'nosources-source-map' | '@eval' | '@inline-source-map' | '@cheap-eval-source-map' | '@cheap-source-map' | '@cheap-module-eval-source-map' | + '@cheap-module-source-map' | '@eval-source-map' | '@source-map' | '@nosources-source-map' | '@hidden-source-map' | '@nosources-source-map' | '#eval' | '#inline-source-map' | + '#cheap-eval-source-map' | '#cheap-source-map' | '#cheap-module-eval-source-map' | '#cheap-module-source-map' | '#eval-source-map' | '#source-map' | '#nosources-source-map' | + '#hidden-source-map' | '#nosources-source-map' | '#@eval' | '#@inline-source-map' | '#@cheap-eval-source-map' | '#@cheap-source-map' | '#@cheap-module-eval-source-map' | + '#@cheap-module-source-map' | '#@eval-source-map' | '#@source-map' | '#@nosources-source-map' | '#@hidden-source-map' | '#@nosources-source-map' | boolean; + + interface Performance { + /** This property allows webpack to control what files are used to calculate performance hints. */ + assetFilter?(assetFilename: string): boolean; + /** + * Turns hints on/off. In addition, tells webpack to throw either an error or a warning when hints are + * found. This property is set to "warning" by default. + */ + hints?: 'warning' | 'error' | false; + /** + * An asset is any emitted file from webpack. This option controls when webpack emits a performance hint + * based on individual asset size. The default value is 250000 (bytes). + */ + maxAssetSize?: number; + /** + * An entrypoint represents all assets that would be utilized during initial load time for a specific entry. + * This option controls when webpack should emit performance hints based on the maximum entrypoint size. + * The default value is 250000 (bytes). + */ + maxEntrypointSize?: number; + } + type Stats = Stats.ToStringOptions; + type WatchOptions = ICompiler.WatchOptions; + } + + // tslint:disable-next-line:interface-name + interface ICompiler { + run(handler: ICompiler.Handler): void; + watch(watchOptions: ICompiler.WatchOptions, handler: ICompiler.Handler): Watching; + } + + namespace ICompiler { + type Handler = (err: Error, stats: Stats) => void; + + interface WatchOptions { + /** + * Add a delay before rebuilding once the first file changed. This allows webpack to aggregate any other + * changes made during this time period into one rebuild. + * Pass a value in milliseconds. Default: 300. + */ + aggregateTimeout?: number; + /** + * For some systems, watching many file systems can result in a lot of CPU or memory usage. + * It is possible to exclude a huge folder like node_modules. + * It is also possible to use anymatch patterns. + */ + ignored?: string | string[] | RegExp; + /** Turn on polling by passing true, or specifying a poll interval in milliseconds. */ + poll?: boolean | number; + } + } + + interface Watching { + close(callback: () => void): void; + invalidate(): void; + } + + class Compiler extends Tapable implements ICompiler { + constructor(); + + name: string; + options: Configuration; + outputFileSystem: any; + run(handler: Compiler.Handler): void; + watch(watchOptions: Compiler.WatchOptions, handler: Compiler.Handler): Compiler.Watching; + } + + namespace Compiler { + type Handler = ICompiler.Handler; + type WatchOptions = ICompiler.WatchOptions; + + class Watching implements Watching { + constructor(compiler: Compiler, watchOptions: Watching.WatchOptions, handler: Watching.Handler); + + close(callback: () => void): void; + invalidate(): void; + } + + namespace Watching { + type WatchOptions = ICompiler.WatchOptions; + type Handler = ICompiler.Handler; + } + } + + abstract class MultiCompiler extends Tapable implements ICompiler { + compilers: ICompiler[]; + run(handler: MultiCompiler.Handler): void; + watch(watchOptions: MultiCompiler.WatchOptions, handler: MultiCompiler.Handler): MultiWatching; + } + + namespace MultiCompiler { + type Handler = ICompiler.Handler; + type WatchOptions = ICompiler.WatchOptions; + } + + abstract class MultiWatching implements Watching { + close(callback: () => void): void; + invalidate(): void; + } + + abstract class Plugin implements Tapable.Plugin { + apply(compiler: Compiler): void; + } + + abstract class ResolvePlugin implements Tapable.Plugin { + apply(resolver: any /* EnhancedResolve.Resolver */): void; + } + + abstract class Stats { + /** Returns true if there were errors while compiling. */ + hasErrors(): boolean; + /** Returns true if there were warnings while compiling. */ + hasWarnings(): boolean; + /** Returns compilation information as a JSON object. */ + toJson(options?: Stats.ToJsonOptions): any; + /** Returns a formatted string of the compilation information (similar to CLI output). */ + toString(options?: Stats.ToStringOptions): string; + } + + namespace Stats { + type Preset + = boolean + | 'errors-only' + | 'minimal' + | 'none' + | 'normal' + | 'verbose'; + + interface ToJsonOptionsObject { + /** Add asset Information */ + assets?: boolean; + /** Sort assets by a field */ + assetsSort?: string; + /** Add information about cached (not built) modules */ + cached?: boolean; + /** Show cached assets (setting this to `false` only shows emitted files) */ + cachedAssets?: boolean; + /** Add children information */ + children?: boolean; + /** Add built modules information to chunk information */ + chunkModules?: boolean; + /** Add the origins of chunks and chunk merging info */ + chunkOrigins?: boolean; + /** Add chunk information (setting this to `false` allows for a less verbose output) */ + chunks?: boolean; + /** Sort the chunks by a field */ + chunksSort?: string; + /** Context directory for request shortening */ + context?: string; + /** Display the distance from the entry point for each module */ + depth?: boolean; + /** Display the entry points with the corresponding bundles */ + entrypoints?: boolean; + /** Add --env information */ + env?: boolean; + /** Add errors */ + errors?: boolean; + /** Add details to errors (like resolving log) */ + errorDetails?: boolean; + /** Exclude assets from being displayed in stats */ + excludeAssets?: StatsExcludeFilter; + /** Exclude modules from being displayed in stats */ + excludeModules?: StatsExcludeFilter; + /** See excludeModules */ + exclude?: StatsExcludeFilter; + /** Add the hash of the compilation */ + hash?: boolean; + /** Set the maximum number of modules to be shown */ + maxModules?: number; + /** Add built modules information */ + modules?: boolean; + /** Sort the modules by a field */ + modulesSort?: string; + /** Show dependencies and origin of warnings/errors */ + moduleTrace?: boolean; + /** Add public path information */ + publicPath?: boolean; + /** Add information about the reasons why modules are included */ + reasons?: boolean; + /** Add the source code of modules */ + source?: boolean; + /** Add timing information */ + timings?: boolean; + /** Add webpack version information */ + version?: boolean; + /** Add warnings */ + warnings?: boolean; + /** Show which exports of a module are used */ + usedExports?: boolean; + /** Filter warnings to be shown */ + warningsFilter?: string | RegExp | Array | ((warning: string) => boolean); + /** Show performance hint when file size exceeds `performance.maxAssetSize` */ + performance?: boolean; + /** Show the exports of the modules */ + providedExports?: boolean; + } + + type ToJsonOptions = Preset | ToJsonOptionsObject; + + type StatsExcludeFilter = string | string[] | RegExp | RegExp[] | ((assetName: string) => boolean) | Array<(assetName: string) => boolean>; + + interface ToStringOptionsObject extends ToJsonOptionsObject { + /** `webpack --colors` equivalent */ + colors?: boolean; + } + + type ToStringOptions = Preset | ToStringOptionsObject; + } + + /** + * Plugins + */ + + class BannerPlugin extends Plugin { + constructor(options: string | BannerPlugin.Options); + } + + namespace BannerPlugin { + type Filter = string | RegExp; + + interface Options { + banner: string; + entryOnly?: boolean; + exclude?: Filter | Filter[]; + include?: Filter | Filter[]; + raw?: boolean; + test?: Filter | Filter[]; + } + } + + class ContextReplacementPlugin extends Plugin { + constructor(resourceRegExp: any, newContentResource?: any, newContentRecursive?: any, newContentRegExp?: any); + } + + class DefinePlugin extends Plugin { + constructor(definitions: { [key: string]: any }); + } + + class DllPlugin extends Plugin { + constructor(options: DllPlugin.Options | DllPlugin.Options[]); + } + + namespace DllPlugin { + interface Options { + /** + * The context of requests in the manifest file. + * + * Defaults to the webpack context. + */ + context?: string; + + /** + * The name of the exposed DLL function (keep consistent with `output.library`). + */ + name: string; + + /** + * The absolute path to the manifest json file (output). + */ + path: string; + } + } + + class DllReferencePlugin extends Plugin { + constructor(options: DllReferencePlugin.Options); + } + + namespace DllReferencePlugin { + interface Options { + /** + * The mappings from the request to module ID. + * + * Defaults to `manifest.content`. + */ + content?: any; + + /** + * The context of requests in the manifest (or content property). + * + * This is an absolute path. + */ + context: string; + + /** + * An object containing `content` and `name`. + */ + manifest: { content: string, name: string } | string; + + /** + * The name where the DLL is exposed. + * + * Defaults to `manifest.name`. + * + * See also `externals`. + */ + name?: string; + + /** + * The prefix which is used for accessing the content of the DLL. + */ + scope?: string; + + /** + * The type how the DLL is exposed. + * + * Defaults to `"var"`. + * + * See also `externals`. + */ + sourceType?: string; + } + } + + class EvalSourceMapDevToolPlugin extends Plugin { + constructor(options?: false | string | EvalSourceMapDevToolPlugin.Options); + } + + namespace EvalSourceMapDevToolPlugin { + interface Options { + append?: false | string; + columns?: boolean; + lineToLine?: boolean | { + exclude?: Condition | Condition[]; + include?: Condition | Condition[]; + test?: Condition | Condition[]; + }; + module?: boolean; + moduleFilenameTemplate?: string; + sourceRoot?: string; + } + } + + class ExtendedAPIPlugin extends Plugin { + constructor(); + } + + class HashedModuleIdsPlugin extends Plugin { + constructor(options?: { + hashFunction?: string, + hashDigest?: string, + hashDigestLength?: number + }); + } + + class HotModuleReplacementPlugin extends Plugin { + constructor(options?: any); + } + + class IgnorePlugin extends Plugin { + constructor(requestRegExp: any, contextRegExp?: any); + } + + class LoaderOptionsPlugin extends Plugin { + constructor(options: any); + } + + class NamedModulesPlugin extends Plugin { + constructor(); + } + + class NamedChunksPlugin extends Plugin { + constructor(nameResolver?: (chunk: any) => string | null); + } + + class NoEmitOnErrorsPlugin extends Plugin { + constructor(); + } + + /** @deprecated use webpack.NoEmitOnErrorsPlugin */ + class NoErrorsPlugin extends Plugin { + constructor(); + } + + class NormalModuleReplacementPlugin extends Plugin { + constructor(resourceRegExp: any, newResource: any); + } + + class PrefetchPlugin extends Plugin { + // tslint:disable-next-line:unified-signatures + constructor(context: any, request: any); + constructor(request: any); + } + + class ProgressPlugin extends Plugin { + constructor(options?: (percentage: number, msg: string, moduleProgress?: string, activeModules?: string, moduleName?: string) => void); + } + + class EnvironmentPlugin extends Plugin { + constructor(envs: string[] | { [key: string]: any }); + } + + class ProvidePlugin extends Plugin { + constructor(definitions: { [key: string]: any }); + } + + class SourceMapDevToolPlugin extends Plugin { + constructor(options?: null | false | string | SourceMapDevToolPlugin.Options); + } + + namespace SourceMapDevToolPlugin { + /** @todo extend EvalSourceMapDevToolPlugin.Options */ + interface Options { + append?: false | string; + columns?: boolean; + exclude?: Condition | Condition[]; + fallbackModuleFilenameTemplate?: string; + filename?: null | false | string; + include?: Condition | Condition[]; + lineToLine?: boolean | { + exclude?: Condition | Condition[]; + include?: Condition | Condition[]; + test?: Condition | Condition[]; + }; + module?: boolean; + moduleFilenameTemplate?: string; + noSources?: boolean; + sourceRoot?: null | string; + test?: Condition | Condition[]; + } + } + + class WatchIgnorePlugin extends Plugin { + constructor(paths: Array); + } + + namespace optimize { + class ModuleConcatenationPlugin extends Plugin { } + class AggressiveMergingPlugin extends Plugin { + constructor(options?: AggressiveMergingPlugin.Options); + } + + namespace AggressiveMergingPlugin { + interface Options { + /** + * When options.moveToParents is set, moving to an entry chunk is more expensive. + * Defaults to 10, which means moving to an entry chunk is ten times more expensive than moving to a + * normal chunk. + */ + entryChunkMultiplicator?: number; + /** + * A factor which defines the minimum required size reduction for chunk merging. + * Defaults to 1.5 which means that the total size needs to be reduced by 50% for chunk merging. + */ + minSizeReduce?: number; + /** + * When set, modules that are not in both merged chunks are moved to all parents of the chunk. + * Defaults to false. + */ + moveToParents?: boolean; + } + } + + class CommonsChunkPlugin extends Plugin { + constructor(options?: CommonsChunkPlugin.Options); + } + + namespace CommonsChunkPlugin { + type MinChunksFn = (module: any, count: number) => boolean; + + interface Options { + /** + * The chunk name of the commons chunk. An existing chunk can be selected by passing a name of an existing chunk. + * If an array of strings is passed this is equal to invoking the plugin multiple times for each chunk name. + * If omitted and `options.async` or `options.children` is set all chunks are used, + * otherwise `options.filename` is used as chunk name. + */ + name?: string; + names?: string[]; + + /** + * The filename template for the commons chunk. Can contain the same placeholders as `output.filename`. + * If omitted the original filename is not modified (usually `output.filename` or `output.chunkFilename`). + */ + filename?: string; + + /** + * The minimum number of chunks which need to contain a module before it's moved into the commons chunk. + * The number must be greater than or equal 2 and lower than or equal to the number of chunks. + * Passing `Infinity` just creates the commons chunk, but moves no modules into it. + * By providing a `function` you can add custom logic. (Defaults to the number of chunks) + */ + minChunks?: number | MinChunksFn; + + /** + * Select the source chunks by chunk names. The chunk must be a child of the commons chunk. + * If omitted all entry chunks are selected. + */ + chunks?: string[]; + + /** + * If `true` all children of the commons chunk are selected + */ + children?: boolean; + + /** + * If `true` a new async commons chunk is created as child of `options.name` and sibling of `options.chunks`. + * It is loaded in parallel with `options.chunks`. It is possible to change the name of the output file + * by providing the desired string instead of `true`. + */ + async?: boolean | string; + + /** + * Minimum size of all common module before a commons chunk is created. + */ + minSize?: number; + } + } + + /** @deprecated */ + class DedupePlugin extends Plugin { + constructor(); + } + + class LimitChunkCountPlugin extends Plugin { + constructor(options: any); + } + + class MinChunkSizePlugin extends Plugin { + constructor(options: any); + } + + class OccurrenceOrderPlugin extends Plugin { + constructor(preferEntry: boolean); + } + + class UglifyJsPlugin extends Plugin { + constructor(options?: UglifyJsPlugin.Options); + } + + namespace UglifyJsPlugin { + type CommentFilter = (astNode: any, comment: any) => boolean; + + interface Options extends UglifyJS.MinifyOptions { + beautify?: boolean; + comments?: boolean | RegExp | CommentFilter; + exclude?: Condition | Condition[]; + include?: Condition | Condition[]; + /** Parallelization can speedup your build significantly and is therefore highly recommended. */ + parallel?: boolean | { cache: boolean, workers: boolean | number }; + sourceMap?: boolean; + test?: Condition | Condition[]; + } + } + } + + namespace dependencies { + } + + namespace loader { + interface Loader extends Function { + (this: LoaderContext, source: string | Buffer, sourceMap?: RawSourceMap): string | Buffer | void | undefined; + + /** + * The order of chained loaders are always called from right to left. + * But, in some cases, loaders do not care about the results of the previous loader or the resource. + * They only care for metadata. The pitch method on the loaders is called from left to right before the loaders are called (from right to left). + * If a loader delivers a result in the pitch method the process turns around and skips the remaining loaders, + * continuing with the calls to the more left loaders. data can be passed between pitch and normal call. + */ + pitch?(remainingRequest: string, precedingRequest: string, data: any): any; + + /** + * By default, the resource file is treated as utf-8 string and passed as String to the loader. + * By setting raw to true the loader is passed the raw Buffer. + * Every loader is allowed to deliver its result as String or as Buffer. + * The compiler converts them between loaders. + */ + raw?: boolean; + } + + type loaderCallback = (err: Error | undefined | null, content?: string | Buffer, sourceMap?: RawSourceMap) => void; + + interface LoaderContext { + /** + * Loader API version. Currently 2. + * This is useful for providing backwards compatibility. + * Using the version you can specify custom logic or fallbacks for breaking changes. + */ + version: string; + + /** + * The directory of the module. Can be used as context for resolving other stuff. + * In the example: /abc because resource.js is in this directory + */ + context: string; + + /** + * The resolved request string. + * In the example: "/abc/loader1.js?xyz!/abc/node_modules/loader2/index.js!/abc/resource.js?rrr" + */ + request: string; + + /** + * A string or any object. The query of the request for the current loader. + */ + query: any; + + /** + * A data object shared between the pitch and the normal phase. + */ + data?: any; + + callback: loaderCallback; + + /** + * Make this loader async. + */ + async(): loaderCallback | undefined; + + /** + * Make this loader result cacheable. By default it's not cacheable. + * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed. + * This means the loader shouldn't have other dependencies than specified with this.addDependency. + * Most loaders are deterministic and cacheable. + */ + cacheable(flag?: boolean): void; + + /** + * loaders = [{request: string, path: string, query: string, module: function}] + * An array of all the loaders. It is writeable in the pitch phase. + * In the example: + * [ + * { request: "/abc/loader1.js?xyz", + * path: "/abc/loader1.js", + * query: "?xyz", + * module: [Function] + * }, + * { request: "/abc/node_modules/loader2/index.js", + * path: "/abc/node_modules/loader2/index.js", + * query: "", + * module: [Function] + * } + * ] + */ + loaders: any[]; + + /** + * The index in the loaders array of the current loader. + * In the example: in loader1: 0, in loader2: 1 + */ + loaderIndex: number; + + /** + * The resource part of the request, including query. + * In the example: "/abc/resource.js?rrr" + */ + resource: string; + + /** + * The resource file. + * In the example: "/abc/resource.js" + */ + resourcePath: string; + + /** + * The query of the resource. + * In the example: "?rrr" + */ + resourceQuery: string; + + /** + * Emit a warning. + */ + emitWarning(message: string | Error): void; + + /** + * Emit a error. + */ + emitError(message: string | Error): void; + + /** + * Execute some code fragment like a module. + * + * Don't use require(this.resourcePath), use this function to make loaders chainable! + * + */ + exec(code: string, filename: string): any; + + /** + * Resolve a request like a require expression. + */ + resolve(context: string, request: string, callback: (err: Error, result: string) => void): any; + + /** + * Resolve a request like a require expression. + */ + resolveSync(context: string, request: string): string; + + /** + * Adds a file as dependency of the loader result in order to make them watchable. + * For example, html-loader uses this technique as it finds src and src-set attributes. + * Then, it sets the url's for those attributes as dependencies of the html file that is parsed. + */ + addDependency(file: string): void; + + /** + * Adds a file as dependency of the loader result in order to make them watchable. + * For example, html-loader uses this technique as it finds src and src-set attributes. + * Then, it sets the url's for those attributes as dependencies of the html file that is parsed. + */ + dependency(file: string): void; + + /** + * Add a directory as dependency of the loader result. + */ + addContextDependency(directory: string): void; + + /** + * Remove all dependencies of the loader result. Even initial dependencies and these of other loaders. Consider using pitch. + */ + clearDependencies(): void; + + /** + * Pass values to the next loader. + * If you know what your result exports if executed as module, set this value here (as a only element array). + */ + value: any; + + /** + * Passed from the last loader. + * If you would execute the input argument as module, consider reading this variable for a shortcut (for performance). + */ + inputValue: any; + + /** + * The options passed to the Compiler. + */ + options: any; + + /** + * A boolean flag. It is set when in debug mode. + */ + debug: boolean; + + /** + * Should the result be minimized. + */ + minimize: boolean; + + /** + * Should a SourceMap be generated. + */ + sourceMap: boolean; + + /** + * Target of compilation. Passed from configuration options. + * Example values: "web", "node" + */ + target: 'web' | 'webworker' | 'async-node' | 'node' | 'electron-main' | 'electron-renderer' | 'node-webkit' | string; + + /** + * This boolean is set to true when this is compiled by webpack. + * + * Loaders were originally designed to also work as Babel transforms. + * Therefore if you write a loader that works for both, you can use this property to know if + * there is access to additional loaderContext and webpack features. + */ + webpack: boolean; + + /** + * Emit a file. This is webpack-specific. + */ + emitFile(name: string, content: Buffer | string, sourceMap: any): void; + + /** + * Access to the compilation's inputFileSystem property. + */ + fs: any; + + /** + * Hacky access to the Compilation object of webpack. + */ + _compilation: any; + + /** + * Hacky access to the Compiler object of webpack. + */ + _compiler: Compiler; + + /** + * Hacky access to the Module object being loaded. + */ + _module: any; + } + } + + /** @deprecated */ + namespace compiler { + /** @deprecated use webpack.Compiler */ + // tslint:disable-next-line:no-unnecessary-qualifier + type Compiler = webpack.Compiler; + + /** @deprecated use webpack.Compiler.Watching */ + type Watching = Compiler.Watching; + + /** @deprecated use webpack.Compiler.WatchOptions */ + + type WatchOptions = Compiler.WatchOptions; + + /** @deprecated use webpack.Stats */ + // tslint:disable-next-line:no-unnecessary-qualifier + type Stats = webpack.Stats; + + /** @deprecated use webpack.Stats.ToJsonOptions */ + type StatsOptions = Stats.ToJsonOptions; + + /** @deprecated use webpack.Stats.ToStringOptions */ + type StatsToStringOptions = Stats.ToStringOptions; + + /** @deprecated use webpack.Compiler.Handler */ + type CompilerCallback = Compiler.Handler; + } + + /** @deprecated use webpack.Options.Performance */ + type PerformanceOptions = Options.Performance; + /** @deprecated use webpack.Options.WatchOptions */ + type WatchOptions = Options.WatchOptions; + /** @deprecated use webpack.EvalSourceMapDevToolPlugin.Options */ + type EvalSourceMapDevToolPluginOptions = EvalSourceMapDevToolPlugin.Options; + /** @deprecated use webpack.SourceMapDevToolPlugin.Options */ + type SourceMapDevToolPluginOptions = SourceMapDevToolPlugin.Options; + /** @deprecated use webpack.optimize.UglifyJsPlugin.CommentFilter */ + type UglifyCommentFunction = optimize.UglifyJsPlugin.CommentFilter; + /** @deprecated use webpack.optimize.UglifyJsPlugin.Options */ + type UglifyPluginOptions = optimize.UglifyJsPlugin.Options; +} \ No newline at end of file diff --git a/types/webpack/v3/package.json b/types/webpack/v3/package.json new file mode 100644 index 0000000000..59c231c54c --- /dev/null +++ b/types/webpack/v3/package.json @@ -0,0 +1,6 @@ +{ + "private": true, + "dependencies": { + "source-map": "^0.6.0" + } +} diff --git a/types/webpack/v3/tsconfig.json b/types/webpack/v3/tsconfig.json new file mode 100644 index 0000000000..a6671e38b4 --- /dev/null +++ b/types/webpack/v3/tsconfig.json @@ -0,0 +1,26 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "baseUrl": "../../", + "typeRoots": [ + "../../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true, + "paths": { + "webpack": ["webpack/v3"] + } + }, + "files": [ + "index.d.ts", + "webpack-tests.ts" + ] +} \ No newline at end of file diff --git a/types/webpack/v3/tslint.json b/types/webpack/v3/tslint.json new file mode 100644 index 0000000000..b4b47a0378 --- /dev/null +++ b/types/webpack/v3/tslint.json @@ -0,0 +1,3 @@ +{ + "extends": "dtslint/dt.json" +} diff --git a/types/webpack/v3/webpack-tests.ts b/types/webpack/v3/webpack-tests.ts new file mode 100644 index 0000000000..f56dbb84b6 --- /dev/null +++ b/types/webpack/v3/webpack-tests.ts @@ -0,0 +1,667 @@ +import webpack = require('webpack'); +import { RawSourceMap } from 'source-map'; + +const { + optimize, +} = webpack; + +let plugins: webpack.Plugin[]; + +/** + * Plugins + */ + +/** + * optimize + */ + +const { + AggressiveMergingPlugin, +} = optimize; + +plugins = [ + new AggressiveMergingPlugin(), + new AggressiveMergingPlugin({}), + new AggressiveMergingPlugin({ + entryChunkMultiplicator: 10, + minSizeReduce: 1.5, + moveToParents: false, + }), +]; + +let configuration: webpack.Configuration; +let rule: webpack.Rule; +let plugin: webpack.Plugin; +declare const __dirname: string; + +// +// https://webpack.github.io/docs/using-loaders.html +// + +configuration = { + module: { + loaders: [ + { test: /\.jade$/, loader: "jade" }, + // => "jade" loader is used for ".jade" files + + { test: /\.css$/, loader: "style!css" }, + // => "style" and "css" loader is used for ".css" files + // Alternative syntax: + { test: /\.css$/, loaders: ["style", "css"] }, + ] + } +}; + +rule = { test: /\.png$/, loader: "url-loader?mimetype=image/png" }; + +rule = { + test: /\.png$/, + loader: "url-loader", + query: { mimetype: "image/png" } +}; + +// +// http://webpack.github.io/docs/tutorials/getting-started/ +// + +configuration = { + entry: "./entry.js", + output: { + path: __dirname, + filename: "bundle.js" + }, + module: { + loaders: [ + { test: /\.css$/, loader: "style!css" } + ] + } +}; + +// +// https://webpack.js.org/configuration/entry-context/#dynamic-entry +// + +configuration = { + entry: () => './demo' +}; + +configuration = { + entry: () => ['./demo', './demo2'] +}; + +configuration = { + entry: () => new Promise((resolve) => resolve('./demo')) +}; + +configuration = { + entry: () => new Promise((resolve) => resolve(['./demo', './demo2'])) +}; + +// +// https://webpack.github.io/docs/code-splitting.html +// + +configuration = { + entry: { + app: "./app.js", + vendor: ["jquery", "underscore"], + }, + output: { + filename: "bundle.js" + }, + plugins: [ + new webpack.optimize.CommonsChunkPlugin({ + name: "vendor", + filename: "vendor.bundle.js", + }), + ] +}; + +configuration = { + entry: { a: "./a", b: "./b" }, + output: { filename: "[name].js" }, + plugins: [new webpack.optimize.CommonsChunkPlugin({ name: "init.js" })] +}; + +// +// https://webpack.github.io/docs/stylesheets.html +// + +configuration = { + // ... + module: { + loaders: [ + { test: /\.css$/, loader: "style-loader!css-loader" } + ] + } +}; + +// +// https://webpack.github.io/docs/optimization.html +// + +configuration = { + entry: { + p1: "./page1", + p2: "./page2", + p3: "./page3" + }, + output: { + filename: "[name].entry.chunk.js" + } +}; + +const CommonsChunkPlugin = webpack.optimize.CommonsChunkPlugin; +configuration = { + entry: { + p1: "./page1", + p2: "./page2", + p3: "./page3" + }, + output: { + filename: "[name].entry.chunk.js" + }, + plugins: [ + new CommonsChunkPlugin({ name: "commons.chunk.js" }) + ] +}; + +configuration = { + entry: { + p1: "./page1", + p2: "./page2", + p3: "./page3", + ap1: "./admin/page1", + ap2: "./admin/page2" + }, + output: { + filename: "[name].js" + }, +}; +//