139 lines
4.7 KiB
JavaScript
139 lines
4.7 KiB
JavaScript
'use strict';
|
|
|
|
const toposort = require('toposort');
|
|
const _ = 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.
|
|
- For webpack < 4, 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).
|
|
- For webpack 4+ the see the chunkGroups param for parent-child relationships
|
|
|
|
@param {Array} chunks an array of ChunkGroups that has a getParents method.
|
|
Each ChunkGroup contains a list of chunks in order.
|
|
|
|
@return {Array} A topologically sorted version of the input chunks
|
|
*/
|
|
module.exports.dependency = (chunks, options, compilation) => {
|
|
const chunkGroups = compilation.chunkGroups;
|
|
if (!chunks) {
|
|
return chunks;
|
|
}
|
|
|
|
// We build a map (chunk-id -> chunk) for faster access during graph building.
|
|
const nodeMap = {};
|
|
|
|
chunks.forEach(chunk => {
|
|
nodeMap[chunk.id] = chunk;
|
|
});
|
|
|
|
// Next, we add an edge for each parent relationship into the graph
|
|
let edges = [];
|
|
|
|
if (chunkGroups) {
|
|
// Add an edge for each parent (parent -> child)
|
|
edges = chunkGroups.reduce((result, chunkGroup) => result.concat(
|
|
Array.from(chunkGroup.parentsIterable, parentGroup => [parentGroup, chunkGroup])
|
|
), []);
|
|
const sortedGroups = toposort.array(chunkGroups, edges);
|
|
// flatten chunkGroup into chunks
|
|
const sortedChunks = sortedGroups
|
|
.reduce((result, chunkGroup) => result.concat(chunkGroup.chunks), [])
|
|
.map(chunk => // use the chunk from the list passed in, since it may be a filtered list
|
|
nodeMap[chunk.id])
|
|
.filter((chunk, index, self) => {
|
|
// make sure exists (ie excluded chunks not in nodeMap)
|
|
const exists = !!chunk;
|
|
// make sure we have a unique list
|
|
const unique = self.indexOf(chunk) === index;
|
|
return exists && unique;
|
|
});
|
|
return sortedChunks;
|
|
} else {
|
|
// before webpack 4 there was no chunkGroups
|
|
chunks.forEach(chunk => {
|
|
if (chunk.parents) {
|
|
// Add an edge for each parent (parent -> child)
|
|
chunk.parents.forEach(parentId => {
|
|
// webpack2 chunk.parents are chunks instead of string id(s)
|
|
const 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 = chunks => 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 = chunks => chunks;
|
|
|
|
/**
|
|
* Sort manually by the chunks
|
|
* @param {Array} chunks the chunks to sort
|
|
* @return {Array} The sorted chunks
|
|
*/
|
|
module.exports.manual = (chunks, options) => {
|
|
const specifyChunks = options.chunks;
|
|
const chunksResult = [];
|
|
let filterResult = [];
|
|
if (Array.isArray(specifyChunks)) {
|
|
for (var i = 0; i < specifyChunks.length; i++) {
|
|
filterResult = chunks.filter(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;
|
|
}
|