metro-source-map 0.83.1 → 0.83.2

package/src/source-map.d.ts

@@ -8,54 +8,148 @@
  * @oncall react_native
  */
 
-export type GeneratedCodeMapping = [number, number];
-export type SourceMapping = [number, number, number, number];
-export type SourceMappingWithName = [number, number, number, number, string];
+import type {IConsumer} from './Consumer/types';
 
+import {BundleBuilder, createIndexMap} from './BundleBuilder';
+import composeSourceMaps from './composeSourceMaps';
+import Consumer from './Consumer';
+import normalizeSourcePath from './Consumer/normalizeSourcePath';
+import {
+  functionMapBabelPlugin,
+  generateFunctionMap,
+} from './generateFunctionMap';
+import Generator from './Generator';
+
+export type {IConsumer};
+type GeneratedCodeMapping = [number, number];
+type SourceMapping = [number, number, number, number];
+type SourceMappingWithName = [number, number, number, number, string];
 export type MetroSourceMapSegmentTuple =
   | SourceMappingWithName
   | SourceMapping
   | GeneratedCodeMapping;
-
-export interface HermesFunctionOffsets {
-  [id: number]: ReadonlyArray<number>;
-}
-
-export type FBSourcesArray = ReadonlyArray<FBSourceMetadata | null>;
-export type FBSourceMetadata = [FBSourceFunctionMap | null];
-export interface FBSourceFunctionMap {
+export type HermesFunctionOffsets = {
+  [$$Key$$: number]: ReadonlyArray<number>;
+};
+export type FBSourcesArray = ReadonlyArray<null | undefined | FBSourceMetadata>;
+export type FBSourceMetadata = [null | undefined | FBSourceFunctionMap];
+export type FBSourceFunctionMap = {
   readonly names: ReadonlyArray<string>;
   readonly mappings: string;
-}
-
-export interface FBSegmentMap {
-  [id: string]: MixedSourceMap;
-}
-
-export interface BasicSourceMap {
+};
+export type BabelSourceMapSegment = Readonly<{
+  generated: Readonly<{column: number; line: number}>;
+  original?: Readonly<{column: number; line: number}>;
+  source?: null | undefined | string;
+  name?: null | undefined | string;
+}>;
+export type FBSegmentMap = {[id: string]: MixedSourceMap};
+export type BasicSourceMap = {
   readonly file?: string;
   readonly mappings: string;
-  readonly names: string[];
+  readonly names: Array<string>;
   readonly sourceRoot?: string;
-  readonly sources: string[];
-  readonly sourcesContent?: Array<string | undefined>;
+  readonly sources: Array<string>;
+  readonly sourcesContent?: Array<null | undefined | string>;
   readonly version: number;
-}
-
-export interface IndexMapSection {
+  readonly x_facebook_offsets?: Array<number>;
+  readonly x_metro_module_paths?: Array<string>;
+  readonly x_facebook_sources?: FBSourcesArray;
+  readonly x_facebook_segments?: FBSegmentMap;
+  readonly x_hermes_function_offsets?: HermesFunctionOffsets;
+  readonly x_google_ignoreList?: Array<number>;
+};
+export type IndexMapSection = {
   map: IndexMap | BasicSourceMap;
-  offset: {
-    line: number;
-    column: number;
-  };
-}
-
-export interface IndexMap {
+  offset: {line: number; column: number};
+};
+export type IndexMap = {
   readonly file?: string;
-  readonly mappings?: unknown;
-  readonly sourcesContent?: unknown;
-  readonly sections: IndexMapSection[];
+  readonly mappings?: void;
+  readonly sourcesContent?: void;
+  readonly sections: Array<IndexMapSection>;
   readonly version: number;
-}
-
+  readonly x_facebook_offsets?: Array<number>;
+  readonly x_metro_module_paths?: Array<string>;
+  readonly x_facebook_sources?: void;
+  readonly x_facebook_segments?: FBSegmentMap;
+  readonly x_hermes_function_offsets?: HermesFunctionOffsets;
+  readonly x_google_ignoreList?: void;
+};
 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.
