diff options
Diffstat (limited to 'node_modules/html-webpack-plugin/index.js')
-rw-r--r-- | node_modules/html-webpack-plugin/index.js | 652 |
1 files changed, 652 insertions, 0 deletions
diff --git a/node_modules/html-webpack-plugin/index.js b/node_modules/html-webpack-plugin/index.js new file mode 100644 index 000000000..40633a68b --- /dev/null +++ b/node_modules/html-webpack-plugin/index.js @@ -0,0 +1,652 @@ +'use strict'; +var vm = require('vm'); +var fs = require('fs'); +var _ = require('lodash'); +var Promise = require('bluebird'); +var path = require('path'); +var childCompiler = require('./lib/compiler.js'); +var prettyError = require('./lib/errors.js'); +var chunkSorter = require('./lib/chunksorter.js'); +Promise.promisifyAll(fs); + +function HtmlWebpackPlugin (options) { + // Default options + this.options = _.extend({ + template: path.join(__dirname, 'default_index.ejs'), + filename: 'index.html', + hash: false, + inject: true, + compile: true, + favicon: false, + minify: false, + cache: true, + showErrors: true, + chunks: 'all', + excludeChunks: [], + title: 'Webpack App', + xhtml: false + }, options); +} + +HtmlWebpackPlugin.prototype.apply = function (compiler) { + var self = this; + var isCompilationCached = false; + var compilationPromise; + + this.options.template = this.getFullTemplatePath(this.options.template, compiler.context); + + // convert absolute filename into relative so that webpack can + // generate it at correct location + var filename = this.options.filename; + if (path.resolve(filename) === path.normalize(filename)) { + this.options.filename = path.relative(compiler.options.output.path, filename); + } + + compiler.plugin('make', function (compilation, callback) { + // Compile the template (queued) + compilationPromise = childCompiler.compileTemplate(self.options.template, compiler.context, self.options.filename, compilation) + .catch(function (err) { + compilation.errors.push(prettyError(err, compiler.context).toString()); + return { + content: self.options.showErrors ? prettyError(err, compiler.context).toJsonHtml() : 'ERROR', + outputName: self.options.filename + }; + }) + .then(function (compilationResult) { + // If the compilation change didnt change the cache is valid + isCompilationCached = compilationResult.hash && self.childCompilerHash === compilationResult.hash; + self.childCompilerHash = compilationResult.hash; + self.childCompilationOutputName = compilationResult.outputName; + callback(); + return compilationResult.content; + }); + }); + + compiler.plugin('emit', function (compilation, callback) { + var applyPluginsAsyncWaterfall = self.applyPluginsAsyncWaterfall(compilation); + // Get all chunks + var allChunks = compilation.getStats().toJson().chunks; + // Filter chunks (options.chunks and options.excludeCHunks) + var chunks = self.filterChunks(allChunks, self.options.chunks, self.options.excludeChunks); + // Sort chunks + chunks = self.sortChunks(chunks, self.options.chunksSortMode); + // Let plugins alter the chunks and the chunk sorting + chunks = compilation.applyPluginsWaterfall('html-webpack-plugin-alter-chunks', chunks, { plugin: self }); + // Get assets + var assets = self.htmlWebpackPluginAssets(compilation, chunks); + // If this is a hot update compilation, move on! + // This solves a problem where an `index.html` file is generated for hot-update js files + // It only happens in Webpack 2, where hot updates are emitted separately before the full bundle + if (self.isHotUpdateCompilation(assets)) { + return callback(); + } + + // If the template and the assets did not change we don't have to emit the html + var assetJson = JSON.stringify(self.getAssetFiles(assets)); + if (isCompilationCached && self.options.cache && assetJson === self.assetJson) { + return callback(); + } else { + self.assetJson = assetJson; + } + + Promise.resolve() + // Favicon + .then(function () { + if (self.options.favicon) { + return self.addFileToAssets(self.options.favicon, compilation) + .then(function (faviconBasename) { + var publicPath = compilation.mainTemplate.getPublicPath({hash: compilation.hash}) || ''; + if (publicPath && publicPath.substr(-1) !== '/') { + publicPath += '/'; + } + assets.favicon = publicPath + faviconBasename; + }); + } + }) + // Wait for the compilation to finish + .then(function () { + return compilationPromise; + }) + .then(function (compiledTemplate) { + // Allow to use a custom function / string instead + if (self.options.templateContent !== undefined) { + return self.options.templateContent; + } + // Once everything is compiled evaluate the html factory + // and replace it with its content + return self.evaluateCompilationResult(compilation, compiledTemplate); + }) + // Allow plugins to make changes to the assets before invoking the template + // This only makes sense to use if `inject` is `false` + .then(function (compilationResult) { + return applyPluginsAsyncWaterfall('html-webpack-plugin-before-html-generation', false, { + assets: assets, + outputName: self.childCompilationOutputName, + plugin: self + }) + .then(function () { + return compilationResult; + }); + }) + // Execute the template + .then(function (compilationResult) { + // If the loader result is a function execute it to retrieve the html + // otherwise use the returned html + return typeof compilationResult !== 'function' + ? compilationResult + : self.executeTemplate(compilationResult, chunks, assets, compilation); + }) + // Allow plugins to change the html before assets are injected + .then(function (html) { + var pluginArgs = {html: html, assets: assets, plugin: self, outputName: self.childCompilationOutputName}; + return applyPluginsAsyncWaterfall('html-webpack-plugin-before-html-processing', true, pluginArgs); + }) + .then(function (result) { + var html = result.html; + var assets = result.assets; + var chunks = result.chunks; + // Prepare script and link tags + var assetTags = self.generateAssetTags(assets); + var pluginArgs = {head: assetTags.head, body: assetTags.body, plugin: self, chunks: chunks, outputName: self.childCompilationOutputName}; + // Allow plugins to change the assetTag definitions + return applyPluginsAsyncWaterfall('html-webpack-plugin-alter-asset-tags', true, pluginArgs) + .then(function (result) { + // Add the stylesheets, scripts and so on to the resulting html + return self.postProcessHtml(html, assets, { body: result.body, head: result.head }) + .then(function (html) { + return _.extend(result, {html: html, assets: assets}); + }); + }); + }) + // Allow plugins to change the html after assets are injected + .then(function (result) { + var html = result.html; + var assets = result.assets; + var pluginArgs = {html: html, assets: assets, plugin: self, outputName: self.childCompilationOutputName}; + return applyPluginsAsyncWaterfall('html-webpack-plugin-after-html-processing', true, pluginArgs) + .then(function (result) { + return result.html; + }); + }) + .catch(function (err) { + // In case anything went wrong the promise is resolved + // with the error message and an error is logged + compilation.errors.push(prettyError(err, compiler.context).toString()); + // Prevent caching + self.hash = null; + return self.options.showErrors ? prettyError(err, compiler.context).toHtml() : 'ERROR'; + }) + .then(function (html) { + // Replace the compilation result with the evaluated html code + compilation.assets[self.childCompilationOutputName] = { + source: function () { + return html; + }, + size: function () { + return html.length; + } + }; + }) + .then(function () { + // Let other plugins know that we are done: + return applyPluginsAsyncWaterfall('html-webpack-plugin-after-emit', false, { + html: compilation.assets[self.childCompilationOutputName], + outputName: self.childCompilationOutputName, + plugin: self + }).catch(function (err) { + console.error(err); + return null; + }).then(function () { + return null; + }); + }) + // Let webpack continue with it + .finally(function () { + callback(); + // Tell blue bird that we don't want to wait for callback. + // Fixes "Warning: a promise was created in a handler but none were returned from it" + // https://github.com/petkaantonov/bluebird/blob/master/docs/docs/warning-explanations.md#warning-a-promise-was-created-in-a-handler-but-none-were-returned-from-it + return null; + }); + }); +}; + +/** + * Evaluates the child compilation result + * Returns a promise + */ +HtmlWebpackPlugin.prototype.evaluateCompilationResult = function (compilation, source) { + if (!source) { + return Promise.reject('The child compilation didn\'t provide a result'); + } + + // The LibraryTemplatePlugin stores the template result in a local variable. + // To extract the result during the evaluation this part has to be removed. + source = source.replace('var HTML_WEBPACK_PLUGIN_RESULT =', ''); + var template = this.options.template.replace(/^.+!/, '').replace(/\?.+$/, ''); + var vmContext = vm.createContext(_.extend({HTML_WEBPACK_PLUGIN: true, require: require}, global)); + var vmScript = new vm.Script(source, {filename: template}); + // Evaluate code and cast to string + var newSource; + try { + newSource = vmScript.runInContext(vmContext); + } catch (e) { + return Promise.reject(e); + } + if (typeof newSource === 'object' && newSource.__esModule && newSource.default) { + newSource = newSource.default; + } + return typeof newSource === 'string' || typeof newSource === 'function' + ? Promise.resolve(newSource) + : Promise.reject('The loader "' + this.options.template + '" didn\'t return html.'); +}; + +/** + * Html post processing + * + * Returns a promise + */ +HtmlWebpackPlugin.prototype.executeTemplate = function (templateFunction, chunks, assets, compilation) { + var self = this; + return Promise.resolve() + // Template processing + .then(function () { + var templateParams = { + compilation: compilation, + webpack: compilation.getStats().toJson(), + webpackConfig: compilation.options, + htmlWebpackPlugin: { + files: assets, + options: self.options + } + }; + var html = ''; + try { + html = templateFunction(templateParams); + } catch (e) { + compilation.errors.push(new Error('Template execution failed: ' + e)); + return Promise.reject(e); + } + return html; + }); +}; + +/** + * Html post processing + * + * Returns a promise + */ +HtmlWebpackPlugin.prototype.postProcessHtml = function (html, assets, assetTags) { + var self = this; + if (typeof html !== 'string') { + return Promise.reject('Expected html to be a string but got ' + JSON.stringify(html)); + } + return Promise.resolve() + // Inject + .then(function () { + if (self.options.inject) { + return self.injectAssetsIntoHtml(html, assets, assetTags); + } else { + return html; + } + }) + // Minify + .then(function (html) { + if (self.options.minify) { + var minify = require('html-minifier').minify; + return minify(html, self.options.minify); + } + return html; + }); +}; + +/* + * Pushes the content of the given filename to the compilation assets + */ +HtmlWebpackPlugin.prototype.addFileToAssets = function (filename, compilation) { + filename = path.resolve(compilation.compiler.context, filename); + return Promise.props({ + size: fs.statAsync(filename), + source: fs.readFileAsync(filename) + }) + .catch(function () { + return Promise.reject(new Error('HtmlWebpackPlugin: could not load file ' + filename)); + }) + .then(function (results) { + var basename = path.basename(filename); + compilation.fileDependencies.push(filename); + compilation.assets[basename] = { + source: function () { + return results.source; + }, + size: function () { + return results.size.size; + } + }; + return basename; + }); +}; + +/** + * Helper to sort chunks + */ +HtmlWebpackPlugin.prototype.sortChunks = function (chunks, sortMode) { + // Sort mode auto by default: + if (typeof sortMode === 'undefined') { + sortMode = 'auto'; + } + // Custom function + if (typeof sortMode === 'function') { + return chunks.sort(sortMode); + } + // Disabled sorting: + if (sortMode === 'none') { + return chunkSorter.none(chunks); + } + // Check if the given sort mode is a valid chunkSorter sort mode + if (typeof chunkSorter[sortMode] !== 'undefined') { + return chunkSorter[sortMode](chunks); + } + throw new Error('"' + sortMode + '" is not a valid chunk sort mode'); +}; + +/** + * Return all chunks from the compilation result which match the exclude and include filters + */ +HtmlWebpackPlugin.prototype.filterChunks = function (chunks, includedChunks, excludedChunks) { + return chunks.filter(function (chunk) { + var chunkName = chunk.names[0]; + // This chunk doesn't have a name. This script can't handled it. + if (chunkName === undefined) { + return false; + } + // Skip if the chunk should be lazy loaded + if (!chunk.initial) { + return false; + } + // Skip if the chunks should be filtered and the given chunk was not added explicity + if (Array.isArray(includedChunks) && includedChunks.indexOf(chunkName) === -1) { + return false; + } + // Skip if the chunks should be filtered and the given chunk was excluded explicity + if (Array.isArray(excludedChunks) && excludedChunks.indexOf(chunkName) !== -1) { + return false; + } + // Add otherwise + return true; + }); +}; + +HtmlWebpackPlugin.prototype.isHotUpdateCompilation = function (assets) { + return assets.js.length && assets.js.every(function (name) { + return /\.hot-update\.js$/.test(name); + }); +}; + +HtmlWebpackPlugin.prototype.htmlWebpackPluginAssets = function (compilation, chunks) { + var self = this; + var webpackStatsJson = compilation.getStats().toJson(); + + // Use the configured public path or build a relative path + var publicPath = typeof compilation.options.output.publicPath !== 'undefined' + // If a hard coded public path exists use it + ? compilation.mainTemplate.getPublicPath({hash: webpackStatsJson.hash}) + // If no public path was set get a relative url path + : path.relative(path.resolve(compilation.options.output.path, path.dirname(self.childCompilationOutputName)), compilation.options.output.path) + .split(path.sep).join('/'); + + if (publicPath.length && publicPath.substr(-1, 1) !== '/') { + publicPath += '/'; + } + + var assets = { + // The public path + publicPath: publicPath, + // Will contain all js & css files by chunk + chunks: {}, + // Will contain all js files + js: [], + // Will contain all css files + css: [], + // Will contain the html5 appcache manifest files if it exists + manifest: Object.keys(compilation.assets).filter(function (assetFile) { + return path.extname(assetFile) === '.appcache'; + })[0] + }; + + // Append a hash for cache busting + if (this.options.hash) { + assets.manifest = self.appendHash(assets.manifest, webpackStatsJson.hash); + assets.favicon = self.appendHash(assets.favicon, webpackStatsJson.hash); + } + + for (var i = 0; i < chunks.length; i++) { + var chunk = chunks[i]; + var chunkName = chunk.names[0]; + + assets.chunks[chunkName] = {}; + + // Prepend the public path to all chunk files + var chunkFiles = [].concat(chunk.files).map(function (chunkFile) { + return publicPath + chunkFile; + }); + + // Append a hash for cache busting + if (this.options.hash) { + chunkFiles = chunkFiles.map(function (chunkFile) { + return self.appendHash(chunkFile, webpackStatsJson.hash); + }); + } + + // Webpack outputs an array for each chunk when using sourcemaps + // But we need only the entry file + var entry = chunkFiles[0]; + assets.chunks[chunkName].size = chunk.size; + assets.chunks[chunkName].entry = entry; + assets.chunks[chunkName].hash = chunk.hash; + assets.js.push(entry); + + // Gather all css files + var css = chunkFiles.filter(function (chunkFile) { + // Some chunks may contain content hash in their names, for ex. 'main.css?1e7cac4e4d8b52fd5ccd2541146ef03f'. + // We must proper handle such cases, so we use regexp testing here + return /.css($|\?)/.test(chunkFile); + }); + assets.chunks[chunkName].css = css; + assets.css = assets.css.concat(css); + } + + // Duplicate css assets can occur on occasion if more than one chunk + // requires the same css. + assets.css = _.uniq(assets.css); + + return assets; +}; + +/** + * Injects the assets into the given html string + */ +HtmlWebpackPlugin.prototype.generateAssetTags = function (assets) { + // Turn script files into script tags + var scripts = assets.js.map(function (scriptPath) { + return { + tagName: 'script', + closeTag: true, + attributes: { + type: 'text/javascript', + src: scriptPath + } + }; + }); + // Make tags self-closing in case of xhtml + var selfClosingTag = !!this.options.xhtml; + // Turn css files into link tags + var styles = assets.css.map(function (stylePath) { + return { + tagName: 'link', + selfClosingTag: selfClosingTag, + attributes: { + href: stylePath, + rel: 'stylesheet' + } + }; + }); + // Injection targets + var head = []; + var body = []; + + // If there is a favicon present, add it to the head + if (assets.favicon) { + head.push({ + tagName: 'link', + selfClosingTag: selfClosingTag, + attributes: { + rel: 'shortcut icon', + href: assets.favicon + } + }); + } + // Add styles to the head + head = head.concat(styles); + // Add scripts to body or head + if (this.options.inject === 'head') { + head = head.concat(scripts); + } else { + body = body.concat(scripts); + } + return {head: head, body: body}; +}; + +/** + * Injects the assets into the given html string + */ +HtmlWebpackPlugin.prototype.injectAssetsIntoHtml = function (html, assets, assetTags) { + var htmlRegExp = /(<html[^>]*>)/i; + var headRegExp = /(<\/head>)/i; + var bodyRegExp = /(<\/body>)/i; + var body = assetTags.body.map(this.createHtmlTag); + var head = assetTags.head.map(this.createHtmlTag); + + if (body.length) { + if (bodyRegExp.test(html)) { + // Append assets to body element + html = html.replace(bodyRegExp, function (match) { + return body.join('') + match; + }); + } else { + // Append scripts to the end of the file if no <body> element exists: + html += body.join(''); + } + } + + if (head.length) { + // Create a head tag if none exists + if (!headRegExp.test(html)) { + if (!htmlRegExp.test(html)) { + html = '<head></head>' + html; + } else { + html = html.replace(htmlRegExp, function (match) { + return match + '<head></head>'; + }); + } + } + + // Append assets to head element + html = html.replace(headRegExp, function (match) { + return head.join('') + match; + }); + } + + // Inject manifest into the opening html tag + if (assets.manifest) { + html = html.replace(/(<html[^>]*)(>)/i, function (match, start, end) { + // Append the manifest only if no manifest was specified + if (/\smanifest\s*=/.test(match)) { + return match; + } + return start + ' manifest="' + assets.manifest + '"' + end; + }); + } + return html; +}; + +/** + * Appends a cache busting hash + */ +HtmlWebpackPlugin.prototype.appendHash = function (url, hash) { + if (!url) { + return url; + } + return url + (url.indexOf('?') === -1 ? '?' : '&') + hash; +}; + +/** + * Turn a tag definition into a html string + */ +HtmlWebpackPlugin.prototype.createHtmlTag = function (tagDefinition) { + var attributes = Object.keys(tagDefinition.attributes || {}) + .filter(function (attributeName) { + return tagDefinition.attributes[attributeName] !== false; + }) + .map(function (attributeName) { + if (tagDefinition.attributes[attributeName] === true) { + return attributeName; + } + return attributeName + '="' + tagDefinition.attributes[attributeName] + '"'; + }); + // Backport of 3.x void tag definition + var voidTag = tagDefinition.voidTag !== undefined ? tagDefinition.voidTag : !tagDefinition.closeTag; + var selfClosingTag = tagDefinition.voidTag !== undefined ? tagDefinition.voidTag && this.options.xhtml : tagDefinition.selfClosingTag; + return '<' + [tagDefinition.tagName].concat(attributes).join(' ') + (selfClosingTag ? '/' : '') + '>' + + (tagDefinition.innerHTML || '') + + (voidTag ? '' : '</' + tagDefinition.tagName + '>'); +}; + +/** + * Helper to return the absolute template path with a fallback loader + */ +HtmlWebpackPlugin.prototype.getFullTemplatePath = function (template, context) { + // If the template doesn't use a loader use the lodash template loader + if (template.indexOf('!') === -1) { + template = require.resolve('./lib/loader.js') + '!' + path.resolve(context, template); + } + // Resolve template path + return template.replace( + /([!])([^/\\][^!?]+|[^/\\!?])($|\?[^!?\n]+$)/, + function (match, prefix, filepath, postfix) { + return prefix + path.resolve(filepath) + postfix; + }); +}; + +/** + * Helper to return a sorted unique array of all asset files out of the + * asset object + */ +HtmlWebpackPlugin.prototype.getAssetFiles = function (assets) { + var files = _.uniq(Object.keys(assets).filter(function (assetType) { + return assetType !== 'chunks' && assets[assetType]; + }).reduce(function (files, assetType) { + return files.concat(assets[assetType]); + }, [])); + files.sort(); + return files; +}; + +/** + * Helper to promisify compilation.applyPluginsAsyncWaterfall that returns + * a function that helps to merge given plugin arguments with processed ones + */ +HtmlWebpackPlugin.prototype.applyPluginsAsyncWaterfall = function (compilation) { + var promisedApplyPluginsAsyncWaterfall = Promise.promisify(compilation.applyPluginsAsyncWaterfall, {context: compilation}); + return function (eventName, requiresResult, pluginArgs) { + return promisedApplyPluginsAsyncWaterfall(eventName, pluginArgs) + .then(function (result) { + if (requiresResult && !result) { + compilation.warnings.push(new Error('Using ' + eventName + ' without returning a result is deprecated.')); + } + return _.extend(pluginArgs, result); + }); + }; +}; + +module.exports = HtmlWebpackPlugin; |