mirror of
https://github.com/idanoo/GoScrobble.git
synced 2024-11-25 09:55:15 +00:00
484 lines
20 KiB
JavaScript
484 lines
20 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _webpack = _interopRequireWildcard(require("webpack"));
|
|
|
|
var _schemaUtils = _interopRequireDefault(require("schema-utils"));
|
|
|
|
var _CssModuleFactory = _interopRequireDefault(require("./CssModuleFactory"));
|
|
|
|
var _CssDependencyTemplate = _interopRequireDefault(require("./CssDependencyTemplate"));
|
|
|
|
var _CssDependency = _interopRequireDefault(require("./CssDependency"));
|
|
|
|
var _pluginOptions = _interopRequireDefault(require("./plugin-options.json"));
|
|
|
|
var _utils = require("./utils");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
/* eslint-disable class-methods-use-this */
|
|
// webpack 5 exposes the sources property to ensure the right version of webpack-sources is used
|
|
const {
|
|
ConcatSource,
|
|
SourceMapSource,
|
|
OriginalSource
|
|
} = // eslint-disable-next-line global-require
|
|
_webpack.default.sources || require('webpack-sources');
|
|
|
|
const {
|
|
Template,
|
|
util: {
|
|
createHash
|
|
}
|
|
} = _webpack.default;
|
|
const isWebpack4 = _webpack.version[0] === '4';
|
|
const pluginName = 'mini-css-extract-plugin';
|
|
const REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/i;
|
|
const REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/i;
|
|
const REGEXP_NAME = /\[name\]/i;
|
|
const REGEXP_PLACEHOLDERS = /\[(name|id|chunkhash)\]/g;
|
|
const DEFAULT_FILENAME = '[name].css';
|
|
|
|
class MiniCssExtractPlugin {
|
|
constructor(options = {}) {
|
|
(0, _schemaUtils.default)(_pluginOptions.default, options, 'Mini CSS Extract Plugin');
|
|
this.options = Object.assign({
|
|
filename: DEFAULT_FILENAME,
|
|
moduleFilename: () => this.options.filename || DEFAULT_FILENAME,
|
|
ignoreOrder: false
|
|
}, options);
|
|
|
|
if (!this.options.chunkFilename) {
|
|
const {
|
|
filename
|
|
} = this.options; // Anything changing depending on chunk is fine
|
|
|
|
if (filename.match(REGEXP_PLACEHOLDERS)) {
|
|
this.options.chunkFilename = filename;
|
|
} else {
|
|
// Elsewise prefix '[id].' in front of the basename to make it changing
|
|
this.options.chunkFilename = filename.replace(/(^|\/)([^/]*(?:\?|$))/, '$1[id].$2');
|
|
}
|
|
}
|
|
|
|
if (!isWebpack4 && 'hmr' in this.options) {
|
|
throw new Error("The 'hmr' option doesn't exist for the mini-css-extract-plugin when using webpack 5 (it's automatically determined)");
|
|
}
|
|
}
|
|
/** @param {import("webpack").Compiler} compiler */
|
|
|
|
|
|
apply(compiler) {
|
|
if (!isWebpack4) {
|
|
const {
|
|
splitChunks
|
|
} = compiler.options.optimization;
|
|
|
|
if (splitChunks) {
|
|
if (splitChunks.defaultSizeTypes.includes('...')) {
|
|
splitChunks.defaultSizeTypes.push(_utils.MODULE_TYPE);
|
|
}
|
|
}
|
|
}
|
|
|
|
compiler.hooks.thisCompilation.tap(pluginName, compilation => {
|
|
compilation.dependencyFactories.set(_CssDependency.default, new _CssModuleFactory.default());
|
|
compilation.dependencyTemplates.set(_CssDependency.default, new _CssDependencyTemplate.default());
|
|
|
|
if (isWebpack4) {
|
|
compilation.mainTemplate.hooks.renderManifest.tap(pluginName, (result, {
|
|
chunk
|
|
}) => {
|
|
const {
|
|
chunkGraph
|
|
} = compilation;
|
|
const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
|
|
|
|
const filenameTemplate = chunk.filenameTemplate || (({
|
|
chunk: chunkData
|
|
}) => this.options.moduleFilename(chunkData));
|
|
|
|
if (renderedModules.length > 0) {
|
|
result.push({
|
|
render: () => this.renderContentAsset(compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
|
|
filenameTemplate,
|
|
pathOptions: {
|
|
chunk,
|
|
contentHashType: _utils.MODULE_TYPE
|
|
},
|
|
identifier: `${pluginName}.${chunk.id}`,
|
|
hash: chunk.contentHash[_utils.MODULE_TYPE]
|
|
});
|
|
}
|
|
});
|
|
compilation.chunkTemplate.hooks.renderManifest.tap(pluginName, (result, {
|
|
chunk
|
|
}) => {
|
|
const {
|
|
chunkGraph
|
|
} = compilation;
|
|
const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
|
|
const filenameTemplate = chunk.filenameTemplate || this.options.chunkFilename;
|
|
|
|
if (renderedModules.length > 0) {
|
|
result.push({
|
|
render: () => this.renderContentAsset(compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
|
|
filenameTemplate,
|
|
pathOptions: {
|
|
chunk,
|
|
contentHashType: _utils.MODULE_TYPE
|
|
},
|
|
identifier: `${pluginName}.${chunk.id}`,
|
|
hash: chunk.contentHash[_utils.MODULE_TYPE]
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
compilation.hooks.renderManifest.tap(pluginName, (result, {
|
|
chunk
|
|
}) => {
|
|
const {
|
|
chunkGraph
|
|
} = compilation; // We don't need hot update chunks for css
|
|
// We will use the real asset instead to update
|
|
|
|
if (chunk instanceof _webpack.default.HotUpdateChunk) return;
|
|
const renderedModules = Array.from(this.getChunkModules(chunk, chunkGraph)).filter(module => module.type === _utils.MODULE_TYPE);
|
|
const filenameTemplate = chunk.canBeInitial() ? ({
|
|
chunk: chunkData
|
|
}) => this.options.moduleFilename(chunkData) : this.options.chunkFilename;
|
|
|
|
if (renderedModules.length > 0) {
|
|
result.push({
|
|
render: () => this.renderContentAsset(compilation, chunk, renderedModules, compilation.runtimeTemplate.requestShortener),
|
|
filenameTemplate,
|
|
pathOptions: {
|
|
chunk,
|
|
contentHashType: _utils.MODULE_TYPE
|
|
},
|
|
identifier: `${pluginName}.${chunk.id}`,
|
|
hash: chunk.contentHash[_utils.MODULE_TYPE]
|
|
});
|
|
}
|
|
});
|
|
}
|
|
/*
|
|
* For webpack 5 this will be unneeded once the logic uses a RuntimeModule
|
|
* as the content of runtime modules is hashed and added to the chunk hash automatically
|
|
* */
|
|
|
|
|
|
if (isWebpack4) {
|
|
compilation.mainTemplate.hooks.hashForChunk.tap(pluginName, (hash, chunk) => {
|
|
const {
|
|
chunkFilename
|
|
} = this.options;
|
|
|
|
if (REGEXP_CHUNKHASH.test(chunkFilename)) {
|
|
hash.update(JSON.stringify(chunk.getChunkMaps(true).hash));
|
|
}
|
|
|
|
if (REGEXP_CONTENTHASH.test(chunkFilename)) {
|
|
hash.update(JSON.stringify(chunk.getChunkMaps(true).contentHash[_utils.MODULE_TYPE] || {}));
|
|
}
|
|
|
|
if (REGEXP_NAME.test(chunkFilename)) {
|
|
hash.update(JSON.stringify(chunk.getChunkMaps(true).name));
|
|
}
|
|
});
|
|
}
|
|
|
|
compilation.hooks.contentHash.tap(pluginName, chunk => {
|
|
const {
|
|
outputOptions,
|
|
chunkGraph
|
|
} = compilation;
|
|
const {
|
|
hashFunction,
|
|
hashDigest,
|
|
hashDigestLength
|
|
} = outputOptions;
|
|
const hash = createHash(hashFunction);
|
|
|
|
for (const m of this.getChunkModules(chunk, chunkGraph)) {
|
|
if (m.type === _utils.MODULE_TYPE) {
|
|
m.updateHash(hash, {
|
|
chunkGraph
|
|
});
|
|
}
|
|
}
|
|
|
|
const {
|
|
contentHash
|
|
} = chunk;
|
|
contentHash[_utils.MODULE_TYPE] = hash.digest(hashDigest).substring(0, hashDigestLength);
|
|
});
|
|
const {
|
|
mainTemplate
|
|
} = compilation;
|
|
|
|
if (isWebpack4) {
|
|
mainTemplate.hooks.localVars.tap(pluginName, (source, chunk) => {
|
|
const chunkMap = this.getCssChunkObject(chunk, compilation);
|
|
|
|
if (Object.keys(chunkMap).length > 0) {
|
|
return Template.asString([source, '', '// object to store loaded CSS chunks', 'var installedCssChunks = {', Template.indent(chunk.ids.map(id => `${JSON.stringify(id)}: 0`).join(',\n')), '};']);
|
|
}
|
|
|
|
return source;
|
|
});
|
|
mainTemplate.hooks.requireEnsure.tap(pluginName, (source, chunk, hash) => {
|
|
const chunkMap = this.getCssChunkObject(chunk, compilation);
|
|
|
|
if (Object.keys(chunkMap).length > 0) {
|
|
const chunkMaps = chunk.getChunkMaps();
|
|
const {
|
|
crossOriginLoading
|
|
} = mainTemplate.outputOptions;
|
|
const linkHrefPath = mainTemplate.getAssetPath(JSON.stringify(this.options.chunkFilename), {
|
|
hash: `" + ${mainTemplate.renderCurrentHashCode(hash)} + "`,
|
|
hashWithLength: length => `" + ${mainTemplate.renderCurrentHashCode(hash, length)} + "`,
|
|
chunk: {
|
|
id: '" + chunkId + "',
|
|
hash: `" + ${JSON.stringify(chunkMaps.hash)}[chunkId] + "`,
|
|
|
|
hashWithLength(length) {
|
|
const shortChunkHashMap = Object.create(null);
|
|
|
|
for (const chunkId of Object.keys(chunkMaps.hash)) {
|
|
if (typeof chunkMaps.hash[chunkId] === 'string') {
|
|
shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substring(0, length);
|
|
}
|
|
}
|
|
|
|
return `" + ${JSON.stringify(shortChunkHashMap)}[chunkId] + "`;
|
|
},
|
|
|
|
contentHash: {
|
|
[_utils.MODULE_TYPE]: `" + ${JSON.stringify(chunkMaps.contentHash[_utils.MODULE_TYPE])}[chunkId] + "`
|
|
},
|
|
contentHashWithLength: {
|
|
[_utils.MODULE_TYPE]: length => {
|
|
const shortContentHashMap = {};
|
|
const contentHash = chunkMaps.contentHash[_utils.MODULE_TYPE];
|
|
|
|
for (const chunkId of Object.keys(contentHash)) {
|
|
if (typeof contentHash[chunkId] === 'string') {
|
|
shortContentHashMap[chunkId] = contentHash[chunkId].substring(0, length);
|
|
}
|
|
}
|
|
|
|
return `" + ${JSON.stringify(shortContentHashMap)}[chunkId] + "`;
|
|
}
|
|
},
|
|
name: `" + (${JSON.stringify(chunkMaps.name)}[chunkId]||chunkId) + "`
|
|
},
|
|
contentHashType: _utils.MODULE_TYPE
|
|
});
|
|
return Template.asString([source, '', `// ${pluginName} CSS loading`, `var cssChunks = ${JSON.stringify(chunkMap)};`, 'if(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);', 'else if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {', Template.indent(['promises.push(installedCssChunks[chunkId] = new Promise(function(resolve, reject) {', Template.indent([`var href = ${linkHrefPath};`, `var fullhref = ${mainTemplate.requireFn}.p + href;`, 'var existingLinkTags = document.getElementsByTagName("link");', 'for(var i = 0; i < existingLinkTags.length; i++) {', Template.indent(['var tag = existingLinkTags[i];', 'var dataHref = tag.getAttribute("data-href") || tag.getAttribute("href");', 'if(tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return resolve();']), '}', 'var existingStyleTags = document.getElementsByTagName("style");', 'for(var i = 0; i < existingStyleTags.length; i++) {', Template.indent(['var tag = existingStyleTags[i];', 'var dataHref = tag.getAttribute("data-href");', 'if(dataHref === href || dataHref === fullhref) return resolve();']), '}', 'var linkTag = document.createElement("link");', 'linkTag.rel = "stylesheet";', 'linkTag.type = "text/css";', 'linkTag.onload = resolve;', 'linkTag.onerror = function(event) {', Template.indent(['var request = event && event.target && event.target.src || fullhref;', 'var err = new Error("Loading CSS chunk " + chunkId + " failed.\\n(" + request + ")");', 'err.code = "CSS_CHUNK_LOAD_FAILED";', 'err.request = request;', 'delete installedCssChunks[chunkId]', 'linkTag.parentNode.removeChild(linkTag)', 'reject(err);']), '};', 'linkTag.href = fullhref;', crossOriginLoading ? Template.asString([`if (linkTag.href.indexOf(window.location.origin + '/') !== 0) {`, Template.indent(`linkTag.crossOrigin = ${JSON.stringify(crossOriginLoading)};`), '}']) : '', 'var head = document.getElementsByTagName("head")[0];', 'head.appendChild(linkTag);']), '}).then(function() {', Template.indent(['installedCssChunks[chunkId] = 0;']), '}));']), '}']);
|
|
}
|
|
|
|
return source;
|
|
});
|
|
} else {
|
|
const enabledChunks = new WeakSet();
|
|
|
|
const handler = (chunk, set) => {
|
|
if (enabledChunks.has(chunk)) return;
|
|
enabledChunks.add(chunk); // eslint-disable-next-line global-require
|
|
|
|
const CssLoadingRuntimeModule = require('./CssLoadingRuntimeModule');
|
|
|
|
set.add(_webpack.default.RuntimeGlobals.publicPath);
|
|
compilation.addRuntimeModule(chunk, new _webpack.default.runtime.GetChunkFilenameRuntimeModule(_utils.MODULE_TYPE, 'mini-css', `${_webpack.default.RuntimeGlobals.require}.miniCssF`, referencedChunk => referencedChunk.canBeInitial() ? ({
|
|
chunk: chunkData
|
|
}) => this.options.moduleFilename(chunkData) : this.options.chunkFilename, true));
|
|
compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
|
|
};
|
|
|
|
compilation.hooks.runtimeRequirementInTree.for(_webpack.default.RuntimeGlobals.ensureChunkHandlers).tap(pluginName, handler);
|
|
compilation.hooks.runtimeRequirementInTree.for(_webpack.default.RuntimeGlobals.hmrDownloadUpdateHandlers).tap(pluginName, handler);
|
|
}
|
|
});
|
|
}
|
|
|
|
getChunkModules(chunk, chunkGraph) {
|
|
return typeof chunkGraph !== 'undefined' ? chunkGraph.getOrderedChunkModulesIterable(chunk, _utils.compareModulesByIdentifier) : chunk.modulesIterable;
|
|
}
|
|
|
|
getCssChunkObject(mainChunk, compilation) {
|
|
const obj = {};
|
|
const {
|
|
chunkGraph
|
|
} = compilation;
|
|
|
|
for (const chunk of mainChunk.getAllAsyncChunks()) {
|
|
for (const module of this.getChunkModules(chunk, chunkGraph)) {
|
|
if (module.type === _utils.MODULE_TYPE) {
|
|
obj[chunk.id] = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
renderContentAsset(compilation, chunk, modules, requestShortener) {
|
|
let usedModules;
|
|
const [chunkGroup] = chunk.groupsIterable;
|
|
const moduleIndexFunctionName = typeof compilation.chunkGraph !== 'undefined' ? 'getModulePostOrderIndex' : 'getModuleIndex2';
|
|
|
|
if (typeof chunkGroup[moduleIndexFunctionName] === 'function') {
|
|
// Store dependencies for modules
|
|
const moduleDependencies = new Map(modules.map(m => [m, new Set()]));
|
|
const moduleDependenciesReasons = new Map(modules.map(m => [m, new Map()])); // Get ordered list of modules per chunk group
|
|
// This loop also gathers dependencies from the ordered lists
|
|
// Lists are in reverse order to allow to use Array.pop()
|
|
|
|
const modulesByChunkGroup = Array.from(chunk.groupsIterable, cg => {
|
|
const sortedModules = modules.map(m => {
|
|
return {
|
|
module: m,
|
|
index: cg[moduleIndexFunctionName](m)
|
|
};
|
|
}) // eslint-disable-next-line no-undefined
|
|
.filter(item => item.index !== undefined).sort((a, b) => b.index - a.index).map(item => item.module);
|
|
|
|
for (let i = 0; i < sortedModules.length; i++) {
|
|
const set = moduleDependencies.get(sortedModules[i]);
|
|
const reasons = moduleDependenciesReasons.get(sortedModules[i]);
|
|
|
|
for (let j = i + 1; j < sortedModules.length; j++) {
|
|
const module = sortedModules[j];
|
|
set.add(module);
|
|
const reason = reasons.get(module) || new Set();
|
|
reason.add(cg);
|
|
reasons.set(module, reason);
|
|
}
|
|
}
|
|
|
|
return sortedModules;
|
|
}); // set with already included modules in correct order
|
|
|
|
usedModules = new Set();
|
|
|
|
const unusedModulesFilter = m => !usedModules.has(m);
|
|
|
|
while (usedModules.size < modules.length) {
|
|
let success = false;
|
|
let bestMatch;
|
|
let bestMatchDeps; // get first module where dependencies are fulfilled
|
|
|
|
for (const list of modulesByChunkGroup) {
|
|
// skip and remove already added modules
|
|
while (list.length > 0 && usedModules.has(list[list.length - 1])) {
|
|
list.pop();
|
|
} // skip empty lists
|
|
|
|
|
|
if (list.length !== 0) {
|
|
const module = list[list.length - 1];
|
|
const deps = moduleDependencies.get(module); // determine dependencies that are not yet included
|
|
|
|
const failedDeps = Array.from(deps).filter(unusedModulesFilter); // store best match for fallback behavior
|
|
|
|
if (!bestMatchDeps || bestMatchDeps.length > failedDeps.length) {
|
|
bestMatch = list;
|
|
bestMatchDeps = failedDeps;
|
|
}
|
|
|
|
if (failedDeps.length === 0) {
|
|
// use this module and remove it from list
|
|
usedModules.add(list.pop());
|
|
success = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!success) {
|
|
// no module found => there is a conflict
|
|
// use list with fewest failed deps
|
|
// and emit a warning
|
|
const fallbackModule = bestMatch.pop();
|
|
|
|
if (!this.options.ignoreOrder) {
|
|
const reasons = moduleDependenciesReasons.get(fallbackModule);
|
|
compilation.warnings.push(new Error([`chunk ${chunk.name || chunk.id} [${pluginName}]`, 'Conflicting order. Following module has been added:', ` * ${fallbackModule.readableIdentifier(requestShortener)}`, 'despite it was not able to fulfill desired ordering with these modules:', ...bestMatchDeps.map(m => {
|
|
const goodReasonsMap = moduleDependenciesReasons.get(m);
|
|
const goodReasons = goodReasonsMap && goodReasonsMap.get(fallbackModule);
|
|
const failedChunkGroups = Array.from(reasons.get(m), cg => cg.name).join(', ');
|
|
const goodChunkGroups = goodReasons && Array.from(goodReasons, cg => cg.name).join(', ');
|
|
return [` * ${m.readableIdentifier(requestShortener)}`, ` - couldn't fulfill desired order of chunk group(s) ${failedChunkGroups}`, goodChunkGroups && ` - while fulfilling desired order of chunk group(s) ${goodChunkGroups}`].filter(Boolean).join('\n');
|
|
})].join('\n')));
|
|
}
|
|
|
|
usedModules.add(fallbackModule);
|
|
}
|
|
}
|
|
} else {
|
|
// fallback for older webpack versions
|
|
// (to avoid a breaking change)
|
|
// TODO remove this in next major version
|
|
// and increase minimum webpack version to 4.12.0
|
|
modules.sort((a, b) => a.index2 - b.index2);
|
|
usedModules = modules;
|
|
}
|
|
|
|
const source = new ConcatSource();
|
|
const externalsSource = new ConcatSource();
|
|
|
|
for (const m of usedModules) {
|
|
if (/^@import url/.test(m.content)) {
|
|
// HACK for IE
|
|
// http://stackoverflow.com/a/14676665/1458162
|
|
let {
|
|
content
|
|
} = m;
|
|
|
|
if (m.media) {
|
|
// insert media into the @import
|
|
// this is rar
|
|
// TODO improve this and parse the CSS to support multiple medias
|
|
content = content.replace(/;|\s*$/, m.media);
|
|
}
|
|
|
|
externalsSource.add(content);
|
|
externalsSource.add('\n');
|
|
} else {
|
|
if (m.media) {
|
|
source.add(`@media ${m.media} {\n`);
|
|
}
|
|
|
|
if (m.sourceMap) {
|
|
source.add(new SourceMapSource(m.content, m.readableIdentifier(requestShortener), m.sourceMap));
|
|
} else {
|
|
source.add(new OriginalSource(m.content, m.readableIdentifier(requestShortener)));
|
|
}
|
|
|
|
source.add('\n');
|
|
|
|
if (m.media) {
|
|
source.add('}\n');
|
|
}
|
|
}
|
|
}
|
|
|
|
return new ConcatSource(externalsSource, source);
|
|
}
|
|
|
|
}
|
|
|
|
MiniCssExtractPlugin.loader = require.resolve('./loader');
|
|
var _default = MiniCssExtractPlugin;
|
|
exports.default = _default; |