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

package/lib/requests/AssetGraphRequestRust.js

@@ -26,11 +26,19 @@ function _logger() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _EnvironmentManager = require("../EnvironmentManager");
+var _Environment = require("../Environment");
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
@@ -38,12 +46,29 @@ function createAssetGraphRequestRust(rustAtlaspack) {
     id: input.name,
     run: async input => {
       let options = input.options;
-      let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
-      serializedAssetGraph.nodes = serializedAssetGraph.nodes.map(node => JSON.parse(node));
+      let {
+        assetGraphPromise,
+        commitPromise
+      } = await rustAtlaspack.buildAssetGraph();
+      let [serializedAssetGraph, assetGraphError] = await assetGraphPromise;
+      if (assetGraphError) {
+        throw new (_diagnostic().default)({
+          diagnostic: assetGraphError
+        });
+      }
+
+      // 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();
+      }
       let {
         assetGraph,
         changedAssets
-      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
+      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => {
+        var _prevResult;
+        return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
+      });
       let changedAssetsPropagation = new Set(changedAssets.keys());
       let errors = (0, _SymbolPropagation.propagateSymbols)({
         options,
@@ -60,7 +85,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
           diagnostic: [...errors.values()][0]
         });
       }
-      return {
+      await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
+      let result = {
         assetGraph,
         assetRequests: [],
         assetGroupsWithRemovedParents: new Set(),
@@ -68,19 +94,64 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined
       };
+      let [_commitResult, commitError] = await commitPromise;
+      if (commitError) {
+        throw new (_diagnostic().default)({
+          diagnostic: {
+            message: 'Error committing asset graph in Rust: ' + commitError.message
+          }
+        });
+      }
+      await input.api.storeResult(result);
+      input.api.invalidateOnBuild();
+      return result;
     },
     input
   });
 }
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+  let graph;
+  let reuseEdges = false;
+  if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+    graph = new _AssetGraph.default({
+      _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.default({
+      _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.default({
+      _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;
+  }
+  (0, _assert().default)(graph, 'Asset graph not initialized');
+  (0, _assert().default)(graph.rootNodeId != null, 'Asset graph has no root node');
 
-// $FlowFixMe
-function getAssetGraph(serializedGraph) {
-  let graph = new _AssetGraph.default({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length
-  });
-  graph.safeToIncrementallyBundle = false;
+  // @ts-expect-error TS7031
   function mapSymbols({
     exported,
     ...symbol
@@ -88,19 +159,16 @@ function getAssetGraph(serializedGraph) {
     let jsSymbol = {
       local: symbol.local ?? undefined,
       loc: symbol.loc ?? undefined,
-      meta: undefined,
-      isWeak: symbol.isWeak
+      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];
   }
 
@@ -112,20 +180,27 @@ function getAssetGraph(serializedGraph) {
     let envKey = [env.context, env.engines.atlaspack, env.engines.browsers, env.engines.electron, env.engines.node, env.includeNodeModules, env.isLibrary, env.outputFormat, env.shouldScopeHoist, env.shouldOptimize, env.sourceType].join(':');
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = envs.size;
+      envId = (0, _Environment.getEnvironmentHash)(env);
       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
-      });
-      graph.setRootNodeId(index);
-    } else if (node.type === 'entry') {
+  function updateNode(newNode, isUpdateNode) {
+    if (isUpdateNode) {
+      let existingNode = graph.getNodeByContentKey(newNode.id);
+      (0, _assert().default)(existingNode && existingNode.type === newNode.type);
+      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];
+    node = JSON.parse(node);
+    if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
       graph.addNodeByContentKey(id, {
         id: id,
@@ -137,8 +212,11 @@ function getAssetGraph(serializedGraph) {
       let id = asset.id;
       asset.committed = true;
       asset.contentKey = id;
-      asset.env.id = getEnvId(asset.env);
+      asset.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(asset.env) : getEnvId(asset.env);
       asset.mapKey = `map:${asset.id}`;
+      asset.env = (0, _EnvironmentManager.toEnvironmentRef)(asset.env);
 
       // This is populated later when we map the edges between assets and dependencies
       asset.dependencies = new Map();
@@ -150,19 +228,25 @@ function getAssetGraph(serializedGraph) {
         asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
       changedAssets.set(id, asset);
-      graph.addNodeByContentKey(id, {
+      let assetNode = {
         id,
         type: 'asset',
         usedSymbols: new Set(),
         usedSymbolsDownDirty: true,
         usedSymbolsUpDirty: true,
         value: asset
-      });
+      };
+      updateNode(assetNode, isUpdateNode);
     } else if (node.type === 'dependency') {
-      let id = node.value.id;
-      let dependency = node.value.dependency;
+      let {
+        dependency,
+        id
+      } = node.value;
       dependency.id = id;
-      dependency.env.id = getEnvId(dependency.env);
+      dependency.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(dependency.env) : getEnvId(dependency.env);
+      dependency.env = (0, _EnvironmentManager.toEnvironmentRef)(dependency.env);
       if (dependency.symbols != null) {
         var _dependency$symbols;
         dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _dependency$symbols.map(mapSymbols));
@@ -173,43 +257,35 @@ function getAssetGraph(serializedGraph) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
       }
-      graph.addNodeByContentKey(id, {
+      let depNode = {
         id,
         type: 'dependency',
         deferred: false,
         excluded: false,
         hasDeferred: node.has_deferred,
+        // @ts-expect-error TS2322
         usedSymbolsDown,
         usedSymbolsDownDirty: true,
         usedSymbolsUp,
         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 ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
-      (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-
-      // For backwards compatibility, create asset group node if needed.
-      let assetGroupNode = (0, _AssetGraph.nodeFromAssetGroup)({
-        filePath: toNode.value.filePath,
-        env: fromNode.value.env,
-        pipeline: toNode.value.pipeline,
-        sideEffects: Boolean(toNode.value.sideEffects)
-      });
-      let index = graph.addNodeByContentKeyIfNeeded(assetGroupNode.id, assetGroupNode);
-      graph.addEdge(from, index);
-      graph.addEdge(index, to);
-    } else if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
-      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-      graph.addEdge(from, to);
-    } else {
+  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 === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
+        (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
+      }
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
+        fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+      }
       graph.addEdge(from, to);
     }
   }

package/lib/requests/AssetRequest.js

@@ -31,6 +31,7 @@ var _ConfigRequest = require("./ConfigRequest");
 var _projectPath = require("../projectPath");
 var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetRequest(input) {
   return {
@@ -42,8 +43,10 @@ function createAssetRequest(input) {
 }
 const type = 'asset_request';
 function getId(input) {
-  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + input.env.id + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
+  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + (0, _EnvironmentManager.toEnvironmentId)(input.env) + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
 }
+
+// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -64,17 +67,31 @@ async function run({
   } = input;
   let {
     cachePath
-  } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
+  } = (0, _nullthrows().default)(
+  // @ts-expect-error TS2347
+  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests()
+  // @ts-expect-error TS7006
+  .filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request)
+  // @ts-expect-error TS7006
+  .map(async req => [req.id,
+  // @ts-expect-error TS2347
+  (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
   let request = {
     ...rest,
     invalidateReason,
-    devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
-    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
+    devDeps: new Map([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
+    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
       return [{
         specifier: req.specifier,
         resolveFrom: req.resolveFrom
-      }, ...(req.additionalInvalidations ?? []).map(i => ({
+      },
+      // @ts-expect-error TS7006
+      ...(req.additionalInvalidations ?? []).map(i => ({
         specifier: i.specifier,
         resolveFrom: i.resolveFrom
       }))];

package/lib/requests/AtlaspackBuildRequest.js

@@ -21,6 +21,14 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAtlaspackBuildRequest(input) {
   return {
@@ -53,13 +61,40 @@ async function run({
   } = await api.runRequest(bundleGraphRequest, {
     force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
   });
+  if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack) {
+    let hasSupportedTarget = false;
+    bundleGraph.traverseBundles((bundle, ctx, actions) => {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
+        hasSupportedTarget = true;
+        actions.stop();
+      }
+    });
+    if (hasSupportedTarget) {
+      // In theory this could be a (somehow) null[] - but we know if we've gotten this far it probably isn't..
+      let nodes = bundleGraph._graph.nodes;
+      let rawEdges = [];
+      const gen = bundleGraph._graph.getAllEdges();
+      let next = gen.next();
+      while (!next.done) {
+        let edge = next.value;
+        rawEdges.push([edge.from, edge.to, edge.type]);
+        next = gen.next();
+      }
+      await rustAtlaspack.loadBundleGraph({
+        nodes,
+        edges: rawEdges
+      });
+    }
+  }
 
-  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
+  // @ts-expect-error TS2345
   (0, _dumpGraphToGraphViz.default)(bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);
   await (0, _ReporterRunner.report)({
     type: 'buildProgress',
     phase: 'bundled',
-    bundleGraph: new _BundleGraph2.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.NamedBundle.get(bundle, bundleGraph, options), options),
+    bundleGraph: new _BundleGraph2.default(bundleGraph,
+    // @ts-expect-error TS2304
+    (bundle, bundleGraph, options) => _Bundle.NamedBundle.get(bundle, bundleGraph, options), options),
     changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)]))
   });
   let packagingMeasurement = _profiler().tracer.createMeasurement('packaging');
@@ -67,13 +102,17 @@ async function run({
     bundleGraph,
     optionsRef
   });
-  let bundleInfo = await api.runRequest(writeBundlesRequest);
+  let {
+    bundleInfo,
+    scopeHoistingStats
+  } = await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
   (0, _utils.assertSignalNotAborted)(signal);
   return {
     bundleGraph,
     bundleInfo,
     changedAssets,
-    assetRequests
+    assetRequests,
+    scopeHoistingStats
   };
 }

package/lib/requests/AtlaspackConfigRequest.js

@@ -68,6 +68,8 @@ var _utils2 = require("../utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// @ts-expect-error TS2344
+
 const type = 'atlaspack_config_request';
 function createAtlaspackConfigRequest() {
   return {
@@ -117,10 +119,12 @@ function getCachedAtlaspackConfig(result, options) {
   } = result;
   let config = atlaspackConfigCache.get(cachePath);
   if (config) {
+    // @ts-expect-error TS2740
     return config;
   }
   config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
   atlaspackConfigCache.set(cachePath, config);
+  // @ts-expect-error TS2322
   return config;
 }
 async function loadAtlaspackConfig(options) {
@@ -157,13 +161,23 @@ async function resolveAtlaspackConfig(options) {
     extendedFiles
   } = await parseAndProcessConfig(configPath, contents, options);
   if (options.additionalReporters.length > 0) {
-    config.reporters = [...options.additionalReporters.map(({
-      packageName,
-      resolveFrom
-    }) => ({
+    var _config$reporters;
+    const reporterMap = new Map();
+    options.additionalReporters.forEach(({
       packageName,
       resolveFrom
-    })), ...(config.reporters ?? [])];
+    }) => {
+      reporterMap.set(packageName, {
+        packageName,
+        resolveFrom
+      });
+    });
+    (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
+      if (!reporterMap.has(reporter.packageName)) {
+        reporterMap.set(reporter.packageName, reporter);
+      }
+    });
+    config.reporters = Array.from(reporterMap.values());
   }
   return {
     config,
@@ -207,7 +221,6 @@ async function parseAndProcessConfig(configPath, contents, options) {
 function processPipeline(options, pipeline, keyPath, filePath) {
   if (pipeline) {
     return pipeline.map((pkg, i) => {
-      // $FlowFixMe
       if (pkg === '...') return pkg;
       return {
         packageName: pkg,
@@ -218,14 +231,8 @@ function processPipeline(options, pipeline, keyPath, filePath) {
   }
 }
 const RESERVED_PIPELINES = new Set(['node:', 'npm:', 'http:', 'https:', 'data:', 'tel:', 'mailto:']);
-async function processMap(
-// $FlowFixMe
-map, keyPath, filePath, options
-// $FlowFixMe
-) {
+async function processMap(map, keyPath, filePath, options) {
   if (!map) return undefined;
-
-  // $FlowFixMe
   let res = {};
   for (let k in map) {
     let i = k.indexOf(':');
@@ -268,6 +275,7 @@ async function processConfig(configFile, options) {
     } : {
       /*::...null*/
     }),
+    // @ts-expect-error TS2322
     resolvers: processPipeline(options, configFile.resolvers, '/resolvers', configFile.filePath),
     transformers: await processMap(configFile.transformers, '/transformers', configFile.filePath, options),
     bundler: configFile.bundler != null ? {
@@ -275,11 +283,14 @@ async function processConfig(configFile, options) {
       resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, configFile.filePath),
       keyPath: '/bundler'
     } : undefined,
+    // @ts-expect-error TS2322
     namers: processPipeline(options, configFile.namers, '/namers', configFile.filePath),
+    // @ts-expect-error TS2322
     runtimes: processPipeline(options, configFile.runtimes, '/runtimes', configFile.filePath),
     packagers: await processMap(configFile.packagers, '/packagers', configFile.filePath, options),
     optimizers: await processMap(configFile.optimizers, '/optimizers', configFile.filePath, options),
     compressors: await processMap(configFile.compressors, '/compressors', configFile.filePath, options),
+    // @ts-expect-error TS2322
     reporters: processPipeline(options, configFile.reporters, '/reporters', configFile.filePath),
     validators: await processMap(configFile.validators, '/validators', configFile.filePath, options)
   };
@@ -462,14 +473,14 @@ function mergeMaps(base, ext, merger) {
   let res = {};
   // Add the extension options first so they have higher precedence in the output glob map
   for (let k in ext) {
-    //$FlowFixMe Flow doesn't correctly infer the type. See https://github.com/facebook/flow/issues/1736.
     let key = k;
-    res[key] = merger && base[key] != null ? merger(base[key], ext[key]) : ext[key];
+    res[key] =
+    // @ts-expect-error TS2345
+    merger && base[key] != null ? merger(base[key], ext[key]) : ext[key];
   }
 
   // Add base options that aren't defined in the extension
   for (let k in base) {
-    // $FlowFixMe
     let key = k;
     if (res[key] == null) {
       res[key] = base[key];