// Require the webpack-chain module. This module exports a single
// constructor function for creating a configuration API.
const Config = require('webpack-chain');

// Instantiate the configuration with a new API
const config = new Config();

// Make configuration changes using the chain API.
// Every API call tracks a change to the stored configuration.

// Interact with entry points
config
  .entry('index')
    .add('src/index.js')
    .end()
  // Modify output settings
  .output
    .path('dist')
    .filename('[name].bundle.js');

// Create named rules which can be modified later
config.module
  .rule('lint')
    .test(/\.js$/)
    .pre()
    .include
      .add('src')
      .end()
    // Even create named uses (loaders) for later modification
    .use('eslint')
      .loader('eslint-loader')
      .options({
        rules: {
          semi: 'off'
        }
      });

config.module
  .rule('compile')
    .test(/\.js$/)
    .include
      .add('src')
      .add('test')
      .end()
    .use('babel')
      .loader('babel-loader')
      .options({
        presets: [
          ['babel-preset-es2015', { modules: false }]
        ]
      });

// Create named plugins, too!
config.plugin('clean')
  .use(CleanPlugin, [['dist'], { root: '/dir' }]);

// Export the completed configuration object to be consumed by webpack
module.exports = config.toConfig();

// webpack.core.js
const Config = require('webpack-chain');
const config = new Config();

// Make configuration shared across targets
// ...

module.exports = config;

// webpack.dev.js
const config = require('./webpack.core');

// Dev-specific configuration
// ...
module.exports = config.toConfig();

// webpack.prod.js
const config = require('./webpack.core');

// Production-specific configuration
// ...
module.exports = config.toConfig();

// Remove all entries from a Map.
clear()

// Remove a single entry from a Map given its key.
// key: *
delete(key)

// Fetch the value from a Map located at the corresponding key.
// key: *
// returns: value
get(key)

// Set a value on the Map stored at the `key` location.
// key: *
// value: *
set(key, value)

// Returns `true` or `false` based on whether a Map as has a value set at a particular key.
// key: *
// returns: Boolean
has(key)

// Returns an array of all the values stored in the Map.
// returns: Array
values()

// Returns an object of all the entries in the backing Map
// where the key is the object property, and the value
// corresponding to the key. Will return `undefined` if the backing 
// Map is empty.
// returns: Object, undefined if empty
entries()

// Provide an object which maps its properties and values 
// into the backing Map as keys and values.
// obj: Object
merge(obj)

// Conditionally execute a function to continue configuration
// condition: Boolean
// truthyHandler: Function -> ChainedMap
  // invoked when condition is truthy, given a single argument of the ChainedMap instance
// falsyHandler: Function -> ChainedMap
  // invoked when condition is falsy, given a single argument of the ChainedMap instance
when(condition, truthyHandler, falsyHandler)

// Add/append a value to the end of a Set.
// value: *
add(value)

// Add a value to the beginning of a Set.
// value: *
prepend(value)

// Remove all values from a Set.
clear()

// Remove a specific value from a Set.
// value: *
delete(value)

// Returns `true` or `false` based on whether or not the
// backing Set contains the specified value.
// value: *
// returns: Boolean
has(value)

// Returns an array of values contained in the backing Set.
// returns: Array
values()

// Concatenates the given array to the end of the backing Set.
// arr: Array
merge(arr)

// Conditionally execute a function to continue configuration
// condition: Boolean
// truthyHandler: Function -> ChainedSet
  // invoked when condition is truthy, given a single argument of the ChainedSet instance
// falsyHandler: Function -> ChainedSet
  // invoked when condition is falsy, given a single argument of the ChainedSet instance
when(condition, truthyHandler, falsyHandler)

// A shorthand method for setting a value on a ChainedMap
devServer.hot(true);

// This would be equivalent to:
devServer.set('hot', true);

const Config = require('webpack-chain');

const config = new Config();

Config : ChainedMap

config
  .amd(amd)
  .bail(bail)
  .cache(cache)
  .devtool(devtool)
  .context(context)
  .externals(externals)
  .loader(loader)
  .profile(profile)
  .recordsPath(recordsPath)
  .recordsInputPath(recordsInputPath)
  .recordsOutputPath(recordsOutputPath)
  .stats(stats)
  .target(target)
  .watch(watch)
  .watchOptions(watchOptions)

