Code coverage report for lib\dependencies\CommonJsRequireDependencyParserPlugin.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
 
 
 
1
1
1
1
1
1
1
 
1
484
 
 
1
 
1
484
484
41
41
41
41
 
484
30
30
30
30
30
30
 
484
3306
3306
3306
3306
40
40
160
160
 
 
 
40
3266
30
30
30
30
 
3236
3236
144
 
3092
 
3236
 
 
484
3396
3252
3252
3252
3252
3252
 
 
484
144
144
144
144
144
144
 
 
 
 
/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var ConstDependency = require("./ConstDependency");
var CommonJsRequireDependency = require("./CommonJsRequireDependency");
var CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
var RequireHeaderDependency = require("./RequireHeaderDependency");
var LocalModuleDependency = require("./LocalModuleDependency");
var ContextDependencyHelpers = require("./ContextDependencyHelpers");
var LocalModulesHelpers = require("./LocalModulesHelpers");
 
function CommonJsRequireDependencyParserPlugin(options) {
	this.options = options;
}
 
module.exports = CommonJsRequireDependencyParserPlugin;
 
CommonJsRequireDependencyParserPlugin.prototype.apply = function(parser) {
	var options = this.options;
	parser.plugin("expression require.cache", function(expr) {
		var dep = new ConstDependency("__webpack_require__.c", expr.range);
		dep.loc = expr.loc;
		this.state.current.addDependency(dep);
		return true;
	});
	parser.plugin("expression require", function(expr) {
		var dep = new CommonJsRequireContextDependency(options.unknownContextRequest, options.unknownContextRecursive, options.unknownContextRegExp, expr.range);
		dep.critical = options.unknownContextCritical && "require function is used in a way, in which dependencies cannot be statically extracted";
		dep.loc = expr.loc;
		dep.optional = !!this.scope.inTry;
		this.state.current.addDependency(dep);
		return true;
	});
	parser.plugin("call require", function(expr) {
		Iif(expr.arguments.length !== 1) return;
		var localModule;
		var param = this.evaluateExpression(expr.arguments[0]);
		if(param.isConditional()) {
			this.state.current.addDependency(new RequireHeaderDependency(expr.callee.range));
			param.options.forEach(function(param) {
				var result = this.applyPluginsBailResult("call require:commonjs:item", expr, param);
				Iif(result === undefined) {
					throw new Error("Cannot convert options with mixed known and unknown stuff");
				}
			}, this);
			return true;
		} else if(param.isString() && (localModule = LocalModulesHelpers.getLocalModule(this.state, param.string))) {
			var dep = new LocalModuleDependency(localModule, expr.range);
			dep.loc = expr.loc;
			this.state.current.addDependency(dep);
			return true;
		} else {
			var result = this.applyPluginsBailResult("call require:commonjs:item", expr, param);
			if(result === undefined) {
				this.applyPluginsBailResult("call require:commonjs:context", expr, param);
			} else {
				this.state.current.addDependency(new RequireHeaderDependency(expr.callee.range));
			}
			return true;
		}
	});
	parser.plugin("call require:commonjs:item", function(expr, param) {
		if(param.isString()) {
			var dep = new CommonJsRequireDependency(param.string, param.range);
			dep.loc = expr.loc;
			dep.optional = !!this.scope.inTry;
			this.state.current.addDependency(dep);
			return true;
		}
	});
	parser.plugin("call require:commonjs:context", function(expr, param) {
		var dep = ContextDependencyHelpers.create(CommonJsRequireContextDependency, expr.range, param, expr, options);
		Iif(!dep) return;
		dep.loc = expr.loc;
		dep.optional = !!this.scope.inTry;
		this.state.current.addDependency(dep);
		return true;
	});
};