@atlaspack/core 2.12.1-dev.3443 → 2.12.1-dev.3460

package/src/public/MutableBundleGraph.js

@@ -55,13 +55,13 @@ export default class MutableBundleGraph
   addAssetGraphToBundle(
     asset: IAsset,
     bundle: IBundle,
-    shouldSkipDependency?: IDependency => boolean,
+    shouldSkipDependency?: (IDependency) => boolean,
   ) {
     this.#graph.addAssetGraphToBundle(
       assetToAssetValue(asset),
       bundleToInternalBundle(bundle),
       shouldSkipDependency
-        ? d => shouldSkipDependency(new Dependency(d, this.#options))
+        ? (d) => shouldSkipDependency(new Dependency(d, this.#options))
         : undefined,
     );
   }
@@ -69,13 +69,13 @@ export default class MutableBundleGraph
   addEntryToBundle(
     asset: IAsset,
     bundle: IBundle,
-    shouldSkipDependency?: IDependency => boolean,
+    shouldSkipDependency?: (IDependency) => boolean,
   ) {
     this.#graph.addEntryToBundle(
       assetToAssetValue(asset),
       bundleToInternalBundle(bundle),
       shouldSkipDependency
-        ? d => shouldSkipDependency(new Dependency(d, this.#options))
+        ? (d) => shouldSkipDependency(new Dependency(d, this.#options))
         : undefined,
     );
   }
@@ -194,7 +194,7 @@ export default class MutableBundleGraph
       return Bundle.get(existing.value, this.#graph, this.#options);
     }
 
-    let publicId = getPublicId(bundleId, existing =>
+    let publicId = getPublicId(bundleId, (existing) =>
       this.#bundlePublicIds.has(existing),
     );
     this.#bundlePublicIds.add(publicId);
@@ -283,13 +283,13 @@ export default class MutableBundleGraph
   getDependencyAssets(dependency: IDependency): Array<IAsset> {
     return this.#graph
       .getDependencyAssets(dependencyToInternalDependency(dependency))
-      .map(asset => assetFromValue(asset, this.#options));
+      .map((asset) => assetFromValue(asset, this.#options));
   }
 
   getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup> {
     return this.#graph
       .getBundleGroupsContainingBundle(bundleToInternalBundle(bundle))
-      .map(bundleGroup => new BundleGroup(bundleGroup, this.#options));
+      .map((bundleGroup) => new BundleGroup(bundleGroup, this.#options));
   }
 
   getParentBundlesOfBundleGroup(bundleGroup: IBundleGroup): Array<IBundle> {
@@ -297,7 +297,7 @@ export default class MutableBundleGraph
       .getParentBundlesOfBundleGroup(
         bundleGroupToInternalBundleGroup(bundleGroup),
       )
-      .map(bundle => Bundle.get(bundle, this.#graph, this.#options));
+      .map((bundle) => Bundle.get(bundle, this.#graph, this.#options));
   }
 
   getTotalSize(asset: IAsset): number {

package/src/requests/AssetGraphRequest.js

@@ -65,7 +65,7 @@ type RunInput = {|
 type AssetGraphRequest = {|
   id: string,
   +type: typeof requestTypes.asset_graph_request,
-  run: RunInput => Async<AssetGraphRequestResult>,
+  run: (RunInput) => Async<AssetGraphRequestResult>,
   input: AssetGraphRequestInput,
 |};
 
@@ -75,7 +75,7 @@ export default function createAssetGraphRequest(
   return {
     type: requestTypes.asset_graph_request,
     id: requestInput.name,
-    run: async input => {
+    run: async (input) => {
       let prevResult =
         await input.api.getPreviousResult<AssetGraphRequestResult>();
 
@@ -171,10 +171,10 @@ export class AssetGraphBuilder {
     this.isSingleChangeRebuild =
       api
         .getInvalidSubRequests()
-        .filter(req => req.requestType === 'asset_request').length === 1;
+        .filter((req) => req.requestType === 'asset_request').length === 1;
     this.queue = new PromiseQueue();
 
-    assetGraph.onNodeRemoved = nodeId => {
+    assetGraph.onNodeRemoved = (nodeId) => {
       this.assetGroupsWithRemovedParents.delete(nodeId);
 
       // This needs to mark all connected nodes that doesn't become orphaned
@@ -365,13 +365,13 @@ export class AssetGraphBuilder {
         // also consider it not lazy (so it gets marked as requested).
         const relativePath = fromProjectPathRelative(node.value.filePath);
         if (this.lazyIncludes.length > 0) {
-          isNodeLazy = this.lazyIncludes.some(lazyIncludeRegex =>
+          isNodeLazy = this.lazyIncludes.some((lazyIncludeRegex) =>
             relativePath.match(lazyIncludeRegex),
           );
         }
         // Excludes override includes, so a node is _not_ lazy if it is included in the exclude list.
         if (this.lazyExcludes.length > 0 && isNodeLazy) {
-          isNodeLazy = !this.lazyExcludes.some(lazyExcludeRegex =>
+          isNodeLazy = !this.lazyExcludes.some((lazyExcludeRegex) =>
             relativePath.match(lazyExcludeRegex),
           );
         }
@@ -381,7 +381,7 @@ export class AssetGraphBuilder {
         } else if (!node.requested) {
           let isAsyncChild = this.assetGraph
             .getIncomingDependencies(node.value)
-            .every(dep => dep.isEntry || dep.priority !== Priority.sync);
+            .every((dep) => dep.isEntry || dep.priority !== Priority.sync);
           if (isAsyncChild) {
             node.requested = !isNodeLazy;
           } else {
@@ -456,7 +456,7 @@ export class AssetGraphBuilder {
         );
     }
     return this.queue.add(() =>
-      promise.then(null, error => errors.push(error)),
+      promise.then(null, (error) => errors.push(error)),
     );
   }
 
@@ -464,7 +464,7 @@ export class AssetGraphBuilder {
     let prevEntries = this.assetGraph.safeToIncrementallyBundle
       ? this.assetGraph
           .getEntryAssets()
-          .map(asset => asset.id)
+          .map((asset) => asset.id)
           .sort()
       : [];
 
@@ -480,7 +480,7 @@ export class AssetGraphBuilder {
     if (this.assetGraph.safeToIncrementallyBundle) {
       let currentEntries = this.assetGraph
         .getEntryAssets()
-        .map(asset => asset.id)
+        .map((asset) => asset.id)
         .sort();
       let didEntriesChange =
         prevEntries.length !== currentEntries.length ||

package/src/requests/AssetGraphRequestRust.js

@@ -25,17 +25,17 @@ type RunInput = {|
 type AssetGraphRequest = {|
   id: string,
   +type: typeof requestTypes.asset_graph_request,
-  run: RunInput => Async<AssetGraphRequestResult>,
+  run: (RunInput) => Async<AssetGraphRequestResult>,
   input: AssetGraphRequestInput,
 |};
 
 export function createAssetGraphRequestRust(
   rustAtlaspack: AtlaspackV3,
 ): (input: AssetGraphRequestInput) => AssetGraphRequest {
-  return input => ({
+  return (input) => ({
     type: requestTypes.asset_graph_request,
     id: input.name,
-    run: async input => {
+    run: async (input) => {
       let options = input.options;
       let serializedAssetGraph;
       try {

package/src/requests/AssetRequest.js

@@ -84,8 +84,8 @@ async function run({input, api, farm, invalidateReason, options}) {
     await Promise.all(
       api
         .getSubRequests()
-        .filter(req => req.requestType === requestTypes.dev_dep_request)
-        .map(async req => [
+        .filter((req) => req.requestType === requestTypes.dev_dep_request)
+        .map(async (req) => [
           req.id,
           nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
         ]),
@@ -112,7 +112,7 @@ async function run({input, api, farm, invalidateReason, options}) {
               specifier: req.specifier,
               resolveFrom: req.resolveFrom,
             },
-            ...(req.additionalInvalidations ?? []).map(i => ({
+            ...(req.additionalInvalidations ?? []).map((i) => ({
               specifier: i.specifier,
               resolveFrom: i.resolveFrom,
             })),

package/src/requests/AtlaspackConfigRequest.js

@@ -469,7 +469,9 @@ export async function processConfigChain(
 
     if (errors.length > 0) {
       throw new ThrowableDiagnostic({
-        diagnostic: errors.flatMap(e => e.diagnostics ?? errorToDiagnostic(e)),
+        diagnostic: errors.flatMap(
+          (e) => e.diagnostics ?? errorToDiagnostic(e),
+        ),
       });
     }
   }
@@ -641,7 +643,7 @@ export function getResolveFrom(
 function assertPurePipeline(
   pipeline: ExtendableAtlaspackConfigPipeline,
 ): PureAtlaspackConfigPipeline {
-  return pipeline.map(s => {
+  return pipeline.map((s) => {
     invariant(typeof s !== 'string');
     return s;
   });
@@ -655,7 +657,7 @@ export function mergePipelines(
     return base ?? [];
   }
 
-  if (ext.filter(v => v === '...').length > 1) {
+  if (ext.filter((v) => v === '...').length > 1) {
     throw new Error(
       'Only one spread element can be included in a config pipeline',
     );

package/src/requests/BundleGraphRequest.js

@@ -82,7 +82,7 @@ export type BundleGraphResult = {|
 type BundleGraphRequest = {|
   id: string,
   +type: typeof requestTypes.bundle_graph_request,
-  run: RunInput => Async<BundleGraphResult>,
+  run: (RunInput) => Async<BundleGraphResult>,
   input: BundleGraphRequestInput,
 |};
 
@@ -92,7 +92,7 @@ export default function createBundleGraphRequest(
   return {
     type: requestTypes.bundle_graph_request,
     id: 'BundleGraph',
-    run: async input => {
+    run: async (input) => {
       let {options, api, invalidateReason} = input;
       let {optionsRef, requestedAssetIds, signal} = input.input;
       let measurement = tracer.createMeasurement('building');
@@ -146,7 +146,7 @@ export default function createBundleGraphRequest(
         Boolean(invalidateReason & OPTION_CHANGE) ||
         input.api
           .getSubRequests()
-          .some(req => !input.api.canSkipSubrequest(req.id));
+          .some((req) => !input.api.canSkipSubrequest(req.id));
 
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
@@ -342,7 +342,7 @@ class BundlerRunner {
         if (tracer.enabled) {
           measurementFilename = graph
             .getEntryAssets()
-            .map(asset => fromProjectPathRelative(asset.filePath))
+            .map((asset) => fromProjectPathRelative(asset.filePath))
             .join(', ');
           measurement = tracer.createMeasurement(
             plugin.name,
@@ -440,7 +440,7 @@ class BundlerRunner {
       // can match them to the correct packager/optimizer plugins.
       let bundles = internalBundleGraph.getBundles({includeInline: true});
       await Promise.all(
-        bundles.map(bundle =>
+        bundles.map((bundle) =>
           this.nameBundle(namers, bundle, internalBundleGraph),
         ),
       );
@@ -502,7 +502,7 @@ class BundlerRunner {
   validateBundles(bundleGraph: InternalBundleGraph): void {
     let bundles = bundleGraph.getBundles();
 
-    let bundleNames = bundles.map(b =>
+    let bundleNames = bundles.map((b) =>
       joinProjectPath(b.target.distDir, nullthrows(b.name)),
     );
     assert.deepEqual(

package/src/requests/ConfigRequest.js

@@ -18,7 +18,7 @@ import type {LoadedPlugin} from '../AtlaspackConfig';
 import type {RequestResult, RunAPI} from '../RequestTracker';
 import type {ProjectPath} from '../projectPath';
 
-import {serializeRaw} from '../serializer.js';
+import {serializeRaw} from '../serializer';
 import {PluginLogger} from '@atlaspack/logger';
 import PluginOptions from '../public/PluginOptions';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
@@ -90,7 +90,7 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
     config.result = await loadConfig({
       config: new PublicConfig(config, options),
       options: new PluginOptions(
-        optionsProxy(options, option => {
+        optionsProxy(options, (option) => {
           config.invalidateOnOptionChange.add(option);
         }),
       ),
@@ -231,7 +231,7 @@ export async function getConfigHash(
     if (config.invalidateOnFileChange.size > 0) {
       hash.writeString(
         await getInvalidationHash(
-          [...config.invalidateOnFileChange].map(filePath => ({
+          [...config.invalidateOnFileChange].map((filePath) => ({
             type: 'file',
             filePath,
           })),
@@ -262,7 +262,7 @@ export function getConfigRequests(
   configs: Array<Config>,
 ): Array<ConfigRequest> {
   return configs
-    .filter(config => {
+    .filter((config) => {
       // No need to send to the graph if there are no invalidations.
       return (
         config.invalidateOnFileChange.size > 0 ||
@@ -274,7 +274,7 @@ export function getConfigRequests(
         config.invalidateOnBuild
       );
     })
-    .map(config => ({
+    .map((config) => ({
       id: config.id,
       invalidateOnFileChange: config.invalidateOnFileChange,
       invalidateOnConfigKeyChange: config.invalidateOnConfigKeyChange,

package/src/requests/DevDepRequest.js

@@ -71,14 +71,14 @@ export async function createDevDependency(
 
   let invalidateOnFileChangeProject = [
     ...invalidations.invalidateOnFileChange,
-  ].map(f => toProjectPath(options.projectRoot, f));
+  ].map((f) => toProjectPath(options.projectRoot, f));
 
   // It is possible for a transformer to have multiple different hashes due to
   // different dependencies (e.g. conditional requires) so we must always
   // recompute the hash and compare rather than only sending a transformer
   // dev dependency once.
   hash = await getInvalidationHash(
-    invalidateOnFileChangeProject.map(f => ({
+    invalidateOnFileChangeProject.map((f) => ({
       type: 'file',
       filePath: f,
     })),
@@ -89,7 +89,7 @@ export async function createDevDependency(
     specifier,
     resolveFrom,
     hash,
-    invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map(i =>
+    invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map((i) =>
       invalidateOnFileCreateToInternal(options.projectRoot, i),
     ),
     invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
@@ -118,8 +118,8 @@ export async function getDevDepRequests<TResult: RequestResult>(
     await Promise.all(
       api
         .getSubRequests()
-        .filter(req => req.requestType === requestTypes.dev_dep_request)
-        .map(async req => [
+        .filter((req) => req.requestType === requestTypes.dev_dep_request)
+        .map(async (req) => [
           req.id,
           nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
         ]),
@@ -144,7 +144,7 @@ export async function getDevDepRequests<TResult: RequestResult>(
               specifier: req.specifier,
               resolveFrom: req.resolveFrom,
             },
-            ...(req.additionalInvalidations ?? []).map(i => ({
+            ...(req.additionalInvalidations ?? []).map((i) => ({
               specifier: i.specifier,
               resolveFrom: i.resolveFrom,
             })),
@@ -232,7 +232,7 @@ const pluginCache = createBuildCache();
 export function getWorkerDevDepRequests(
   devDepRequests: Array<DevDepRequest>,
 ): Array<DevDepRequest> {
-  return devDepRequests.map(devDepRequest => {
+  return devDepRequests.map((devDepRequest) => {
     // If we've already sent a matching transformer + hash to the main thread during this build,
     // there's no need to repeat ourselves.
     let {specifier, resolveFrom, hash} = devDepRequest;

package/src/requests/EntryRequest.js

@@ -121,7 +121,7 @@ async function assertFile(
             ]),
           },
         ],
-        hints: alternatives.map(r => {
+        hints: alternatives.map((r) => {
           return md`Did you mean '__${r}__'?`;
         }),
       },
@@ -174,7 +174,7 @@ export class EntryResolver {
         onlyFiles: false,
       });
       let results = await Promise.all(
-        files.map(f => this.resolveEntry(path.normalize(f))),
+        files.map((f) => this.resolveEntry(path.normalize(f))),
       );
       return results.reduce(
         (p, res) => ({

package/src/requests/TargetRequest.js

@@ -225,14 +225,14 @@ export class TargetResolver {
         // Only build the intersection of the exclusive target and option targets.
         if (exclusiveTarget != null) {
           optionTargets = optionTargets.filter(
-            target => target === exclusiveTarget,
+            (target) => target === exclusiveTarget,
           );
         }
 
         // If an array of strings is passed, it's a filter on the resolved package
         // targets. Load them, and find the matching targets.
         targets = optionTargets
-          .map(target => {
+          .map((target) => {
             // null means skipped.
             if (!packageTargets.has(target)) {
               throw new ThrowableDiagnostic({
@@ -326,7 +326,8 @@ export class TargetResolver {
             return target;
           })
           .filter(
-            target => !skipTarget(target.name, exclusiveTarget, target.source),
+            (target) =>
+              !skipTarget(target.name, exclusiveTarget, target.source),
           );
       }
 
@@ -387,7 +388,7 @@ export class TargetResolver {
       } else {
         targets = Array.from(packageTargets.values())
           .filter(Boolean)
-          .filter(descriptor => {
+          .filter((descriptor) => {
             return (
               descriptor &&
               !skipTarget(descriptor.name, exclusiveTarget, descriptor.source)
@@ -920,7 +921,7 @@ export class TargetResolver {
     }
 
     let customTargets = (Object.keys(pkgTargets): Array<string>).filter(
-      targetName => !COMMON_TARGETS[targetName],
+      (targetName) => !COMMON_TARGETS[targetName],
     );
 
     // Custom targets
@@ -1377,7 +1378,7 @@ function assertNoDuplicateTargets(options, targets, pkgFilePath, pkgContents) {
             code: pkgContents,
             codeHighlights: generateJSONCodeHighlights(
               pkgContents,
-              targetNames.map(t => ({
+              targetNames.map((t) => ({
                 key: `/${t}`,
                 type: 'value',
               })),
@@ -1580,7 +1581,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
       includeNodeModules =
         'only ' +
         listFormat.format(
-          target.env.includeNodeModules.map(m => JSON.stringify(m)),
+          target.env.includeNodeModules.map((m) => JSON.stringify(m)),
         );
     } else if (
       target.env.includeNodeModules &&
@@ -1595,7 +1596,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
         );
     }
 
-    let format = v => (v.message != null ? md.italic(v.message) : '');
+    let format = (v) => (v.message != null ? md.italic(v.message) : '');
     logger.verbose({
       origin: '@atlaspack/core',
       message: md`**Target** "${target.name}"

package/src/requests/ValidationRequest.js

@@ -43,13 +43,13 @@ export default function createValidationRequest(
       );
 
       let config = new AtlaspackConfig(processedConfig, options);
-      let trackedRequestsDesc = assetRequests.filter(request => {
+      let trackedRequestsDesc = assetRequests.filter((request) => {
         return config.getValidatorNames(request.filePath).length > 0;
       });
 
       // Schedule validations on workers for all plugins that implement the one-asset-at-a-time "validate" method.
       let promises = trackedRequestsDesc.map(
-        async request =>
+        async (request) =>
           ((await farm.createHandle('runValidate'))({
             requests: [request],
             optionsRef: optionsRef,

package/src/requests/WriteBundleRequest.js

@@ -3,7 +3,6 @@
 import type {FileSystem, FileOptions} from '@atlaspack/fs';
 import type {ContentKey} from '@atlaspack/graph';
 import type {Async, FilePath, Compressor} from '@atlaspack/types';
-import {replaceHashReferences} from '@atlaspack/rust';
 
 import type {RunAPI, StaticRunOpts} from '../RequestTracker';
 import type {Bundle, PackagedBundleInfo, AtlaspackOptions} from '../types';
@@ -17,7 +16,7 @@ import {HASH_REF_HASH_LEN, HASH_REF_PREFIX} from '../constants';
 import nullthrows from 'nullthrows';
 import path from 'path';
 import {NamedBundle} from '../public/Bundle';
-import {blobToStream} from '@atlaspack/utils';
+import {blobToStream, TapStream} from '@atlaspack/utils';
 import {Readable, Transform, pipeline} from 'stream';
 import {
   fromProjectPath,
@@ -130,8 +129,20 @@ async function run({input, options, api}) {
       : {
           mode: (await inputFS.stat(mainEntry.filePath)).mode,
         };
-  const contents: Buffer = await options.cache.getBlob(cacheKeys.content);
-  const size = contents.byteLength;
+  let contentStream: Readable;
+  if (info.isLargeBlob) {
+    contentStream = options.cache.getStream(cacheKeys.content);
+  } else {
+    contentStream = blobToStream(
+      await options.cache.getBlob(cacheKeys.content),
+    );
+  }
+  let size = 0;
+  contentStream = contentStream.pipe(
+    new TapStream((buf) => {
+      size += buf.length;
+    }),
+  );
 
   let configResult = nullthrows(
     await api.runRequest<null, ConfigAndCachePath>(
@@ -144,7 +155,7 @@ async function run({input, options, api}) {
   invalidateDevDeps(invalidDevDeps, options, config);
 
   await writeFiles(
-    contents,
+    contentStream,
     info,
     hashRefToNameHash,
     options,
@@ -163,7 +174,7 @@ async function run({input, options, api}) {
     (await options.cache.has(mapKey))
   ) {
     await writeFiles(
-      await options.cache.getBlob(mapKey),
+      blobToStream(await options.cache.getBlob(mapKey)),
       info,
       hashRefToNameHash,
       options,
@@ -190,7 +201,7 @@ async function run({input, options, api}) {
 }
 
 async function writeFiles(
-  contents: Buffer,
+  inputStream: stream$Readable,
   info: BundleInfo,
   hashRefToNameHash: Map<string, string>,
   options: AtlaspackOptions,
@@ -206,19 +217,16 @@ async function writeFiles(
   );
   let fullPath = fromProjectPath(options.projectRoot, filePath);
 
-  const stream = info.hashReferences.length
-    ? replaceHashReferences(
-        contents,
-        Object.fromEntries(hashRefToNameHash.entries()),
-      )
-    : contents;
+  let stream = info.hashReferences.length
+    ? inputStream.pipe(replaceStream(hashRefToNameHash))
+    : inputStream;
 
   let promises = [];
   for (let compressor of compressors) {
     promises.push(
       runCompressor(
         compressor,
-        blobToStream(stream),
+        cloneStream(stream),
         options,
         outputFS,
         fullPath,
@@ -264,7 +272,7 @@ async function runCompressor(
             filePath + (res.type != null ? '.' + res.type : ''),
             writeOptions,
           ),
-          err => {
+          (err) => {
             if (err) reject(err);
             else resolve();
           },
@@ -292,9 +300,7 @@ async function runCompressor(
   }
 }
 
-export function replaceStream(
-  hashRefToNameHash: Map<string, string>,
-): Transform {
+function replaceStream(hashRefToNameHash) {
   let boundaryStr = Buffer.alloc(0);
   let replaced = Buffer.alloc(0);
   return new Transform({
@@ -349,8 +355,8 @@ function cloneStream(readable) {
   let res = new Readable();
   // $FlowFixMe
   res._read = () => {};
-  readable.on('data', chunk => res.push(chunk));
+  readable.on('data', (chunk) => res.push(chunk));
   readable.on('end', () => res.push(null));
-  readable.on('error', err => res.emit('error', err));
+  readable.on('error', (err) => res.emit('error', err));
   return res;
 }

package/src/requests/WriteBundlesRequest.js

@@ -63,7 +63,7 @@ async function run({input, api, farm, options}) {
   |} = {};
   let writeEarlyPromises = {};
   let hashRefToNameHash = new Map();
-  let bundles = bundleGraph.getBundles().filter(bundle => {
+  let bundles = bundleGraph.getBundles().filter((bundle) => {
     // 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) {
@@ -91,12 +91,12 @@ async function run({input, api, farm, options}) {
   // This avoids the cost of serializing the bundle graph for single file change builds.
   let useMainThread =
     bundles.length === 1 ||
-    bundles.filter(b => !api.canSkipSubrequest(bundleGraph.getHash(b)))
+    bundles.filter((b) => !api.canSkipSubrequest(bundleGraph.getHash(b)))
       .length === 1;
 
   try {
     await Promise.all(
-      bundles.map(async bundle => {
+      bundles.map(async (bundle) => {
         let request = createPackageRequest({
           bundle,
           bundleGraph,
@@ -142,7 +142,7 @@ async function run({input, api, farm, options}) {
     );
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
     await Promise.all(
-      bundles.map(bundle => {
+      bundles.map((bundle) => {
         let promise =
           writeEarlyPromises[bundle.id] ??
           api.runRequest(
@@ -154,7 +154,7 @@ async function run({input, api, farm, options}) {
             }),
           );
 
-        return promise.then(r => res.set(bundle.id, r));
+        return promise.then((r) => res.set(bundle.id, r));
       }),
     );
 
@@ -180,7 +180,7 @@ function assignComplexNameHashes(
       options.shouldContentHash
         ? hashString(
             [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              .map(bundleId => bundleInfoMap[bundleId].hash)
+              .map((bundleId) => bundleInfoMap[bundleId].hash)
               .join(':'),
           ).slice(-8)
         : bundle.id.slice(-8),

package/src/requests/asset-graph-diff.js

@@ -49,12 +49,12 @@ function compactDeep(
     });
     return copy;
   } else if (Array.isArray(obj)) {
-    return obj.map(v => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
+    return obj.map((v) => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
   } else if (typeof obj === 'object') {
     const copy = {};
     Object.entries(obj ?? {}).forEach(([key, value]) => {
       const path = `${currentPath}.${key}`;
-      if (ignoredPatterns.some(pattern => path.includes(pattern))) {
+      if (ignoredPatterns.some((pattern) => path.includes(pattern))) {
         return;
       }
       // Equivalent false == null
@@ -73,10 +73,10 @@ function compactDeep(
 }
 
 function assetGraphDiff(jsAssetGraph: AssetGraph, rustAssetGraph: AssetGraph) {
-  const getNodes = graph => {
+  const getNodes = (graph) => {
     let nodes = {};
 
-    graph.traverse(nodeId => {
+    graph.traverse((nodeId) => {
       let node: AssetGraphNode | null = graph.getNode(nodeId) ?? null;
       if (!node) return;