metro-source-map 0.54.1 → 0.55.0

package/src/composeSourceMaps.js.flow

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+'use strict';
+
+// eslint-disable-next-line lint/sort-requires
+const Consumer = require('./Consumer');
+const {SourceMapGenerator} = require('source-map');
+
+import type {IConsumer, MixedSourceMap} from './source-map';
+import type {Number0, Number1} from 'ob1';
+
+// Originally based on https://github.com/jakobwesthoff/source-map-merger
+function composeSourceMaps(
+  maps: $ReadOnlyArray<MixedSourceMap>,
+): MixedSourceMap {
+  // NOTE: require() here to break dependency cycle
+  const SourceMetadataMapConsumer = require('metro-symbolicate/src/SourceMetadataMapConsumer');
+  if (maps.length < 1) {
+    throw new Error('composeSourceMaps: Expected at least one map');
+  }
+  const firstMap = maps[0];
+
+  const consumers = maps
+    .map(function(map) {
+      return new Consumer(map);
+    })
+    .reverse();
+
+  const generator = new SourceMapGenerator({
+    file: consumers[0].file,
+  });
+
+  consumers[0].eachMapping(mapping => {
+    const original = findOriginalPosition(
+      consumers,
+      mapping.generatedLine,
+      mapping.generatedColumn,
+    );
+    generator.addMapping({
+      generated: {
+        line: mapping.generatedLine,
+        column: mapping.generatedColumn,
+      },
+      original:
+        original.line != null
+          ? {
+              line: original.line,
+              column: original.column,
+            }
+          : null,
+      source: original.source,
+      name: original.name,
+    });
+  });
+
+  const composedMap = generator.toJSON();
+
+  const metadataConsumer = new SourceMetadataMapConsumer(firstMap);
+  composedMap.x_facebook_sources = metadataConsumer.toArray(
+    composedMap.sources,
+  );
+  return composedMap;
+}
+
+function findOriginalPosition(
+  consumers: $ReadOnlyArray<IConsumer>,
+  generatedLine: Number1,
+  generatedColumn: Number0,
+): {
+  line: ?number,
+  column: ?number,
+  source: ?string,
+  name: ?string,
+} {
+  let currentLine = generatedLine;
+  let currentColumn = generatedColumn;
+  let original = {
+    line: null,
+    column: null,
+    source: null,
+    name: null,
+  };
+
+  for (const consumer of consumers) {
+    if (currentLine == null || currentColumn == null) {
+      return {line: null, column: null, source: null, name: null};
+    }
+    original = consumer.originalPositionFor({
+      line: currentLine,
+      column: currentColumn,
+    });
+
+    currentLine = original.line;
+    currentColumn = original.column;
+
+    if (currentLine == null) {
+      return {
+        line: null,
+        column: null,
+        source: null,
+        name: null,
+      };
+    }
+  }
+  return original;
+}
+
+module.exports = composeSourceMaps;

package/src/source-map.js