// Backed at config.entryPoints : ChainedMap
config.entry(name) : ChainedSet

config
  .entry(name)
    .add(value)
    .add(value)

config
  .entry(name)
  .clear()
  
// Using low-level config.entryPoints:
 
config.entryPoints
  .get(name)
    .add(value)
    .add(value)
    
config.entryPoints
  .get(name)
  .clear()

config.output : ChainedMap

config.output
  .chunkFilename(chunkFilename)
  .crossOriginLoading(crossOriginLoading)
  .filename(filename)
  .library(library)
  .libraryTarget(libraryTarget)
  .devtoolFallbackModuleFilenameTemplate(devtoolFallbackModuleFilenameTemplate)
  .devtoolLineToLine(devtoolLineToLine)
  .devtoolModuleFilenameTemplate(devtoolModuleFilenameTemplate)
  .hashFunction(hashFunction)
  .hashDigest(hashDigest)
  .hashDigestLength(hashDigestLength)
  .hashSalt(hashSalt)
  .hotUpdateChunkFilename(hotUpdateChunkFilename)
  .hotUpdateFunction(hotUpdateFunction)
  .hotUpdateMainFilename(hotUpdateMainFilename)
  .jsonpFunction(jsonpFunction)
  .path(path)
  .pathinfo(pathinfo)
  .publicPath(publicPath)
  .sourceMapFilename(sourceMapFilename)
  .sourcePrefix(sourcePrefix)
  .strictModuleExceptionHandling(strictModuleExceptionHandling)
  .umdNamedDefine(umdNamedDefine)

config.resolve : ChainedMap

config.resolve
  .enforceExtension(enforceExtension)
  .enforceModuleExtension(enforceModuleExtension)
  .unsafeCache(unsafeCache)
  .symlinks(symlinks)
  .cachePredicate(cachePredicate)

config.resolve.alias : ChainedMap

config.resolve.alias
  .set(key, value)
  .set(key, value)
  .delete(key)
  .clear()

config.resolve.modules : ChainedSet

config.resolve.modules
  .add(value)
  .prepend(value)
  .clear()

config.resolve.aliasFields : ChainedSet

config.resolve.aliasFields
  .add(value)
  .prepend(value)
  .clear()

config.resolve.descriptionFields : ChainedSet

config.resolve.descriptionFields
  .add(value)
  .prepend(value)
  .clear()

config.resolve.extensions : ChainedSet

config.resolve.extensions
  .add(value)
  .prepend(value)
  .clear()

config.resolve.mainFields : ChainedSet

config.resolve.mainFields
  .add(value)
  .prepend(value)
  .clear()

config.resolve.mainFiles : ChainedSet

config.resolve.mainFiles
  .add(value)
  .prepend(value)
  .clear()

config.resolveLoader : ChainedMap

config.resolveLoader.extensions : ChainedSet

config.resolveLoader.extensions
  .add(value)
  .prepend(value)
  .clear()

config.resolveLoader.modules : ChainedSet

config.resolveLoader.modules
  .add(value)
  .prepend(value)
  .clear()

config.resolveLoader.moduleExtensions : ChainedSet

config.resolveLoader.moduleExtensions
  .add(value)
  .prepend(value)
  .clear()

config.resolveLoader.packageMains : ChainedSet

config.resolveLoader.packageMains
  .add(value)
  .prepend(value)
  .clear()

config.performance : ChainedMap

config.performance
  .hints(hints)
  .maxEntrypointSize(maxEntrypointSize)
  .maxAssetSize(maxAssetSize)
  .assetFilter(assetFilter)

// Backed at config.plugins
config.plugin(name) : ChainedMap

config
  .plugin(name)
  .use(WebpackPlugin, args)

// Examples
config
  .plugin('hot')
  .use(webpack.HotModuleReplacementPlugin);

config
  .plugin('env')
  .use(webpack.EnvironmentPlugin, ['NODE_ENV']);

config
  .plugin(name)
  .tap(args => newArgs)

// Example
config
  .plugin('env')
  .tap(args => [...args, 'SECRET_KEY']);

config
  .plugin(name)
  .init((Plugin, args) => new Plugin(...args));

// Backed at config.plugins
config.resolve.plugin(name) : ChainedMap

config.resolve
  .plugin(name)
  .use(WebpackPlugin, args)

