@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/lib/BundleGraph.js

@@ -51,6 +51,7 @@ function _featureFlags() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -85,7 +86,7 @@ function makeReadOnlySet(set) {
       if (property === 'delete' || property === 'add' || property === 'clear') {
         return undefined;
       } else {
-        // $FlowFixMe[incompatible-type]
+        // @ts-expect-error TS7053
         let value = target[property];
         return typeof value === 'function' ? value.bind(target) : value;
       }
@@ -167,7 +168,7 @@ class BundleGraph {
         // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
         // to dependencies
         const dep = node.value;
-        // $FlowFixMe[incompatible-type] Meta is untyped
+        // @ts-expect-error TS2322
         const placeholder = (_dep$meta = dep.meta) === null || _dep$meta === void 0 ? void 0 : _dep$meta.placeholder;
         if (placeholder != null) {
           placeholderToDependency.set(placeholder, dep);
@@ -182,7 +183,6 @@ class BundleGraph {
       if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
         const asset = node.value;
         if (Array.isArray(asset.meta.conditions)) {
-          // $FlowFixMe
           for (const condition of asset.meta.conditions) {
             // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
             // as well as create a public id for the condition.
@@ -207,7 +207,7 @@ class BundleGraph {
           }
         }
       }
-      if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
+      if (node.type === 'dependency' && node.value.symbols != null && (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
         let nodeValueSymbols = node.value.symbols;
@@ -263,9 +263,13 @@ class BundleGraph {
               ...node,
               value: {
                 ...node.value,
-                symbols: new Map([...nodeValueSymbols].filter(([k]) => externalSymbols.has(k)))
+                symbols: new Map(
+                // @ts-expect-error TS2769
+                [...nodeValueSymbols].filter(([k]) => externalSymbols.has(k)))
               },
-              usedSymbolsUp: new Map([...node.usedSymbolsUp].filter(([k]) => externalSymbols.has(k))),
+              usedSymbolsUp: new Map(
+              // @ts-expect-error TS2769
+              [...node.usedSymbolsUp].filter(([k]) => externalSymbols.has(k))),
               usedSymbolsDown: new Set(),
               excluded: externalSymbols.size === 0
             })
@@ -294,8 +298,13 @@ class BundleGraph {
                     loc: reexportAllLoc
                   });
                   if (node.value.sourceAssetId != null) {
-                    let sourceAssetId = (0, _nullthrows().default)(assetGraphNodeIdToBundleGraphNodeId.get(assetGraph.getNodeIdByContentKey(node.value.sourceAssetId)));
-                    let sourceAsset = (0, _nullthrows().default)(graph.getNode(sourceAssetId));
+                    let sourceAssetId;
+                    if ((0, _featureFlags().getFeatureFlag)('sourceAssetIdBundleGraphFix')) {
+                      [sourceAssetId] = assetGraph.getNodeIdsConnectedTo(nodeId);
+                    } else {
+                      sourceAssetId = assetGraph.getNodeIdByContentKey(node.value.sourceAssetId);
+                    }
+                    let sourceAsset = (0, _nullthrows().default)(graph.getNode((0, _nullthrows().default)(assetGraphNodeIdToBundleGraphNodeId.get(sourceAssetId))));
                     (0, _assert().default)(sourceAsset.type === 'asset');
                     let sourceAssetSymbols = sourceAsset.value.symbols;
                     if (sourceAssetSymbols) {
@@ -312,7 +321,9 @@ class BundleGraph {
                 }
               }
             }
-            let usedSymbolsUp = new Map([...node.usedSymbolsUp].filter(([k]) => target.has(k) || k === '*').map(([k, v]) => [target.get(k) ?? k, v]));
+            let usedSymbolsUp = new Map([...node.usedSymbolsUp]
+            // @ts-expect-error TS2769
+            .filter(([k]) => target.has(k) || k === '*').map(([k, v]) => [target.get(k) ?? k, v]));
             return {
               asset,
               dep: graph.addNodeByContentKey(newNodeId, {
@@ -363,6 +374,8 @@ class BundleGraph {
       }
     }
     walk((0, _nullthrows().default)(assetGraph.rootNodeId));
+
+    // @ts-expect-error TS2488
     for (let edge of assetGraph.getAllEdges()) {
       var _dependencies$get, _assetGroupIds$get;
       if (assetGroupIds.has(edge.from)) {
@@ -416,11 +429,14 @@ class BundleGraph {
     });
   }
   createBundle(opts) {
+    // @ts-expect-error TS2339
     let {
       entryAsset,
       target
     } = opts;
-    let bundleId = (0, _rust().hashString)('bundle:' + (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) + (0, _projectPath.fromProjectPathRelative)(target.distDir) + (opts.bundleBehavior ?? ''));
+    let bundleId = (0, _rust().hashString)('bundle:' + (
+    // @ts-expect-error TS2339
+    opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) + (0, _projectPath.fromProjectPathRelative)(target.distDir) + (opts.bundleBehavior ?? ''));
     let existing = this._graph.getNodeByContentKey(bundleId);
     if (existing != null) {
       (0, _assert().default)(existing.type === 'bundle');
@@ -440,14 +456,21 @@ class BundleGraph {
       value: {
         id: bundleId,
         hashReference: opts.shouldContentHash ? _constants.HASH_REF_PREFIX + bundleId : bundleId.slice(-8),
+        // @ts-expect-error TS2339
         type: opts.entryAsset ? opts.entryAsset.type : opts.type,
         env: opts.env,
         entryAssetIds: entryAsset ? [entryAsset.id] : [],
         mainEntryId: entryAsset === null || entryAsset === void 0 ? void 0 : entryAsset.id,
+        // @ts-expect-error TS2339
         pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
         needsStableName: opts.needsStableName,
         bundleBehavior: opts.bundleBehavior != null ? _types.BundleBehavior[opts.bundleBehavior] : null,
-        isSplittable: opts.entryAsset ? opts.entryAsset.isBundleSplittable : opts.isSplittable,
+        // @ts-expect-error TS2339
+        isSplittable: opts.entryAsset ?
+        // @ts-expect-error TS2339
+        opts.entryAsset.isBundleSplittable :
+        // @ts-expect-error TS2339
+        opts.isSplittable,
         isPlaceholder,
         target,
         name: null,
@@ -456,8 +479,12 @@ class BundleGraph {
       }
     };
     let bundleNodeId = this._graph.addNodeByContentKey(bundleId, bundleNode);
+
+    // @ts-expect-error TS2339
     if (opts.entryAsset) {
-      this._graph.addEdge(bundleNodeId, this._graph.getNodeIdByContentKey(opts.entryAsset.id));
+      this._graph.addEdge(bundleNodeId,
+      // @ts-expect-error TS2339
+      this._graph.getNodeIdByContentKey(opts.entryAsset.id));
     }
     _assert().default;
     return bundleNode.value;
@@ -470,9 +497,14 @@ class BundleGraph {
     for (let dependency of dependencies) {
       let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
       this._graph.addEdge(bundleNodeId, dependencyNodeId, bundleGraphEdgeTypes.contains);
-      for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(dependencyNodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]).filter(([, node]) => node.type === 'bundle_group')) {
+      for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(dependencyNodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))])
+      // @ts-expect-error TS2769
+      .filter(([, node]) => node.type === 'bundle_group')) {
+        // @ts-expect-error TS2339
         (0, _assert().default)(bundleGroupNode.type === 'bundle_group');
-        this._graph.addEdge(bundleNodeId, bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
+        this._graph.addEdge(bundleNodeId,
+        // @ts-expect-error TS2345
+        bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
       }
       // If the dependency references a target bundle, add a reference edge from
       // the source bundle to the dependency for easy traversal.
@@ -503,9 +535,14 @@ class BundleGraph {
         this._graph.addEdge(bundleNodeId, nodeId, bundleGraphEdgeTypes.contains);
       }
       if (node.type === 'dependency') {
-        for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]).filter(([, node]) => node.type === 'bundle_group')) {
+        for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))])
+        // @ts-expect-error TS2769
+        .filter(([, node]) => node.type === 'bundle_group')) {
+          // @ts-expect-error TS2339
           (0, _assert().default)(bundleGroupNode.type === 'bundle_group');
-          this._graph.addEdge(bundleNodeId, bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
+          this._graph.addEdge(bundleNodeId,
+          // @ts-expect-error TS2345
+          bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
         }
 
         // If the dependency references a target bundle, add a reference edge from
@@ -616,8 +653,12 @@ class BundleGraph {
       return this.getBundlesInBundleGroup(node.value, {
         includeInline: true
       }).find(b => {
-        let mainEntryId = b.entryAssetIds[b.entryAssetIds.length - 1];
-        return mainEntryId != null && node.value.entryAssetId === mainEntryId;
+        if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+          return b.entryAssetIds.some(id => id === node.value.entryAssetId);
+        } else {
+          let mainEntryId = b.entryAssetIds[b.entryAssetIds.length - 1];
+          return mainEntryId != null && node.value.entryAssetId === mainEntryId;
+        }
       });
     }
   }
@@ -805,6 +846,7 @@ class BundleGraph {
         }
       }, this._graph.getNodeIdByContentKey(dep.id), bundleGraphEdgeTypes.references);
       if (bundle) {
+        // @ts-expect-error TS2322
         resolved = potential.find(a => a.type === bundle.type);
       }
       resolved ||= potential[0];