@@ -9,10 +9,49 @@
  */
 "use strict";
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function() {
+    var self = this,
+      args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
+
+const Consumer = require("./Consumer");
+
 const Generator = require("./Generator");
 
 const SourceMap = require("source-map");
 
+// We need to export this for `metro-symbolicate`
+const normalizeSourcePath = require("./Consumer/normalizeSourcePath");
+
+const composeSourceMaps = require("./composeSourceMaps");
+
 const _require = require("./BundleBuilder"),
   createIndexMap = _require.createIndexMap,
   BundleBuilder = _require.BundleBuilder;
@@ -20,42 +59,109 @@ const _require = require("./BundleBuilder"),
 const _require2 = require("./generateFunctionMap"),
   generateFunctionMap = _require2.generateFunctionMap;
 
-/**
- * Creates a source map from modules with "raw mappings", i.e. an array of
- * tuples with either 2, 4, or 5 elements:
- * generated line, generated column, source line, source line, symbol name.
- * Accepts an `offsetLines` argument in case modules' code is to be offset in
- * the resulting bundle, e.g. by some prefix code.
- */
-function fromRawMappings(modules) {
-  let offsetLines =
-    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function fromRawMappingsImpl(isBlocking, onDone, modules, offsetLines) {
+  const modulesToProcess = modules.slice();
   const generator = new Generator();
   let carryOver = offsetLines;
 
-  for (var j = 0, o = modules.length; j < o; ++j) {
-    var module = modules[j];
-    var code = module.code,
-      map = module.map;
+  function processNextModule() {
+    if (modulesToProcess.length === 0) {
+      return true;
+    }
+
+    const mod = modulesToProcess.shift();
+    const code = mod.code,
+      map = mod.map;
 
     if (Array.isArray(map)) {
-      addMappingsForFile(generator, map, module, carryOver);
+      addMappingsForFile(generator, map, mod, carryOver);
     } else if (map != null) {
       throw new Error(
-        `Unexpected module with full source map found: ${module.path}`
+        `Unexpected module with full source map found: ${mod.path}`
       );
     }
 
     carryOver = carryOver + countLines(code);
+    return false;
+  }
+
+  function workLoop() {
+    const time = process.hrtime();
+
+    while (true) {
+      const isDone = processNextModule();
+
+      if (isDone) {
+        onDone(generator);
+        break;
+      }
+
+      if (!isBlocking) {
+        // Keep the loop running but try to avoid blocking
+        // for too long because this is not in a worker yet.
+        const diff = process.hrtime(time);
+        const NS_IN_MS = 1000000;
+
+        if (diff[1] > 50 * NS_IN_MS) {
+          // We've blocked for more than 50ms.
+          // This code currently runs on the main thread,
+          // so let's give Metro an opportunity to handle requests.
+          setImmediate(workLoop);
+          break;
+        }
+      }
+    }
+  }
+
+  workLoop();
+}
+/**
+ * Creates a source map from modules with "raw mappings", i.e. an array of
+ * tuples with either 2, 4, or 5 elements:
+ * generated line, generated column, source line, source line, symbol name.
+ * Accepts an `offsetLines` argument in case modules' code is to be offset in
+ * the resulting bundle, e.g. by some prefix code.
+ */
+
+function fromRawMappings(modules) {
+  let offsetLines =
+    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let generator;
+  fromRawMappingsImpl(
+    true,
+    g => {
+      generator = g;
+    },
+    modules,
+    offsetLines
+  );
+
+  if (generator == null) {
+    throw new Error("Expected fromRawMappingsImpl() to finish synchronously.");
   }
 
   return generator;
 }
+
+function fromRawMappingsNonBlocking(_x) {
+  return _fromRawMappingsNonBlocking.apply(this, arguments);
+}
 /**
  * Transforms a standard source map object into a Raw Mappings object, to be
  * used across the bundler.
  */
 
+function _fromRawMappingsNonBlocking() {
+  _fromRawMappingsNonBlocking = _asyncToGenerator(function*(modules) {
+    let offsetLines =
+      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    return new Promise(resolve => {
+      fromRawMappingsImpl(false, resolve, modules, offsetLines);
+    });
+  });
+  return _fromRawMappingsNonBlocking.apply(this, arguments);
+}
+
 function toBabelSegments(sourceMap) {
   const rawMappings = [];
   new SourceMap.SourceMapConsumer(sourceMap).eachMapping(map => {
@@ -94,7 +200,7 @@ function toSegmentTuple(mapping) {
 }
 
 function addMappingsForFile(generator, mappings, module, carryOver) {
-  generator.startFile(module.path, module.source);
+  generator.startFile(module.path, module.source, module.functionMap);
 
   for (let i = 0, n = mappings.length; i < n; ++i) {
     addMapping(generator, mappings[i], carryOver);
@@ -134,9 +240,13 @@ function countLines(string) {
 
 module.exports = {
   BundleBuilder,
+  composeSourceMaps,
+  Consumer,
   createIndexMap,
   generateFunctionMap,
   fromRawMappings,
+  fromRawMappingsNonBlocking,
+  normalizeSourcePath,
   toBabelSegments,
   toSegmentTuple
 };

package/src/source-map.js.flow

@@ -10,13 +10,20 @@
 
 'use strict';
 
+const Consumer = require('./Consumer');
 const Generator = require('./Generator');
 const SourceMap = require('source-map');
 
+import type {IConsumer} from './Consumer/types.flow';
+export type {IConsumer};
+
+// We need to export this for `metro-symbolicate`
+const normalizeSourcePath = require('./Consumer/normalizeSourcePath');
+
+const composeSourceMaps = require('./composeSourceMaps');
 const {createIndexMap, BundleBuilder} = require('./BundleBuilder');
 const {generateFunctionMap} = require('./generateFunctionMap');
 
-import type {BabelSourceMap} from '@babel/core';
 import type {BabelSourceMapSegment} from '@babel/generator';
 
 type GeneratedCodeMapping = [number, number];
@@ -28,12 +35,6 @@ export type MetroSourceMapSegmentTuple =
   | SourceMapping
   | GeneratedCodeMapping;
 
-type FBExtensions = {
-  x_facebook_offsets: Array<number>,
-  x_metro_module_paths: Array<string>,
-  x_facebook_sources?: FBSourcesArray,
-};
-
 export type FBSourcesArray = $ReadOnlyArray<?FBSourceMetadata>;
 export type FBSourceMetadata = [?FBSourceFunctionMap];
 export type FBSourceFunctionMap = {|
@@ -41,66 +42,156 @@ export type FBSourceFunctionMap = {|
   +mappings: string,
 |};
 
+export type FBSegmentMap = {
+  [id: string]: MixedSourceMap,
+};
+
+export type BasicSourceMap = {|
+  +file?: string,
+  +mappings: string,
+  +names: Array<string>,
+  +sourceRoot?: string,
+  +sources: Array<string>,
+  +sourcesContent?: Array<?string>,
+  +version: number,
+  +x_facebook_offsets?: Array<number>,
+  +x_metro_module_paths?: Array<string>,
+  +x_facebook_sources?: FBSourcesArray,
+  +x_facebook_segments?: FBSegmentMap,
+|};
+
 export type IndexMapSection = {
-  map: MetroSourceMap,
+  map: IndexMap | BasicSourceMap,
   offset: {line: number, column: number},
 };
 
-export type IndexMap = {
-  file?: string,
-  mappings?: void, // avoids SourceMap being a disjoint union
-  sections: Array<IndexMapSection>,
-  version: number,
-};
+export type IndexMap = {|
+  +file?: string,
+  +mappings?: void, // avoids SourceMap being a disjoint union
+  +sections: Array<IndexMapSection>,
+  +version: number,
+  +x_facebook_offsets?: Array<number>,
+  +x_metro_module_paths?: Array<string>,
+  +x_facebook_sources?: FBSourcesArray,
+  +x_facebook_segments?: FBSegmentMap,
+|};
 
-export type FBIndexMap = IndexMap & FBExtensions;
-export type MetroSourceMap = IndexMap | BabelSourceMap;
-export type FBBasicSourceMap = BabelSourceMap & FBExtensions;
-export type FBSourceMap = FBIndexMap | (BabelSourceMap & FBExtensions);
+export type MixedSourceMap = IndexMap | BasicSourceMap;
 
-/**
- * Creates a source map from modules with "raw mappings", i.e. an array of
- * tuples with either 2, 4, or 5 elements:
- * generated line, generated column, source line, source line, symbol name.
- * Accepts an `offsetLines` argument in case modules' code is to be offset in
- * the resulting bundle, e.g. by some prefix code.
- */
-function fromRawMappings(
+function fromRawMappingsImpl(
+  isBlocking: boolean,
+  onDone: Generator => void,
   modules: $ReadOnlyArray<{
     +map: ?Array<MetroSourceMapSegmentTuple>,
+    +functionMap: ?FBSourceFunctionMap,
     +path: string,
     +source: string,
     +code: string,
   }>,
-  offsetLines: number = 0,
-): Generator {
+  offsetLines: number,
+): void {
+  const modulesToProcess = modules.slice();
   const generator = new Generator();
   let carryOver = offsetLines;
 
-  for (var j = 0, o = modules.length; j < o; ++j) {
-    var module = modules[j];
-    var {code, map} = module;
+  function processNextModule() {
+    if (modulesToProcess.length === 0) {
+      return true;
+    }
 
+    const mod = modulesToProcess.shift();
+    const {code, map} = mod;
     if (Array.isArray(map)) {
-      addMappingsForFile(generator, map, module, carryOver);
+      addMappingsForFile(generator, map, mod, carryOver);
     } else if (map != null) {
       throw new Error(
-        `Unexpected module with full source map found: ${module.path}`,
+        `Unexpected module with full source map found: ${mod.path}`,
       );
     }
-
     carryOver = carryOver + countLines(code);
+    return false;
   }
 
+  function workLoop() {
+    const time = process.hrtime();
+    while (true) {
+      const isDone = processNextModule();
+      if (isDone) {
+        onDone(generator);
+        break;
+      }
+      if (!isBlocking) {
+        // Keep the loop running but try to avoid blocking
+        // for too long because this is not in a worker yet.
+        const diff = process.hrtime(time);
+        const NS_IN_MS = 1000000;
+        if (diff[1] > 50 * NS_IN_MS) {
+          // We've blocked for more than 50ms.
+          // This code currently runs on the main thread,
+          // so let's give Metro an opportunity to handle requests.
+          setImmediate(workLoop);
+          break;
+        }
+      }
+    }
+  }
+
+  workLoop();
+}
+
+/**
+ * Creates a source map from modules with "raw mappings", i.e. an array of
+ * tuples with either 2, 4, or 5 elements:
+ * generated line, generated column, source line, source line, symbol name.
+ * Accepts an `offsetLines` argument in case modules' code is to be offset in
+ * the resulting bundle, e.g. by some prefix code.
+ */
+function fromRawMappings(
+  modules: $ReadOnlyArray<{
+    +map: ?Array<MetroSourceMapSegmentTuple>,
+    +functionMap: ?FBSourceFunctionMap,
+    +path: string,
+    +source: string,
+    +code: string,
+  }>,
+  offsetLines: number = 0,
+): Generator {
+  let generator: void | Generator;
+  fromRawMappingsImpl(
+    true,
+    g => {
+      generator = g;
+    },
+    modules,
+    offsetLines,
+  );
+  if (generator == null) {
+    throw new Error('Expected fromRawMappingsImpl() to finish synchronously.');
+  }
   return generator;
 }
 
+async function fromRawMappingsNonBlocking(
+  modules: $ReadOnlyArray<{
+    +map: ?Array<MetroSourceMapSegmentTuple>,
+    +functionMap: ?FBSourceFunctionMap,
+    +path: string,
+    +source: string,
+    +code: string,
+  }>,
+  offsetLines: number = 0,
+): Promise<Generator> {
+  return new Promise(resolve => {
+    fromRawMappingsImpl(false, resolve, modules, offsetLines);
+  });
+}
+
 /**
  * Transforms a standard source map object into a Raw Mappings object, to be
  * used across the bundler.
  */
 function toBabelSegments(
-  sourceMap: BabelSourceMap,
+  sourceMap: BasicSourceMap,
 ): Array<BabelSourceMapSegment> {
   const rawMappings = [];
 
@@ -140,7 +231,7 @@ function toSegmentTuple(
 }
 
 function addMappingsForFile(generator, mappings, module, carryOver) {
-  generator.startFile(module.path, module.source);
+  generator.startFile(module.path, module.source, module.functionMap);
 
   for (let i = 0, n = mappings.length; i < n; ++i) {
     addMapping(generator, mappings[i], carryOver);
@@ -181,9 +272,13 @@ function countLines(string) {
 
 module.exports = {
   BundleBuilder,
+  composeSourceMaps,
+  Consumer,
   createIndexMap,
   generateFunctionMap,
   fromRawMappings,
+  fromRawMappingsNonBlocking,
+  normalizeSourcePath,
   toBabelSegments,
   toSegmentTuple,
 };