.24-浅析webpack源码之事件流compilation(2)

  下一个compilation来源于以下代码:

compiler.apply(new EntryOptionPlugin());
compiler.applyPluginsBailResult("entry-option", options.context, options.entry);

  之前简单分析该处的apply,此处只看非数组单入口的情况,此时会引入SingleEntryDependency模块,与compilation相关的内容如下:

compiler.plugin("compilation", (compilation, params) => {
    const normalModuleFactory = params.normalModuleFactory;
    // ES6的Map
    compilation.dependencyFactories.set(SingleEntryDependency, normalModuleFactory);
});

  此处用到了ES6新加的数据结构Map,SingleEntryDependency是个没什么营养的类,之前简单讲过。

  总的来说就是设置了compilation.dependencyFactories的一条属性。

 

  下面是一长串的apply:

compiler.apply(
    new CompatibilityPlugin(),
    new HarmonyModulesPlugin(options.module),
    new AMDPlugin(options.module, options.amd || {}),
    new CommonJsPlugin(options.module),
    new LoaderPlugin(),
    new NodeStuffPlugin(options.node),
    new RequireJsStuffPlugin(),
    new APIPlugin(),
    new ConstPlugin(),
    new UseStrictPlugin(),
    new RequireIncludePlugin(),
    new RequireEnsurePlugin(),
    new RequireContextPlugin(options.resolve.modules, options.resolve.extensions, options.resolve.mainFiles),
    new ImportPlugin(options.module),
    new SystemPlugin(options.module)
);

  这一批注入了16个'compilation'事件。

  其中大部分都还是给其他的属性注入事件流,所以下面的内容基本上只是保证源码完整而列出来,并没有什么东西。

  看看流程图就行了,后面的内容全部可以跳过:

 

CompatibilityPlugin

class CompatibilityPlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            // 这两个模块没什么讲的
            compilation.dependencyFactories.set(ConstDependency, new NullFactory());
            compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
            params.normalModuleFactory.plugin("after-resolve", (data, done) => { /**/ });
        });
    }
}

  这个插件给Map上设置的属性没看懂什么用,主要还是注入了2个事件,先做记录。

 

HarmonyModulesPlugin

class HarmonyModulesPlugin {
    // options.module
    constructor(options) {
        this.options = options;
    }
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;

            compilation.dependencyFactories.set(HarmonyImportDependency, normalModuleFactory);
            compilation.dependencyTemplates.set(HarmonyImportDependency, new HarmonyImportDependency.Template());
            // ...大量set

            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

  设置了大量的属性,注入了一个parser事件……也没有什么动静。

 

AMDPlugin

class AMDPlugin {
    // options.module,options.amd
    constructor(options, amdOptions) {
        this.amdOptions = amdOptions;
        this.options = options;
    }
    apply(compiler) {
        const options = this.options;
        const amdOptions = this.amdOptions;
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            const contextModuleFactory = params.contextModuleFactory;

            compilation.dependencyFactories.set(AMDRequireDependency, new NullFactory());
            compilation.dependencyTemplates.set(AMDRequireDependency, new AMDRequireDependency.Template());
            // more set...

            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
        compiler.plugin("after-resolvers", () => { /**/ });
    }
}

  先不管这里的set,总之这里依然是注入了一个parser事件。

 

CommonJsPlugin

class CommonJsPlugin {
    constructor(options) {
        this.options = options;
    }
    apply(compiler) {
        const options = this.options;
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            const contextModuleFactory = params.contextModuleFactory;
            compilation.dependencyFactories.set(CommonJsRequireDependency, normalModuleFactory);
            compilation.dependencyTemplates.set(CommonJsRequireDependency, new CommonJsRequireDependency.Template());
            // set...
            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

  这两个插件从名字来看比较明了,但是具体行为还需要调用的时候做分析。

 

LoaderPlugin

class LoaderPlugin {
    apply(compiler) {
        // 属性设置
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            compilation.dependencyFactories.set(LoaderDependency, normalModuleFactory);
        });
        // plugin
        compiler.plugin("compilation", (compilation) => {
            compilation.plugin("normal-module-loader", (loaderContext, module) => { /**/ });
        });
    }
}