config.resolve
  .plugin(name)
  .tap(args => newArgs)

config.resolve
  .plugin(name)
  .init((Plugin, args) => new Plugin(...args))

config.node : ChainedMap

config.node
  .set('__dirname', 'mock')
  .set('__filename', 'mock');

config.devServer : ChainedMap

config.devServer
  .clientLogLevel(clientLogLevel)
  .compress(compress)
  .contentBase(contentBase)
  .filename(filename)
  .headers(headers)
  .historyApiFallback(historyApiFallback)
  .host(host)
  .hot(hot)
  .hotOnly(hotOnly)
  .https(https)
  .inline(inline)
  .lazy(lazy)
  .noInfo(noInfo)
  .overlay(overlay)
  .port(port)
  .progress(progress)
  .proxy(proxy)
  .public(public)
  .publicPath(publicPath)
  .quiet(quiet)
  .setup(setup)
  .staticOptions(staticOptions)
  .stats(stats)
  .watchContentBase(watchContentBase)
  .watchOptions(watchOptions)

config.module : ChainedMap

config.module.noParse : ChainedSet

config.module.noParse
  .add(value)
  .prepend(value)
  .clear()

config.module.rules : ChainedMap

config.module
  .rule(name)
    .test(test)
    .pre()
    .post()
    .enforce(preOrPost)

config.module.rules{}.uses : ChainedMap

config.module
  .rule(name)
    .use(name)
      .loader(loader)
      .options(options)
    
// Example

config.module
  .rule('compile')
    .use('babel')
      .loader('babel-loader')
      .options({ presets: ['babel-preset-es2015'] });

config.module
  .rule(name)
    .use(name)
      .tap(options => newOptions)

// Example

config.module
  .rule('compile')
    .use('babel')
      .tap(options => merge(options, { plugins: ['babel-plugin-syntax-object-rest-spread'] }));

config.merge({ devtool: 'source-map' });

config.get('devtool') // "source-map"

config.merge({
  [key]: value,
  
  amd,
  bail,
  cache,
  devtool,
  context,
  externals,
  loader,
  profile,
  recordsPath,
  recordsInputPath,
  recordsOutputPath,
  stats,
  target,
  watch,
  watchOptions,
  
  entry: {
    [name]: [...values]
  },
  
  plugin: {
    [name]: {
      plugin: WebpackPlugin,
      args: [...args]
    }
  },
  
  devServer: {
    [key]: value,
    
    clientLogLevel,
    compress,
    contentBase,
    filename,
    headers,
    historyApiFallback,
    host,
    hot,
    hotOnly,
    https,
    inline,
    lazy,
    noInfo,
    overlay,
    port,
    proxy,
    quiet,
    setup,
    stats,
    watchContentBase
  },
  
  node: {
    [key]: value
  },
  
  performance: {
    [key]: value,
    
    hints,
    maxEntrypointSize,
    maxAssetSize,
    assetFilter
  },
  
  resolve: {
    [key]: value,
    
    alias: {
      [key]: value
    },
    aliasFields: [...values],
    descriptionFields: [...values],
    extensions: [...values],
    mainFields: [...values],
    mainFiles: [...values],
    modules: [...values],
    
    plugin: {
      [name]: {
        plugin: WebpackPlugin,
        args: [...args]
      }
    }
  },
  
  resolveLoader: {
    [key]: value,
    
    extensions: [...values],
    modules: [...values],
    moduleExtensions: [...values],
    packageMains: [...values]
  },
  
  module: {
    [key]: value,
    
    noParse: [...values],
    rule: {
      [name]: {
        [key]: value,
        
        enforce,
        test,
        parser,
        
        include: [...paths],
        exclude: [...paths],
        
        use: {
          [name]: {
            loader: LoaderString,
            options: LoaderOptions
          }
        }
      }
    }
  }
})

// Example: Only add minify plugin during production
config
  .when(process.env.NODE_ENV === 'production', config => {
    config
      .plugin('minify')
      .use(BabiliWebpackPlugin);
  });

// Example: Only add minify plugin during production,
// otherwise set devtool to source-map
config
  .when(process.env.NODE_ENV === 'production',
    config => config.plugin('minify').use(BabiliWebpackPlugin),
    config => config.devtool('source-map')
  );