docs(api): clean up formatting and fix linting errors

Author: skipjack

src/content/api/compilation.md

@@ -6,68 +6,76 @@ sort: 3
 
 The Compilation instance extends from the compiler i.e. `compiler.compilation`. It is the literal compilation of all the objects in the require graph. This object has access to all the modules and their dependencies (most of which are circular references). In the compilation phase, modules are loaded, sealed, optimized, chunked, hashed and restored, etc. This would be the main lifecycle of any operations of the compilation.
 
-```javascript
+``` js
 compiler.plugin("compilation", function(compilation) {
-    //the main compilation instance
-    //all subsequent methods are derived from compilation.plugin
+  // the main compilation instance
+  // all subsequent methods are derived from compilation.plugin
 });
 ```
 
+
 ## `normal-module-loader`
 
 The normal module loader, is the function that actually loads all the modules in the module graph (one-by-one).
 
-```javascript
+``` js
 compilation.plugin('normal-module-loader', function(loaderContext, module) {
-    //this is where all the modules are loaded
-    //one by one, no dependencies are created yet
+  // this is where all the modules are loaded
+  // one by one, no dependencies are created yet
 });
 ```
 
+
 ## `seal`
 
 The sealing of the compilation has started.
 
-```javascript
+``` js
 compilation.plugin('seal', function() {
-    //you are not accepting any more modules
-    //no arguments
+  // you are not accepting any more modules
+  // no arguments
 });
 ```
 
+
 ## `optimize`
 
 Optimize the compilation.
 
-```javascript
+``` js
 compilation.plugin('optimize', function() {
-    //webpack is begining the optimization phase
-    // no arguments
+  // webpack is begining the optimization phase
+  // no arguments
 });
 ```
 
+
 ## `optimize-tree(chunks, modules)` async
 
 Async optimization of the tree.
 
-```javascript
+``` js
 compilation.plugin('optimize-tree', function(chunks, modules) {
 
 });
 ```
 
 #### `optimize-modules(modules: Module[])`
+
 Optimize the modules.
-```javascript
+
+``` js
 compilation.plugin('optimize-modules', function(modules) {
-    //handle to the modules array during tree optimization
+  // handle to the modules array during tree optimization
 });
 ```
 
+
 ## `after-optimize-modules(modules: Module[])`
 
 Optimizing the modules has finished.
 
+
 ## `optimize-chunks(chunks: Chunk[])`
 
 Optimize the chunks.
