Minify: Use the minifier's decoded source map where available

flow-typed/sourcemap-codec.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ * @oncall react_native
+ */
+
+declare module '@jridgewell/sourcemap-codec' {
+  declare export type SourceMapSegment =
+    | [number]
+    | [number, number, number, number]
+    | [number, number, number, number, number];
+
+  declare export function decode(
+    mappings: string,
+  ): Array<Array<SourceMapSegment>>;
+}

flow-typed/uglify.js

@@ -110,5 +110,21 @@ declare module 'terser' {
   declare function minify(
     code: _Input,
     options: {..._Options, sourceMap: _SourceMapOptions, ...},
-  ): _Error | {..._Result, map: string};
+  ):
+    | _Error
+    | {
+        ..._Result,
+        map: string,
+        decoded_map?: ?{
+          mappings: Array<
+            Array<
+              | [number]
+              | [number, number, number, number]
+              | [number, number, number, number, number],
+            >,
+          >,
+          names: Array<string>,
+          ...
+        },
+      };
 }

packages/metro-minify-terser/src/__tests__/minify-test.js

@@ -98,4 +98,26 @@ describe('Minification:', () => {
     const result = await minify({...baseOptions, filename});
     expect(result.map).toEqual({...map, sources: [filename]});
   });
+
+  test('returns the decoded source map provided by terser, and encodes `map` only when read', async () => {
+    const decodedMap = {...map, mappings: [[[0, 0, 0, 0]]]};
+    let encodeCount = 0;
+    /* $FlowFixMe[incompatible-type] The mocked `minify` result isn't typed as
+     * Terser's. */
+    terser.minify.mockResolvedValue({
+      code: '',
+      decoded_map: decodedMap,
+      // flowlint-next-line unsafe-getters-setters:off
+      get map() {
+        encodeCount++;
+        return JSON.stringify(map);
+      },
+    });
+    const result = await minify({...baseOptions, filename});
+    expect(result.decodedMap).toEqual(decodedMap);
+    expect(encodeCount).toBe(0);
+    expect(result.map).toEqual({...map, sources: [filename]});
+    expect(result.map).toBe(result.map);
+    expect(encodeCount).toBe(1);
+  });
 });

packages/metro-minify-terser/src/minifier.js

@@ -9,7 +9,7 @@
  * @oncall react_native
  */
 
-import type {BasicSourceMap} from 'metro-source-map';
+import type {BabelDecodedMap, BasicSourceMap} from 'metro-source-map';
 import type {MinifierOptions, MinifierResult} from 'metro-transform-worker';
 
 import terser from 'terser';
