//@ts-check
const fs = require('graceful-fs');
const path = require('path');
const SOURCEMAP_URL_REGEX = /^\/\/#\s*sourceMappingURL=/;
const CHARSET_REGEX = /^;charset=([^;]+);/;
/**
* @param {*} logger
* @param {karmaSourcemapLoader.Config} config
* @returns {karmaSourcemapLoader.Preprocessor}
*/
function createSourceMapLocatorPreprocessor(logger, config) {
const options = (config && config.sourceMapLoader) || {};
const remapPrefixes = options.remapPrefixes;
const remapSource = options.remapSource;
const useSourceRoot = options.useSourceRoot;
const onlyWithURL = options.onlyWithURL;
const strict = options.strict;
const needsUpdate = remapPrefixes || remapSource || useSourceRoot;
const log = logger.create('preprocessor.sourcemap');
/**
* @param {string[]} sources
*/
function remapSources(sources) {
const all = sources.length;
let remapped = 0;
/** @type {Record<string, boolean>} */
const remappedPrefixes = {};
let remappedSource = false;
/**
* Replaces source path prefixes using a key:value map
* @param {string} source
* @returns {string | undefined}
*/
function handlePrefixes(source) {
if (!remapPrefixes) {
return undefined;
}
let sourcePrefix, targetPrefix, target;
for (sourcePrefix in remapPrefixes) {
targetPrefix = remapPrefixes[sourcePrefix];
if (source.startsWith(sourcePrefix)) {
target = targetPrefix + source.substring(sourcePrefix.length);
++remapped;
// Log only one remapping as an example for each prefix to prevent
// flood of messages on the console
if (!remappedPrefixes[sourcePrefix]) {
remappedPrefixes[sourcePrefix] = true;
log.debug(' ', source, '>>', target);
}
return target;
}
}
}
// Replaces source paths using a custom function
/**
* @param {string} source
* @returns {string | undefined}
*/
function handleMapper(source) {
if (!remapSource) {
return undefined;
}
const target = remapSource(source);
// Remapping is considered happenned only if the handler returns
// a non-empty path different from the existing one
if (target && target !== source) {
++remapped;
// Log only one remapping as an example to prevent flooding the console
if (!remappedSource) {
remappedSource = true;
log.debug(' ', source, '>>', target);
}
return target;
}
}
const result = sources.map((rawSource) => {
const source = rawSource.replace(/\\/g, '/');
const sourceWithRemappedPrefixes = handlePrefixes(source);
if (sourceWithRemappedPrefixes) {
// One remapping is enough; if a prefix was replaced, do not let
// the handler below check the source path any more
return sourceWithRemappedPrefixes;
}
return handleMapper(source) || source;
});
if (remapped) {
log.debug(' ...');
log.debug(' ', remapped, 'sources from', all, 'were remapped');
}
return result;
}
return function karmaSourcemapLoaderPreprocessor(content, file, done) {
/**
* Parses a string with source map as JSON and handles errors
* @param {string} data
* @returns {karmaSourcemapLoader.SourceMap | false | undefined}
*/
function parseMap(data) {
try {
return JSON.parse(data);
} catch (err) {
if (strict) {
done(new Error('malformed source map for' + file.originalPath + '\nError: ' + err));
// Returning `false` will make the caller abort immediately
return false;
}
log.warn('malformed source map for', file.originalPath);
log.warn('Error:', err);
}
}
/**
* Sets the sourceRoot property to a fixed or computed value
* @param {karmaSourcemapLoader.SourceMap} sourceMap
*/
function setSourceRoot(sourceMap) {
const sourceRoot = typeof useSourceRoot === 'function' ? useSourceRoot(file) : useSourceRoot;
if (sourceRoot) {
sourceMap.sourceRoot = sourceRoot;
}
}
/**
* Performs configured updates of the source map content
* @param {karmaSourcemapLoader.SourceMap} sourceMap
*/
function updateSourceMap(sourceMap) {
if (remapPrefixes || remapSource) {
sourceMap.sources = remapSources(sourceMap.sources);
}
if (useSourceRoot) {
setSourceRoot(sourceMap);
}
}
/**
* @param {string} data
* @returns {void}
*/
function sourceMapData(data) {
const sourceMap = parseMap(data);
if (sourceMap) {
// Perform the remapping only if there is a configuration for it
if (needsUpdate) {
updateSourceMap(sourceMap);
}
file.sourceMap = sourceMap;
} else if (sourceMap === false) {
return;
}
done(content);
}
/**
* @param {string} inlineData
*/
function inlineMap(inlineData) {
let charset = 'utf-8';
if (CHARSET_REGEX.test(inlineData)) {
const matches = inlineData.match(CHARSET_REGEX);
if (matches && matches.length === 2) {
charset = matches[1];
inlineData = inlineData.slice(matches[0].length - 1);
}
}
if (/^;base64,/.test(inlineData)) {
// base64-encoded JSON string
log.debug('base64-encoded source map for', file.originalPath);
const buffer = Buffer.from(inlineData.slice(';base64,'.length), 'base64');
//@ts-ignore Assume the parsed charset is supported by Buffer.
sourceMapData(buffer.toString(charset));
} else if (inlineData.startsWith(',')) {
// straight-up URL-encoded JSON string
log.debug('raw inline source map for', file.originalPath);
sourceMapData(decodeURIComponent(inlineData.slice(1)));
} else {
if (strict) {
done(new Error('invalid source map in ' + file.originalPath));
} else {
log.warn('invalid source map in', file.originalPath);
done(content);
}
}
}
/**
* @param {string} mapPath
* @param {boolean} optional
*/
function fileMap(mapPath, optional) {
fs.readFile(mapPath, function (err, data) {
// File does not exist
if (err && err.code === 'ENOENT') {
if (!optional) {
if (strict) {
done(new Error('missing external source map for ' + file.originalPath));
return;
} else {
log.warn('missing external source map for', file.originalPath);
}
}
done(content);
return;
}
// Error while reading the file
if (err) {
if (strict) {
done(
new Error('reading external source map failed for ' + file.originalPath + '\n' + err)
);
} else {
log.warn('reading external source map failed for', file.originalPath);
log.warn(err);
done(content);
}
return;
}
log.debug('external source map exists for', file.originalPath);
sourceMapData(data.toString());
});
}
// Remap source paths in a directly served source map
function convertMap() {
let sourceMap;
// Perform the remapping only if there is a configuration for it
if (needsUpdate) {
log.debug('processing source map', file.originalPath);
sourceMap = parseMap(content);
if (sourceMap) {
updateSourceMap(sourceMap);
content = JSON.stringify(sourceMap);
} else if (sourceMap === false) {
return;
}
}
done(content);
}
if (file.path.endsWith('.map')) {
return convertMap();
}
const lines = content.split(/\n/);
let lastLine = lines.pop();
while (typeof lastLine === 'string' && /^\s*$/.test(lastLine)) {
lastLine = lines.pop();
}
const mapUrl =
lastLine && SOURCEMAP_URL_REGEX.test(lastLine) && lastLine.replace(SOURCEMAP_URL_REGEX, '');
if (!mapUrl) {
if (onlyWithURL) {
done(content);
} else {
fileMap(file.path + '.map', true);
}
} else if (/^data:application\/json/.test(mapUrl)) {
inlineMap(mapUrl.slice('data:application/json'.length));
} else {
fileMap(path.resolve(path.dirname(file.path), mapUrl), false);
}
};
}
createSourceMapLocatorPreprocessor.$inject = ['logger', 'config'];
// PUBLISH DI MODULE
module.exports = {
'preprocessor:sourcemap': ['factory', createSourceMapLocatorPreprocessor],
};