switch to vuepress

1 files changed, 139 insertions, 0 deletions

diff --git a/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js b/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js
new file mode 100644
index 00000000..36b5c9a9
--- /dev/null
+++ b/node_modules/vuepress-html-webpack-plugin/lib/chunksorter.js
@@ -0,0 +1,139 @@
+'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;
+}