@@ -18,22 +18,33 @@ export default async function minifier(
   options: MinifierOptions,
 ): Promise<MinifierResult> {
   const result = await minify(options);
+  const {getMap} = result;
 
-  if (!options.map || result.map == null) {
+  if (!options.map || getMap == null) {
     return {code: result.code};
   }
 
-  const map: BasicSourceMap = JSON.parse(result.map);
+  let map: ?BasicSourceMap;
 
-  return {code: result.code, map: {...map, sources: [options.filename]}};
+  return {
+    code: result.code,
+    // Terser encodes its map only when `result.map` is read.
+    // flowlint-next-line unsafe-getters-setters:off
+    get map(): BasicSourceMap {
+      if (map == null) {
+        map = {...JSON.parse(getMap()), sources: [options.filename]};
+      }
+      return map;
+    },
+    decodedMap: result.decodedMap,
+  };
 }
 
-async function minify({
-  code,
-  map,
-  reserved,
-  config,
-}: MinifierOptions): Promise<{code: string, map: ?string}> {
+async function minify({code, map, reserved, config}: MinifierOptions): Promise<{
+  code: string,
+  getMap: ?() => string,
+  decodedMap: ?BabelDecodedMap,
+}> {
   const options = {
     ...config,
     output: {
@@ -65,6 +76,7 @@ async function minify({
 
   return {
     code: result.code,
-    map: result.map,
+    getMap: options.sourceMap ? () => result.map : null,
+    decodedMap: result.decoded_map,
   };
 }

packages/metro-source-map/API.md

@@ -125,10 +125,13 @@ export interface SourceMapGenerator {
   toString(file?: string, options?: {excludeSource?: boolean | undefined}): string;
 }
 
+// @deprecated
 export function toBabelSegments(sourceMap: BasicSourceMap): Array<BabelSourceMapSegment>;
 
+// @deprecated
 export function toSegmentTuple(mapping: BabelSourceMapSegment): MetroSourceMapSegmentTuple;
 
+// @deprecated
 export function tuplesFromBabelDecodedMap(decodedMap: BabelDecodedMap): Array<MetroSourceMapSegmentTuple>;
 
 export type VlqMap = {

packages/metro-source-map/src/source-map.js

@@ -346,6 +346,9 @@ function toIndexMapSection(module: RawMappingsModule): BasicSourceMap {
 /**
  * Transforms a standard source map object into a Raw Mappings object, to be
  * used across the bundler.
+ *
+ * @deprecated Unused by Metro, and will be removed. `Consumer`'s
+ * `generatedMappings()` decodes a source map.
  */
 function toBabelSegments(
   sourceMap: BasicSourceMap,
@@ -383,6 +386,9 @@ function toBabelSegments(
   return rawMappings;
 }
 
+/**
+ * @deprecated Unused by Metro, and will be removed.
+ */
 function toSegmentTuple(
   mapping: BabelSourceMapSegment,
 ): MetroSourceMapSegmentTuple {
@@ -409,6 +415,8 @@ function toSegmentTuple(
  * during generation, whereas accessing `rawMappings` triggers a second decode
  * (`allMappings`) that allocates ~4-5 objects per segment. No terminating
  * mapping is appended (callers that need one use `countLinesAndTerminateMap`).
+ *
+ * @deprecated Unused by Metro, and will be removed.
  */
 function tuplesFromBabelDecodedMap(
   decodedMap: BabelDecodedMap,

packages/metro-transform-worker/API.md

@@ -72,7 +72,11 @@ export type MinifierOptions = {
   config: MinifierConfig;
 };
 
-export type MinifierResult = {code: string; map?: BasicSourceMap | undefined};
+export type MinifierResult = {
+  code: string;
+  map?: BasicSourceMap | undefined;
+  decodedMap?: null | undefined | BabelDecodedMap;
+};
 
 export const transform: (config: JsTransformerConfig, projectRoot: string, projectRelativePath: string, data: Buffer, options: JsTransformOptions) => Promise<TransformResponse>;
 

packages/metro-transform-worker/package.json

@@ -23,6 +23,7 @@
     "@babel/generator": "^7.29.1",
     "@babel/parser": "^7.29.9",
     "@babel/types": "^7.29.8",
+    "@jridgewell/sourcemap-codec": "^1.5.0",
     "flow-enums-runtime": "^0.0.6",
     "metro": "0.87.1",
     "metro-babel-transformer": "0.87.1",

packages/metro-transform-worker/src/__tests__/index-test.js

@@ -12,14 +12,17 @@
 'use strict';
 
 jest
-  .mock('../utils/getMinifier', () => () => ({code, map, config}) => {
-    const trimmed = config.output.comments
-      ? code
-      : code.replace('/*#__PURE__*/', '');
-    return {
-      code: trimmed.replace('arbitrary(code)', 'minified(code)'),
-      map,
-    };
+  .mock('../utils/getMinifier', () => {
+    const minifier = jest.fn(({code, map, config}) => {
+      const trimmed = config.output.comments
+        ? code
+        : code.replace('/*#__PURE__*/', '');
+      return {
+        code: trimmed.replace('arbitrary(code)', 'minified(code)'),
+        map,
+      };
+    });
+    return () => minifier;
   })
   .mock('metro-transform-plugins', () => ({
     ...jest.requireActual('metro-transform-plugins'),
@@ -32,6 +35,7 @@ import type {JsTransformerConfig, JsTransformOptions} from '../index';
 import typeof * as TransformerType from '../index';
 import typeof FSType from 'node:fs';
 
+const {vlqMapFromBabelDecodedMap} = require('metro-source-map');
 const {Buffer} = require('node:buffer');
 const path = require('node:path');
 
@@ -433,7 +437,7 @@ test('emits a compact VlqMap for both the non-minified and minified paths', asyn
     source,
     {...baseTransformOptions, experimentalImportSupport: true},
   );
-  // Minified path re-encodes the minifier's tuple output to VLQ.
+  // Minified path encodes VLQ from the minifier's decoded map.
   const minifiedResult = await Transformer.transform(
     baseConfig,
     '/root',
@@ -455,6 +459,32 @@ test('emits a compact VlqMap for both the non-minified and minified paths', asyn
   }
 });
 
+test("uses the minifier's decoded map, if it has one, without reading `map`", async () => {
+  const decodedMap = {mappings: [[[0, 0, 0, 0, 0]]], names: ['arbitrary']};
+  jest
+    .requireMock('../utils/getMinifier')()
+    .mockImplementationOnce(() => ({
+      code: 'minified(code);',
+      decodedMap,
+      // flowlint-next-line unsafe-getters-setters:off
+      get map() {
+        throw new Error('Expected the decoded map to be used');
+      },
+    }));
+
+  const result = await Transformer.transform(
+    baseConfig,
+    '/root',
+    'local/file.js',
+    Buffer.from('arbitrary(code);', 'utf8'),
+    {...baseTransformOptions, dev: false, minify: true},
+  );
+
+  expect(result.output[0].data.map).toEqual(
+    vlqMapFromBabelDecodedMap(decodedMap, [1, 'minified(code);'.length]),
+  );
+});
+
 test('throws if the reserved dependency map name appears in the input', async () => {
   await expect(
     Transformer.transform(