analyzer.js
4.85 KB
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
'use strict';
var fs = require('fs');
var path = require('path');
var _ = require('lodash');
var gzipSize = require('gzip-size');
var Logger = require('./Logger');
var _require = require('../lib/tree'),
Folder = _require.Folder;
var _require2 = require('../lib/parseUtils'),
parseBundle = _require2.parseBundle;
var FILENAME_QUERY_REGEXP = /\?.*$/;
module.exports = {
getViewerData: getViewerData,
readStatsFromFile: readStatsFromFile
};
function getViewerData(bundleStats, bundleDir, opts) {
var _ref = opts || {},
_ref$logger = _ref.logger,
logger = _ref$logger === undefined ? new Logger() : _ref$logger;
// Sometimes all the information is located in `children` array (e.g. problem in #10)
if (_.isEmpty(bundleStats.assets) && !_.isEmpty(bundleStats.children)) {
bundleStats = bundleStats.children[0];
}
// Picking only `*.js` assets from bundle that has non-empty `chunks` array
bundleStats.assets = _.filter(bundleStats.assets, function (asset) {
// Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
// See #22
asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '');
return _.endsWith(asset.name, '.js') && !_.isEmpty(asset.chunks);
});
// Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
var parsedModuleSizes = null;
var bundlesSources = {};
var parsedModules = {};
if (bundleDir) {
for (var _iterator = bundleStats.assets, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref2;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref2 = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref2 = _i.value;
}
var statAsset = _ref2;
var assetFile = path.join(bundleDir, statAsset.name);
var bundleInfo = void 0;
try {
bundleInfo = parseBundle(assetFile);
} catch (err) {
bundleInfo = null;
}
if (bundleInfo) {
bundlesSources[statAsset.name] = bundleInfo.src;
_.assign(parsedModules, bundleInfo.modules);
} else {
logger.warn('\nCouldn\'t parse bundle asset "' + assetFile + '".\n' + 'Analyzer will use module sizes from stats file.\n');
parsedModules = null;
bundlesSources = null;
break;
}
}
if (parsedModules) {
parsedModuleSizes = _.mapValues(parsedModules, function (moduleSrc) {
return {
raw: moduleSrc.length,
gzip: gzipSize.sync(moduleSrc)
};
});
}
}
var assets = _.transform(bundleStats.assets, function (result, statAsset) {
var asset = result[statAsset.name] = _.pick(statAsset, 'size');
if (bundlesSources) {
asset.parsedSize = bundlesSources[statAsset.name].length;
asset.gzipSize = gzipSize.sync(bundlesSources[statAsset.name]);
}
// Picking modules from current bundle script
asset.modules = _(bundleStats.modules).filter(function (statModule) {
return assetHasModule(statAsset, statModule);
}).each(function (statModule) {
if (parsedModuleSizes) {
statModule.parsedSize = parsedModuleSizes[statModule.id].raw;
statModule.gzipSize = parsedModuleSizes[statModule.id].gzip;
}
});
asset.tree = createModulesTree(asset.modules);
}, {});
return _.transform(assets, function (result, asset, filename) {
result.push({
label: filename,
// Not using `asset.size` here provided by Webpack because it can be very confusing when `UglifyJsPlugin` is used.
// In this case all module sizes from stats file will represent unminified module sizes, but `asset.size` will
// be the size of minified bundle.
statSize: asset.tree.size,
parsedSize: asset.parsedSize,
gzipSize: asset.gzipSize,
groups: _.invokeMap(asset.tree.children, 'toChartData')
});
}, []);
}
function readStatsFromFile(filename) {
return JSON.parse(fs.readFileSync(filename, 'utf8'));
}
function assetHasModule(statAsset, statModule) {
return _.some(statModule.chunks, function (moduleChunk) {
return _.includes(statAsset.chunks, moduleChunk);
});
}
function createModulesTree(modules) {
var root = new Folder('.');
_.each(modules, function (module) {
var path = getModulePath(module.name);
if (path) {
root.addModuleByPath(path, module);
}
});
return root;
}
function getModulePath(path) {
var parsedPath = _
// Removing loaders from module path: they're joined by `!` and the last part is a raw module path
.last(path.split('!'))
// Splitting module path into parts
.split('/')
// Removing first `.`
.slice(1)
// Replacing `~` with `node_modules`
.map(function (part) {
return part === '~' ? 'node_modules' : part;
});
return parsedPath.length ? parsedPath : null;
}