@@ -91,73 +99,89 @@ compilation.plugin('optimize-chunks', function(chunks) {
 
 Optimizing the chunks has finished.
 
+
 ## `revive-modules(modules: Module[], records)`
 
 Restore module info from records.
 
+
 ## `optimize-module-order(modules: Module[])`
 
 Sort the modules in order of importance. The first is the most important module. It will get the smallest id.
 
+
 ## `optimize-module-ids(modules: Module[])`
 
 Optimize the module ids.
 
+
 ## `after-optimize-module-ids(modules: Module[])`
 
 Optimizing the module ids has finished.
 
+
 ## `record-modules(modules: Module[], records)`
 
 Store module info to the records.
 
+
 ## `revive-chunks(chunks: Chunk[], records)`
 
 Restore chunk info from records.
 
+
 ## `optimize-chunk-order(chunks: Chunk[])`
 
 Sort the chunks in order of importance. The first is the most important chunk. It will get the smallest id.
 
+
 ## `optimize-chunk-ids(chunks: Chunk[])`
 
 Optimize the chunk ids.
 
+
 ## `after-optimize-chunk-ids(chunks: Chunk[])`
 
 Optimizing the chunk ids has finished.
 
+
 ## `record-chunks(chunks: Chunk[], records)`
 
 Store chunk info to the records.
 
+
 ## `before-hash`
 
 Before the compilation is hashed.
 
+
 ## `after-hash`
 
 After the compilation is hashed.
 
+
 ## `before-chunk-assets`
 
 Before creating the chunk assets.
 
+
 ## `additional-chunk-assets(chunks: Chunk[])`
 
 Create additional assets for the chunks.
 
+
 ## `record(compilation, records)`
 
 Store info about the compilation to the records
 
+
 ## `additional-assets` async
 
 Create additional assets for the compilation
 
 Here's an example that downloads an image.
 
-```javascript
+``` js
 compiler.plugin('compilation', function(compilation) {
   compilation.plugin('additional-assets', function(callback) {
     download('https://img.shields.io/npm/v/webpack.svg', function(resp) {
@@ -172,6 +196,7 @@ compiler.plugin('compilation', function(compilation) {
 });
 ```
 
+
 ## `optimize-chunk-assets(chunks: Chunk[])` async
 
 Optimize the assets for the chunks.
@@ -180,85 +205,92 @@ The assets are stored in `this.assets`, but not all of them are chunk assets. A
 
 Here's an example that simply adds a banner to each chunk.
 
-```javascript
+``` js
 compilation.plugin("optimize-chunk-assets", function(chunks, callback) {
-    chunks.forEach(function(chunk) {
-        chunk.files.forEach(function(file) {
-            compilation.assets[file] = new ConcatSource("\/**Sweet Banner**\/", "\n", compilation.assets[file]);
-        });
+  chunks.forEach(function(chunk) {
+    chunk.files.forEach(function(file) {
+      compilation.assets[file] = new ConcatSource("\/**Sweet Banner**\/", "\n", compilation.assets[file]);
     });
-    callback();
+  });
+  callback();
 });
 ```
 
 ## `after-optimize-chunk-assets(chunks: Chunk[])`
 
 The chunk assets have been optimized. Here's an example plugin from [@boopathi](https://github.com/boopathi) that outputs exactly what went into each chunk.
 
-```javascript
+``` js
 var PrintChunksPlugin = function() {};
+
 PrintChunksPlugin.prototype.apply = function(compiler) {
-    compiler.plugin('compilation', function(compilation, params) {
-        compilation.plugin('after-optimize-chunk-assets', function(chunks) {
-            console.log(chunks.map(function(c) {
-                return {
-                    id: c.id,
-                    name: c.name,
-                    includes: c.modules.map(function(m) {
-                        return m.request;
-                    })
-                };
-            }));
-        });
+  compiler.plugin('compilation', function(compilation, params) {
+    compilation.plugin('after-optimize-chunk-assets', function(chunks) {
+      console.log(chunks.map(function(c) {
+        return {
+          id: c.id,
+          name: c.name,
+          includes: c.modules.map(function(m) {
+            return m.request;
+          })
+        };
+      }));
     });
+  });
 };
 ```
 
+
 ## `optimize-assets(assets: Object{name: Source})` async
 
 Optimize all assets.
 
 The assets are stored in `this.assets`.
 
+
 ## `after-optimize-assets(assets: Object{name: Source})`
 
 The assets has been optimized.
 
+
 ## `build-module(module)`
 
 Before a module build has started.
 
-```javascript
+``` js
 compilation.plugin('build-module', function(module){
-    console.log('build module');
-    console.log(module);
+  console.log('About to build: ', module);
 });
 ```
 
+
 ## `succeed-module(module)`
 
 A module has been built successfully.
-```javascript
+
+``` js
 compilation.plugin('succeed-module', function(module){
-    console.log('succeed module');
-    console.log(module);
+  console.log('Successfully built: ', module);
 });
 ```
 
+
 ## `failed-module(module)`
 
 The module build has failed.
-```javascript
+
+``` js
 compilation.plugin('failed-module', function(module){
-    console.log('failed module');
-    console.log(module);
+  console.log('Failed to build: ', module);
 });
 ```
 
+
 ## `module-asset(module, filename)`
 
 An asset from a module was added to the compilation.
 
+
 ## `chunk-asset(chunk, filename)`
 
 An asset from a chunk was added to the compilation.

src/content/api/module-factories.md

@@ -4,9 +4,11 @@ group: Plugins
 sort: 5
 ---
 
+?> Lead in...
+
 ## `NormalModuleFactory`
 
-### `before-resolve(data)` async waterfall
+`before-resolve(data)` async waterfall
 
 Before the factory starts resolving. The `data` object has these properties:
 
@@ -15,7 +17,7 @@ Before the factory starts resolving. The `data` object has these properties:
 
 Plugins are allowed to modify the object or to pass a new similar object to the callback.
 
-### `after-resolve(data)` async waterfall
+`after-resolve(data)` async waterfall
 
 After the factory has resolved the request. The `data` object has these properties:
 
@@ -26,10 +28,17 @@ After the factory has resolved the request. The `data` object has these properti
 * `resource`: The resource. It will be loaded by the NormalModule.
 * `parser`: The parser that will be used by the NormalModule.
 
+
 ## `ContextModuleFactory`
 
-### `before-resolve(data)` async waterfall
+`before-resolve(data)` async waterfall
+
+?> Add documentation.
+
+`after-resolve(data)` async waterfall
+
+?> Add documentation.
 
-### `after-resolve(data)` async waterfall
+`alternatives(options: Array)` async waterfall
 
-### `alternatives(options: Array)` async waterfall
+?> Add documentation.

src/content/api/plugins.md

@@ -12,9 +12,9 @@ Many objects in webpack extend the `Tapable` class, which exposes a `plugin` met
 
 A plugin is installed once as webpack starts up. webpack installs a plugin by calling its `apply` method, and passes a reference to the webpack `compiler` object. You may then call `compiler.plugin` to access asset compilations and their individual build steps. An example would look like this:
 
-```javascript
-// MyPlugin.js
+__my-plugin.js__
 
+``` js
 function MyPlugin(options) {
   // Configure your plugin with options...
 }
@@ -41,14 +41,17 @@ MyPlugin.prototype.apply = function(compiler) {
 module.exports = MyPlugin;
 ```
 
-Then in `webpack.config.js`
+__webpack.config.js__
 
-```javascript
-    plugins: [
-        new MyPlugin({options: 'nada'})
-    ]
+``` js
+plugins: [
+  new MyPlugin({
+    options: 'nada'
+  })
+]
 ```
 
+
 ## Plugin Interfaces
 
 There are two types of plugin interfaces.