const fs = require('fs');
|
const path = require('path');
|
|
const _ = require('lodash');
|
const gzipSize = require('gzip-size');
|
|
const Logger = require('./Logger');
|
const Folder = require('./tree/Folder').default;
|
const {parseBundle} = require('./parseUtils');
|
const {createAssetsFilter} = require('./utils');
|
|
const FILENAME_QUERY_REGEXP = /\?.*$/u;
|
const FILENAME_EXTENSIONS = /\.(js|mjs)$/iu;
|
|
module.exports = {
|
getViewerData,
|
readStatsFromFile
|
};
|
|
function getViewerData(bundleStats, bundleDir, opts) {
|
const {
|
logger = new Logger(),
|
excludeAssets = null
|
} = opts || {};
|
|
const isAssetIncluded = createAssetsFilter(excludeAssets);
|
|
// Sometimes all the information is located in `children` array (e.g. problem in #10)
|
if (_.isEmpty(bundleStats.assets) && !_.isEmpty(bundleStats.children)) {
|
const {children} = bundleStats;
|
bundleStats = bundleStats.children[0];
|
// Sometimes if there are additional child chunks produced add them as child assets,
|
// leave the 1st one as that is considered the 'root' asset.
|
for (let i = 1; i < children.length; i++) {
|
bundleStats.children[i].assets.forEach((asset) => {
|
asset.isChild = true;
|
bundleStats.assets.push(asset);
|
});
|
}
|
} else if (!_.isEmpty(bundleStats.children)) {
|
// Sometimes if there are additional child chunks produced add them as child assets
|
bundleStats.children.forEach((child) => {
|
child.assets.forEach((asset) => {
|
asset.isChild = true;
|
bundleStats.assets.push(asset);
|
});
|
});
|
}
|
|
// Picking only `*.js or *.mjs` assets from bundle that has non-empty `chunks` array
|
bundleStats.assets = _.filter(bundleStats.assets, 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 FILENAME_EXTENSIONS.test(asset.name) && !_.isEmpty(asset.chunks) && isAssetIncluded(asset.name);
|
});
|
|
// Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
|
let bundlesSources = null;
|
let parsedModules = null;
|
|
if (bundleDir) {
|
bundlesSources = {};
|
parsedModules = {};
|
|
for (const statAsset of bundleStats.assets) {
|
const assetFile = path.join(bundleDir, statAsset.name);
|
let bundleInfo;
|
|
try {
|
bundleInfo = parseBundle(assetFile);
|
} catch (err) {
|
const msg = (err.code === 'ENOENT') ? 'no such file' : err.message;
|
logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
|
continue;
|
}
|
|
bundlesSources[statAsset.name] = bundleInfo.src;
|
_.assign(parsedModules, bundleInfo.modules);
|
}
|
|
if (_.isEmpty(bundlesSources)) {
|
bundlesSources = null;
|
parsedModules = null;
|
logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n');
|
}
|
}
|
|
const assets = _.transform(bundleStats.assets, (result, statAsset) => {
|
// If asset is a childAsset, then calculate appropriate bundle modules by looking through stats.children
|
const assetBundles = statAsset.isChild ? getChildAssetBundles(bundleStats, statAsset.name) : bundleStats;
|
const modules = assetBundles ? getBundleModules(assetBundles) : [];
|
const asset = result[statAsset.name] = _.pick(statAsset, 'size');
|
|
if (bundlesSources && _.has(bundlesSources, statAsset.name)) {
|
asset.parsedSize = Buffer.byteLength(bundlesSources[statAsset.name]);
|
asset.gzipSize = gzipSize.sync(bundlesSources[statAsset.name]);
|
}
|
|
// Picking modules from current bundle script
|
asset.modules = _(modules)
|
.filter(statModule => assetHasModule(statAsset, statModule))
|
.each(statModule => {
|
if (parsedModules) {
|
statModule.parsedSrc = parsedModules[statModule.id];
|
}
|
});
|
|
asset.tree = createModulesTree(asset.modules);
|
}, {});
|
|
return _.transform(assets, (result, asset, filename) => {
|
result.push({
|
label: filename,
|
isAsset: true,
|
// 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.
|
// Using `asset.size` only if current asset doesn't contain any modules (resulting size equals 0)
|
statSize: asset.tree.size || asset.size,
|
parsedSize: asset.parsedSize,
|
gzipSize: asset.gzipSize,
|
groups: _.invokeMap(asset.tree.children, 'toChartData')
|
});
|
}, []);
|
}
|
|
function readStatsFromFile(filename) {
|
return JSON.parse(
|
fs.readFileSync(filename, 'utf8')
|
);
|
}
|
|
function getChildAssetBundles(bundleStats, assetName) {
|
return _.find(bundleStats.children, (c) =>
|
_(c.assetsByChunkName)
|
.values()
|
.flatten()
|
.includes(assetName)
|
);
|
}
|
|
function getBundleModules(bundleStats) {
|
return _(bundleStats.chunks)
|
.map('modules')
|
.concat(bundleStats.modules)
|
.compact()
|
.flatten()
|
.uniqBy('id')
|
.value();
|
}
|
|
function assetHasModule(statAsset, statModule) {
|
// Checking if this module is the part of asset chunks
|
return _.some(statModule.chunks, moduleChunk =>
|
_.includes(statAsset.chunks, moduleChunk)
|
);
|
}
|
|
function createModulesTree(modules) {
|
const root = new Folder('.');
|
|
_.each(modules, module => root.addModule(module));
|
root.mergeNestedFolders();
|
|
return root;
|
}
|
