@atlaspack/core 2.26.3-dev-compiled-hash-e5f8a1735.0 → 2.28.0

package/src/requests/AssetGraphRequestRust.ts

@@ -5,11 +5,17 @@ import type {Async} from '@atlaspack/types';
 import {instrument} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-import AssetGraph, {nodeFromAssetGroup} from '../AssetGraph';
+import AssetGraph from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
 import {requestTypes, StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
-import type {Environment, Asset} from '../types';
+import type {
+  Environment,
+  Asset,
+  AssetGraphNode,
+  AssetNode,
+  DependencyNode,
+} from '../types';
 
 import type {
   AssetGraphRequestInput,
@@ -17,6 +23,8 @@ import type {
 } from './AssetGraphRequest';
 import {toEnvironmentRef} from '../EnvironmentManager';
 import {getEnvironmentHash} from '../Environment';
+import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
+import assert from 'assert';
 
 type RunInput = {
   input: AssetGraphRequestInput;
@@ -29,6 +37,14 @@ type AssetGraphRequest = {
   input: AssetGraphRequestInput;
 };
 
+type SerializedAssetGraphDelta = {
+  nodes: Array<any>;
+  edges: Array<string>;
+  updates: Array<any>;
+  safeToSkipBundling: boolean;
+  hadPreviousGraph: boolean;
+};
+
 export function createAssetGraphRequestRust(
   rustAtlaspack: AtlaspackV3,
 ): (input: AssetGraphRequestInput) => AssetGraphRequest {
@@ -37,16 +53,29 @@ export function createAssetGraphRequestRust(
     id: input.name,
     run: async (input) => {
       let options = input.options;
-      let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
+      let serializedAssetGraph =
+        (await rustAtlaspack.buildAssetGraph()) as SerializedAssetGraphDelta;
 
-      // @ts-expect-error TS7006
+      // Newly created nodes
       serializedAssetGraph.nodes = serializedAssetGraph.nodes.map((node) =>
         JSON.parse(node),
       );
 
+      // Updated existing nodes
+      serializedAssetGraph.updates = serializedAssetGraph.updates.map((node) =>
+        JSON.parse(node),
+      );
+
+      // Don't reuse a previous asset graph result if Rust didn't have one too
+      let prevResult = null;
+      if (serializedAssetGraph.hadPreviousGraph) {
+        prevResult =
+          await input.api.getPreviousResult<AssetGraphRequestResult>();
+      }
+
       let {assetGraph, changedAssets} = instrument(
         'atlaspack_v3_getAssetGraph',
-        () => getAssetGraph(serializedAssetGraph),
+        () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph),
       );
 
       let changedAssetsPropagation = new Set(changedAssets.keys());
@@ -66,30 +95,81 @@ export function createAssetGraphRequestRust(
         });
       }
 
-      return {
+      await dumpGraphToGraphViz(assetGraph, 'AssetGraphV3');
+
+      let result = {
         assetGraph,
         assetRequests: [],
-        assetGroupsWithRemovedParents: new Set(),
+        assetGroupsWithRemovedParents: new Set<number>(),
         changedAssets,
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined,
       };
+
+      await input.api.storeResult(result);
+      input.api.invalidateOnBuild();
+
+      return result;
     },
     input,
   });
 }
 
