JS Source Maps support

.gitignore

@@ -11,4 +11,4 @@ lib
 !test/**/node_modules
 .vscode/
 .idea/
-*.min.js
+*.min.js

package.json

@@ -39,6 +39,7 @@
     "resolve": "^1.4.0",
     "sanitize-filename": "^1.6.1",
     "serve-static": "^1.12.4",
+    "source-map": "0.6.1",
     "uglify-es": "^3.2.1",
     "v8-compile-cache": "^1.1.0",
     "worker-farm": "^1.4.1",
@@ -48,6 +49,7 @@
     "babel-cli": "^6.26.0",
     "babel-preset-env": "^1.6.1",
     "bsb-js": "^1.0.1",
+    "codecov": "^3.0.0",
     "coffeescript": "^2.0.3",
     "cross-env": "^5.1.1",
     "eslint": "^4.13.0",
@@ -67,7 +69,7 @@
     "rimraf": "^2.6.1",
     "stylus": "^0.54.5",
     "typescript": "^2.6.2",
-    "codecov": "^3.0.0"
+    "sourcemap-validator": "^1.0.6"
   },
   "scripts": {
     "test": "cross-env NODE_ENV=test mocha",

src/Asset.js

@@ -23,6 +23,7 @@ class Asset {
     this.options = options;
     this.encoding = 'utf8';
     this.type = path.extname(this.name).slice(1);
+    this.relativename = path.relative(this.options.rootDir, this.name);
 
     this.processed = false;
     this.contents = null;
@@ -125,7 +126,7 @@ class Asset {
     // do nothing by default
   }
 
-  generate() {
+  async generate() {
     return {
       [this.type]: this.contents
     };
@@ -137,7 +138,7 @@ class Asset {
       await this.pretransform();
       await this.getDependencies();
       await this.transform();
-      this.generated = this.generate();
+      this.generated = await this.generate();
       this.hash = this.generateHash();
     }
 

src/Bundle.js

@@ -15,8 +15,13 @@ class Bundle {
     this.entryAsset = null;
     this.assets = new Set();
     this.childBundles = new Set();
-    this.siblingBundles = new Set;
+    this.siblingBundles = new Set();
     this.siblingBundlesMap = new Map();
+    this.offsets = new Map();
+  }
+
+  addOffset(asset, line, column) {
+    this.offsets.set(asset.relativename, {line, column});
   }
 
   static createWithAsset(asset, parentBundle) {
@@ -89,15 +94,23 @@ class Bundle {
     newHashes.set(this.name, hash);
 
     let promises = [];
+    let mappings = [];
     if (!oldHashes || oldHashes.get(this.name) !== hash) {
       promises.push(this._package(bundler));
     }
 
     for (let bundle of this.childBundles.values()) {
-      promises.push(bundle.package(bundler, oldHashes, newHashes));
+      if (bundle.type === 'map') {
+        mappings.push(bundle);
+      } else {
+        promises.push(bundle.package(bundler, oldHashes, newHashes));
+      }
     }
 
     await Promise.all(promises);
+    for (let bundle of mappings) {
+      await bundle.package(bundler, oldHashes, newHashes);
+    }
     return newHashes;
   }
 

src/Bundler.js

@@ -80,6 +80,11 @@ class Bundler extends EventEmitter {
       logLevel: typeof options.logLevel === 'number' ? options.logLevel : 3,
       mainFile: this.mainFile,
       hmrPort: options.hmrPort || 0,
+      rootDir: Path.dirname(this.mainFile),
+      sourcemaps:
+        typeof options.sourcemaps === 'boolean'
+          ? options.sourcemaps
+          : !isProduction,
       hmrHostname: options.hmrHostname || ''
     };
   }
@@ -204,6 +209,8 @@ class Bundler extends EventEmitter {
 
       if (process.env.NODE_ENV === 'production') {
         process.exitCode = 1;
+      } else if (process.env.NODE_ENV === 'test' && !this.hmr) {
+        throw err;
       }
     } finally {
       this.pending = false;

src/SourceMap.js

@@ -0,0 +1,192 @@
+const sourceMap = require('source-map');
+const textUtils = require('./utils/textUtils');
+
+class SourceMap {
+  constructor(file) {
+    this.sources = {};
+    this.mappings = [];
+    this.file = file;
+  }
+
+  copyConstructor(map) {
+    let sourcemap = new SourceMap();
+    sourcemap.mappings = map.mappings;
+    sourcemap.sources = map.sources;
+    sourcemap.file = map.file;
+    return sourcemap;
+  }
+
+  isConsumer(map) {
+    return map && map.computeColumnSpans;
+  }
+
+  async getConsumer(map) {
+    if (this.isConsumer(map)) {
+      return map;
+    }
+    return await new sourceMap.SourceMapConsumer(map);
+  }
+
+  async addMap(map, lineOffset = 0, columnOffset = 0) {
+    if (!isSourceMapInstance(map) && map.version) {
+      let consumer = await this.getConsumer(map);
+
+      consumer.eachMapping(mapping => {
+        this.addConsumerMapping(mapping, lineOffset, columnOffset);
+        if (!this.sources[mapping.source]) {
+          this.sources[mapping.source] = consumer.sourceContentFor(
+            mapping.source,
+            true
+          );
+        }
+      });
+      if (consumer.destroy) {
+        // Only needs to happen in source-map 0.7
+        consumer.destroy();
+      }
+    } else {
+      if (!map.eachMapping) {
+        map = this.copyConstructor(map);
+      }
+      if (lineOffset === 0 && columnOffset === 0) {
+        this.concatMappings(map.mappings);
+      } else {
+        map.eachMapping(mapping => {
+          this.addMapping(mapping, lineOffset, columnOffset);
+        });
+      }
+      Object.keys(map.sources).forEach(sourceName => {
+        if (!this.sources[sourceName]) {
+          this.sources[sourceName] = map.sources[sourceName];
+        }
+      });
+    }
+  }
+
+  concatMappings(mappings) {
+    this.mappings = this.mappings.concat(mappings);
+  }
+
+  addMapping(mapping, lineOffset = 0, columnOffset = 0) {
+    mapping.generated = {
+      line: mapping.generated.line + lineOffset,
+      column: mapping.generated.column + columnOffset
+    };
+    this.mappings.push(mapping);
+  }
+
+  addConsumerMapping(mapping, lineOffset = 0, columnOffset = 0) {
+    if (
+      !mapping.source ||
+      !mapping.originalLine ||
+      (!mapping.originalColumn && mapping.originalColumn !== 0)
+    ) {
+      return;
+    }
+
+    this.mappings.push({
+      source: mapping.source,
+      original: {
+        line: mapping.originalLine,
+        column: mapping.originalColumn
+      },
+      generated: {
+        line: mapping.generatedLine + lineOffset,
+        column: mapping.generatedColumn + columnOffset
+      },
+      name: mapping.name
+    });
+  }
+
+  eachMapping(callback) {
+    this.mappings.forEach(callback);
+  }
+
+  generateEmptyMap(sourceName, sourceContent) {
+    this.sources[sourceName] = sourceContent;
+    let lines = textUtils.lineCounter(sourceContent);
+    for (let line = 1; line < lines + 1; line++) {
+      this.addMapping({
+        source: sourceName,
+        original: {
+          line: line,
+          column: 0
+        },
+        generated: {
+          line: line,
+          column: 0
+        }
+      });
+    }
+    return this;
+  }
+
+  async extendSourceMap(original, extension) {
+    if (!isSourceMapInstance(extension)) {
+      throw new Error(
+        '[SOURCEMAP] Type of extension should be a SourceMap instance!'
+      );
+    }
+
+    original = await this.getConsumer(original);
+    extension.eachMapping(mapping => {
+      let originalMapping = original.originalPositionFor({
+        line: mapping.original.line,
+        column: mapping.original.column
+      });
+
+      if (!originalMapping.line) {
+        return false;
+      }
+
+      this.addMapping({
+        source: originalMapping.source,
+        name: originalMapping.name,
+        original: {
+          line: originalMapping.line,
+          column: originalMapping.column
+        },
+        generated: {
+          line: mapping.generated.line,
+          column: mapping.generated.column
+        }
+      });
+      if (!this.sources[originalMapping.source]) {
+        this.sources[originalMapping.source] = original.sourceContentFor(
+          originalMapping.source,
+          true
+        );
+      }
+    });
+    if (original.destroy) {
+      // Only needs to happen in source-map 0.7
+      original.destroy();
+    }
+  }
+
+  offset(lineOffset = 0, columnOffset = 0) {
+    this.mappings.map(mapping => {
+      mapping.generated.line = mapping.generated.line + lineOffset;
+      mapping.generated.column = mapping.generated.column + columnOffset;
+      return mapping;
+    });
+  }
+
+  stringify() {
+    let generator = new sourceMap.SourceMapGenerator({
+      file: this.file
+    });
+    this.eachMapping(mapping => generator.addMapping(mapping));
+    Object.keys(this.sources).forEach(sourceName =>
+      generator.setSourceContent(sourceName, this.sources[sourceName])
+    );
+    return generator.toString();
+  }
+}
+
+function isSourceMapInstance(map) {
+  return !map.sources.length;
+}
+
+module.exports = SourceMap;
+module.exports.isSourceMapInstance = isSourceMapInstance;

src/assets/CoffeeScriptAsset.js

@@ -7,7 +7,15 @@ class CoffeeScriptAsset extends JSAsset {
     let coffee = await localRequire('coffeescript', this.name);
 
     // Transpile Module using CoffeeScript and parse result as ast format through babylon
-    this.contents = coffee.compile(code, {});
+    let transpiled = coffee.compile(code, {
+      sourceMap: this.options.sourcemaps
+    });
+    if (transpiled.sourceMap) {
+      this.sourcemap = transpiled.sourceMap.generate();
+      this.sourcemap.sources = [this.relativename];
+      this.sourcemap.sourcesContent = [this.contents];
+    }
+    this.contents = this.options.sourcemaps ? transpiled.js : transpiled;
     return await super.parse(this.contents);
   }
 }

src/assets/GlobAsset.js

@@ -36,9 +36,9 @@ class GlobAsset extends Asset {
     return matches;
   }
 
-  generate() {
+  async generate() {
     return {
-      js: 'module.exports = ' + generate(this.contents) + ';'
+      js: 'module.exports = ' + (await generate(this.contents)) + ';'
     };
   }
 }