Code coverage report for lib\ModuleFilenameHelpers.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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
 
 
 
1
 
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 
1
1211
1211
 
 
1
2422
2422
 
 
1
1211
1211
1211
 
 
1
1211
193
193
193
193
193
 
1018
1018
1018
1018
1018
 
1211
1211
1211
1211
1211
1211
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1174
193
 
 
 
 
 
981
 
 
 
 
1027
 
 
 
 
 
1
447
447
447
1550
1550
1550
 
447
88
610
 
 
447
1550
61
24
37
1489
 
 
 
/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var ModuleFilenameHelpers = exports;
 
ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE = /\[all-?loaders\]\[resource\]/gi;
ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
ModuleFilenameHelpers.RESOURCE = "[resource]";
ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH = /\[abs(olute)?-?resource-?path\]/gi;
ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
ModuleFilenameHelpers.LOADERS = "[loaders]";
ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
ModuleFilenameHelpers.QUERY = "[query]";
ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
ModuleFilenameHelpers.ID = "[id]";
ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
ModuleFilenameHelpers.HASH = "[hash]";
ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
 
function getAfter(str, token) {
	var idx = str.indexOf(token);
	return idx < 0 ? "" : str.substr(idx);
}
 
function getBefore(str, token) {
	var idx = str.lastIndexOf(token);
	return idx < 0 ? "" : str.substr(0, idx);
}
 
function getHash(str) {
	var hash = require("crypto").createHash("md5");
	hash.update(str);
	return hash.digest("hex").substr(0, 4);
}
 
ModuleFilenameHelpers.createFilename = function createFilename(module, moduleFilenameTemplate, requestShortener) {
	if(typeof module === "string") {
		var shortIdentifier = requestShortener.shorten(module);
		var identifier = shortIdentifier;
		var moduleId = "";
		var absoluteResourcePath = module.split("!").pop();
		var hash = getHash(identifier);
	} else {
		var shortIdentifier = module.readableIdentifier(requestShortener);
		var identifier = requestShortener.shorten(module.identifier());
		var moduleId = module.id;
		var absoluteResourcePath = module.resourcePath || module.identifier().split("!").pop();
		var hash = getHash(identifier);
	}
	var resource = shortIdentifier.split("!").pop();
	var loaders = getBefore(shortIdentifier, "!");
	var allLoaders = getBefore(identifier, "!");
	var query = getAfter(resource, "?");
	var resourcePath = resource.substr(0, resource.length - query.length);
	return (moduleFilenameTemplate
		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, identifier)
		.replace(ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE, shortIdentifier)
		.replace(ModuleFilenameHelpers.REGEXP_RESOURCE, resource)
		.replace(ModuleFilenameHelpers.REGEXP_RESOURCE_PATH, resourcePath)
		.replace(ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH, absoluteResourcePath)
		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS, allLoaders)
		.replace(ModuleFilenameHelpers.REGEXP_LOADERS, loaders)
		.replace(ModuleFilenameHelpers.REGEXP_QUERY, query)
		.replace(ModuleFilenameHelpers.REGEXP_ID, moduleId)
		.replace(ModuleFilenameHelpers.REGEXP_HASH, hash)
	);
};
 
ModuleFilenameHelpers.createFooter = function createFooter(module, requestShortener) {
	if(typeof module === "string") {
		return [
			"/** WEBPACK FOOTER **",
			" ** " + requestShortener.shorten(module),
			" **/"
		].join("\n");
	} else {
		return [
			"/*****************",
			" ** WEBPACK FOOTER",
			" ** " + module.readableIdentifier(requestShortener),
			" ** module id = " + module.id,
			" ** module chunks = " + module.chunks.map(function(c) { return c.id; }).join(" "),
			" **/"
		].join("\n");
	}
};
 
ModuleFilenameHelpers.replaceDuplicates = function replaceDuplicates(array, fn, comparator) {
	var countMap = {};
	var posMap = {};
	array.forEach(function(item, idx) {
		countMap[item] = (countMap[item] || []);
		countMap[item].push(idx);
		posMap[item] = 0;
	});
	if(comparator) {
		Object.keys(countMap).forEach(function(item) {
			countMap[item].sort(comparator);
		});
	}
	return array.map(function(item, i) {
		if(countMap[item].length > 1) {
			if(comparator && countMap[item][0] === i)
				return item;
			return fn(item, i, posMap[item]++);
		} else return item;
	});
};