@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/src/requests/{AssetGraphRequest.js → AssetGraphRequest.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {NodeId} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -20,6 +18,7 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -30,44 +29,47 @@ import createEntryRequest from './EntryRequest';
 import createTargetRequest from './TargetRequest';
 import createAssetRequest from './AssetRequest';
 import createPathRequest from './PathRequest';
-import {type ProjectPath, fromProjectPathRelative} from '../projectPath';
+import {ProjectPath, fromProjectPathRelative} from '../projectPath';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
 import {propagateSymbols} from '../SymbolPropagation';
 import {requestTypes} from '../RequestTracker';
 
-export type AssetGraphRequestInput = {|
-  entries?: Array<ProjectPath>,
-  assetGroups?: Array<AssetGroup>,
-  optionsRef: SharedReference,
-  name: string,
-  shouldBuildLazily?: boolean,
-  lazyIncludes?: RegExp[],
-  lazyExcludes?: RegExp[],
-  requestedAssetIds?: Set<string>,
-|};
-
-export type AssetGraphRequestResult = {|
-  assetGraph: AssetGraph,
+export type AssetGraphRequestInput = {
+  entries?: Array<ProjectPath>;
+  assetGroups?: Array<AssetGroup>;
+  optionsRef: SharedReference;
+  name: string;
+  shouldBuildLazily?: boolean;
+  lazyIncludes?: RegExp[];
+  lazyExcludes?: RegExp[];
+  requestedAssetIds?: Set<string>;
+  skipSymbolProp?: boolean;
+};
+
+export type AssetGraphRequestResult = {
+  assetGraph: AssetGraph;
   /** Assets added/modified since the last successful build. */
-  changedAssets: Map<string, Asset>,
+  changedAssets: Map<string, Asset>;
   /** Assets added/modified since the last symbol propagation invocation. */
-  changedAssetsPropagation: Set<string>,
-  assetGroupsWithRemovedParents: ?Set<NodeId>,
-  previousSymbolPropagationErrors: ?Map<NodeId, Array<Diagnostic>>,
-  assetRequests: Array<AssetGroup>,
-|};
-
-type RunInput = {|
-  input: AssetGraphRequestInput,
-  ...StaticRunOpts<AssetGraphRequestResult>,
-|};
-
-type AssetGraphRequest = {|
-  id: string,
-  +type: typeof requestTypes.asset_graph_request,
-  run: (RunInput) => Async<AssetGraphRequestResult>,
-  input: AssetGraphRequestInput,
-|};
+  changedAssetsPropagation: Set<string>;
+  assetGroupsWithRemovedParents: Set<NodeId> | null | undefined;
+  previousSymbolPropagationErrors:
+    | Map<NodeId, Array<Diagnostic>>
+    | null
+    | undefined;
+  assetRequests: Array<AssetGroup>;
+};
+
+type RunInput = {
+  input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+
+type AssetGraphRequest = {
+  id: string;
+  readonly type: typeof requestTypes.asset_graph_request;
+  run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+  input: AssetGraphRequestInput;
+};
 
 export default function createAssetGraphRequest(
   requestInput: AssetGraphRequestInput,
@@ -80,9 +82,14 @@ export default function createAssetGraphRequest(
         await input.api.getPreviousResult<AssetGraphRequestResult>();
 
       let builder = new AssetGraphBuilder(input, prevResult);
-      let assetGraphRequest = await await builder.build();
+      let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
+      assetGraphRequest.assetGraph.setDisableIncrementalBundling(
+        !input.options.shouldBundleIncrementally ||
+          input.options.mode === 'production',
+      );
+
       if (
         !input.options.shouldBundleIncrementally ||
         input.options.mode === 'production'
@@ -106,10 +113,10 @@ const typesWithRequests = new Set([
 export class AssetGraphBuilder {
   assetGraph: AssetGraph;
   assetRequests: Array<AssetGroup> = [];
-  queue: PromiseQueue<mixed>;
+  queue: PromiseQueue<unknown>;
   changedAssets: Map<string, Asset>;
   changedAssetsPropagation: Set<string>;
-  prevChangedAssetsPropagation: ?Set<string>;
+  prevChangedAssetsPropagation: Set<string> | null | undefined;
   optionsRef: SharedReference;
   options: AtlaspackOptions;
   api: RunAPI<AssetGraphRequestResult>;
@@ -122,10 +129,11 @@ export class AssetGraphBuilder {
   isSingleChangeRebuild: boolean;
   assetGroupsWithRemovedParents: Set<NodeId>;
   previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>>;
+  skipSymbolProp: boolean;
 
   constructor(
     {input, api, options}: RunInput,
-    prevResult: ?AssetGraphRequestResult,
+    prevResult?: AssetGraphRequestResult | null,
   ) {
     let {
       entries,
@@ -161,20 +169,32 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey =
-      hashString(
+    this.skipSymbolProp = input.skipSymbolProp ?? false;
+
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-AssetGraph';
+      );
+      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
+            options.mode
+          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-AssetGraph';
+    }
 
     this.isSingleChangeRebuild =
       api
         .getInvalidSubRequests()
+        // @ts-expect-error TS2367
         .filter((req) => req.requestType === 'asset_request').length === 1;
     this.queue = new PromiseQueue();
 
-    assetGraph.onNodeRemoved = (nodeId) => {
+    assetGraph.onNodeRemoved = (nodeId: NodeId) => {
       this.assetGroupsWithRemovedParents.delete(nodeId);
 
       // This needs to mark all connected nodes that doesn't become orphaned
@@ -196,7 +216,7 @@ export class AssetGraphBuilder {
   }
 
   async build(): Promise<AssetGraphRequestResult> {
-    let errors = [];
+    let errors: Array<Error> = [];
     let rootNodeId = nullthrows(
       this.assetGraph.rootNodeId,
       'A root node is required to traverse',
@@ -224,6 +244,7 @@ export class AssetGraphBuilder {
       for (let childNodeId of this.assetGraph.getNodeIdsConnectedFrom(nodeId)) {
         let child = nullthrows(this.assetGraph.getNode(childNodeId));
         if (
+          // @ts-expect-error TS2339
           (!visited.has(childNodeId) || child.hasDeferred) &&
           this.shouldVisitChild(nodeId, childNodeId)
         ) {
@@ -281,41 +302,51 @@ export class AssetGraphBuilder {
         this.assetGraph,
         'AssetGraph_' + this.name + '_before_prop',
       );
-      try {
-        let errors = propagateSymbols({
-          options: this.options,
-          assetGraph: this.assetGraph,
-          changedAssetsPropagation: this.changedAssetsPropagation,
-          assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
-          previousErrors: this.previousSymbolPropagationErrors,
-        });
-        this.changedAssetsPropagation.clear();
-
-        if (errors.size > 0) {
-          this.api.storeResult(
-            {
-              assetGraph: this.assetGraph,
-              changedAssets: this.changedAssets,
-              changedAssetsPropagation: this.changedAssetsPropagation,
-              assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
-              previousSymbolPropagationErrors: errors,
-              assetRequests: [],
-            },
-            this.cacheKey,
-          );
 
-          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-          throw new ThrowableDiagnostic({
-            diagnostic: [...errors.values()][0],
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (this.skipSymbolProp) {
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph',
+        });
+      } else {
+        try {
+          let errors = propagateSymbols({
+            options: this.options,
+            assetGraph: this.assetGraph,
+            changedAssetsPropagation: this.changedAssetsPropagation,
+            assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
+            previousErrors: this.previousSymbolPropagationErrors,
           });
+          this.changedAssetsPropagation.clear();
+
+          if (errors.size > 0) {
+            this.api.storeResult(
+              {
+                assetGraph: this.assetGraph,
+                changedAssets: this.changedAssets,
+                changedAssetsPropagation: this.changedAssetsPropagation,
+                assetGroupsWithRemovedParents:
+                  this.assetGroupsWithRemovedParents,
+                previousSymbolPropagationErrors: errors,
+                assetRequests: [],
+              },
+              this.cacheKey,
+            );
+
+            // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+            // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+            throw new ThrowableDiagnostic({
+              diagnostic: [...errors.values()][0],
+            });
+          }
+        } catch (e: any) {
+          await dumpGraphToGraphViz(
+            this.assetGraph,
+            'AssetGraph_' + this.name + '_failed',
+          );
+          throw e;
         }
-      } catch (e) {
-        await dumpGraphToGraphViz(
-          this.assetGraph,
-          'AssetGraph_' + this.name + '_failed',
-        );
-        throw e;
       }
     }
     await dumpGraphToGraphViz(this.assetGraph, 'AssetGraph_' + this.name);
@@ -428,9 +459,12 @@ export class AssetGraphBuilder {
   shouldSkipRequest(nodeId: NodeId): boolean {
     let node = nullthrows(this.assetGraph.getNode(nodeId));
     return (
+      // @ts-expect-error TS2339
       node.complete === true ||
       !typesWithRequests.has(node.type) ||
+      // @ts-expect-error TS2339
       (node.correspondingRequest != null &&
+        // @ts-expect-error TS2339
         this.api.canSkipSubrequest(node.correspondingRequest))
     );
   }
@@ -459,7 +493,7 @@ export class AssetGraphBuilder {
           `Can not queue corresponding request of node with type ${node.type}`,
         );
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve: (result: Promise<null> | null) => void) => {
       this.queue.add(() =>
         promise.then(
           () => {
@@ -501,6 +535,7 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
+        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -515,15 +550,16 @@ export class AssetGraphBuilder {
 
   async runPathRequest(input: Dependency) {
     let request = createPathRequest({dependency: input, name: this.name});
-    let result = await this.api.runRequest<PathRequestInput, ?AssetGroup>(
-      request,
-      {force: true},
-    );
+    let result = await this.api.runRequest<
+      PathRequestInput,
+      AssetGroup | null | undefined
+    >(request, {force: true});
     this.assetGraph.resolveDependency(input, result, request.id);
   }
 
   async runAssetRequest(input: AssetGroup) {
     this.assetRequests.push(input);
+    // @ts-expect-error TS2345
     let request = createAssetRequest({
       ...input,
       name: this.name,
@@ -538,16 +574,28 @@ export class AssetGraphBuilder {
 
     if (assets != null) {
       for (let asset of assets) {
+        // Pass the runtimeAssetRequiringExecutionOnLoad flag from the asset
+        // group down to the asset itself, for reading in the packager.
+        if (input.runtimeAssetRequiringExecutionOnLoad) {
+          asset.meta = {
+            ...(asset.meta ?? {}),
+            runtimeAssetRequiringExecutionOnLoad:
+              input.runtimeAssetRequiringExecutionOnLoad,
+          };
+        }
+
         if (this.assetGraph.safeToIncrementallyBundle) {
           let otherAsset = this.assetGraph.getNodeByContentKey(asset.id);
           if (otherAsset != null) {
             invariant(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
+              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
+            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -556,6 +604,7 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
+      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;