@atlaspack/core 2.33.0 → 2.34.0

package/src/requests/WriteBundleRequest.ts

@@ -13,6 +13,7 @@ import type {ProjectPath} from '../projectPath';
 import {HASH_REF_HASH_LEN, HASH_REF_PREFIX} from '../constants';
 import nullthrows from 'nullthrows';
 import path from 'path';
+import url from 'url';
 import {NamedBundle} from '../public/Bundle';
 import {blobToStream, TapStream} from '@atlaspack/utils';
 import {Readable, Transform, pipeline} from 'stream';
@@ -40,9 +41,18 @@ import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {fromEnvironmentId} from '../EnvironmentManager';
+import SourceMap from '@atlaspack/source-map';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
+const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN;
+
+export type HashRefReplacement = {
+  line: number;
+  column: number;
+  originalLength: number;
+  newLength: number;
+};
 
 type WriteBundleRequestInput = {
   bundleGraph: BundleGraph;
@@ -158,6 +168,9 @@ async function run({input, options, api}) {
   let {devDeps, invalidDevDeps} = await getDevDepRequests(api);
   invalidateDevDeps(invalidDevDeps, options, config);
 
+  const bundleReplacements = getFeatureFlag('fixSourceMapHashRefs')
+    ? []
+    : undefined;
   await writeFiles(
     contentStream,
     info,
@@ -169,17 +182,50 @@ async function run({input, options, api}) {
     writeOptions,
     devDeps,
     api,
+    bundleReplacements,
   );
 
   const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
     ? await options.cache.hasLargeBlob(mapKey)
     : await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
-    const mapEntry = getFeatureFlag('cachePerformanceImprovements')
-      ? await options.cache.getLargeBlob(mapKey)
-      : await options.cache.getBlob(mapKey);
+    let mapStream: Readable;
+    if (
+      getFeatureFlag('fixSourceMapHashRefs') &&
+      bundleReplacements &&
+      bundleReplacements.length > 0
+    ) {
+      const mapEntry = getFeatureFlag('cachePerformanceImprovements')
+        ? await options.cache.getLargeBlob(mapKey)
+        : await options.cache.getBlob(mapKey);
+      const mapBuffer = Buffer.isBuffer(mapEntry)
+        ? mapEntry
+        : Buffer.from(mapEntry);
+      const projectRoot =
+        typeof options.projectRoot === 'string'
+          ? options.projectRoot
+          : String(options.projectRoot);
+      const sourceMap = new SourceMap(projectRoot, mapBuffer);
+      applyReplacementsToSourceMap(sourceMap, bundleReplacements);
+      const mapJson = await sourceMap.stringify({
+        format: 'string',
+        file: name,
+        sourceRoot: computeSourceMapRoot(bundle, options),
+      });
+      mapStream = blobToStream(
+        Buffer.from(
+          typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson),
+          'utf8',
+        ),
+      );
+    } else {
+      const mapEntry = getFeatureFlag('cachePerformanceImprovements')
+        ? await options.cache.getLargeBlob(mapKey)
+        : await options.cache.getBlob(mapKey);
+      mapStream = blobToStream(mapEntry);
+    }
     await writeFiles(
-      blobToStream(mapEntry),
+      mapStream,
       info,
       hashRefToNameHash,
       options,
@@ -206,6 +252,88 @@ async function run({input, options, api}) {
   return res;
 }
 
+export function applyReplacementsToSourceMap(
+  sourceMap: SourceMap,
+  replacements: HashRefReplacement[],
+): void {
+  if (replacements.length === 0) return;
+  const sorted = [...replacements].sort(
+    (a, b) => a.line - b.line || a.column - b.column,
+  );
+  for (const r of sorted) {
+    const delta = r.newLength - r.originalLength;
+    if (delta !== 0) {
+      // r.column is in post-replacement coordinates (matching the already-shifted
+      // source map state after previous offsetColumns calls). The end of the
+      // placeholder in these coordinates is simply r.column + r.originalLength.
+      const offsetStartColumn = r.column + r.originalLength;
+      const line1Based = r.line + 1;
+      if (line1Based >= 1 && offsetStartColumn + delta >= 0) {
+        sourceMap.offsetColumns(line1Based, offsetStartColumn, delta);
+      }
+    }
+  }
+}
+
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+export function computeSourceMapRoot(
+  bundle: Bundle,
+  options: AtlaspackOptions,
+): string | undefined {
+  let name = nullthrows(bundle.name);
+  let filePath = joinProjectPath(bundle.target.distDir, name);
+  let fullPath = fromProjectPath(options.projectRoot, filePath);
+  let sourceRoot: string = path.relative(
+    path.dirname(fullPath),
+    options.projectRoot,
+  );
+
+  let inlineSources = false;
+
+  const bundleEnv = fromEnvironmentId(bundle.env);
+  if (bundle.target) {
+    const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
+
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+      sourceRoot = bundleEnv.sourceMap.sourceRoot;
+    } else if (options.serveOptions && bundleTargetEnv.context === 'browser') {
+      sourceRoot = '/__parcel_source_root';
+    }
+
+    if (
+      bundleEnv.sourceMap &&
+      bundleEnv.sourceMap.inlineSources !== undefined
+    ) {
+      inlineSources = bundleEnv.sourceMap.inlineSources;
+    } else if (bundleTargetEnv.context !== 'node') {
+      inlineSources = options.mode === 'production';
+    }
+  }
+
+  let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+
+  if (getFeatureFlag('omitSourcesContentInMemory') && !isInlineMap) {
+    if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+      inlineSources = true;
+    }
+  }
+
+  if (inlineSources) {
+    return undefined;
+  }
+
+  return url.format(url.parse(sourceRoot + '/'));
+}
+
 async function writeFiles(
   // @ts-expect-error TS2503
   inputStream: stream.Readable,
@@ -218,6 +346,7 @@ async function writeFiles(
   writeOptions: FileOptions | null | undefined,
   devDeps: Map<string, string>,
   api: RunAPI<PackagedBundleInfo>,
+  bundleReplacements?: HashRefReplacement[],
 ) {
   let compressors = await config.getCompressors(
     fromProjectPathRelative(filePath),
@@ -225,7 +354,7 @@ async function writeFiles(
   let fullPath = fromProjectPath(options.projectRoot, filePath);
 
   let stream = info.hashReferences.length
-    ? inputStream.pipe(replaceStream(hashRefToNameHash))
+    ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements))
     : inputStream;
 
   let promises: Array<Promise<undefined>> = [];
@@ -314,9 +443,30 @@ async function runCompressor(
   }
 }
 
-function replaceStream(hashRefToNameHash: Map<string, string>) {
+function advanceLineColumn(
+  line: number,
+  column: number,
+  buf: Buffer,
+): {line: number; column: number} {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0x0a) {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return {line, column};
+}
+
+function replaceStream(
+  hashRefToNameHash: Map<string, string>,
+  replacements?: HashRefReplacement[],
+) {
   let boundaryStr = Buffer.alloc(0);
   let replaced = Buffer.alloc(0);
+  let outputLine = 0;
+  let outputColumn = 0;
   return new Transform({
     transform(
       chunk: Buffer | string,
@@ -347,22 +497,42 @@ function replaceStream(hashRefToNameHash: Map<string, string>) {
             .subarray(matchI, matchI + HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN)
             .toString();
           let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+          // Copy pre-match content FIRST so position calculation includes it
           replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
           replacedLength += matchI - lastMatchI;
+          if (replacements) {
+            const pos = advanceLineColumn(
+              outputLine,
+              outputColumn,
+              replaced.subarray(0, replacedLength),
+            );
+            replacements.push({
+              line: pos.line,
+              column: pos.column,
+              originalLength: HASH_REF_PLACEHOLDER_LEN,
+              newLength: replacement.byteLength,
+            });
+          }
           replaced.set(replacement, replacedLength);
           replacedLength += replacement.byteLength;
           lastMatchI = matchI + HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN;
         }
       }
 
+      const pushLen = replacedLength - BOUNDARY_LENGTH;
+      const pushed = advanceLineColumn(
+        outputLine,
+        outputColumn,
+        replaced.subarray(0, pushLen),
+      );
+      outputLine = pushed.line;
+      outputColumn = pushed.column;
+
       boundaryStr = replaced.subarray(
         replacedLength - BOUNDARY_LENGTH,
         replacedLength,
       );
-      let strUpToBoundary = replaced.subarray(
-        0,
-        replacedLength - BOUNDARY_LENGTH,
-      );
+      let strUpToBoundary = replaced.subarray(0, pushLen);
       cb(null, strUpToBoundary);
     },
 

package/src/requests/WriteBundlesRequest.ts

@@ -22,6 +22,16 @@ import {createPackageRequest} from './PackageRequest';
 import createWriteBundleRequest from './WriteBundleRequest';
 import {debugTools} from '@atlaspack/utils';
 
+/** Length of the hash suffix in output filenames (e.g. .runtime.13dc01ac.js). */
+const NAME_HASH_DISPLAY_LEN = 8;
+
+/** Use at most NAME_HASH_DISPLAY_LEN chars for the name hash so filenames stay short. */
+function nameHashForFilename(hash: string): string {
+  return hash.length <= NAME_HASH_DISPLAY_LEN
+    ? hash
+    : hash.slice(-NAME_HASH_DISPLAY_LEN);
+}
+
 type WriteBundlesRequestInput = {
   bundleGraph: BundleGraph;
   optionsRef: SharedReference;
@@ -111,12 +121,12 @@ async function run({
       // Do not package and write placeholder bundles to disk. We just
       // need to update the name so other bundles can reference it.
       if (bundle.isPlaceholder) {
-        let hash = bundle.id.slice(-8);
-        hashRefToNameHash.set(bundle.hashReference, hash);
+        const nameHash = nameHashForFilename(bundle.id);
+        hashRefToNameHash.set(bundle.hashReference, nameHash);
         let name = nullthrows(
           bundle.name,
           `Expected ${bundle.type} bundle to have a name`,
-        ).replace(bundle.hashReference, hash);
+        ).replace(bundle.hashReference, nameHash);
         res.set(bundle.id, {
           filePath: joinProjectPath(bundle.target.distDir, name),
           bundleId: bundle.id,
@@ -178,9 +188,9 @@ async function run({
         if (!info.hashReferences.length) {
           hashRefToNameHash.set(
             bundle.hashReference,
-            options.shouldContentHash
-              ? info.hash.slice(-8)
-              : bundle.id.slice(-8),
+            nameHashForFilename(
+              options.shouldContentHash ? info.hash : bundle.id,
+            ),
           );
           let writeBundleRequest = createWriteBundleRequest({
             bundle,
@@ -256,13 +266,15 @@ function assignComplexNameHashes(
     }
     hashRefToNameHash.set(
       bundle.hashReference,
-      options.shouldContentHash
-        ? hashString(
-            [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              .map((bundleId) => bundleInfoMap[bundleId].hash)
-              .join(':'),
-          ).slice(-8)
-        : bundle.id.slice(-8),
+      nameHashForFilename(
+        options.shouldContentHash
+          ? hashString(
+              [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
+                .map((bundleId) => bundleInfoMap[bundleId].hash)
+                .join(':'),
+            )
+          : bundle.id,
+      ),
     );
   }
 }

package/test/requests/WriteBundleRequest.test.ts

@@ -0,0 +1,239 @@
+import assert from 'assert';
+import SourceMap from '@atlaspack/source-map';
+import {
+  applyReplacementsToSourceMap,
+  type HashRefReplacement,
+} from '../../src/requests/WriteBundleRequest';
+
+const HASH_REF = 'HASH_REF_0123456789abcdef'; // 25 chars
+const HASH_REPLACEMENT = 'a1b2c3d4'; // 8 chars
+const HASH_REF_LEN = HASH_REF.length; // 25
+const REPLACEMENT_LEN = HASH_REPLACEMENT.length; // 8
+
+/**
+ * Build a single-line code string with HASH_REF placeholders at known positions.
+ * Returns original code, replaced code, correct replacement coordinates, and
+ * identifier position tracking in both coordinate spaces.
+ */
+function buildCodeWithHashRefs(
+  segments: Array<{type: 'code'; text: string} | {type: 'hashref'}>,
+) {
+  let code = '';
+  const hashPositions: Array<{column: number}> = [];
+  const identifierPositions = new Map<string, number>();
+
+  for (const seg of segments) {
+    if (seg.type === 'hashref') {
+      hashPositions.push({column: code.length});
+      code += HASH_REF;
+    } else {
+      const regex = /[A-Z][A-Z_0-9]{3,}/g;
+      let match;
+      while ((match = regex.exec(seg.text)) !== null) {
+        identifierPositions.set(match[0], code.length + match.index);
+      }
+      code += seg.text;
+    }
+  }
+
+  // Build replaced code and compute CORRECT replacement coordinates
+  let replacedCode = '';
+  const correctReplacements: HashRefReplacement[] = [];
+  let srcIdx = 0;
+  for (const hp of hashPositions) {
+    replacedCode += code.slice(srcIdx, hp.column);
+    correctReplacements.push({
+      line: 0,
+      column: replacedCode.length,
+      originalLength: HASH_REF_LEN,
+      newLength: REPLACEMENT_LEN,
+    });
+    replacedCode += HASH_REPLACEMENT;
+    srcIdx = hp.column + HASH_REF_LEN;
+  }
+  replacedCode += code.slice(srcIdx);
+
+  // Track where identifiers end up in the replaced code
+  const replacedIdentifierPositions = new Map<string, number>();
+  for (const [name] of identifierPositions) {
+    const idx = replacedCode.indexOf(name);
+    if (idx >= 0) replacedIdentifierPositions.set(name, idx);
+  }
+
+  return {
+    originalCode: code,
+    replacedCode,
+    correctReplacements,
+    identifierPositions,
+    replacedIdentifierPositions,
+  };
+}
+
+describe('applyReplacementsToSourceMap', () => {
+  describe('with correct replacement coordinates', () => {
+    it('should correctly adjust a single HASH_REF replacement', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'hashref'},
+        {type: 'code', text: ';var x=SOME_IDENT;'},
+      ]);
+
+      const origCol = identifierPositions.get('SOME_IDENT')!;
+      const expectedCol = replacedIdentifierPositions.get('SOME_IDENT')!;
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: origCol},
+        original: {line: 10, column: 5},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      const mapping = mappings.find(
+        (m) => m.original?.line === 10 && m.original?.column === 5,
+      );
+      assert.ok(mapping, 'Mapping should exist');
+      assert.strictEqual(mapping!.generated.column, expectedCol);
+    });
+
+    it('should correctly adjust multiple HASH_REF replacements on the same line', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'hashref'},
+        {type: 'code', text: ';var a=IDENT_ALPHA;require("'},
+        {type: 'hashref'},
+        {type: 'code', text: '");var b=IDENT_BETA;require("'},
+        {type: 'hashref'},
+        {type: 'code', text: '");var c=IDENT_GAMMA;'},
+      ]);
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_ALPHA')!},
+        original: {line: 10, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_BETA')!},
+        original: {line: 20, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('IDENT_GAMMA')!},
+        original: {line: 30, column: 0},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      for (const [name, origLine] of [
+        ['IDENT_ALPHA', 10],
+        ['IDENT_BETA', 20],
+        ['IDENT_GAMMA', 30],
+      ] as const) {
+        const mapping = mappings.find((m) => m.original?.line === origLine);
+        const expectedCol = replacedIdentifierPositions.get(name)!;
+        assert.ok(mapping, `${name} mapping should exist`);
+        assert.strictEqual(
+          mapping!.generated.column,
+          expectedCol,
+          `${name}: expected col ${expectedCol}, got ${mapping!.generated.column}`,
+        );
+      }
+    });
+
+    it('should handle 10 replacements on the same line', () => {
+      const segments: Array<{type: 'code'; text: string} | {type: 'hashref'}> =
+        [];
+      for (let i = 0; i < 10; i++) {
+        segments.push({type: 'hashref'});
+        segments.push({
+          type: 'code',
+          text: `;var x${i}=TARGET_${String(i).padStart(2, '0')};require("`,
+        });
+      }
+      segments.push({type: 'code', text: '");'});
+
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs(segments);
+
+      const sm = new SourceMap('/');
+      for (let i = 0; i < 10; i++) {
+        const name = `TARGET_${String(i).padStart(2, '0')}`;
+        sm.addIndexedMapping({
+          generated: {line: 1, column: identifierPositions.get(name)!},
+          original: {line: (i + 1) * 10, column: 0},
+          source: 'test.js',
+        });
+      }
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      for (let i = 0; i < 10; i++) {
+        const name = `TARGET_${String(i).padStart(2, '0')}`;
+        const mapping = mappings.find((m) => m.original?.line === (i + 1) * 10);
+        const expectedCol = replacedIdentifierPositions.get(name)!;
+        assert.ok(mapping, `${name} mapping should exist`);
+        assert.strictEqual(
+          mapping!.generated.column,
+          expectedCol,
+          `${name}: expected col ${expectedCol}, got ${mapping!.generated.column}`,
+        );
+      }
+    });
+
+    it('should not affect mappings before the first HASH_REF', () => {
+      const {
+        correctReplacements,
+        identifierPositions,
+        replacedIdentifierPositions,
+      } = buildCodeWithHashRefs([
+        {type: 'code', text: 'var BEFORE_HASH=1;'},
+        {type: 'hashref'},
+        {type: 'code', text: ';var AFTER_HASH=2;'},
+      ]);
+
+      const sm = new SourceMap('/');
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('BEFORE_HASH')!},
+        original: {line: 1, column: 0},
+        source: 'test.js',
+      });
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get('AFTER_HASH')!},
+        original: {line: 2, column: 0},
+        source: 'test.js',
+      });
+
+      applyReplacementsToSourceMap(sm, correctReplacements);
+
+      const mappings = sm.getMap().mappings;
+      const beforeMapping = mappings.find((m) => m.original?.line === 1);
+      assert.ok(beforeMapping);
+      assert.strictEqual(
+        beforeMapping!.generated.column,
+        replacedIdentifierPositions.get('BEFORE_HASH'),
+      );
+
+      const afterMapping = mappings.find((m) => m.original?.line === 2);
+      assert.ok(afterMapping);
+      assert.strictEqual(
+        afterMapping!.generated.column,
+        replacedIdentifierPositions.get('AFTER_HASH'),
+      );
+    });
+  });
+});