116 lines
3.5 KiB
JavaScript
116 lines
3.5 KiB
JavaScript
'use strict';
|
|
|
|
var toposort = require('toposort');
|
|
var _ = require('lodash');
|
|
|
|
/*
|
|
Sorts dependencies between chunks by their "parents" attribute.
|
|
|
|
This function sorts chunks based on their dependencies with each other.
|
|
The parent relation between chunks as generated by Webpack for each chunk
|
|
is used to define a directed (and hopefully acyclic) graph, which is then
|
|
topologically sorted in order to retrieve the correct order in which
|
|
chunks need to be embedded into HTML. A directed edge in this graph is
|
|
describing a "is parent of" relationship from a chunk to another (distinct)
|
|
chunk. Thus topological sorting orders chunks from bottom-layer chunks to
|
|
highest level chunks that use the lower-level chunks.
|
|
|
|
@param {Array} chunks an array of chunks as generated by the html-webpack-plugin.
|
|
It is assumed that each entry contains at least the properties "id"
|
|
(containing the chunk id) and "parents" (array containing the ids of the
|
|
parent chunks).
|
|
|
|
@return {Array} A topologically sorted version of the input chunks
|
|
*/
|
|
module.exports.dependency = function (chunks) {
|
|
if (!chunks) {
|
|
return chunks;
|
|
}
|
|
|
|
// We build a map (chunk-id -> chunk) for faster access during graph building.
|
|
var nodeMap = {};
|
|
|
|
chunks.forEach(function (chunk) {
|
|
nodeMap[chunk.id] = chunk;
|
|
});
|
|
|
|
// Next, we add an edge for each parent relationship into the graph
|
|
var edges = [];
|
|
|
|
chunks.forEach(function (chunk) {
|
|
if (chunk.parents) {
|
|
// Add an edge for each parent (parent -> child)
|
|
chunk.parents.forEach(function (parentId) {
|
|
// webpack2 chunk.parents are chunks instead of string id(s)
|
|
var parentChunk = _.isObject(parentId) ? parentId : nodeMap[parentId];
|
|
// If the parent chunk does not exist (e.g. because of an excluded chunk)
|
|
// we ignore that parent
|
|
if (parentChunk) {
|
|
edges.push([parentChunk, chunk]);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
// We now perform a topological sorting on the input chunks and built edges
|
|
return toposort.array(chunks, edges);
|
|
};
|
|
|
|
/**
|
|
* Sorts the chunks based on the chunk id.
|
|
*
|
|
* @param {Array} chunks the list of chunks to sort
|
|
* @return {Array} The sorted list of chunks
|
|
*/
|
|
module.exports.id = function (chunks) {
|
|
return chunks.sort(function orderEntryLast (a, b) {
|
|
if (a.entry !== b.entry) {
|
|
return b.entry ? 1 : -1;
|
|
} else {
|
|
return b.id - a.id;
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Performs identity mapping (no-sort).
|
|
* @param {Array} chunks the chunks to sort
|
|
* @return {Array} The sorted chunks
|
|
*/
|
|
module.exports.none = function (chunks) {
|
|
return chunks;
|
|
};
|
|
|
|
/**
|
|
* Sort manually by the chunks
|
|
* @param {Array} chunks the chunks to sort
|
|
* @return {Array} The sorted chunks
|
|
*/
|
|
module.exports.manual = function (chunks, specifyChunks) {
|
|
var chunksResult = [];
|
|
var filterResult = [];
|
|
if (Array.isArray(specifyChunks)) {
|
|
for (var i = 0; i < specifyChunks.length; i++) {
|
|
filterResult = chunks.filter(function (chunk) {
|
|
if (chunk.names[0] && chunk.names[0] === specifyChunks[i]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
filterResult.length > 0 && chunksResult.push(filterResult[0]);
|
|
}
|
|
}
|
|
return chunksResult;
|
|
};
|
|
|
|
/**
|
|
* Defines the default sorter.
|
|
*/
|
|
module.exports.auto = module.exports.id;
|
|
|
|
// In webpack 2 the ids have been flipped.
|
|
// Therefore the id sort doesn't work the same way as it did for webpack 1
|
|
// Luckily the dependency sort is working as expected
|
|
if (Number(require('webpack/package.json').version.split('.')[0]) > 1) {
|
|
module.exports.auto = module.exports.dependency;
|
|
}
|