fix(sourcemaps): Handle null mappings properly

packages/core/parcel-bundler/src/SourceMap.js

@@ -10,20 +10,20 @@ class SourceMap {
 
   purifyMappings(mappings) {
     if (Array.isArray(mappings)) {
-      return mappings.filter(mapping => {
-        return (
+      return mappings.filter(
+        mapping =>
           mapping &&
-          mapping.source &&
-          mapping.original &&
-          typeof mapping.original.line === 'number' &&
-          mapping.original.line > 0 &&
-          typeof mapping.original.column === 'number' &&
+          (typeof mapping.original === 'object' &&
+            (mapping.original === null ||
+              (typeof mapping.original.line === 'number' &&
+                mapping.original.line > 0 &&
+                typeof mapping.original.column === 'number' &&
+                mapping.source))) &&
           mapping.generated &&
           typeof mapping.generated.line === 'number' &&
           mapping.generated.line > 0 &&
           typeof mapping.generated.column === 'number'
-        );
-      });
+      );
     }
 
     return [];
@@ -34,12 +34,14 @@ class SourceMap {
       return map;
     }
     map = typeof map === 'string' ? JSON.parse(map) : map;
+    if (map.sourceRoot) delete map.sourceRoot;
     return await new SourceMapConsumer(map);
   }
 
   async addMap(map, lineOffset = 0, columnOffset = 0) {
-    if (!(map instanceof SourceMap) && map.version) {
+    if (typeof map === 'string' || (typeof map === 'object' && map.version)) {
       let consumer = await this.getConsumer(map);
+      if (!consumer) return this;
 
       consumer.eachMapping(mapping => {
         this.addConsumerMapping(mapping, lineOffset, columnOffset);
@@ -55,7 +57,7 @@ class SourceMap {
         // Only needs to happen in source-map 0.7
         consumer.destroy();
       }
-    } else {
+    } else if (map.mappings && map.sources) {
       if (!map.eachMapping) {
         map = new SourceMap(map.mappings, map.sources);
       }
@@ -91,21 +93,22 @@ class SourceMap {
   }
 
   addConsumerMapping(mapping, lineOffset = 0, columnOffset = 0) {
+    let original = null;
     if (
-      !mapping.source ||
-      !mapping.originalLine ||
-      (!mapping.originalColumn && mapping.originalColumn !== 0)
+      typeof mapping.originalLine === 'number' &&
+      mapping.originalLine > 0 &&
+      typeof mapping.originalColumn === 'number'
     ) {
-      return;
+      original = {
+        line: mapping.originalLine,
+        column: mapping.originalColumn
+      };
     }
 
     this.mappings.push({
-      source: mapping.source,
+      source: original ? mapping.source : null,
       name: mapping.name,
-      original: {
-        line: mapping.originalLine,
-        column: mapping.originalColumn
-      },
+      original,
       generated: {
         line: mapping.generatedLine + lineOffset,
         column: mapping.generatedColumn + columnOffset

packages/core/parcel-bundler/test/sourcemaps.js

@@ -0,0 +1,199 @@
+const assert = require('assert');
+const fs = require('@parcel/fs');
+const SourceMap = require('../src/SourceMap');
+
+describe('sourcemaps', function() {
+  it('should purify mappings properly', async function() {
+    let mappings = [
+      {
+        source: 'index.js',
+        name: 'A',
+        original: {
+          line: 0,
+          column: 0
+        },
+        generated: {
+          line: 0,
+          column: 0
+        }
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: null,
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: null,
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 0,
+          column: 0
+        },
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: 'index.js',
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 0,
+          column: 0
+        },
+        source: 'index.js',
+        name: null
+      },
+      {
+        source: 'index.js',
+        name: 'A',
+        original: {
+          line: 1,
+          column: 18
+        },
+        generated: {
+          line: 4,
+          column: 187
+        }
+      }
+    ];
+
+    let expectedResult = [
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: null,
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: null,
+        source: null,
+        name: null
+      },
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: 'index.js',
+        name: null
+      },
+      {
+        source: 'index.js',
+        name: 'A',
+        original: {
+          line: 1,
+          column: 18
+        },
+        generated: {
+          line: 4,
+          column: 187
+        }
+      }
+    ];
+
+    let sourcemap = new SourceMap(mappings, {});
+    assert.deepEqual(sourcemap.mappings, expectedResult);
+  });
+
+  it('should be able to handle null mappings properly', async function() {
+    let mappings = [
+      {
+        generated: {
+          line: 1,
+          column: 0
+        },
+        original: {
+          line: 1,
+          column: 0
+        },
+        source: 'input.js',
+        name: 'console'
+      },
+      {
+        generated: {
+          line: 1,
+          column: 7
+        },
+        original: null,
+        source: null,
+        name: null
+      }
+    ];
+
+    let sources = {
+      'input.js': 'console.log("hello world!");'
+    };
+
+    let sourcemap = new SourceMap(mappings, sources);
+    assert.equal(sourcemap.mappings.length, 2);
+    assert.deepEqual(sourcemap.mappings, mappings);
+
+    let mapString = sourcemap.stringify('index.map', '/');
+    let combinedSourcemap = new SourceMap(mappings, sources);
+    await combinedSourcemap.addMap(mapString);
+
+    let newMapString = combinedSourcemap.stringify('index.map', '/');
+    assert.equal(mapString, newMapString);
+
+    let newSourcemap = new SourceMap([], {});
+    await newSourcemap.addMap(sourcemap);
+
+    assert.deepEqual(newSourcemap.mappings, mappings);
+
+    newSourcemap = new SourceMap([], {});
+    await newSourcemap.addMap(mapString);
+
+    assert.deepEqual(newSourcemap.mappings, mappings);
+  });
+});