module.exports = function (content) {
var self = this;
self.cacheable && this.cacheable();
if (!self.emitFile) throw new Error('emitFile is required from module system');
if (!self.async) throw new Error('async is required');
var callback = self.async();
var query = loaderUtils.parseQuery(self.query);
var pathPrefix = loaderUtils.interpolateName(self, query.outputFilePrefix, {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
});
var fileHash = loaderUtils.interpolateName(self, '[hash]', {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
});
var cacheFile = pathPrefix + '.cache';
faviconPersitenceCache.loadIconsFromDiskCache(self, query, cacheFile, fileHash, function (err, cachedResult) {
if (err) return callback(err);
if (cachedResult) {
return callback(null, 'module.exports = ' + JSON.stringify(cachedResult));
}
// Generate icons
generateIcons(self, content, pathPrefix, query, function (err, iconResult) {
if (err) return callback(err);
faviconPersitenceCache.emitCacheInformationFile(self, query, cacheFile, fileHash, iconResult);
callback(null, 'module.exports = ' + JSON.stringify(iconResult));
});
});
};
function getExtractedSVG(svgStr, query) {
// interpolate hashes in classPrefix
if(!!query && !!query.classPrefix) {
const name = query.classPrefix === true ? '__[hash:base64:7]__' : query.classPrefix;
query.classPrefix = loaderUtils.interpolateName({}, name, {content: svgStr});
}
if (!!query && !!query.idPrefix) {
const id_name = query.idPrefix === true ? '__[hash:base64:7]__' : query.idPrefix;
query.idPrefix = loaderUtils.interpolateName({}, id_name, {content: svgStr});
}
// Clean-up XML crusts like comments and doctype, etc.
var tokens;
var cleanedUp = regexSequences.reduce(function (prev, regexSequence) {
return ''.replace.apply(prev, regexSequence);
}, svgStr).trim();
// Tokenize and filter attributes using `simpleHTMLTokenizer.tokenize(source)`.
try {
tokens = tokenize(cleanedUp);
} catch (e) {
// If tokenization has failed, return earlier with cleaned-up string
console.warn('svg-inline-loader: Tokenization has failed, please check SVG is correct.');
return cleanedUp;
}
// If the token is <svg> start-tag, then remove width and height attributes.
return generate(transformer.runTransform(tokens, query));
}
module.exports = function getLocalIdent(
context,
localIdentName,
localName,
options
) {
// Use the filename or folder name, based on some uses the index.js / index.module.(css|scss|sass) project style
const fileNameOrFolder = context.resourcePath.match(
/index\.module\.(css|scss|sass)$/
)
? '[folder]'
: '[name]';
// Create a hash based on a the file location and class name. Will be unique across a project, and close to globally unique.
const hash = loaderUtils.getHashDigest(
path.posix.relative(context.rootContext, context.resourcePath) + localName,
'md5',
'base64',
5
);
// Use loaderUtils to find the file or folder name
const className = loaderUtils.interpolateName(
context,
fileNameOrFolder + '_' + localName + '__' + hash,
options
);
// remove the .module that appears in every classname when based on the file.
return className.replace('.module_', '_');
};
module.exports = function(content) {
var callback = this.async();
this.cacheable && this.cacheable();
this.value = content;
var config = Object.assign({
extensions: ['.css'],
resolveUrls: true,
context: this.context
}, loaderUtils.getLoaderConfig(this, 'cssConcat'));
var url = loaderUtils.interpolateName(this, '[path][name].[ext]', {
context: this.context,
content: content
});
try {
var result = parseImports(path.join(this.context, url), content, config);
var cssAsString = JSON.stringify(result.css);
cssAsString = cssAsString.replace(/___CSS_LOADER_URL___([0-9]+)___/g, function (match, id) {
return 'url(\\"" + require("' + result.urls[id] + '") + "\\")';
});
callback(null, "module.exports = " + cssAsString);
} catch (err) {
callback(err);
}
};
module.exports = function(content) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
var limit = (this.options && this.options.url && this.options.url.dataUrlLimit) || 0;
if (query.limit) limit = parseInt(query.limit, 10);
var mimetype = query.mimetype ||
query.minetype ||
mime.lookup(this.resourcePath);
// Use data url
if (limit <= 0 || content.length < limit) {
return "module.exports = " + JSON.stringify("data:" + (mimetype ? mimetype + ";" : "") + "base64," + content.toString("base64"));
// Use file-loader
} else if (typeof query.emit !== 'undefined' && !query.emit) {
var url = loaderUtils.interpolateName(this, query.name || "[hash].[ext]", {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
});
return "module.exports = __webpack_public_path__ + " + JSON.stringify(url) + ";";
// Use file-loader without emitting files
} else {
var fileLoader = require("file-loader");
return fileLoader.call(this, content);
}
}
module.exports.pitch = function (remainingRequest) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
var chunkName;
if (query.name || defaultQueryName) {
chunkName = loaderUtils.interpolateName(this, query.name || defaultQueryName, {
context: query.context || this.options.context,
content: remainingRequest,
});
}
var chunkNameParam = !!chunkName ? (', ' + JSON.stringify(chunkName)) : '';
var moduleRequest = '!!' + remainingRequest;
return [
'var React = require("react");',
'var component;',
'var desc = {',
' loadComponent: function(callback) {',
' if(!component) {',
' require.ensure([], function() {',
' var module = require(' + JSON.stringify(moduleRequest) + ');',
' component = module.__esModule ? module.default : module;',
' if(callback) callback(component);',
' }' + chunkNameParam + ');',
' } else if(callback) callback(component);',
' return component;',
' }',
'};',
'var mixinReactProxy = require(' + JSON.stringify(require.resolve("./mixinReactProxy")) + ');',
'mixinReactProxy(React, desc);',
'module.exports = React.createClass(desc);',
'module.exports.Mixin = desc;'
].join("\n");
};
function loader(content) {
const ext = loaderUtils.interpolateName(this, '[ext]', {});
const is_known_extension = ['js', 'mjs', 'wasm', 'json'].includes(ext);
const is_not_the_only_loader = this.loaders.length >= 2;
if( is_known_extension || is_not_the_only_loader ) {
return content;
}
/*
assert_usage(
ext!=='json',
"Add a JSON loader in order to load .json files while using the fallback loader."
);
*/
assert_internal(this.loaders.length===1);
assert_internal(this.loaderIndex===0);
assert_internal(content.constructor===Buffer);
/*
console.log('\n');
console.log(loaderUtils.interpolateName(this, '[name].[ext]', {}));
console.log(content.toString().slice(0, 100));
//*/
const options = loaderUtils.getOptions(this) || {};
const fallback = require(options.fallback);
if( ! fallback.raw ) {
content = content.toString();
}
return fallback.call(this, content);
}
module.exports.pitch = function(remainingRequest) {
this.cacheable && this.cacheable();
if(!this.query) throw new Error("query parameter is missing");
var query = utils.interpolateName(this, this.query, {});
return accesorString(query.substr(1)) + " = " +
"require(" + JSON.stringify("-!" + remainingRequest) + ");";
};
module.exports.pitch = function(request) {
if(!this.webpack) throw new Error("Only usable with webpack");
var callback = this.async();
var query = loaderUtils.parseQuery(this.query);
var filename = loaderUtils.interpolateName(this, query.name || "[hash].worker.js", {
context: query.context || this.options.context,
regExp: query.regExp
});
var outputOptions = {
filename: filename,
chunkFilename: "[id]." + filename,
namedChunkFilename: null
};
if(this.options && this.options.worker && this.options.worker.output) {
for(var name in this.options.worker.output) {
outputOptions[name] = this.options.worker.output[name];
}
}
var workerCompiler = this._compilation.createChildCompiler("worker", outputOptions);
workerCompiler.apply(new WebWorkerTemplatePlugin(outputOptions));
workerCompiler.apply(new SingleEntryPlugin(this.context, "!!" + request, "main"));
if(this.options && this.options.worker && this.options.worker.plugins) {
this.options.worker.plugins.forEach(function(plugin) {
workerCompiler.apply(plugin);
});
}
var subCache = "subcache " + __dirname + " " + request;
workerCompiler.plugin("compilation", function(compilation) {
if(compilation.cache) {
if(!compilation.cache[subCache])
compilation.cache[subCache] = {};
compilation.cache = compilation.cache[subCache];
}
});
workerCompiler.runAsChild(function(err, entries, compilation) {
if(err) return callback(err);
if (entries[0]) {
var workerFile = entries[0].files[0];
var constructor;
if(query.shared) {
constructor = "new SharedWorker(__webpack_public_path__ + " + JSON.stringify(workerFile) + ")";
if(query.inline) {
constructor = "require(" + JSON.stringify("!!" + path.join(__dirname, "createInlineSharedWorker.js")) + ")(" +
JSON.stringify(compilation.assets[workerFile].source()) + ", __webpack_public_path__ + " + JSON.stringify(workerFile) + ")";
}
} else if(query.service) {
constructor = "navigator.serviceWorker.register(__webpack_public_path__ + " + JSON.stringify(workerFile) + ", options);"
} else {
constructor = "new Worker(__webpack_public_path__ + " + JSON.stringify(workerFile) + ")";
if(query.inline) {
constructor = "require(" + JSON.stringify("!!" + path.join(__dirname, "createInlineWorker.js")) + ")(" +
JSON.stringify(compilation.assets[workerFile].source()) + ", __webpack_public_path__ + " + JSON.stringify(workerFile) + ")";
}
}
return callback(null, "module.exports = function(options) {\n\treturn " + constructor + ";\n};");
} else {
return callback(null, null);
}
});
};
module.exports = function getLocalIdent(loaderContext, localIdentName, localName, options) {
if(!options.context)
options.context = loaderContext.options && typeof loaderContext.options.context === "string" ? loaderContext.options.context : loaderContext.context;
var request = path.relative(options.context, loaderContext.resourcePath);
options.content = options.hashPrefix + request + "+" + localName;
localIdentName = localIdentName.replace(/\[local\]/gi, localName);
var hash = loaderUtils.interpolateName(loaderContext, localIdentName, options);
return hash.replace(new RegExp("[^a-zA-Z0-9\\-_\u00A0-\uFFFF]", "g"), "-").replace(/^((-?[0-9])|--)/, "_$1");
};
const nameInterpolator = (input) => ({file, content, index}) => {
const res = interpolateName({
context: '/',
resourcePath: `/${file}`,
}, input, {
content,
}).replace(/\[part\]/g, index + 1);
return res;
};
function getAndInterpolateOption(optionKey, def) {
return options[optionKey]
? loaderUtils.interpolateName(this, options[optionKey], {
context: options.context,
content: content,
regExp: options[optionKey + 'RegExp'] || options['regExp']
})
: def
}
module.exports = function(content) {
this.cacheable && this.cacheable()
var query = loaderUtils.parseQuery(this.query)
var url = loaderUtils.interpolateName(this, query.name || "[path][name].[ext]", {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
})
return "module.exports = __webpack_public_path__ + " + JSON.stringify(url)
}
module.exports = function(content) {
this.cacheable && this.cacheable();
if(!this.emitFile) throw new Error("emitFile is required from module system");
var query = loaderUtils.parseQuery(this.query);
var configKey = query.config || "fileLoader";
var options = this.options[configKey] || {};
var config = {
publicPath: false,
name: "[hash].[ext]"
};
// options takes precedence over config
Object.keys(options).forEach(function(attr) {
config[attr] = options[attr];
});
// query takes precedence over config and options
Object.keys(query).forEach(function(attr) {
config[attr] = query[attr];
});
var url = loaderUtils.interpolateName(this, config.name, {
context: config.context || this.options.context,
content: content,
regExp: config.regExp
});
var outputPath = url;
var publicPath = "__webpack_public_path__ + " + JSON.stringify(url);
if (config.outputPath) {
// support functions as outputPath to generate them dynamically
outputPath = typeof config.outputPath === "function"
? config.outputPath(url)
: config.outputPath + url
}
if (config.publicPath) {
// support functions as publicPath to generate them dynamically
publicPath = JSON.stringify(
typeof config.publicPath === "function"
? config.publicPath(url)
: config.publicPath + url
);
}
if (query.emitFile === undefined || query.emitFile) {
this.emitFile(outputPath, content);
}
return "module.exports = " + publicPath + ";";
}
module.exports = function(content) {
this.cacheable && this.cacheable();
if(!this.emitFile) throw new Error("emitFile is required from module system");
var query = loaderUtils.parseQuery(this.query);
var url = loaderUtils.interpolateName(this, query.name || "[hash].[ext]", {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
});
return "module.exports = __webpack_public_path__ + " + JSON.stringify(url) + ";";
}
module.exports = function(source){
this.cacheable && this.cacheable();
formatters = merge(formatters, { markdown: markdownFormatter });
var results = new Parker(metrics).run(source);
var query = loaderUtils.parseQuery(this.query);
var formatter = formatters[query.format] || formatters.markdown;
var url = loaderUtils.interpolateName(this, query.filename || '[name]-analysis.md', {});
var output = formatter(metrics, results);
this.emitFile(url, output);
return source;
};
module.exports.pitch = function pitch(request) {
if (!this.webpack) throw new Error('Only usable with webpack');
this.cacheable(false);
const callback = this.async();
const options = loaderUtils.getOptions(this) || {};
validateOptions(schema, options, 'Worker Loader');
const filename = loaderUtils.interpolateName(this, options.name || '[hash].worker.js', {
context: options.context || this.options.context,
regExp: options.regExp,
});
const outputOptions = {
filename,
chunkFilename: `[id].${filename}`,
namedChunkFilename: null,
};
if (this.options && this.options.worker && this.options.worker.output) {
Object.keys(this.options.worker.output).forEach((name) => {
outputOptions[name] = this.options.worker.output[name];
});
}
const workerCompiler = this._compilation.createChildCompiler('worker', outputOptions);
workerCompiler.apply(new WebWorkerTemplatePlugin(outputOptions));
if (this.target !== 'webworker' && this.target !== 'web') {
workerCompiler.apply(new NodeTargetPlugin());
}
workerCompiler.apply(new SingleEntryPlugin(this.context, `!!${request}`, 'main'));
if (this.options && this.options.worker && this.options.worker.plugins) {
this.options.worker.plugins.forEach(plugin => workerCompiler.apply(plugin));
}
const subCache = `subcache ${__dirname} ${request}`;
workerCompiler.plugin('compilation', (compilation) => {
if (compilation.cache) {
if (!compilation.cache[subCache]) {
compilation.cache[subCache] = {};
}
compilation.cache = compilation.cache[subCache];
}
});
workerCompiler.runAsChild((err, entries, compilation) => {
if (err) return callback(err);
if (entries[0]) {
const workerFile = entries[0].files[0];
const workerFactory = getWorker(workerFile, compilation.assets[workerFile].source(), options);
if (options.fallback === false) {
delete this._compilation.assets[workerFile];
}
return callback(null, `module.exports = function() {\n\treturn ${workerFactory};\n};`);
}
return callback(null, null);
});
};
['id', 'class'].forEach(function(param) {
if (query[param]) {
var interpolateOptions = {
content: content,
regExp: config.regExp
};
if (context) {
interpolateOptions.context = context
}
targetEl.setAttribute(param, loaderUtils.interpolateName(this, query[param], interpolateOptions));
}
}, this);
.then(sources => {
const concatSource = new webpack_sources_1.ConcatSource();
sources.forEach(source => {
concatSource.add(source);
concatSource.add('\n;');
});
const combinedSource = new webpack_sources_1.CachedSource(concatSource);
const filename = loader_utils_1.interpolateName({ resourcePath: 'scripts.js' }, this.options.filename, { content: combinedSource.source() });
const output = { filename, source: combinedSource };
this._insertOutput(compilation, output);
this._cachedOutput = output;
addDependencies(compilation, scripts);
callback();
})
.getBuffer(mime, function(err, buf) {
if (err) {
return queueCallback(err);
}
var fileName = loaderUtils.interpolateName(loaderContext, name + ext, {content: buf}).replace(/\[width\]/ig, width);
loaderContext.emitFile(fileName, buf);
queueCallback(null, {
src: '__webpack_public_path__ + ' + JSON.stringify(fileName + ' ' + width + 'w'),
path: '__webpack_public_path__ + ' + JSON.stringify(fileName),
width: width
});
});
module.exports = function(content) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
var ext = loaderUtils.interpolateName(this, "[ext]", {
context: query.context || this.options.context,
content: content,
regExp: query.regExp
}).toLowerCase();
if (!dictionary.hasOwnProperty(ext)) {
throw new Error(ext + ' font type is not supported');
}
var url = 'data:' + dictionary[ext] + ';charset=utf-8;base64,';
url += content.toString('base64');
return 'module.exports = ' + JSON.stringify(url);
}
compiler.plugin('emit', (compilation, callback) => {
if (this._errors.length > 0) {
return callback(
`SVG-EXTRACT-PLUGIN: Unable to build '${this._filenameTemplate}':\n` +
`\t${this._errors.map(e => e.message).join('\n\t')}\n`
);
}
const compiledSprite = this._sprite.render();
const filename = loaderUtils.interpolateName({}, this._filenameTemplate, {
content: compiledSprite.source()
});
compilation.assets[filename] = compiledSprite;
callback();
});
module.exports = function (content) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
/** @type {SVGSpriteLoaderConfig} */
var config = extend({}, defaultConfig, query);
var resourcePath = this.resourcePath;
var basename = path.basename(resourcePath);
var isRasterImage = utils.isRasterImage(resourcePath);
this.addDependency(resourcePath);
if (isRasterImage)
content = procs.rasterImageToSVG(resourcePath);
var doc = new SVGDoc(content);
// Calculate sprite symbol id
var id = loaderUtils.interpolateName(this, config.name, {
context: this.options.context,
content: content
});
if (config.name.indexOf('[pathhash]') !== -1)
id = utils.generateHashFromPath(resourcePath);
if (config.prefixize)
procs.prefixize(doc, id + '_');
// Check raster image pixel ratio from file name (e.g. image@2x.png)
if (isRasterImage) {
var pixelRatio = utils.getPixelRatioFromFilename(basename);
var scale = Number((1 / pixelRatio).toFixed(1));
if (scale !== 1)
doc.$('image').attr('transform', 'scale('+ scale +')');
}
doc.$svg.attr('id', id);
content = doc.toString(SVGDoc.OUTPUT_FORMAT.SYMBOL);
return [
config.angularBaseWorkaround ? 'require("' + path.resolve(__dirname, 'lib/web/angular-base-workaround').replace(/\\/g, "/") + '");' : '',
'var sprite = require("' + config.spriteModule.replace(/\\/g, "/") + '");',
'var image = ' + JSON.stringify(content),
'module.exports = sprite.add(image, "' + id + '");'
].join(';\n');
};
fs.readFile(assetName, (err, data) => {
if (err) {
console.log(err);
reject(err);
} else {
usedContext.resourcePath = assetName;
const name = loaderUtils.interpolateName(usedContext, pluginOptions.assetname, {
content: data
});
compilation.assets[name] = {
source: () => data,
size: () => data.length
};
replacements[assetUrl] = name + queryString;
resolve();
}
});
return query.files.reduce(function(resourceContents, file) {
var interpolatedName = loaderUtils.interpolateName(loaderContext, file, {
context: loaderContext.options.context
});
try {
var dir = path.dirname(resourcePath);
var filePath = path.join(dir, interpolatedName)
var stats = fs.lstatSync(filePath);
if (stats.isFile()) {
return 'import \'' + interpolatedName + '\'\n' + resourceContents;
}
} catch (e) {} // eslint-disable-line no-empty
return resourceContents;
}, source);
return function generate(localName, filepath) {
var name = pattern.replace(/\[local\]/gi, localName);
var loaderContext = {
resourcePath: filepath
};
var loaderOptions = {
content: util.format('%s%s+%s',
hashPrefix,
path.relative(context, filepath),
localName),
context: context
};
var genericName = interpolateName(loaderContext, name, loaderOptions);
return genericName
.replace(new RegExp('[^a-zA-Z0-9\\-_\u00A0-\uFFFF]', 'g'), '-')
.replace(/^([^a-zA-Z_])/, '_$1');
};
// This loader performs two tasks:
// 1. It extracts the app name, description, instructions and parameters keys
// and saves them to the dist/translations/[locale].json files
// 2. It compiles the Handlebars templates for the translation file to be used
// within the app's i18n shim
function TranslationsLoader(content) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
var name = query.name || '../translations/[name].json';
var runtimePath = query.runtime || require.resolve("handlebars/runtime");
var translationsInput = JSON.parse(content);
var translationsPath = path.relative(this.options.context, this.resourcePath);
var marketplaceTranslations = extractMarketplaceTranslation(translationsInput, translationsPath);
var url = loaderUtils.interpolateName(this, name, { content: marketplaceTranslations });
this.emitFile(url, marketplaceTranslations);
var compiledTranslations = compileTranslations(translationsInput);
return `
var Handlebars = require(${JSON.stringify(runtimePath)});
module.exports = ${compiledTranslations};
`;
}
Jimp.read(originalImage).then(function (image) {
var extension = loaderUtils.interpolateName(this, '.[ext]', {});
var size = {
width: image.bitmap.width,
height: image.bitmap.height
};
image.scaleToFit(42, 42) // resize
.quality(60) // set JPEG quality
image.getBuffer(Jimp.MIME_JPEG, function (err, result) {
var dataUri = new Datauri().format(extension, result).content;
callback(null, "module.exports = " + JSON.stringify({
dataUri: dataUri,
size: size
}) + ";", map);
}.bind(this));
}.bind(this)).catch(function (err) {
loader.fs.readFile(result, (err, content) => {
if (err) {
reject(err);
return;
}
let outputPath = loader_utils_1.interpolateName({ resourcePath: result }, filename, { content });
if (resourcesOutputPath) {
outputPath = path.posix.join(resourcesOutputPath, outputPath);
}
loader.addDependency(result);
loader.emitFile(outputPath, content, undefined);
let outputUrl = outputPath.replace(/\\/g, '/');
if (hash || search) {
outputUrl = url.format({ pathname: outputUrl, hash, search });
}
if (deployUrl && loader.loaders[loader.loaderIndex].options.ident !== 'extracted') {
outputUrl = url.resolve(deployUrl, outputUrl);
}
resourceCache.set(cacheKey, outputUrl);
resolve(outputUrl);
});
module.exports.pitch = function(remainingRequest) {
this.cacheable && this.cacheable();
var query = loaderUtils.parseQuery(this.query);
if(query.name) {
var options = {
context: query.context || this.options.context,
regExp: query.regExp
};
var chunkName = loaderUtils.interpolateName(this, query.name, options);
var chunkNameParam = ", " + JSON.stringify(chunkName);
} else {
var chunkNameParam = '';
}
var result;
if(query.lazy) {
result = [
"module.exports = function(cb) {\n",
" require.ensure([], function(require) {\n",
" cb(require(", JSON.stringify("!!" + remainingRequest), "));\n",
" }" + chunkNameParam + ");\n",
"}"];
} else {
result = [
"var cbs = [], \n",
" data;\n",
"module.exports = function(cb) {\n",
" if(cbs) cbs.push(cb);\n",
" else cb(data);\n",
"}\n",
"require.ensure([], function(require) {\n",
" data = require(", JSON.stringify("!!" + remainingRequest), ");\n",
" var callbacks = cbs;\n",
" cbs = null;\n",
" for(var i = 0, l = callbacks.length; i < l; i++) {\n",
" callbacks[i](data);\n",
" }\n",
"}" + chunkNameParam + ");"];
}
return result.join("");
}