+ */
+declare function fromRawMappings(
+  modules: ReadonlyArray<{
+    readonly map: null | undefined | ReadonlyArray<MetroSourceMapSegmentTuple>;
+    readonly functionMap: null | undefined | FBSourceFunctionMap;
+    readonly path: string;
+    readonly source: string;
+    readonly code: string;
+    readonly isIgnored: boolean;
+    readonly lineCount?: number;
+  }>,
+  offsetLines?: number,
+): Generator;
+declare function fromRawMappingsNonBlocking(
+  modules: ReadonlyArray<{
+    readonly map: null | undefined | ReadonlyArray<MetroSourceMapSegmentTuple>;
+    readonly functionMap: null | undefined | FBSourceFunctionMap;
+    readonly path: string;
+    readonly source: string;
+    readonly code: string;
+    readonly isIgnored: boolean;
+    readonly lineCount?: number;
+  }>,
+  offsetLines?: number,
+): Promise<Generator>;
+/**
+ * Transforms a standard source map object into a Raw Mappings object, to be
+ * used across the bundler.
+ */
+declare function toBabelSegments(
+  sourceMap: BasicSourceMap,
+): Array<BabelSourceMapSegment>;
+declare function toSegmentTuple(
+  mapping: BabelSourceMapSegment,
+): MetroSourceMapSegmentTuple;
+export {
+  BundleBuilder,
+  composeSourceMaps,
+  Consumer,
+  createIndexMap,
+  generateFunctionMap,
+  fromRawMappings,
+  fromRawMappingsNonBlocking,
+  functionMapBabelPlugin,
+  normalizeSourcePath,
+  toBabelSegments,
+  toSegmentTuple,
+};
+/**
+ * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
+ * Do not add to this list.
+ *
+ * @deprecated Default import from 'metro-source-map' is deprecated, use named exports.
+ */
+declare const $$EXPORT_DEFAULT_DECLARATION$$: {
+  BundleBuilder: typeof BundleBuilder;
+  composeSourceMaps: typeof composeSourceMaps;
+  Consumer: typeof Consumer;
+  createIndexMap: typeof createIndexMap;
+  generateFunctionMap: typeof generateFunctionMap;
+  fromRawMappings: typeof fromRawMappings;
+  fromRawMappingsNonBlocking: typeof fromRawMappingsNonBlocking;
+  functionMapBabelPlugin: typeof functionMapBabelPlugin;
+  normalizeSourcePath: typeof normalizeSourcePath;
+  toBabelSegments: typeof toBabelSegments;
+  toSegmentTuple: typeof toSegmentTuple;
+};
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/source-map.js

@@ -1,18 +1,70 @@
 "use strict";
 