-export function getAssetGraph(serializedGraph: any): {
+export function getAssetGraph(
+  serializedGraph: any,
+  prevAssetGraph?: AssetGraph,
+): {
   assetGraph: AssetGraph;
   changedAssets: Map<string, Asset>;
 } {
-  let graph = new AssetGraph({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length,
-  });
+  let graph: AssetGraph;
+
+  let reuseEdges = false;
+
+  if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+    graph = new AssetGraph({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      rootNodeId: prevAssetGraph.rootNodeId,
+      adjacencyList: prevAssetGraph.adjacencyList,
+    });
+    reuseEdges = true;
+  } else if (
+    prevAssetGraph &&
+    (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)
+  ) {
+    graph = new AssetGraph({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+      rootNodeId: prevAssetGraph.rootNodeId,
+    });
+    graph.safeToIncrementallyBundle = false;
+  } else {
+    graph = new AssetGraph({
+      _contentKeyToNodeId: new Map(),
+      _nodeIdToContentKey: new Map(),
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: serializedGraph.nodes.length + 1,
+    });
+
+    let rootNodeId = graph.addNodeByContentKey('@@root', {
+      id: '@@root',
+      type: 'root',
+      value: null,
+    });
+
+    graph.setRootNodeId(rootNodeId);
+    graph.safeToIncrementallyBundle = false;
+  }
 
-  graph.safeToIncrementallyBundle = false;
+  invariant(graph, 'Asset graph not initialized');
+  invariant(graph.rootNodeId != null, 'Asset graph has no root node');
 
   // @ts-expect-error TS7031
   function mapSymbols({exported, ...symbol}) {
@@ -133,23 +213,36 @@ export function getAssetGraph(serializedGraph: any): {
 
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = `${envs.size}`;
+      envId = envs.size.toString();
       envs.set(envKey, envId);
     }
 
     return envId;
   };
 
-  for (let node of serializedGraph.nodes) {
-    if (node.type === 'root') {
-      let index = graph.addNodeByContentKey('@@root', {
-        id: '@@root',
-        type: 'root',
-        value: null,
-      });
+  function updateNode(newNode: AssetGraphNode, isUpdateNode: boolean) {
+    if (isUpdateNode) {
+      let existingNode = graph.getNodeByContentKey(newNode.id);
+
+      assert(existingNode && existingNode.type === newNode.type);
 
-      graph.setRootNodeId(index);
-    } else if (node.type === 'entry') {
+      Object.assign(existingNode, newNode);
+    } else {
+      graph.addNodeByContentKey(newNode.id, newNode);
+    }
+  }
+
+  let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+  let nodesCount =
+    serializedGraph.nodes.length + serializedGraph.updates.length;
+
+  for (let index = 0; index < nodesCount; index++) {
+    let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+    let node = isUpdateNode
+      ? serializedGraph.updates[index - nodeTypeSwitchoverIndex]
+      : serializedGraph.nodes[index];
+
+    if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
 
       graph.addNodeByContentKey(id, {
@@ -184,14 +277,15 @@ export function getAssetGraph(serializedGraph: any): {
 
       changedAssets.set(id, asset);
 
-      graph.addNodeByContentKey(id, {
+      let assetNode: AssetNode = {
         id,
         type: 'asset',
         usedSymbols: new Set(),
         usedSymbolsDownDirty: true,
         usedSymbolsUpDirty: true,
         value: asset,
-      });
+      };
+      updateNode(assetNode, isUpdateNode);
     } else if (node.type === 'dependency') {
       let {dependency, id} = node.value;
 
@@ -213,7 +307,7 @@ export function getAssetGraph(serializedGraph: any): {
         usedSymbolsUp.set('*', undefined);
       }
 
-      graph.addNodeByContentKey(id, {
+      let depNode: DependencyNode = {
         id,
         type: 'dependency',
         deferred: false,
@@ -226,25 +320,29 @@ export function getAssetGraph(serializedGraph: any): {
         usedSymbolsUpDirtyDown: true,
         usedSymbolsUpDirtyUp: true,
         value: dependency,
-      });
+      };
+
+      updateNode(depNode, isUpdateNode);
     }
   }
 
-  for (let i = 0; i < serializedGraph.edges.length; i += 2) {
-    let from = serializedGraph.edges[i];
-    let to = serializedGraph.edges[i + 1];
-    let fromNode = graph.getNode(from);
-    let toNode = graph.getNode(to);
+  if (!reuseEdges) {
+    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+      let from = serializedGraph.edges[i];
+      let to = serializedGraph.edges[i + 1];
+      let fromNode = graph.getNode(from);
+      let toNode = graph.getNode(to);
 
-    if (fromNode?.type === 'dependency') {
-      invariant(toNode?.type === 'asset');
-    }
+      if (fromNode?.type === 'dependency') {
+        invariant(toNode?.type === 'asset');
+      }
 
-    if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
-      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-    }
+      if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+        fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+      }
 
-    graph.addEdge(from, to);
+      graph.addEdge(from, to);
+    }
   }
 
   return {

package/src/requests/AtlaspackConfigRequest.ts

@@ -198,29 +198,19 @@ export async function resolveAtlaspackConfig(
     await parseAndProcessConfig(configPath, contents, options);
 
   if (options.additionalReporters.length > 0) {
-    if (options.featureFlags.deduplicateReporters) {
-      const reporterMap = new Map<PackageName, AtlaspackPluginNode>();
+    const reporterMap = new Map<PackageName, AtlaspackPluginNode>();
 
-      options.additionalReporters.forEach(({packageName, resolveFrom}) => {
-        reporterMap.set(packageName, {packageName, resolveFrom});
-      });
+    options.additionalReporters.forEach(({packageName, resolveFrom}) => {
+      reporterMap.set(packageName, {packageName, resolveFrom});
+    });
 
-      config.reporters?.forEach((reporter) => {
-        if (!reporterMap.has(reporter.packageName)) {
-          reporterMap.set(reporter.packageName, reporter);
-        }
-      });
+    config.reporters?.forEach((reporter) => {
+      if (!reporterMap.has(reporter.packageName)) {
+        reporterMap.set(reporter.packageName, reporter);
+      }
+    });
 
-      config.reporters = Array.from(reporterMap.values());
-    } else {
-      config.reporters = [
-        ...options.additionalReporters.map(({packageName, resolveFrom}) => ({
-          packageName,
-          resolveFrom,
-        })),
-        ...(config.reporters ?? []),
-      ];
-    }
+    config.reporters = Array.from(reporterMap.values());
   }
 
   return {config, extendedFiles, usedDefault};

package/src/requests/BundleGraphRequest.ts

@@ -17,7 +17,7 @@ import fs from 'fs';
 import invariant from 'assert';
 import assert from 'assert';
 import nullthrows from 'nullthrows';
-import {PluginLogger} from '@atlaspack/logger';
+import {instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
@@ -155,12 +155,14 @@ export default function createBundleGraphRequest(
         requestedAssetIds,
       });
 
-      let {assetGraph, changedAssets, assetRequests} = await api.runRequest(
-        request,
-        {
-          force:
-            Boolean(input.rustAtlaspack) ||
-            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+      let {assetGraph, changedAssets, assetRequests} = await instrumentAsync(
+        'asset-graph-request',
+        () => {
+          return api.runRequest(request, {
+            force:
+              Boolean(input.rustAtlaspack) ||
+              (options.shouldBuildLazily && requestedAssetIds.size > 0),
+          });
         },
       );
 

package/src/resolveOptions.ts

@@ -269,6 +269,7 @@ export default async function resolveOptions(
       : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,

package/src/types.ts

@@ -335,6 +335,7 @@ export type AtlaspackOptions = {
   logLevel: LogLevel;
   projectRoot: FilePath;
   shouldProfile: boolean;
+  nativeProfiler: 'instruments' | 'samply' | undefined;
   shouldTrace: boolean;
   shouldPatchConsole: boolean;
   detailedReport?: DetailedReportOptions | null | undefined;

package/src/worker.ts

@@ -21,7 +21,7 @@ import Validation, {ValidationOpts} from './Validation';
 import {AtlaspackConfig} from './AtlaspackConfig';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {clearBuildCaches} from '@atlaspack/build-cache';
-import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initSourcemaps} from '@atlaspack/source-map';
 // @ts-expect-error TS2305
 import {init as initRust} from '@atlaspack/rust';
 import WorkerFarm from '@atlaspack/workers';

package/test/requests/AssetGraphRequestRust.test.ts

@@ -436,5 +436,6 @@ function getSerializedGraph() {
         },
       },
     ],
+    updates: [],
   };
 }

package/tsconfig.json

@@ -52,6 +52,9 @@
     },
     {
       "path": "../workers/tsconfig.json"
+    },
+    {
+      "path": "../source-map/tsconfig.json"
     }
   ]
 }