@atlaspack/packager-js 2.25.10 → 2.25.11-dev-fix-sourcemaps-50acc1acf.0

package/src/ScopeHoistingPackager.ts

@@ -53,6 +53,29 @@ const REPLACEMENT_RE =
   /\n|import\s+"([0-9a-f]{16,20}:.+?)";|(?:\$[0-9a-f]{16,20}\$exports)|(?:\$[0-9a-f]{16,20}\$(?:import|importAsync|require)\$[0-9a-f]+(?:\$[0-9a-f]+)?)/g;
 
 const BUILTINS = Object.keys(globals.builtin);
+
+/**
+ * Joins filtered hoisted parcelRequire values into the bundle output,
+ * returning the text to append and the number of newlines it adds.
+ *
+ * Returns `{text: '', lineCount: 0}` when there are no values, to avoid
+ * emitting a stray leading `\n` (which would over-count lineCount and
+ * desynchronise the bundle source-map offset bookkeeping).
+ *
+ * Exported for direct unit testing of the lineCount bookkeeping.
+ */
+export function appendHoistedValues(values: ReadonlyArray<string>): {
+  text: string;
+  lineCount: number;
+} {
+  if (values.length === 0) {
+    return {text: '', lineCount: 0};
+  }
+  return {
+    text: '\n' + values.join('\n'),
+    lineCount: values.length,
+  };
+}
 const GLOBALS_BY_CONTEXT = {
   browser: new Set([...BUILTINS, ...Object.keys(globals.browser)]),
   'web-worker': new Set([...BUILTINS, ...Object.keys(globals.worker)]),
@@ -191,9 +214,13 @@ export class ScopeHoistingPackager {
       let [content, map, lines] = this.visitAsset(asset);
 
       if (sourceMap && map) {
+        this.addAssetBoundaryMarker(sourceMap, asset, lineCount);
         sourceMap.addSourceMap(map, lineCount);
       } else if (this.bundle.env.sourceMap) {
         sourceMap = map;
+        if (sourceMap) {
+          this.addAssetBoundaryMarker(sourceMap, asset, lineCount);
+        }
       }
 
       res += content + '\n';
@@ -334,6 +361,7 @@ export class ScopeHoistingPackager {
         this.parcelRequireName,
       );
       if (sourceMap && map) {
+        this.addAssetBoundaryMarker(sourceMap, mainEntry, lineCount);
         // @ts-expect-error TS2339 - addSourceMap method exists but missing from @parcel/source-map type definitions
         sourceMap.addSourceMap(map, lineCount);
       }
@@ -696,6 +724,34 @@ export class ScopeHoistingPackager {
     return this.buildAsset(asset, code, map);
   }
 
+  /**
+   * Insert a single "boundary marker" mapping at the start of the line where
+   * `asset`'s source map is about to be appended. Without this marker, source
+   * map consumers (and downstream optimizers such as swc that need to compose
+   * via nearest-neighbour lookups) will attribute the columns at the start of
+   * this asset's region to the *previous* asset's last mapping, because there
+   * is no mapping anchoring the start of the new asset. This is especially
+   * visible for assets with sparse maps (e.g. codegen'd `.graphql.ts` files
+   * from Relay) whose first mapping may be hundreds of columns into the line.
+   *
+   * The marker points at `(asset.filePath, 1, 0)`. Any mapping the asset's
+   * own map provides at the same generated position will override this one
+   * (last-write-wins inside `parcel_sourcemap`).
+   */
+  addAssetBoundaryMarker(
+    sourceMap: SourceMap,
+    asset: Asset,
+    lineOffset: number,
+  ): void {
+    if (!sourceMap) return;
+    let source = this.getAssetFilePath(asset);
+    sourceMap.addIndexedMapping({
+      generated: {line: lineOffset + 1, column: 0},
+      original: {line: 1, column: 0},
+      source,
+    });
+  }
+
   getAssetFilePath(asset: Asset): string {
     return path.relative(this.options.projectRoot, asset.filePath);
   }
@@ -712,6 +768,13 @@ export class ScopeHoistingPackager {
       this.bundle.env.sourceMap && map
         ? new SourceMap(this.options.projectRoot, map)
         : null;
+    // Anchor the start of this asset's region with a boundary marker so the
+    // first columns of the asset don't fall back to a previous asset's
+    // mapping during downstream source-map composition. See the
+    // addAssetBoundaryMarker JSDoc for the full rationale.
+    if (sourceMap) {
+      this.addAssetBoundaryMarker(sourceMap, asset, 0);
+    }
 
     // If this asset is skipped, just add dependencies and not the asset's content.
     if (this.shouldSkipAsset(asset)) {
@@ -751,6 +814,7 @@ export class ScopeHoistingPackager {
             let [code, map, lines] = this.visitAsset(resolved);
             depCode += code + '\n';
             if (sourceMap && map) {
+              this.addAssetBoundaryMarker(sourceMap, resolved, lineCount);
               sourceMap.addSourceMap(map, lineCount);
             }
             lineCount += lines + 1;
@@ -788,7 +852,9 @@ export class ScopeHoistingPackager {
     code += append;
 
     let lineCount = 0;
-    let depContent: Array<[string, SourceMap | null | undefined, number]> = [];
+    let depContent: Array<
+      [string, SourceMap | null | undefined, number, Asset?]
+    > = [];
     if (depMap.size === 0 && replacements.size === 0) {
       // If there are no dependencies or replacements, use a simple function to count the number of lines.
       lineCount = countLines(code) - 1;
@@ -877,7 +943,13 @@ export class ScopeHoistingPackager {
                     }
                   } else {
                     if (shouldWrap) {
-                      depContent.push(this.visitAsset(resolved));
+                      let visited = this.visitAsset(resolved);
+                      depContent.push([
+                        visited[0],
+                        visited[1],
+                        visited[2],
+                        resolved,
+                      ]);
                     } else {
                       let [depCode, depMap, depLines] =
                         this.visitAsset(resolved);
@@ -906,6 +978,7 @@ export class ScopeHoistingPackager {
                   }
 
                   if (map) {
+                    this.addAssetBoundaryMarker(sourceMap, resolved, lineCount);
                     sourceMap.addSourceMap(map, lineCount);
                   }
                 }
@@ -959,10 +1032,13 @@ ${code}
         lineCount += 1;
       }
 
-      for (let [depCode, map, lines] of depContent) {
+      for (let [depCode, map, lines, depAsset] of depContent) {
         if (!depCode) continue;
         code += depCode + '\n';
         if (sourceMap && map) {
+          if (depAsset) {
+            this.addAssetBoundaryMarker(sourceMap, depAsset, lineCount);
+          }
           sourceMap.addSourceMap(map, lineCount);
         }
         lineCount += lines + 1;
@@ -1453,8 +1529,13 @@ ${code}
           this.seenHoistedRequires.add(val);
         }
 
-        res += '\n' + hoistedValues.join('\n');
-        lineCount += hoisted.size;
+        // Only emit the leading `\n` and bump the line count when we
+        // actually have values to write. Otherwise `res += '\n' + ''` would
+        // emit a stray blank line and the line count would over-count by
+        // `hoisted.size` (which includes the now-filtered entries).
+        let appended = appendHoistedValues(hoistedValues);
+        res += appended.text;
+        lineCount += appended.lineCount;
       } else {
         res += '\n' + [...hoisted.values()].join('\n');
         lineCount += hoisted.size;

package/test/appendHoistedValues.test.ts

@@ -0,0 +1,94 @@
+import assert from 'assert';
+
+import {appendHoistedValues} from '../src/ScopeHoistingPackager';
+
+describe('appendHoistedValues', function () {
+  // This helper exists because the previous implementation in
+  // `getHoistedParcelRequires` would emit `res += '\n' + ''` and then
+  // `lineCount += hoisted.size` whenever the filtered hoisted set was empty
+  // (or smaller than the unfiltered set). Both bugs desynchronised the
+  // source-map line-offset bookkeeping in `ScopeHoistingPackager`. These
+  // tests pin the corrected behaviour.
+
+  it('returns an empty result and zero lineCount when given no values', function () {
+    const out = appendHoistedValues([]);
+    assert.strictEqual(
+      out.text,
+      '',
+      'no text should be appended when there are zero hoisted values (avoids stray leading \\n)',
+    );
+    assert.strictEqual(
+      out.lineCount,
+      0,
+      'lineCount must be 0 when no values were appended (was previously off-by-`hoisted.size`)',
+    );
+  });
+
+  it('emits exactly one leading \\n plus the joined values, with lineCount equal to value count', function () {
+    const out = appendHoistedValues([
+      'parcelRequire("aaaaaaa");',
+      'parcelRequire("bbbbbbb");',
+      'parcelRequire("ccccccc");',
+    ]);
+    assert.strictEqual(
+      out.text,
+      '\nparcelRequire("aaaaaaa");\nparcelRequire("bbbbbbb");\nparcelRequire("ccccccc");',
+      'joined values must be prefixed with one \\n and separated by \\n',
+    );
+    assert.strictEqual(
+      out.lineCount,
+      3,
+      'lineCount must equal the number of newlines actually written (3 for 3 values: 1 leading + 2 separators = 3 \\n)',
+    );
+    // Cross-check: count actual newlines in the returned text.
+    assert.strictEqual(
+      out.text.split('\n').length - 1,
+      out.lineCount,
+      'lineCount must equal the actual number of \\n characters in the appended text',
+    );
+  });
+
+  it('handles a single value correctly', function () {
+    const out = appendHoistedValues(['parcelRequire("only");']);
+    assert.strictEqual(out.text, '\nparcelRequire("only");');
+    assert.strictEqual(out.lineCount, 1);
+    assert.strictEqual(
+      out.text.split('\n').length - 1,
+      out.lineCount,
+      'lineCount must equal the actual number of \\n characters in the appended text',
+    );
+  });
+
+  it('lineCount always equals the newline count of the emitted text', function () {
+    // Property: for *any* input, the lineCount must match the actual number
+    // of newline characters in `text`. This is the invariant the
+    // ScopeHoistingPackager relies on to track lineOffset for the merged
+    // source map. The previous bug violated this invariant when filtering
+    // dropped some entries (lineCount was `hoisted.size`, but text only
+    // contained `filteredValues.length` newlines).
+    for (const values of [
+      [],
+      ['x'],
+      ['x', 'y'],
+      ['x', 'y', 'z'],
+      ['p\nq', 'r\ns'], // values containing embedded newlines — lineCount
+      // intentionally tracks only the separator newlines we emit (1 leading
+      // + N-1 separators = N), NOT the embedded ones; the caller is
+      // responsible for not embedding extra newlines in hoisted require
+      // strings. Document the assumption with this guard:
+    ]) {
+      const out = appendHoistedValues(values);
+      if (values.length === 0) {
+        assert.strictEqual(out.text, '');
+        assert.strictEqual(out.lineCount, 0);
+      } else if (values.every((v) => !v.includes('\n'))) {
+        const actualNewlines = out.text.split('\n').length - 1;
+        assert.strictEqual(
+          out.lineCount,
+          actualNewlines,
+          `lineCount mismatch for values=${JSON.stringify(values)}: claimed ${out.lineCount}, actual ${actualNewlines}`,
+        );
+      }
+    }
+  });
+});