  这个也没有任何操作,设置了一个属性,注入normal-module-loader事件。

 

NodeStuffPlugin

  这个node参数的东西暂时不管了

 

RequireJsStuffPlugin

class RequireJsStuffPlugin {
    apply(compiler) {
        compiler.plugin("compilation", function(compilation, params) {
            compilation.dependencyFactories.set(ConstDependency, new NullFactory());
            compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
            params.normalModuleFactory.plugin("parser", function(parser, parserOptions) { /**/ });
        });
    }
};

 

APIPlugin

class APIPlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            compilation.dependencyFactories.set(ConstDependency, new NullFactory());
            compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
            params.normalModuleFactory.plugin("parser", parser => { /**/ });
        });
    }
}

 

ConstPlugin

class ConstPlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            compilation.dependencyFactories.set(ConstDependency, new NullFactory());
            compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());

            params.normalModuleFactory.plugin("parser", parser => { /**/ });
        });
    }
}

 

UseStrictPlugin

class UseStrictPlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            params.normalModuleFactory.plugin("parser", (parser) => { /**/ });
        });
    }
}

 

RequireIncludePlugin

class RequireIncludePlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            compilation.dependencyFactories.set(RequireIncludeDependency, normalModuleFactory);
            compilation.dependencyTemplates.set(RequireIncludeDependency, new RequireIncludeDependency.Template());
            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

 

RequireEnsurePlugin

class RequireEnsurePlugin {
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            compilation.dependencyFactories.set(RequireEnsureItemDependency, normalModuleFactory);
            compilation.dependencyTemplates.set(RequireEnsureItemDependency, new RequireEnsureItemDependency.Template());
            compilation.dependencyFactories.set(RequireEnsureDependency, new NullFactory());
            compilation.dependencyTemplates.set(RequireEnsureDependency, new RequireEnsureDependency.Template());
            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

 

RequireContextPlugin

class RequireContextPlugin {
    constructor(modulesDirectories, extensions, mainFiles) {
        if (!Array.isArray(modulesDirectories))
            throw new Error("modulesDirectories must be an array");
        if (!Array.isArray(extensions))
            throw new Error("extensions must be an array");
        this.modulesDirectories = modulesDirectories;
        this.extensions = extensions;
        this.mainFiles = mainFiles;
    }
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            const contextModuleFactory = params.contextModuleFactory;
            const normalModuleFactory = params.normalModuleFactory;

            compilation.dependencyFactories.set(RequireContextDependency, contextModuleFactory);
            compilation.dependencyTemplates.set(RequireContextDependency, new RequireContextDependency.Template());

            compilation.dependencyFactories.set(ContextElementDependency, normalModuleFactory);

            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
            params.contextModuleFactory.plugin("alternatives", (items, callback) => { /**/ });
            params.contextModuleFactory.plugin("alternatives", (items, callback) => { /**/ });
            params.contextModuleFactory.plugin("alternatives", (items, callback) => { /**/ });
        });
    }
}

  这个插件还有点内容,构造函数中3个参数分贝代表模块文件夹、默认扩展名、主入口文件名。

 

ImportPlugin

class ImportPlugin {
    constructor(options) {
        this.options = options;
    }
    apply(compiler) {
        const options = this.options;
        compiler.plugin("compilation", (compilation, params) => {
            const normalModuleFactory = params.normalModuleFactory;
            const contextModuleFactory = params.contextModuleFactory;
            compilation.dependencyFactories.set(ImportDependency, normalModuleFactory);
            compilation.dependencyTemplates.set(ImportDependency, new ImportDependency.Template());

            // more set...
            normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

 

SystemPlugin

class SystemPlugin {
    constructor(options) {
        this.options = options;
    }
    apply(compiler) {
        compiler.plugin("compilation", (compilation, params) => {
            params.normalModuleFactory.plugin("parser", (parser, parserOptions) => { /**/ });
        });
    }
}

 

  这一批的plugin基本上都是为normalModuleFactory注入parser事件,所以说编译行为还在准备中……

posted @ 2018-01-08 16:04  书生小龙  阅读(1307)  评论(0编辑  收藏  举报