@parcel/packager-js 2.7.0 → 2.8.1

package/lib/DevPackager.js

@@ -74,16 +74,14 @@ class DevPackager {
     let queue = new (_utils().PromiseQueue)({
       maxConcurrent: 32
     });
-    this.bundle.traverse(node => {
-      if (node.type === 'asset') {
-        queue.add(async () => {
-          let [code, mapBuffer] = await Promise.all([node.value.getCode(), this.bundle.env.sourceMap && node.value.getMapBuffer()]);
-          return {
-            code,
-            mapBuffer
-          };
-        });
-      }
+    this.bundle.traverseAssets(asset => {
+      queue.add(async () => {
+        let [code, mapBuffer] = await Promise.all([asset.getCode(), this.bundle.env.sourceMap && asset.getMapBuffer()]);
+        return {
+          code,
+          mapBuffer
+        };
+      });
     });
     let results = await queue.run();
     let assets = '';

package/lib/ScopeHoistingPackager.js

@@ -468,55 +468,60 @@ class ScopeHoistingPackager {
 
 
         if (d != null) {
-          let dep = depMap.get(d);
+          let deps = depMap.get(d);
 
-          if (!dep) {
+          if (!deps) {
             return m;
           }
 
-          let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
-          let skipped = this.bundleGraph.isDependencySkipped(dep);
-
-          if (resolved && !skipped) {
-            // Hoist variable declarations for the referenced parcelRequire dependencies
-            // after the dependency is declared. This handles the case where the resulting asset
-            // is wrapped, but the dependency in this asset is not marked as wrapped. This means
-            // that it was imported/required at the top-level, so its side effects should run immediately.
-            let [res, lines] = this.getHoistedParcelRequires(asset, dep, resolved);
-            let map;
-
-            if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved.id)) {
-              // If this asset is wrapped, we need to hoist the code for the dependency
-              // outside our parcelRequire.register wrapper. This is safe because all
-              // assets referenced by this asset will also be wrapped. Otherwise, inline the
-              // asset content where the import statement was.
-              if (shouldWrap) {
-                depContent.push(this.visitAsset(resolved));
-              } else {
-                let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                res = depCode + '\n' + res;
-                lines += 1 + depLines;
-                map = depMap;
-              }
-            } // Push this asset's source mappings down by the number of lines in the dependency
-            // plus the number of hoisted parcelRequires. Then insert the source map for the dependency.
+          let replacement = ''; // A single `${id}:${specifier}:esm` might have been resolved to multiple assets due to
+          // reexports.
+
+          for (let dep of deps) {
+            let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+            let skipped = this.bundleGraph.isDependencySkipped(dep);
+
+            if (resolved && !skipped) {
+              // Hoist variable declarations for the referenced parcelRequire dependencies
+              // after the dependency is declared. This handles the case where the resulting asset
+              // is wrapped, but the dependency in this asset is not marked as wrapped. This means
+              // that it was imported/required at the top-level, so its side effects should run immediately.
+              let [res, lines] = this.getHoistedParcelRequires(asset, dep, resolved);
+              let map;
+
+              if (this.bundle.hasAsset(resolved) && !this.seenAssets.has(resolved.id)) {
+                // If this asset is wrapped, we need to hoist the code for the dependency
+                // outside our parcelRequire.register wrapper. This is safe because all
+                // assets referenced by this asset will also be wrapped. Otherwise, inline the
+                // asset content where the import statement was.
+                if (shouldWrap) {
+                  depContent.push(this.visitAsset(resolved));
+                } else {
+                  let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                  res = depCode + '\n' + res;
+                  lines += 1 + depLines;
+                  map = depMap;
+                }
+              } // Push this asset's source mappings down by the number of lines in the dependency
+              // plus the number of hoisted parcelRequires. Then insert the source map for the dependency.
 
 
-            if (sourceMap) {
-              if (lines > 0) {
-                sourceMap.offsetLines(lineCount + 1, lines);
-              }
+              if (sourceMap) {
+                if (lines > 0) {
+                  sourceMap.offsetLines(lineCount + 1, lines);
+                }
 
-              if (map) {
-                sourceMap.addSourceMap(map, lineCount);
+                if (map) {
+                  sourceMap.addSourceMap(map, lineCount);
+                }
               }
-            }
 
-            lineCount += lines;
-            return res;
+              replacement += res;
+              lineCount += lines;
+            }
           }
 
-          return '';
+          return replacement;
         } // If it wasn't a dependency, then it was an inline replacement (e.g. $id$import$foo -> $id$export$foo).
 
 
@@ -571,12 +576,12 @@ ${code}
     (0, _assert().default)(typeof assetId === 'string'); // Build two maps: one of import specifiers, and one of imported symbols to replace.
     // These will be used to build a regex below.
 
-    let depMap = new Map();
+    let depMap = new (_utils().DefaultMap)(() => []);
     let replacements = new Map();
 
     for (let dep of deps) {
       let specifierType = dep.specifierType === 'esm' ? `:${dep.specifierType}` : '';
-      depMap.set(`${assetId}:${(0, _utils2.getSpecifier)(dep)}${!dep.meta.placeholder ? specifierType : ''}`, dep);
+      depMap.get(`${assetId}:${(0, _utils2.getSpecifier)(dep)}${!dep.meta.placeholder ? specifierType : ''}`).push(dep);
       let asyncResolution = this.bundleGraph.resolveAsyncDependency(dep, this.bundle);
       let resolved = (asyncResolution === null || asyncResolution === void 0 ? void 0 : asyncResolution.type) === 'asset' ? // Prefer the underlying asset over a runtime to load it. It will
       // be wrapped in Promise.resolve() later.
@@ -850,44 +855,9 @@ ${code}
         prepend += `\n$parcel$defineInteropFlag($${assetId}$exports);\n`;
         prependLineCount += 2;
         this.usedHelpers.add('$parcel$defineInteropFlag');
-      } // Find the used exports of this module. This is based on the used symbols of
-      // incoming dependencies rather than the asset's own used exports so that we include
-      // re-exported symbols rather than only symbols declared in this asset.
-
-
-      let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
-      let usedExports = [...asset.symbols.exportSymbols()].filter(symbol => {
-        if (symbol === '*') {
-          return false;
-        } // If we need default interop, then all symbols are needed because the `default`
-        // symbol really maps to the whole namespace.
-
-
-        if (defaultInterop) {
-          return true;
-        }
-
-        let unused = incomingDeps.every(d => {
-          let symbols = (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(d));
-          return !symbols.has(symbol) && !symbols.has('*');
-        });
-        return !unused;
-      });
-
-      if (usedExports.length > 0) {
-        // Insert $parcel$export calls for each of the used exports. This creates a getter/setter
-        // for the symbol so that when the value changes the object property also changes. This is
-        // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
-        // additional assignments after each mutation of the original binding.
-        prepend += `\n${usedExports.map(exp => {
-          let resolved = this.getSymbolResolution(asset, asset, exp);
-          let get = this.buildFunctionExpression([], resolved);
-          let set = asset.meta.hasCJSExports ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`) : '';
-          return `$parcel$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});`;
-        }).join('\n')}\n`;
-        this.usedHelpers.add('$parcel$export');
-        prependLineCount += 1 + usedExports.length;
-      } // Find wildcard re-export dependencies, and make sure their exports are also included in ours.
+      } // Find wildcard re-export dependencies, and make sure their exports are also included in
+      // ours. Importantly, add them before the asset's own exports so that wildcard exports get
+      // correctly overwritten by own exports of the same name.
 
 
       for (let dep of deps) {
@@ -936,6 +906,43 @@ ${code}
             }
           }
         }
+      } // Find the used exports of this module. This is based on the used symbols of
+      // incoming dependencies rather than the asset's own used exports so that we include
+      // re-exported symbols rather than only symbols declared in this asset.
+
+
+      let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
+      let usedExports = [...asset.symbols.exportSymbols()].filter(symbol => {
+        if (symbol === '*') {
+          return false;
+        } // If we need default interop, then all symbols are needed because the `default`
+        // symbol really maps to the whole namespace.
+
+
+        if (defaultInterop) {
+          return true;
+        }
+
+        let unused = incomingDeps.every(d => {
+          let symbols = (0, _nullthrows().default)(this.bundleGraph.getUsedSymbols(d));
+          return !symbols.has(symbol) && !symbols.has('*');
+        });
+        return !unused;
+      });
+
+      if (usedExports.length > 0) {
+        // Insert $parcel$export calls for each of the used exports. This creates a getter/setter
+        // for the symbol so that when the value changes the object property also changes. This is
+        // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
+        // additional assignments after each mutation of the original binding.
+        prepend += `\n${usedExports.map(exp => {
+          let resolved = this.getSymbolResolution(asset, asset, exp);
+          let get = this.buildFunctionExpression([], resolved);
+          let set = asset.meta.hasCJSExports ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`) : '';
+          return `$parcel$export($${assetId}$exports, ${JSON.stringify(exp)}, ${get}${set});`;
+        }).join('\n')}\n`;
+        this.usedHelpers.add('$parcel$export');
+        prependLineCount += 1 + usedExports.length;
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/packager-js",
-  "version": "2.7.0",
+  "version": "2.8.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -17,16 +17,16 @@
   "source": "src/index.js",
   "engines": {
     "node": ">= 12.0.0",
-    "parcel": "^2.7.0"
+    "parcel": "^2.8.1"
   },
   "dependencies": {
-    "@parcel/diagnostic": "2.7.0",
-    "@parcel/hash": "2.7.0",
-    "@parcel/plugin": "2.7.0",
-    "@parcel/source-map": "^2.0.0",
-    "@parcel/utils": "2.7.0",
+    "@parcel/diagnostic": "2.8.1",
+    "@parcel/hash": "2.8.1",
+    "@parcel/plugin": "2.8.1",
+    "@parcel/source-map": "^2.1.1",
+    "@parcel/utils": "2.8.1",
     "globals": "^13.2.0",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "9e5d05586577e89991ccf90400f2c741dca11aa3"
+  "gitHead": "f8d3fc30ca5b33d8f8674525f2a741d662c5986a"
 }

package/src/DevPackager.js

@@ -39,16 +39,14 @@ export class DevPackager {
   async package(): Promise<{|contents: string, map: ?SourceMap|}> {
     // Load assets
     let queue = new PromiseQueue({maxConcurrent: 32});
-    this.bundle.traverse(node => {
-      if (node.type === 'asset') {
-        queue.add(async () => {
-          let [code, mapBuffer] = await Promise.all([
-            node.value.getCode(),
-            this.bundle.env.sourceMap && node.value.getMapBuffer(),
-          ]);
-          return {code, mapBuffer};
-        });
-      }
+    this.bundle.traverseAssets(asset => {
+      queue.add(async () => {
+        let [code, mapBuffer] = await Promise.all([
+          asset.getCode(),
+          this.bundle.env.sourceMap && asset.getMapBuffer(),
+        ]);
+        return {code, mapBuffer};
+      });
     });
 
     let results = await queue.run();

package/src/ScopeHoistingPackager.js

@@ -9,6 +9,7 @@ import type {
 } from '@parcel/types';
 
 import {
+  DefaultMap,
   PromiseQueue,
   relativeBundlePath,
   countLines,
@@ -472,59 +473,64 @@ export class ScopeHoistingPackager {
 
         // If we matched an import, replace with the source code for the dependency.
         if (d != null) {
-          let dep = depMap.get(d);
-          if (!dep) {
+          let deps = depMap.get(d);
+          if (!deps) {
             return m;
           }
 
-          let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
-          let skipped = this.bundleGraph.isDependencySkipped(dep);
-          if (resolved && !skipped) {
-            // Hoist variable declarations for the referenced parcelRequire dependencies
-            // after the dependency is declared. This handles the case where the resulting asset
-            // is wrapped, but the dependency in this asset is not marked as wrapped. This means
-            // that it was imported/required at the top-level, so its side effects should run immediately.
-            let [res, lines] = this.getHoistedParcelRequires(
-              asset,
-              dep,
-              resolved,
-            );
-            let map;
-            if (
-              this.bundle.hasAsset(resolved) &&
-              !this.seenAssets.has(resolved.id)
-            ) {
-              // If this asset is wrapped, we need to hoist the code for the dependency
-              // outside our parcelRequire.register wrapper. This is safe because all
-              // assets referenced by this asset will also be wrapped. Otherwise, inline the
-              // asset content where the import statement was.
-              if (shouldWrap) {
-                depContent.push(this.visitAsset(resolved));
-              } else {
-                let [depCode, depMap, depLines] = this.visitAsset(resolved);
-                res = depCode + '\n' + res;
-                lines += 1 + depLines;
-                map = depMap;
+          let replacement = '';
+
+          // A single `${id}:${specifier}:esm` might have been resolved to multiple assets due to
+          // reexports.
+          for (let dep of deps) {
+            let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+            let skipped = this.bundleGraph.isDependencySkipped(dep);
+            if (resolved && !skipped) {
+              // Hoist variable declarations for the referenced parcelRequire dependencies
+              // after the dependency is declared. This handles the case where the resulting asset
+              // is wrapped, but the dependency in this asset is not marked as wrapped. This means
+              // that it was imported/required at the top-level, so its side effects should run immediately.
+              let [res, lines] = this.getHoistedParcelRequires(
+                asset,
+                dep,
+                resolved,
+              );
+              let map;
+              if (
+                this.bundle.hasAsset(resolved) &&
+                !this.seenAssets.has(resolved.id)
+              ) {
+                // If this asset is wrapped, we need to hoist the code for the dependency
+                // outside our parcelRequire.register wrapper. This is safe because all
+                // assets referenced by this asset will also be wrapped. Otherwise, inline the
+                // asset content where the import statement was.
+                if (shouldWrap) {
+                  depContent.push(this.visitAsset(resolved));
+                } else {
+                  let [depCode, depMap, depLines] = this.visitAsset(resolved);
+                  res = depCode + '\n' + res;
+                  lines += 1 + depLines;
+                  map = depMap;
+                }
               }
-            }
 
-            // Push this asset's source mappings down by the number of lines in the dependency
-            // plus the number of hoisted parcelRequires. Then insert the source map for the dependency.
-            if (sourceMap) {
-              if (lines > 0) {
-                sourceMap.offsetLines(lineCount + 1, lines);
-              }
+              // Push this asset's source mappings down by the number of lines in the dependency
+              // plus the number of hoisted parcelRequires. Then insert the source map for the dependency.
+              if (sourceMap) {
+                if (lines > 0) {
+                  sourceMap.offsetLines(lineCount + 1, lines);
+                }
 
-              if (map) {
-                sourceMap.addSourceMap(map, lineCount);
+                if (map) {
+                  sourceMap.addSourceMap(map, lineCount);
+                }
               }
-            }
 
-            lineCount += lines;
-            return res;
+              replacement += res;
+              lineCount += lines;
+            }
           }
-
-          return '';
+          return replacement;
         }
 
         // If it wasn't a dependency, then it was an inline replacement (e.g. $id$import$foo -> $id$export$foo).
@@ -580,23 +586,24 @@ ${code}
   buildReplacements(
     asset: Asset,
     deps: Array<Dependency>,
-  ): [Map<string, Dependency>, Map<string, string>] {
+  ): [Map<string, Array<Dependency>>, Map<string, string>] {
     let assetId = asset.meta.id;
     invariant(typeof assetId === 'string');
 
     // Build two maps: one of import specifiers, and one of imported symbols to replace.
     // These will be used to build a regex below.
-    let depMap = new Map();
+    let depMap = new DefaultMap<string, Array<Dependency>>(() => []);
     let replacements = new Map();
     for (let dep of deps) {
       let specifierType =
         dep.specifierType === 'esm' ? `:${dep.specifierType}` : '';
-      depMap.set(
-        `${assetId}:${getSpecifier(dep)}${
-          !dep.meta.placeholder ? specifierType : ''
-        }`,
-        dep,
-      );
+      depMap
+        .get(
+          `${assetId}:${getSpecifier(dep)}${
+            !dep.meta.placeholder ? specifierType : ''
+          }`,
+        )
+        .push(dep);
 
       let asyncResolution = this.bundleGraph.resolveAsyncDependency(
         dep,
@@ -989,50 +996,9 @@ ${code}
         this.usedHelpers.add('$parcel$defineInteropFlag');
       }
 
-      // Find the used exports of this module. This is based on the used symbols of
-      // incoming dependencies rather than the asset's own used exports so that we include
-      // re-exported symbols rather than only symbols declared in this asset.
-      let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
-      let usedExports = [...asset.symbols.exportSymbols()].filter(symbol => {
-        if (symbol === '*') {
-          return false;
-        }
-
-        // If we need default interop, then all symbols are needed because the `default`
-        // symbol really maps to the whole namespace.
-        if (defaultInterop) {
-          return true;
-        }
-
-        let unused = incomingDeps.every(d => {
-          let symbols = nullthrows(this.bundleGraph.getUsedSymbols(d));
-          return !symbols.has(symbol) && !symbols.has('*');
-        });
-        return !unused;
-      });
-
-      if (usedExports.length > 0) {
-        // Insert $parcel$export calls for each of the used exports. This creates a getter/setter
-        // for the symbol so that when the value changes the object property also changes. This is
-        // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
-        // additional assignments after each mutation of the original binding.
-        prepend += `\n${usedExports
-          .map(exp => {
-            let resolved = this.getSymbolResolution(asset, asset, exp);
-            let get = this.buildFunctionExpression([], resolved);
-            let set = asset.meta.hasCJSExports
-              ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`)
-              : '';
-            return `$parcel$export($${assetId}$exports, ${JSON.stringify(
-              exp,
-            )}, ${get}${set});`;
-          })
-          .join('\n')}\n`;
-        this.usedHelpers.add('$parcel$export');
-        prependLineCount += 1 + usedExports.length;
-      }
-
-      // Find wildcard re-export dependencies, and make sure their exports are also included in ours.
+      // Find wildcard re-export dependencies, and make sure their exports are also included in
+      // ours. Importantly, add them before the asset's own exports so that wildcard exports get
+      // correctly overwritten by own exports of the same name.
       for (let dep of deps) {
         let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
         if (dep.isOptional || this.bundleGraph.isDependencySkipped(dep)) {
@@ -1098,6 +1064,49 @@ ${code}
           }
         }
       }
+
+      // Find the used exports of this module. This is based on the used symbols of
+      // incoming dependencies rather than the asset's own used exports so that we include
+      // re-exported symbols rather than only symbols declared in this asset.
+      let incomingDeps = this.bundleGraph.getIncomingDependencies(asset);
+      let usedExports = [...asset.symbols.exportSymbols()].filter(symbol => {
+        if (symbol === '*') {
+          return false;
+        }
+
+        // If we need default interop, then all symbols are needed because the `default`
+        // symbol really maps to the whole namespace.
+        if (defaultInterop) {
+          return true;
+        }
+
+        let unused = incomingDeps.every(d => {
+          let symbols = nullthrows(this.bundleGraph.getUsedSymbols(d));
+          return !symbols.has(symbol) && !symbols.has('*');
+        });
+        return !unused;
+      });
+
+      if (usedExports.length > 0) {
+        // Insert $parcel$export calls for each of the used exports. This creates a getter/setter
+        // for the symbol so that when the value changes the object property also changes. This is
+        // required to simulate ESM live bindings. It's easier to do it this way rather than inserting
+        // additional assignments after each mutation of the original binding.
+        prepend += `\n${usedExports
+          .map(exp => {
+            let resolved = this.getSymbolResolution(asset, asset, exp);
+            let get = this.buildFunctionExpression([], resolved);
+            let set = asset.meta.hasCJSExports
+              ? ', ' + this.buildFunctionExpression(['v'], `${resolved} = v`)
+              : '';
+            return `$parcel$export($${assetId}$exports, ${JSON.stringify(
+              exp,
+            )}, ${get}${set});`;
+          })
+          .join('\n')}\n`;
+        this.usedHelpers.add('$parcel$export');
+        prependLineCount += 1 + usedExports.length;
+      }
     }
 
     return [prepend, prependLineCount, append];