@@ -859,13 +901,14 @@ class BundleGraph {
           return;
         }
         visitedBundles.add(descendant);
-        if (descendant.type !== bundle.type || descendant.env.context !== bundle.env.context) {
+        if (descendant.type !== bundle.type || (0, _EnvironmentManager.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) {
           actions.skipChildren();
           return;
         }
         if (bundleHasReference(descendant)) {
           isReferenced = true;
           actions.stop();
+          return;
         }
       }, referencer);
       return isReferenced;
@@ -887,7 +930,7 @@ class BundleGraph {
   isAssetReachableFromBundle(asset, bundle) {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
-    if (_Environment.ISOLATED_ENVS.has(bundle.env.context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
+    if (_Environment.ISOLATED_ENVS.has((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline || bundle.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
       return false;
     }
 
@@ -897,7 +940,7 @@ class BundleGraph {
     return bundleGroups.every(bundleGroup => {
       // If the asset is in any sibling bundles of the original bundle, it is reachable.
       let bundles = this.getBundlesInBundleGroup(bundleGroup);
-      if (bundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && this.bundleHasAsset(b, asset))) {
+      if (bundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && b.bundleBehavior !== _types.BundleBehavior.inlineIsolated && this.bundleHasAsset(b, asset))) {
         return true;
       }
 
@@ -907,7 +950,7 @@ class BundleGraph {
       // Check that every parent bundle has a bundle group in its ancestry that contains the asset.
       return parentBundleNodes.every(bundleNodeId => {
         let bundleNode = (0, _nullthrows().default)(this._graph.getNode(bundleNodeId));
-        if (bundleNode.type !== 'bundle' || bundleNode.value.bundleBehavior === _types.BundleBehavior.isolated || bundleNode.value.bundleBehavior === _types.BundleBehavior.inline) {
+        if (bundleNode.type !== 'bundle' || bundleNode.value.bundleBehavior === _types.BundleBehavior.isolated || bundleNode.value.bundleBehavior === _types.BundleBehavior.inline || bundleNode.value.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
           return false;
         }
         let isReachable = true;
@@ -915,15 +958,16 @@ class BundleGraph {
           let node = (0, _nullthrows().default)(this._graph.getNode(nodeId));
           // If we've reached the root or a context change without
           // finding this asset in the ancestry, it is not reachable.
-          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || node.value.env.context !== bundle.env.context)) {
+          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context)) {
             isReachable = false;
             actions.stop();
             return;
           }
           if (node.type === 'bundle_group') {
             let childBundles = this.getBundlesInBundleGroup(node.value);
-            if (childBundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && this.bundleHasAsset(b, asset))) {
+            if (childBundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && b.bundleBehavior !== _types.BundleBehavior.inlineIsolated && this.bundleHasAsset(b, asset))) {
               actions.skipChildren();
+              return;
             }
           }
         }, [bundleGraphEdgeTypes.references, bundleGraphEdgeTypes.bundle]);
@@ -958,7 +1002,9 @@ class BundleGraph {
       startNodeId: startAsset ? this._graph.getNodeIdByContentKey(startAsset.id) : bundleNodeId,
       getChildren: nodeId => {
         let children = this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]);
-        let sorted = entries && bundle.entryAssetIds.length > 0 ? children.sort(([, a], [, b]) => {
+        let sorted = entries && bundle.entryAssetIds.length > 0 ?
+        // @ts-expect-error TS2345
+        children.sort(([, a], [, b]) => {
           let aIndex = bundle.entryAssetIds.indexOf(a.id);
           let bIndex = bundle.entryAssetIds.indexOf(b.id);
           if (aIndex === bIndex) {
@@ -973,6 +1019,7 @@ class BundleGraph {
           return aIndex - bIndex;
         }) : children;
         entries = false;
+        // @ts-expect-error TS2345
         return sorted.map(([id]) => id);
       }
     });
@@ -1010,7 +1057,7 @@ class BundleGraph {
   getBundles(opts) {
     let bundles = [];
     this.traverseBundles(bundle => {
-      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline) {
+      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
         bundles.push(bundle);
       }
     });
@@ -1061,7 +1108,7 @@ class BundleGraph {
       let bundleNode = (0, _nullthrows().default)(this._graph.getNode(bundleNodeId));
       (0, _assert().default)(bundleNode.type === 'bundle');
       let bundle = bundleNode.value;
-      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline) {
+      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
         bundles.add(bundle);
       }
       for (let referencedBundle of this.getReferencedBundles(bundle, {
@@ -1085,7 +1132,7 @@ class BundleGraph {
         if (node.value.id === bundle.id) {
           return;
         }
-        if (includeInline || node.value.bundleBehavior !== _types.BundleBehavior.inline) {
+        if (includeInline || node.value.bundleBehavior !== _types.BundleBehavior.inline && node.value.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
           referencedBundles.add(node.value);
         }
         if (!recursive) {
@@ -1099,6 +1146,8 @@ class BundleGraph {
       // TODO: Should this be the case?
       this._graph.getNodeIdsConnectedFrom(nodeId, bundleGraphEdgeTypes.references)
     });
+
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
   getIncomingDependencies(asset) {
@@ -1118,7 +1167,9 @@ class BundleGraph {
     }
     let res = null;
     let count = 0;
-    this._graph.forEachNodeIdConnectedTo(this._graph.getNodeIdByContentKey(dep.id), node => {
+    this._graph.forEachNodeIdConnectedTo(this._graph.getNodeIdByContentKey(dep.id),
+    // @ts-expect-error TS2345
+    node => {
       res = node;
       count += 1;
       if (count > 1) {
@@ -1282,11 +1333,13 @@ class BundleGraph {
       let result = identifier;
       if (skipped) {
         // ... and it was excluded (by symbol propagation) or deferred.
+        // @ts-expect-error TS2322
         result = false;
       } else {
         // ... and there is no single reexport, but it might still be exported:
         if (found) {
           // Fallback to namespace access, because of a bundle boundary.
+          // @ts-expect-error TS2322
           result = null;
         } else if (result === undefined) {
           var _asset$symbols5;
@@ -1294,6 +1347,7 @@ class BundleGraph {
           if (nonStaticDependency || (_asset$symbols5 = asset.symbols) !== null && _asset$symbols5 !== void 0 && _asset$symbols5.has('*')) {
             // ... and if there are non-statically analyzable dependencies or it's a CJS asset,
             // fallback to namespace access.
+            // @ts-expect-error TS2322
             result = null;
           }
           // (It shouldn't be possible for the symbol to be in a reexport-all and to end up here).
@@ -1381,7 +1435,7 @@ class BundleGraph {
         includeInline: true
       });
       for (let referenced of referencedBundles) {
-        if (referenced.bundleBehavior === _types.BundleBehavior.inline) {
+        if (referenced.bundleBehavior === _types.BundleBehavior.inline || referenced.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
           bundles.push(referenced);
           addReferencedBundles(referenced);
         }
@@ -1389,7 +1443,7 @@ class BundleGraph {
     };
     addReferencedBundles(bundle);
     this.traverseBundles((childBundle, _, traversal) => {
-      if (childBundle.bundleBehavior === _types.BundleBehavior.inline) {
+      if (childBundle.bundleBehavior === _types.BundleBehavior.inline || childBundle.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
         bundles.push(childBundle);
       } else if (childBundle.id !== bundle.id) {
         traversal.skipChildren();
@@ -1410,7 +1464,7 @@ class BundleGraph {
     for (let referencedBundle of this.getReferencedBundles(bundle)) {
       hash.writeString(referencedBundle.id);
     }
-    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)(bundle.env)));
+    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)((0, _EnvironmentManager.fromEnvironmentId)(bundle.env))));
     return hash.finish();
   }
   getBundleGraphHash() {
@@ -1469,6 +1523,8 @@ class BundleGraph {
         otherGraphIdToThisNodeId.set(otherNodeId, updateNodeId);
       }
     }
+
+    // @ts-expect-error TS2488
     for (let edge of other._graph.getAllEdges()) {
       this._graph.addEdge((0, _nullthrows().default)(otherGraphIdToThisNodeId.get(edge.from)), (0, _nullthrows().default)(otherGraphIdToThisNodeId.get(edge.to)), edge.type);
     }
@@ -1521,6 +1577,8 @@ class BundleGraph {
       startNodeId: this._graph.getNodeIdByContentKey(bundle.id),
       getChildren: nodeId => this._graph.getNodeIdsConnectedFrom(nodeId, bundleGraphEdgeTypes.conditional)
     });
+
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
 }

package/lib/CommittedAsset.js

@@ -74,6 +74,7 @@ class CommittedAsset {
     if (typeof content === 'string' || content instanceof Buffer) {
       return content.toString();
     } else if (content != null) {
+      // @ts-expect-error TS2345
       this.content = (0, _utils().bufferStream)(content);
       return (await this.content).toString();
     }
@@ -86,7 +87,10 @@ class CommittedAsset {
     } else if (typeof content === 'string' || content instanceof Buffer) {
       return Buffer.from(content);
     }
+
+    // @ts-expect-error TS2345
     this.content = (0, _utils().bufferStream)(content);
+    // @ts-expect-error TS2322
     return this.content;
   }
   getStream() {
@@ -125,6 +129,8 @@ class CommittedAsset {
         }
       })();
     }
+
+    // @ts-expect-error TS2322
     return this.mapBuffer ?? Promise.resolve();
   }
   getMap() {

package/lib/Dependency.js

@@ -24,6 +24,7 @@ function _assert() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createDependencyId({
   sourceAssetId,
@@ -41,8 +42,11 @@ function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(env),
+    target: target != null ? {
+      ...target,
+      env: (0, _EnvironmentManager.fromEnvironmentId)(target.env)
+    } : null,
     pipeline,
     specifierType: _types.SpecifierType[specifierType],
     bundleBehavior,
@@ -121,7 +125,9 @@ function convertConditions(conditions, dep) {
   let packageConditions = 0;
   let customConditions = [];
   for (let condition of conditions) {
+    // @ts-expect-error TS7053
     if (_types.ExportsCondition[condition]) {
+      // @ts-expect-error TS7053
       packageConditions |= _types.ExportsCondition[condition];
     } else {
       customConditions.push(condition);

package/lib/Environment.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEnvironment = createEnvironment;
+exports.getEnvironmentHash = getEnvironmentHash;
 exports.mergeEnvironments = mergeEnvironments;
 function _rust() {
   const data = require("@atlaspack/rust");
@@ -15,6 +16,7 @@ function _rust() {
 var _utils = require("./utils");
 var _Environment = _interopRequireWildcard(require("./public/Environment"));
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 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; }
 const DEFAULT_ENGINES = {
@@ -32,7 +34,8 @@ function createEnvironment({
   shouldScopeHoist = false,
   sourceMap,
   unstableSingleFileOutput = false,
-  loc
+  loc,
+  customEnv
 } = {
   /*::...null*/
 }) {
@@ -57,8 +60,10 @@ function createEnvironment({
       case 'browser':
       case 'web-worker':
       case 'service-worker':
+      case 'tesseract':
       case 'electron-renderer':
         engines = {
+          // @ts-expect-error TS2322
           browsers: DEFAULT_ENGINES.browsers
         };
         break;
@@ -76,6 +81,7 @@ function createEnvironment({
       case 'browser':
       case 'web-worker':
       case 'service-worker':
+      case 'tesseract':
       default:
         includeNodeModules = true;
         break;
@@ -96,6 +102,7 @@ function createEnvironment({
   let res = {
     id: '',
     context,
+    // @ts-expect-error TS2322
     engines,
     includeNodeModules,
     outputFormat,
@@ -105,21 +112,20 @@ function createEnvironment({
     shouldScopeHoist,
     sourceMap,
     unstableSingleFileOutput,
-    loc
+    loc,
+    customEnv
   };
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+  return (0, _EnvironmentManager.toEnvironmentRef)(Object.freeze(res));
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return (0, _EnvironmentManager.toEnvironmentRef)(a);
   }
   if (b instanceof _Environment.default) {
-    return (0, _Environment.environmentToInternalEnvironment)(b);
+    return (0, _EnvironmentManager.toEnvironmentRef)((0, _Environment.environmentToInternalEnvironment)(b));
   }
-
-  // $FlowFixMe - ignore the `id` that is already on a
   return createEnvironment({
     ...a,
     ...b,
@@ -136,7 +142,8 @@ function getEnvironmentHash(env) {
     isLibrary: env.isLibrary,
     shouldOptimize: env.shouldOptimize,
     shouldScopeHoist: env.shouldScopeHoist,
-    sourceMap: env.sourceMap
+    sourceMap: env.sourceMap,
+    customEnv: env.customEnv
   };
   const id = (0, _rust().createEnvironmentId)(data);
   _IdentifierRegistry.identifierRegistry.addIdentifier('environment', id, data);

package/lib/EnvironmentManager.js

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromEnvironmentId = fromEnvironmentId;
+exports.loadEnvironmentsFromCache = loadEnvironmentsFromCache;
+exports.toEnvironmentId = toEnvironmentId;
+exports.toEnvironmentRef = toEnvironmentRef;
+exports.writeEnvironmentsToCache = writeEnvironmentsToCache;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _constants = require("./constants");
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+
+const localEnvironmentCache = new Map();
+
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+function toEnvironmentRef(env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return env;
+  }
+  const id = toEnvironmentId(env);
+  return id;
+}
+
+/**
+ * Convert environment to a string ID
+ */
+function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return typeof env === 'string' ? env : env.id;
+  }
+  if (typeof env === 'string') {
+    return env;
+  }
+  (0, _rust().addEnvironment)(env);
+  return env.id;
+}
+function fromEnvironmentId(id) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    if (typeof id === 'string') {
+      throw new Error('This should never happen when environmentDeduplication feature-flag is off');
+    } else {
+      return id;
+    }
+  }
+  if (typeof id !== 'string') {
+    return id;
+  }
+  const localEnv = localEnvironmentCache.get(id);
+  if (localEnv) {
+    return localEnv;
+  }
+  const env = Object.freeze((0, _rust().getEnvironment)(id));
+  // @ts-expect-error TS2345
+  localEnvironmentCache.set(id, env);
+  // @ts-expect-error TS2322
+  return env;
+}
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function writeEnvironmentsToCache(cache) {
+  const environments = (0, _rust().getAllEnvironments)();
+  const environmentIds = new Set();
+
+  // Store each environment individually
+  for (const env of environments) {
+    // @ts-expect-error TS18046
+    environmentIds.add(env.id);
+    // @ts-expect-error TS18046
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${env.id}`;
+    await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${envKey})`, async () => {
+      await cache.set(envKey, env);
+    });
+  }
+
+  // Store the list of environment IDs
+  await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${_constants.ATLASPACK_VERSION}`})`, async () => {
+    await cache.set(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`, Array.from(environmentIds));
+  });
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function loadEnvironmentsFromCache(cache) {
+  const cachedEnvIds = await cache.get(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`);
+  if (cachedEnvIds == null) {
+    return;
+  }
+  const environments = [];
+  // @ts-expect-error TS2488
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    (0, _rust().setAllEnvironments)(environments);
+  }
+}