-const { BundleBuilder, createIndexMap } = require("./BundleBuilder");
-const composeSourceMaps = require("./composeSourceMaps");
-const Consumer = require("./Consumer");
-const normalizeSourcePath = require("./Consumer/normalizeSourcePath");
-const {
-  functionMapBabelPlugin,
-  generateFunctionMap,
-} = require("./generateFunctionMap");
-const Generator = require("./Generator");
-const SourceMap = require("source-map");
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+Object.defineProperty(exports, "BundleBuilder", {
+  enumerable: true,
+  get: function () {
+    return _BundleBuilder.BundleBuilder;
+  },
+});
+Object.defineProperty(exports, "Consumer", {
+  enumerable: true,
+  get: function () {
+    return _Consumer.default;
+  },
+});
+Object.defineProperty(exports, "composeSourceMaps", {
+  enumerable: true,
+  get: function () {
+    return _composeSourceMaps.default;
+  },
+});
+Object.defineProperty(exports, "createIndexMap", {
+  enumerable: true,
+  get: function () {
+    return _BundleBuilder.createIndexMap;
+  },
+});
+exports.default = void 0;
+exports.fromRawMappings = fromRawMappings;
+exports.fromRawMappingsNonBlocking = fromRawMappingsNonBlocking;
+Object.defineProperty(exports, "functionMapBabelPlugin", {
+  enumerable: true,
+  get: function () {
+    return _generateFunctionMap.functionMapBabelPlugin;
+  },
+});
+Object.defineProperty(exports, "generateFunctionMap", {
+  enumerable: true,
+  get: function () {
+    return _generateFunctionMap.generateFunctionMap;
+  },
+});
+Object.defineProperty(exports, "normalizeSourcePath", {
+  enumerable: true,
+  get: function () {
+    return _normalizeSourcePath.default;
+  },
+});
+exports.toBabelSegments = toBabelSegments;
+exports.toSegmentTuple = toSegmentTuple;
+var _BundleBuilder = require("./BundleBuilder");
+var _composeSourceMaps = _interopRequireDefault(require("./composeSourceMaps"));
+var _Consumer = _interopRequireDefault(require("./Consumer"));
+var _normalizeSourcePath = _interopRequireDefault(
+  require("./Consumer/normalizeSourcePath"),
+);
+var _generateFunctionMap = require("./generateFunctionMap");
+var _Generator = _interopRequireDefault(require("./Generator"));
+var _sourceMap = _interopRequireDefault(require("source-map"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
 function fromRawMappingsImpl(isBlocking, onDone, modules, offsetLines) {
   const modulesToProcess = modules.slice();
-  const generator = new Generator();
+  const generator = new _Generator.default();
   let carryOver = offsetLines;
   function processNextModule() {
     if (modulesToProcess.length === 0) {
@@ -24,7 +76,7 @@ function fromRawMappingsImpl(isBlocking, onDone, modules, offsetLines) {
       addMappingsForFile(generator, map, mod, carryOver);
     } else if (map != null) {
       throw new Error(
-        `Unexpected module with full source map found: ${mod.path}`
+        `Unexpected module with full source map found: ${mod.path}`,
       );
     }
     carryOver = carryOver + countLines(code);
@@ -58,7 +110,7 @@ function fromRawMappings(modules, offsetLines = 0) {
       generator = g;
     },
     modules,
-    offsetLines
+    offsetLines,
   );
   if (generator == null) {
     throw new Error("Expected fromRawMappingsImpl() to finish synchronously.");
@@ -72,7 +124,7 @@ async function fromRawMappingsNonBlocking(modules, offsetLines = 0) {
 }
 function toBabelSegments(sourceMap) {
   const rawMappings = [];
-  new SourceMap.SourceMapConsumer(sourceMap).eachMapping((map) => {
+  new _sourceMap.default.SourceMapConsumer(sourceMap).eachMapping((map) => {
     rawMappings.push(
       map.originalLine == null || map.originalColumn == null
         ? {
@@ -94,7 +146,7 @@ function toBabelSegments(sourceMap) {
             },
             source: map.source,
             name: map.name,
-          }
+          },
     );
   });
   return rawMappings;
@@ -135,7 +187,7 @@ function addMapping(generator, mapping, carryOver) {
         column,
         mapping[2],
         mapping[3],
-        mapping[4]
+        mapping[4],
       );
       return;
   }
@@ -143,16 +195,16 @@ function addMapping(generator, mapping, carryOver) {
 }
 const newline = /\r\n?|\n|\u2028|\u2029/g;
 const countLines = (string) => (string.match(newline) || []).length + 1;
-module.exports = {
-  BundleBuilder,
-  composeSourceMaps,
-  Consumer,
-  createIndexMap,
-  generateFunctionMap,
+var _default = (exports.default = {
+  BundleBuilder: _BundleBuilder.BundleBuilder,
+  composeSourceMaps: _composeSourceMaps.default,
+  Consumer: _Consumer.default,
+  createIndexMap: _BundleBuilder.createIndexMap,
+  generateFunctionMap: _generateFunctionMap.generateFunctionMap,
   fromRawMappings,
   fromRawMappingsNonBlocking,
-  functionMapBabelPlugin,
-  normalizeSourcePath,
+  functionMapBabelPlugin: _generateFunctionMap.functionMapBabelPlugin,
+  normalizeSourcePath: _normalizeSourcePath.default,
   toBabelSegments,
   toSegmentTuple,
-};
+});

package/src/source-map.js.flow

@@ -9,23 +9,20 @@
  * @oncall react_native
  */
 
-'use strict';
+import type {IConsumer} from './Consumer/types';
 
-import type {IConsumer} from './Consumer/types.flow';
-import type {BabelSourceMapSegment} from '@babel/generator';
-
-const {BundleBuilder, createIndexMap} = require('./BundleBuilder');
-const composeSourceMaps = require('./composeSourceMaps');
-const Consumer = require('./Consumer');
+import {BundleBuilder, createIndexMap} from './BundleBuilder';
+import composeSourceMaps from './composeSourceMaps';
+import Consumer from './Consumer';
 // We need to export this for `metro-symbolicate`
-const normalizeSourcePath = require('./Consumer/normalizeSourcePath');
-const {
+import normalizeSourcePath from './Consumer/normalizeSourcePath';
+import {
   functionMapBabelPlugin,
   generateFunctionMap,
-} = require('./generateFunctionMap');
-const Generator = require('./Generator');
+} from './generateFunctionMap';
+import Generator from './Generator';
 // $FlowFixMe[untyped-import] - source-map
-const SourceMap = require('source-map');
+import SourceMap from 'source-map';
 
 export type {IConsumer};
 
@@ -47,6 +44,14 @@ export type FBSourceFunctionMap = {
   +mappings: string,
 };
 
+export type BabelSourceMapSegment = $ReadOnly<{
+  generated: $ReadOnly<{column: number, line: number, ...}>,
+  original?: $ReadOnly<{column: number, line: number, ...}>,
+  source?: ?string,
+  name?: ?string,
+  ...
+}>;
+
 export type FBSegmentMap = {[id: string]: MixedSourceMap, ...};
 
 export type BasicSourceMap = {
@@ -127,7 +132,7 @@ function fromRawMappingsImpl(
     // $FlowFixMe[incompatible-use]
     const {code, map} = mod;
     if (Array.isArray(map)) {
-      // $FlowFixMe[incompatible-call]
+      // $FlowFixMe[incompatible-type]
       addMappingsForFile(generator, map, mod, carryOver);
     } else if (map != null) {
       throw new Error(
@@ -332,7 +337,27 @@ const newline = /\r\n?|\n|\u2028|\u2029/g;
 const countLines = (string: string): number =>
   (string.match(newline) || []).length + 1;
 
-module.exports = {
+export {
+  BundleBuilder,
+  composeSourceMaps,
+  Consumer,
+  createIndexMap,
+  generateFunctionMap,
+  fromRawMappings,
+  fromRawMappingsNonBlocking,
+  functionMapBabelPlugin,
+  normalizeSourcePath,
+  toBabelSegments,
+  toSegmentTuple,
+};
+
+/**
+ * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
+ * Do not add to this list.
+ *
+ * @deprecated Default import from 'metro-source-map' is deprecated, use named exports.
+ */
+export default {
   BundleBuilder,
   composeSourceMaps,
   Consumer,