@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

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,46 @@ 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>;
+};
+
+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,
@@ -83,6 +84,11 @@ export default function createAssetGraphRequest(
       let assetGraphRequest = await 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 +112,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>;
@@ -125,7 +131,7 @@ export class AssetGraphBuilder {
 
   constructor(
     {input, api, options}: RunInput,
-    prevResult: ?AssetGraphRequestResult,
+    prevResult?: AssetGraphRequestResult | null,
   ) {
     let {
       entries,
@@ -161,20 +167,30 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey =
-      hashString(
+    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 +212,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 +240,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)
         ) {
@@ -310,7 +327,7 @@ export class AssetGraphBuilder {
             diagnostic: [...errors.values()][0],
           });
         }
-      } catch (e) {
+      } catch (e: any) {
         await dumpGraphToGraphViz(
           this.assetGraph,
           'AssetGraph_' + this.name + '_failed',
@@ -428,9 +445,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 +479,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 +521,7 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
+        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -515,15 +536,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 +560,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 +590,7 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
+      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;

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

@@ -1,14 +1,13 @@
-// @flow strict-local
-
 import invariant from 'assert';
 
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Async} from '@atlaspack/types';
 import {instrument} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph, {nodeFromAssetGroup} from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
-import {requestTypes, type StaticRunOpts} from '../RequestTracker';
+import {requestTypes, StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
 import type {Environment, Asset} from '../types';
 
@@ -16,29 +15,31 @@ import type {
   AssetGraphRequestInput,
   AssetGraphRequestResult,
 } from './AssetGraphRequest';
+import {toEnvironmentRef} from '../EnvironmentManager';
+import {getEnvironmentHash} from '../Environment';
 
-type RunInput = {|
-  input: AssetGraphRequestInput,
-  ...StaticRunOpts<AssetGraphRequestResult>,
-|};
+type RunInput = {
+  input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
 
-type AssetGraphRequest = {|
-  id: string,
-  +type: typeof requestTypes.asset_graph_request,
-  run: (RunInput) => Async<AssetGraphRequestResult>,
-  input: AssetGraphRequestInput,
-|};
+type AssetGraphRequest = {
+  id: string;
+  readonly type: typeof requestTypes.asset_graph_request;
+  run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+  input: AssetGraphRequestInput;
+};
 
 export function createAssetGraphRequestRust(
   rustAtlaspack: AtlaspackV3,
 ): (input: AssetGraphRequestInput) => AssetGraphRequest {
-  return (input) => ({
+  return (input: AssetGraphRequestInput) => ({
     type: requestTypes.asset_graph_request,
     id: input.name,
     run: async (input) => {
       let options = input.options;
       let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
 
+      // @ts-expect-error TS7006
       serializedAssetGraph.nodes = serializedAssetGraph.nodes.map((node) =>
         JSON.parse(node),
       );
@@ -78,10 +79,9 @@ export function createAssetGraphRequestRust(
   });
 }
 
-// $FlowFixMe
 export function getAssetGraph(serializedGraph: any): {
-  assetGraph: AssetGraph,
-  changedAssets: Map<string, Asset>,
+  assetGraph: AssetGraph;
+  changedAssets: Map<string, Asset>;
 } {
   let graph = new AssetGraph({
     _contentKeyToNodeId: new Map(),
@@ -91,26 +91,23 @@ export function getAssetGraph(serializedGraph: any): {
 
   graph.safeToIncrementallyBundle = false;
 
+  // @ts-expect-error TS7031
   function mapSymbols({exported, ...symbol}) {
     let jsSymbol = {
       local: symbol.local ?? undefined,
       loc: symbol.loc ?? undefined,
-      meta: undefined,
       isWeak: symbol.isWeak,
+      meta: {
+        isEsm: symbol.isEsmExport,
+        isStaticBindingSafe: symbol.isStaticBindingSafe,
+      },
     };
 
     if (symbol.exported) {
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       jsSymbol.exported = symbol.exported;
     }
 
-    if (symbol.isEsmExport) {
-      // $FlowFixMe
-      jsSymbol.meta = {
-        isEsm: true,
-      };
-    }
-
     return [exported, jsSymbol];
   }
 
@@ -136,7 +133,7 @@ export function getAssetGraph(serializedGraph: any): {
 
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = envs.size;
+      envId = `${envs.size}`;
       envs.set(envKey, envId);
     }
 
@@ -166,9 +163,14 @@ export function getAssetGraph(serializedGraph: any): {
 
       asset.committed = true;
       asset.contentKey = id;
-      asset.env.id = getEnvId(asset.env);
+      asset.env.id = getFeatureFlag('environmentDeduplication')
+        ? // TODO: Rust can do this and avoid copying a significant amount of data over
+          getEnvironmentHash(asset.env)
+        : getEnvId(asset.env);
       asset.mapKey = `map:${asset.id}`;
 
+      asset.env = toEnvironmentRef(asset.env);
+
       // This is populated later when we map the edges between assets and dependencies
       asset.dependencies = new Map();
 
@@ -195,7 +197,11 @@ export function getAssetGraph(serializedGraph: any): {
       let dependency = node.value.dependency;
 
       dependency.id = id;
-      dependency.env.id = getEnvId(dependency.env);
+      dependency.env.id = getFeatureFlag('environmentDeduplication')
+        ? // TODO: Rust can do this and avoid copying a significant amount of data over
+          getEnvironmentHash(dependency.env)
+        : getEnvId(dependency.env);
+      dependency.env = toEnvironmentRef(dependency.env);
 
       if (dependency.symbols != null) {
         dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
@@ -214,6 +220,7 @@ export function getAssetGraph(serializedGraph: any): {
         deferred: false,
         excluded: false,
         hasDeferred: node.has_deferred,
+        // @ts-expect-error TS2322
         usedSymbolsDown,
         usedSymbolsDownDirty: true,
         usedSymbolsUp,

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import type {StaticRunOpts} from '../RequestTracker';
@@ -21,18 +19,18 @@ import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 import {report} from '../ReporterRunner';
 import {requestTypes} from '../RequestTracker';
 import type {DevDepRequestResult} from './DevDepRequest';
+import {toEnvironmentId} from '../EnvironmentManager';
 
-type RunInput<TResult> = {|
-  input: AssetRequestInput,
-  ...StaticRunOpts<TResult>,
-|};
+type RunInput<TResult> = {
+  input: AssetRequestInput;
+} & StaticRunOpts<TResult>;
 
-export type AssetRequest = {|
-  id: ContentKey,
-  +type: typeof requestTypes.asset_request,
-  run: (RunInput<AssetRequestResult>) => Async<AssetRequestResult>,
-  input: AssetRequestInput,
-|};
+export type AssetRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.asset_request;
+  run: (arg1: RunInput<AssetRequestResult>) => Async<AssetRequestResult>;
+  input: AssetRequestInput;
+};
 
 export default function createAssetRequest(
   input: AssetRequestInput,
@@ -51,7 +49,7 @@ function getId(input: AssetRequestInput) {
   return hashString(
     type +
       fromProjectPathRelative(input.filePath) +
-      input.env.id +
+      toEnvironmentId(input.env) +
       String(input.isSource) +
       String(input.sideEffects) +
       (input.code ?? '') +
@@ -62,6 +60,7 @@ function getId(input: AssetRequestInput) {
   );
 }
 
+// @ts-expect-error TS7031
 async function run({input, api, farm, invalidateReason, options}) {
   report({
     type: 'buildProgress',
@@ -73,6 +72,7 @@ async function run({input, api, farm, invalidateReason, options}) {
   let start = Date.now();
   let {optionsRef, ...rest} = input;
   let {cachePath} = nullthrows(
+    // @ts-expect-error TS2347
     await api.runRequest<null, ConfigAndCachePath>(
       createAtlaspackConfigRequest(),
     ),
@@ -82,9 +82,12 @@ async function run({input, api, farm, invalidateReason, options}) {
     await Promise.all(
       api
         .getSubRequests()
+        // @ts-expect-error TS7006
         .filter((req) => req.requestType === requestTypes.dev_dep_request)
+        // @ts-expect-error TS7006
         .map(async (req) => [
           req.id,
+          // @ts-expect-error TS2347
           nullthrows(await api.getRequestResult<DevDepRequestResult>(req.id)),
         ]),
     ),
@@ -95,21 +98,24 @@ async function run({input, api, farm, invalidateReason, options}) {
     invalidateReason,
     devDeps: new Map(
       [...previousDevDepRequests.entries()]
-        .filter(([id]) => api.canSkipSubrequest(id))
-        .map(([, req]: [string, DevDepRequestResult]) => [
+        // @ts-expect-error TS2769
+        .filter(([id]: [any]) => api.canSkipSubrequest(id))
+        .map(([, req]: [any, any]) => [
           `${req.specifier}:${fromProjectPathRelative(req.resolveFrom)}`,
           req.hash,
         ]),
     ),
     invalidDevDeps: await Promise.all(
       [...previousDevDepRequests.entries()]
-        .filter(([id]) => !api.canSkipSubrequest(id))
-        .flatMap(([, req]: [string, DevDepRequestResult]) => {
+        // @ts-expect-error TS2769
+        .filter(([id]: [any]) => !api.canSkipSubrequest(id))
+        .flatMap(([, req]: [any, any]) => {
           return [
             {
               specifier: req.specifier,
               resolveFrom: req.resolveFrom,
             },
+            // @ts-expect-error TS7006
             ...(req.additionalInvalidations ?? []).map((i) => ({
               specifier: i.specifier,
               resolveFrom: i.resolveFrom,
@@ -127,7 +133,7 @@ async function run({input, api, farm, invalidateReason, options}) {
       configCachePath: cachePath,
       optionsRef,
       request,
-    }): TransformationResult);
+    })) as TransformationResult;
 
   let time = Date.now() - start;
   if (assets) {

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -9,7 +7,7 @@ import type {Asset, AssetGroup, PackagedBundleInfo} from '../types';
 import type BundleGraph from '../BundleGraph';
 
 import createBundleGraphRequest, {
-  type BundleGraphResult,
+  BundleGraphResult,
 } from './BundleGraphRequest';
 import createWriteBundlesRequest from './WriteBundlesRequest';
 import {assertSignalNotAborted} from '../utils';
@@ -23,32 +21,31 @@ import {assetFromValue} from '../public/Asset';
 import {tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 
-type AtlaspackBuildRequestInput = {|
-  optionsRef: SharedReference,
-  requestedAssetIds: Set<string>,
-  signal?: AbortSignal,
-|};
-
-export type AtlaspackBuildRequestResult = {|
-  bundleGraph: BundleGraph,
-  bundleInfo: Map<string, PackagedBundleInfo>,
-  changedAssets: Map<string, Asset>,
-  assetRequests: Array<AssetGroup>,
-|};
-
-type RunInput<TResult> = {|
-  input: AtlaspackBuildRequestInput,
-  ...StaticRunOpts<TResult>,
-|};
-
-export type AtlaspackBuildRequest = {|
-  id: ContentKey,
-  +type: typeof requestTypes.atlaspack_build_request,
+type AtlaspackBuildRequestInput = {
+  optionsRef: SharedReference;
+  requestedAssetIds: Set<string>;
+  signal?: AbortSignal;
+};
+
+export type AtlaspackBuildRequestResult = {
+  bundleGraph: BundleGraph;
+  bundleInfo: Map<string, PackagedBundleInfo>;
+  changedAssets: Map<string, Asset>;
+  assetRequests: Array<AssetGroup>;
+};
+
+type RunInput<TResult> = {
+  input: AtlaspackBuildRequestInput;
+} & StaticRunOpts<TResult>;
+
+export type AtlaspackBuildRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.atlaspack_build_request;
   run: (
-    RunInput<AtlaspackBuildRequestResult>,
-  ) => Async<AtlaspackBuildRequestResult>,
-  input: AtlaspackBuildRequestInput,
-|};
+    arg1: RunInput<AtlaspackBuildRequestResult>,
+  ) => Async<AtlaspackBuildRequestResult>;
+  input: AtlaspackBuildRequestInput;
+};
 
 export default function createAtlaspackBuildRequest(
   input: AtlaspackBuildRequestInput,
@@ -61,6 +58,7 @@ export default function createAtlaspackBuildRequest(
   };
 }
 
+// @ts-expect-error TS7031
 async function run({input, api, options, rustAtlaspack}) {
   let {optionsRef, requestedAssetIds, signal} = input;
 
@@ -77,7 +75,7 @@ async function run({input, api, options, rustAtlaspack}) {
         (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
 
-  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
+  // @ts-expect-error TS2345
   dumpGraphToGraphViz(bundleGraph._graph, 'BundleGraph', bundleGraphEdgeTypes);
 
   await report({
@@ -85,12 +83,13 @@ async function run({input, api, options, rustAtlaspack}) {
     phase: 'bundled',
     bundleGraph: new IBundleGraph(
       bundleGraph,
-      (bundle, bundleGraph, options) =>
+      // @ts-expect-error TS2304
+      (bundle: Bundle, bundleGraph: BundleGraph, options: AtlaspackOptions) =>
         NamedBundle.get(bundle, bundleGraph, options),
       options,
     ),
     changedAssets: new Map(
-      Array.from(changedAssets).map(([id, asset]) => [
+      Array.from(changedAssets).map(([id, asset]: [any, any]) => [
         id,
         assetFromValue(asset, options),
       ]),