@parcel/packager-js 2.0.0-beta.3.1 → 2.0.0-dev.1510

package/src/DevPackager.js

@@ -1,11 +1,17 @@
 // @flow strict-local
 import type {BundleGraph, PluginOptions, NamedBundle} from '@parcel/types';
 
-import {PromiseQueue, relativeBundlePath, countLines} from '@parcel/utils';
+import {
+  PromiseQueue,
+  relativeBundlePath,
+  countLines,
+  normalizeSeparators,
+} from '@parcel/utils';
 import SourceMap from '@parcel/source-map';
 import invariant from 'assert';
 import path from 'path';
 import fs from 'fs';
+import {replaceScriptDependencies, getSpecifier} from './utils';
 
 const PRELUDE = fs
   .readFileSync(path.join(__dirname, 'dev-prelude.js'), 'utf8')
@@ -33,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();
@@ -54,12 +58,13 @@ export class DevPackager {
 
     let prefix = this.getPrefix();
     let lineOffset = countLines(prefix);
+    let script: ?{|code: string, mapBuffer: ?Buffer|} = null;
 
     this.bundle.traverse(node => {
       let wrapped = first ? '' : ',';
 
       if (node.type === 'dependency') {
-        let resolved = this.bundleGraph.getDependencyResolution(
+        let resolved = this.bundleGraph.getResolvedAsset(
           node.value,
           this.bundle,
         );
@@ -82,17 +87,28 @@ export class DevPackager {
           'all assets in a js bundle must be js assets',
         );
 
+        // If this is the main entry of a script rather than a module, we need to hoist it
+        // outside the bundle wrapper function so that its variables are exposed as globals.
+        if (
+          this.bundle.env.sourceType === 'script' &&
+          asset === this.bundle.getMainEntry()
+        ) {
+          script = results[i++];
+          return;
+        }
+
         let deps = {};
         let dependencies = this.bundleGraph.getDependencies(asset);
         for (let dep of dependencies) {
-          let resolved = this.bundleGraph.getDependencyResolution(
-            dep,
-            this.bundle,
-          );
-          if (resolved) {
-            deps[dep.moduleSpecifier] = this.bundleGraph.getAssetPublicId(
-              resolved,
-            );
+          let resolved = this.bundleGraph.getResolvedAsset(dep, this.bundle);
+          if (this.bundleGraph.isDependencySkipped(dep)) {
+            deps[getSpecifier(dep)] = false;
+          } else if (resolved) {
+            deps[getSpecifier(dep)] =
+              this.bundleGraph.getAssetPublicId(resolved);
+          } else {
+            // An external module - map placeholder to original specifier.
+            deps[getSpecifier(dep)] = dep.specifier;
           }
         }
 
@@ -106,6 +122,20 @@ export class DevPackager {
         wrapped += JSON.stringify(deps);
         wrapped += ']';
 
+        if (
+          this.bundle.env.isNode() &&
+          asset.meta.has_node_replacements === true
+        ) {
+          const relPath = normalizeSeparators(
+            path.relative(
+              this.bundle.target.distDir,
+              path.dirname(asset.filePath),
+            ),
+          );
+          wrapped = wrapped.replace('$parcel$dirnameReplace', relPath);
+          wrapped = wrapped.replace('$parcel$filenameReplace', relPath);
+        }
+
         if (this.bundle.env.sourceMap) {
           if (mapBuffer) {
             map.addBuffer(mapBuffer, lineOffset);
@@ -130,7 +160,10 @@ export class DevPackager {
 
     let entries = this.bundle.getEntryAssets();
     let mainEntry = this.bundle.getMainEntry();
-    if (!this.isEntry() && this.bundle.env.outputFormat === 'global') {
+    if (
+      (!this.isEntry() && this.bundle.env.outputFormat === 'global') ||
+      this.bundle.env.sourceType === 'script'
+    ) {
       // In async bundles we don't want the main entry to execute until we require it
       // as there might be dependencies in a sibling bundle that hasn't loaded yet.
       entries = entries.filter(a => a.id !== mainEntry?.id);
@@ -154,6 +187,27 @@ export class DevPackager {
       ')' +
       '\n';
 
+    // The entry asset of a script bundle gets hoisted outside the bundle wrapper function
+    // so that its variables become globals. We need to replace any require calls for
+    // runtimes with a parcelRequire call.
+    if (this.bundle.env.sourceType === 'script' && script) {
+      let entryMap;
+      let mapBuffer = script.mapBuffer;
+      if (mapBuffer) {
+        entryMap = new SourceMap(this.options.projectRoot, mapBuffer);
+      }
+      contents += replaceScriptDependencies(
+        this.bundleGraph,
+        this.bundle,
+        script.code,
+        entryMap,
+        this.parcelRequireName,
+      );
+      if (this.bundle.env.sourceMap && entryMap) {
+        map.addSourceMap(entryMap, lineOffset);
+      }
+    }
+
     return {
       contents,
       map,
@@ -192,7 +246,7 @@ export class DevPackager {
     return (
       !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') ||
       this.bundle.env.isIsolated() ||
-      !!this.bundle.getMainEntry()?.isIsolated
+      this.bundle.bundleBehavior === 'isolated'
     );
   }
 }

package/src/ESMOutputFormat.js

@@ -70,14 +70,31 @@ export class ESMOutputFormat implements OutputFormat {
     return [res, lines];
   }
 
-  buildBundlePostlude(): string {
+  buildBundlePostlude(): [string, number] {
     let res = '';
+    let lines = 0;
     let exportSpecifiers = [];
-    for (let exported of this.packager.exportedSymbols.values()) {
-      for (let {exportAs, local} of exported) {
+    for (let {
+      asset,
+      exportSymbol,
+      local,
+      exportAs,
+    } of this.packager.exportedSymbols.values()) {
+      if (this.packager.wrappedAssets.has(asset.id)) {
+        let obj = `parcelRequire("${this.packager.bundleGraph.getAssetPublicId(
+          asset,
+        )}")`;
+        res += `\nvar ${local} = ${this.packager.getPropertyAccess(
+          obj,
+          exportSymbol,
+        )};`;
+        lines++;
+      }
+
+      for (let as of exportAs) {
         let specifier = local;
         if (exportAs !== local) {
-          specifier += ` as ${exportAs}`;
+          specifier += ` as ${as}`;
         }
 
         exportSpecifiers.push(specifier);
@@ -86,8 +103,20 @@ export class ESMOutputFormat implements OutputFormat {
 
     if (exportSpecifiers.length > 0) {
       res += `\nexport {${exportSpecifiers.join(', ')}};`;
+      lines++;
     }
 
-    return res;
+    if (
+      this.packager.needsPrelude &&
+      this.packager.shouldBundleQueue(this.packager.bundle)
+    ) {
+      // Should be last thing the bundle executes on intial eval
+      res += `\n$parcel$global.rlb(${JSON.stringify(
+        this.packager.bundle.publicId,
+      )})`;
+      lines++;
+    }
+
+    return [res, lines];
   }
 }

package/src/GlobalOutputFormat.js

@@ -12,10 +12,13 @@ export class GlobalOutputFormat implements OutputFormat {
   }
 
   buildBundlePrelude(): [string, number] {
-    return ['(function () {\n', 1];
+    let prelude = this.packager.bundle.env.supports('arrow-functions', true)
+      ? '(() => {\n'
+      : '(function () {\n';
+    return [prelude, 1];
   }
 
-  buildBundlePostlude(): string {
-    return '})();';
+  buildBundlePostlude(): [string, number] {
+    return ['})();', 0];
   }
 }