浅谈Webpack4 plugins 实现原理

// 创建一个编译器
createChildCompiler(
  compilation,
  compilerName,
  compilerIndex,
  outputOptions,
  plugins // 里边就有包含插件
) {

   // new 一个 编译器
  const childCompiler = new Compiler(this.context);
  // 寻找存在的所有 plugins 插件
  if (Array.isArray(plugins)) {
    for (const plugin of plugins) {
       // 如果存在， 就调用 plugin 的 apply 方法
      plugin.apply(childCompiler);
    }
  }
  
  // 遍历寻找 plugin 对应的 hooks
  for (const name in this.hooks) {
    if (
      ![
        "make",
        "compile",
        "emit",
        "afterEmit",
        "invalid",
        "done",
        "thisCompilation"
      ].includes(name)
    ) {
    
      // 找到对应的 hooks 并调用， 
      if (childCompiler.hooks[name]) {
        childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
      }
    }
  }
 
 // .... 省略 ....

  return childCompiler;
}

// 上述的 Compiler 类继承自 Tapable 类，而 Tapable 就定义了这些 hooks 事件流
class Compiler extends Tapable {
 constructor(context) {
            super();
            this.hooks = {
                    
                    shouldEmit: new SyncBailHook(["compilation"]),
                    
                    done: new AsyncSeriesHook(["stats"]),
                    
                    additionalPass: new AsyncSeriesHook([]),
                    
                    beforeRun: new AsyncSeriesHook(["compiler"]),
                    
                    run: new AsyncSeriesHook(["compiler"]),
                    
                    emit: new AsyncSeriesHook(["compilation"]),
                    
                    assetEmitted: new AsyncSeriesHook(["file", "content"]),
                    
                    afterEmit: new AsyncSeriesHook(["compilation"]),

                    
                    thisCompilation: new SyncHook(["compilation", "params"]),
                    
                    compilation: new SyncHook(["compilation", "params"]),
                    
                    nORMalModuleFactory: new SyncHook(["normalModuleFactory"]),
                    
                    contextModuleFactory: new SyncHook(["contextModulefactory"]),

                    
                    beforeCompile: new AsyncSeriesHook(["params"]),
                    
                    compile: new SyncHook(["params"]),
                    
                    make: new AsyncParallelHook(["compilation"]),
                    
                    afterCompile: new AsyncSeriesHook(["compilation"]),

                    
                    watchRun: new AsyncSeriesHook(["compiler"]),
                    
                    failed: new SyncHook(["error"]),
                    
                    invalid: new SyncHook(["filename", "changeTime"]),
                    
                    watchClose: new SyncHook([]),

                    
                    infrastructureLog: new SyncBailHook(["origin", "type", "args"]),

                    // TODO the following hooks are weirdly located here
                    // TODO move them for webpack 5
                    
                    environment: new SyncHook([]),
                    
                    afterEnvironment: new SyncHook([]),
                    
                    afterPlugins: new SyncHook(["compiler"]),
                    
                    afterResolvers: new SyncHook(["compiler"]),
                    
                    entryOption: new SyncBailHook(["context", "entry"])
            };
            
            // TODO webpack 5 remove this
            this.hooks.infrastructurelog = this.hooks.infrastructureLog;
               
            // 通过 tab 调用对应的 comiler 编译器，并传入一个回调函数
            this._pluginCompat.tap("Compiler", options => {
                    switch (options.name) {
                            case "additional-pass":
                            case "before-run":
                            case "run":
                            case "emit":
                            case "after-emit":
                            case "before-compile":
                            case "make":
                            case "after-compile":
                            case "watch-run":
                                    options.async = true;
                                    break;
                    }
            });
            // 下方省略 ......
  }

// 定义一个 plugins 类   
class MyPlugins {
    // 上边有说 new 一个编译器实例，会执行实例的 apply 方法，传入对应的 comiler 实例
    apply (compiler) {
        // 调用 new 出来 compiler 实例下的 hooks 事件流，通过 tab 触发，并接收一个回调函数
        compiler.hooks.done.tap('一般为插件昵称', (默认接收参数) => {
            console.log('进入执行体');
        })
    }
}
// 导出
module.exports = MyPlugins

let path = require('path')
let DonePlugin = require('./plugins/DonePlugins')
let AsyncPlugins = require('./plugins/AsyncPlugins')

module.exports = {
    mode: 'development',
    entry: './src/index.js',
    output: {
        filename: 'build.js',
        path: path.resolve(__dirname, 'dist')
    },
    plugins: [
        new DonePlugin(),    // 内部同步 hooks
        new AsyncPlugins()   // 内部异步 hooks
    ]
}

class DonePlugins {
    apply (compiler) {
        compiler.hooks.done.tap('DonePlugin', (stats) => {
            console.log('执行： 编译完成');
        })
    }
}

module.exports = DonePlugins

class AsyncPlugins {
    apply (compiler) {
        compiler.hooks.emit.tapAsync('AsyncPlugin', (complete, callback) => {
            setTimeout(() => {
                console.log('执行：文件发射出来');
                callback()
            }, 1000)
        })
    }
}

module.exports = AsyncPlugins

class FileListPlugin {
    // 初始化，获取文件的名称
    constructor ({filename}) {
        this.filename = filename
    }
    // 同样的模板形式，定义 apply 方法
    apply (compiler) {
        compiler.hooks.emit.tap('FileListPlugin', (compilation) => {
            // assets 静态资源，可以打印出  compilation 参数，还有很多方法和属性
            let assets = compilation.assets;
            
            // 定义输出文档结构
            let content = `## 文件名  资源大小\r\n`
            
            // 遍历静态资源，动态组合输出内容
            Object.entries(assets).forEach(([filename, stateObj]) => {
                content += `- ${filename}    ${stateObj.size()}\r\n`
            })
            
            // 输出资源对象
            assets[this.filename] = {
                source () {
                    return content;
                },
                size () {
                    return content.length
                }
            }
            
        })
    }
}
// 导出
module.exports = FileListPlugin

let path = require('path')
let HtmlWebpackPlugin = require('html-webpack-plugin')
// plugins 目录与node_modules 同级， 自定义 plugins , 与 loader 类似
let FileListPlugin = require('./plugins/FileListPlugin')

module.exports = {
    mode: 'development',
    entry: './src/index.js',
    output: {
        filename: 'build.js',
        path: path.resolve(__dirname, 'dist')
    },
    plugins: [
        new HtmlWebpackPlugin({
            template: './src/index.html',
            filename: 'index.html'
        }),
        new FileListPlugin({
            filename: 'list.md'
        })
    ]
}