Page MenuHomec4science
Files F102825702

generate-sourcemap.js
No OneTemporary
Actions

File Metadata

Created
Mon, Feb 24, 14:21

generate-sourcemap.js
View Options

"use strict";
const os = require("os");
const convertSourceMap = require("convert-source-map");
const SourceMapConsumer = require("source-map").SourceMapConsumer;
const SourceMapGenerator = require("source-map").SourceMapGenerator;
const stableSort = require("stable");
function SourceMapper(src, nodePositions, fragments, inFile, sourceRoot) {
this.generator = new SourceMapGenerator({ sourceRoot: sourceRoot });
this.src = src;
// stableSort does not mutate input array so no need to copy it
this.nodePositions = stableSort(nodePositions, compareLoc);
this.fragments = stableSort(fragments, function(a, b) { return a.start - b.start });
this.inFile = inFile;
this.generator.setSourceContent(this.inFile, src);
}
SourceMapper.prototype.calculateMappings = function() {
const self = this;
// These offsets represent the difference in coordinates between a node in the source
// and the corresponding position in the output.
let lineOffset = 0;
let columnOffset = 0;
// Since the column position resets to zero after each newline, we have to keep track
// of the current line that columnOffset refers to in order to know whether to reset it
let currentLine = 0;
let frag = 0;
let pos = 0;
while (pos < self.nodePositions.length) {
while (frag < self.fragments.length &&
compareLoc(self.fragments[frag].loc.start, self.nodePositions[pos]) < 1) {
const fragmentLines = self.fragments[frag].str.split("\n");
const addedNewlines = fragmentLines.length - 1;
const replacedLines = self.fragments[frag].loc.end.line - self.fragments[frag].loc.start.line;
const replacedColumns = self.fragments[frag].loc.end.column - self.fragments[frag].loc.start.column;
// If there were any lines added by the fragment string, the line offset should increase;
// If there were any lines removed by the fragment replacement then the line offset should decrease
lineOffset = lineOffset + addedNewlines - replacedLines;
// The column position needs to reset after each newline. So if the fragment added any
// newlines then the column offset is the difference between the column of the last line of
// the fragment, and the column of the end of the replaced section of the source.
// Otherwise we increment or decrement the column offset just like how the line offset works.
// Note that "replacedColumns" might be negative in some cases (if the beginning of the source
// was further right than the end due to a newline); the math still works out.
columnOffset = fragmentLines.length > 1 ?
fragmentLines[fragmentLines.length - 1].length - self.fragments[frag].loc.end.column :
columnOffset + self.fragments[frag].str.length - replacedColumns;
currentLine = self.fragments[frag].loc.end.line;
// Skip creating mappings for any source nodes that were replaced by this fragment (and are thus
// no longer a part of the output)
while (pos < self.nodePositions.length &&
compareLoc(self.fragments[frag].loc.end, self.nodePositions[pos]) > 0) {
++pos;
}
++frag;
}
if (pos < self.nodePositions.length) {
if (currentLine < self.nodePositions[pos].line)
columnOffset = 0;
self.addMapping(self.nodePositions[pos], {
line: self.nodePositions[pos].line + lineOffset,
column: self.nodePositions[pos].column + columnOffset
});
++pos;
}
}
}
SourceMapper.prototype.addMapping = function(input, output) {
this.generator.addMapping({
source: this.inFile,
original: input,
generated: output
});
}
SourceMapper.prototype.applySourceMap = function (consumer) {
this.generator.applySourceMap(consumer);
}
SourceMapper.prototype.generate = function () {
return this.generator.toString();
}
function compareLoc(a, b) {
return (a.line - b.line) || (a.column - b.column);
}
module.exports = function generateSourcemap(result, src, nodePositions, fragments, mapOpts) {
const existingMap = convertSourceMap.fromSource(src);
const existingMapObject = existingMap && existingMap.toObject();
const inFile = (existingMapObject && existingMapObject.file) || mapOpts.inFile || "source.js";
const sourceRoot = (existingMapObject && existingMapObject.sourceRoot) || mapOpts.sourceRoot;
src = convertSourceMap.removeMapFileComments(src);
const mapper = new SourceMapper(src, nodePositions, fragments, inFile, sourceRoot);
mapper.calculateMappings();
if (mapOpts.inline) {
if (existingMapObject)
mapper.applySourceMap(new SourceMapConsumer(existingMapObject));
result.src = convertSourceMap.removeMapFileComments(result.src) +
os.EOL +
convertSourceMap.fromJSON(mapper.generate()).toComment();
} else {
result.map = mapper.generate();
}
}

Event Timeline

c4science · Help