127 lines
3.7 KiB
JavaScript
127 lines
3.7 KiB
JavaScript
var fs = require('fs');
|
|
var path = require('path');
|
|
|
|
var isAllowedResource = require('./is-allowed-resource');
|
|
|
|
var hasProtocol = require('../utils/has-protocol');
|
|
var isRemoteResource = require('../utils/is-remote-resource');
|
|
|
|
function loadOriginalSources(context, callback) {
|
|
var loadContext = {
|
|
callback: callback,
|
|
fetch: context.options.fetch,
|
|
index: 0,
|
|
inline: context.options.inline,
|
|
inlineRequest: context.options.inlineRequest,
|
|
inlineTimeout: context.options.inlineTimeout,
|
|
localOnly: context.localOnly,
|
|
rebaseTo: context.options.rebaseTo,
|
|
sourcesContent: context.sourcesContent,
|
|
uriToSource: uriToSourceMapping(context.inputSourceMapTracker.all()),
|
|
warnings: context.warnings
|
|
};
|
|
|
|
return context.options.sourceMap && context.options.sourceMapInlineSources ?
|
|
doLoadOriginalSources(loadContext) :
|
|
callback();
|
|
}
|
|
|
|
function uriToSourceMapping(allSourceMapConsumers) {
|
|
var mapping = {};
|
|
var consumer;
|
|
var uri;
|
|
var source;
|
|
var i, l;
|
|
|
|
for (source in allSourceMapConsumers) {
|
|
consumer = allSourceMapConsumers[source];
|
|
|
|
for (i = 0, l = consumer.sources.length; i < l; i++) {
|
|
uri = consumer.sources[i];
|
|
source = consumer.sourceContentFor(uri, true);
|
|
|
|
mapping[uri] = source;
|
|
}
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
function doLoadOriginalSources(loadContext) {
|
|
var uris = Object.keys(loadContext.uriToSource);
|
|
var uri;
|
|
var source;
|
|
var total;
|
|
|
|
for (total = uris.length; loadContext.index < total; loadContext.index++) {
|
|
uri = uris[loadContext.index];
|
|
source = loadContext.uriToSource[uri];
|
|
|
|
if (source) {
|
|
loadContext.sourcesContent[uri] = source;
|
|
} else {
|
|
return loadOriginalSource(uri, loadContext);
|
|
}
|
|
}
|
|
|
|
return loadContext.callback();
|
|
}
|
|
|
|
function loadOriginalSource(uri, loadContext) {
|
|
var content;
|
|
|
|
if (isRemoteResource(uri)) {
|
|
return loadOriginalSourceFromRemoteUri(uri, loadContext, function (content) {
|
|
loadContext.index++;
|
|
loadContext.sourcesContent[uri] = content;
|
|
return doLoadOriginalSources(loadContext);
|
|
});
|
|
} else {
|
|
content = loadOriginalSourceFromLocalUri(uri, loadContext);
|
|
loadContext.index++;
|
|
loadContext.sourcesContent[uri] = content;
|
|
return doLoadOriginalSources(loadContext);
|
|
}
|
|
}
|
|
|
|
function loadOriginalSourceFromRemoteUri(uri, loadContext, whenLoaded) {
|
|
var isAllowed = isAllowedResource(uri, true, loadContext.inline);
|
|
var isRuntimeResource = !hasProtocol(uri);
|
|
|
|
if (loadContext.localOnly) {
|
|
loadContext.warnings.push('Cannot fetch remote resource from "' + uri + '" as no callback given.');
|
|
return whenLoaded(null);
|
|
} else if (isRuntimeResource) {
|
|
loadContext.warnings.push('Cannot fetch "' + uri + '" as no protocol given.');
|
|
return whenLoaded(null);
|
|
} else if (!isAllowed) {
|
|
loadContext.warnings.push('Cannot fetch "' + uri + '" as resource is not allowed.');
|
|
return whenLoaded(null);
|
|
}
|
|
|
|
loadContext.fetch(uri, loadContext.inlineRequest, loadContext.inlineTimeout, function (error, content) {
|
|
if (error) {
|
|
loadContext.warnings.push('Missing original source at "' + uri + '" - ' + error);
|
|
}
|
|
|
|
whenLoaded(content);
|
|
});
|
|
}
|
|
|
|
function loadOriginalSourceFromLocalUri(relativeUri, loadContext) {
|
|
var isAllowed = isAllowedResource(relativeUri, false, loadContext.inline);
|
|
var absoluteUri = path.resolve(loadContext.rebaseTo, relativeUri);
|
|
|
|
if (!fs.existsSync(absoluteUri) || !fs.statSync(absoluteUri).isFile()) {
|
|
loadContext.warnings.push('Ignoring local source map at "' + absoluteUri + '" as resource is missing.');
|
|
return null;
|
|
} else if (!isAllowed) {
|
|
loadContext.warnings.push('Cannot fetch "' + absoluteUri + '" as resource is not allowed.');
|
|
return null;
|
|
}
|
|
|
|
return fs.readFileSync(absoluteUri, 'utf8');
|
|
}
|
|
|
|
module.exports = loadOriginalSources;
|