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

package/lib/CJSOutputFormat.js

@@ -4,137 +4,33 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CJSOutputFormat = void 0;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-// List of engines that support object destructuring syntax
-const DESTRUCTURING_ENGINES = {
-  chrome: '51',
-  edge: '15',
-  firefox: '53',
-  safari: '10',
-  node: '6.5',
-  ios: '10',
-  samsung: '5',
-  opera: '38',
-  electron: '1.2'
-};
-
 class CJSOutputFormat {
   constructor(packager) {
-    _defineProperty(this, "packager", void 0);
-
     this.packager = packager;
   }
-
   buildBundlePrelude() {
     let res = '';
     let lines = 0;
-
     for (let [source, specifiers] of this.packager.externals) {
-      let properties = [];
-      let categories = new Set();
-
-      for (let [imported, symbol] of specifiers) {
-        if (imported === '*') {
-          categories.add('namespace');
-        } else if (imported === 'default') {
-          categories.add('default');
-        } else {
-          categories.add('named');
-          properties.push({
-            key: imported,
-            value: symbol
-          });
-        }
-      }
-
-      let specifiersWildcard = specifiers.get('*');
-      let specifiersDefault = specifiers.get('default'); // Attempt to combine require calls as much as possible. Namespace, default, and named specifiers
-      // cannot be combined, so in the case where we have more than one type, assign the require() result
-      // to a variable first and then create additional variables for each specifier based on that.
-      // Otherwise, if just one category is imported, just assign and require all at once.
-
-      if (categories.size > 1) {
-        let name = specifiersWildcard || this.packager.getTopLevelName(source);
-        res += `var ${name} = require(${JSON.stringify(source)});\n`;
-        lines++;
-
-        if (specifiersDefault) {
-          res += `var ${specifiersDefault} = $parcel$interopDefault(${name});\n`;
-          lines++;
-          this.packager.usedHelpers.add('$parcel$interopDefault');
-        }
-
-        if (properties.length > 0) {
-          let [r, l] = this.generateDestructuringAssignment(properties, name, true);
-          res += r;
-          lines += l;
-        }
-      } else if (specifiersDefault) {
-        res += `var ${specifiersDefault} = $parcel$interopDefault(require(${JSON.stringify(source)}));\n`;
-        lines++;
-        this.packager.usedHelpers.add('$parcel$interopDefault');
-      } else if (specifiersWildcard) {
-        res += `var ${specifiersWildcard} = require(${JSON.stringify(source)});\n`;
+      // CJS only supports the namespace symbol. This ensures that all accesses
+      // are live and the `this` binding is correct.
+      let namespace = specifiers.get('*');
+      if (namespace) {
+        res += `var ${namespace} = require(${JSON.stringify(source)});\n`;
         lines++;
-      } else if (properties.length > 0) {
-        let [r, l] = this.generateDestructuringAssignment(properties, `require(${JSON.stringify(source)})`, false);
-        res += r;
-        lines += l;
       } else {
         res += `require(${JSON.stringify(source)});\n`;
         lines++;
       }
     }
-
     if (res.length > 0) {
       res += '\n';
       lines++;
     }
-
     return [res, lines];
   }
-
-  generateDestructuringAssignment(specifiers, value, isIdentifier) {
-    let res = '';
-    let lines = 0; // If destructuring is not supported, generate a series of variable declarations
-    // with member expressions for each property.
-
-    if (!this.packager.bundle.env.matchesEngines(DESTRUCTURING_ENGINES)) {
-      if (!isIdentifier && specifiers.length > 1) {
-        let name = this.packager.getTopLevelName('temp');
-        res += `var ${name} = ${value};\n`;
-        lines++;
-        value = name;
-      }
-
-      for (let specifier of specifiers) {
-        res += `var ${specifier.value} = ${value}.${specifier.key};\n`;
-        lines++;
-      }
-
-      return [res, lines];
-    }
-
-    let s = specifiers.map(specifier => {
-      let s = specifier.key;
-
-      if (specifier.value !== specifier.key) {
-        s += `: ${specifier.value}`;
-      }
-
-      return s;
-    });
-    res += `var {${s.join(', ')}} = ${value};\n`;
-    lines++;
-    return [res, lines];
-  }
-
   buildBundlePostlude() {
-    return '';
+    return ['', 0];
   }
-
 }
-
 exports.CJSOutputFormat = CJSOutputFormat;

package/lib/DevPackager.js

@@ -4,94 +4,64 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DevPackager = void 0;
-
 function _utils() {
   const data = require("@parcel/utils");
-
   _utils = function () {
     return data;
   };
-
   return data;
 }
-
 function _sourceMap() {
   const data = _interopRequireDefault(require("@parcel/source-map"));
-
   _sourceMap = function () {
     return data;
   };
-
   return data;
 }
-
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
-
   _assert = function () {
     return data;
   };
-
   return data;
 }
-
 function _path() {
   const data = _interopRequireDefault(require("path"));
-
   _path = function () {
     return data;
   };
-
   return data;
 }
-
 function _fs() {
   const data = _interopRequireDefault(require("fs"));
-
   _fs = function () {
     return data;
   };
-
   return data;
 }
-
+var _utils2 = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 const PRELUDE = _fs().default.readFileSync(_path().default.join(__dirname, 'dev-prelude.js'), 'utf8').trim().replace(/;$/, '');
-
 class DevPackager {
   constructor(options, bundleGraph, bundle, parcelRequireName) {
-    _defineProperty(this, "options", void 0);
-
-    _defineProperty(this, "bundleGraph", void 0);
-
-    _defineProperty(this, "bundle", void 0);
-
-    _defineProperty(this, "parcelRequireName", void 0);
-
     this.options = options;
     this.bundleGraph = bundleGraph;
     this.bundle = bundle;
     this.parcelRequireName = parcelRequireName;
   }
-
   async package() {
     // Load assets
     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 = '';
@@ -100,12 +70,11 @@ class DevPackager {
     let map = new (_sourceMap().default)(this.options.projectRoot);
     let prefix = this.getPrefix();
     let lineOffset = (0, _utils().countLines)(prefix);
+    let script = null;
     this.bundle.traverse(node => {
       let wrapped = first ? '' : ',';
-
       if (node.type === 'dependency') {
-        let resolved = this.bundleGraph.getDependencyResolution(node.value, this.bundle);
-
+        let resolved = this.bundleGraph.getResolvedAsset(node.value, this.bundle);
         if (resolved && resolved.type !== 'js') {
           // if this is a reference to another javascript asset, we should not include
           // its output, as its contents should already be loaded.
@@ -115,21 +84,29 @@ class DevPackager {
           return;
         }
       }
-
       if (node.type === 'asset') {
         let asset = node.value;
         (0, _assert().default)(asset.type === 'js', '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[(0, _utils2.getSpecifier)(dep)] = false;
+          } else if (resolved) {
+            deps[(0, _utils2.getSpecifier)(dep)] = this.bundleGraph.getAssetPublicId(resolved);
+          } else {
+            // An external module - map placeholder to original specifier.
+            deps[(0, _utils2.getSpecifier)(dep)] = dep.specifier;
           }
         }
-
         let {
           code,
           mapBuffer
@@ -138,75 +115,78 @@ class DevPackager {
         wrapped += JSON.stringify(this.bundleGraph.getAssetPublicId(asset)) + ':[function(require,module,exports) {\n' + output + '\n},';
         wrapped += JSON.stringify(deps);
         wrapped += ']';
-
+        if (this.bundle.env.isNode() && asset.meta.has_node_replacements === true) {
+          const relPath = (0, _utils().normalizeSeparators)(_path().default.relative(this.bundle.target.distDir, _path().default.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);
           } else {
             map.addEmptyMap(_path().default.relative(this.options.projectRoot, asset.filePath).replace(/\\+/g, '/'), output, lineOffset);
           }
-
           lineOffset += (0, _utils().countLines)(output) + 1;
         }
-
         i++;
       }
-
       assets += wrapped;
       first = false;
     });
     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 => {
         var _mainEntry;
-
         return a.id !== ((_mainEntry = mainEntry) === null || _mainEntry === void 0 ? void 0 : _mainEntry.id);
       });
       mainEntry = null;
     }
-
     let contents = prefix + '({' + assets + '},' + JSON.stringify(entries.map(asset => this.bundleGraph.getAssetPublicId(asset))) + ', ' + JSON.stringify(mainEntry ? this.bundleGraph.getAssetPublicId(mainEntry) : null) + ', ' + JSON.stringify(this.parcelRequireName) + ')' + '\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().default)(this.options.projectRoot, mapBuffer);
+      }
+      contents += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, script.code, entryMap, this.parcelRequireName);
+      if (this.bundle.env.sourceMap && entryMap) {
+        map.addSourceMap(entryMap, lineOffset);
+      }
+    }
     return {
       contents,
       map
     };
   }
-
   getPrefix() {
     let interpreter;
     let mainEntry = this.bundle.getMainEntry();
-
     if (mainEntry && this.isEntry() && !this.bundle.target.env.isBrowser()) {
       let _interpreter = mainEntry.meta.interpreter;
       (0, _assert().default)(_interpreter == null || typeof _interpreter === 'string');
       interpreter = _interpreter;
     }
-
     let importScripts = '';
-
     if (this.bundle.env.isWorker()) {
       let bundles = this.bundleGraph.getReferencedBundles(this.bundle);
-
       for (let b of bundles) {
         importScripts += `importScripts("${(0, _utils().relativeBundlePath)(this.bundle, b)}");\n`;
       }
     }
-
-    return (// If the entry asset included a hashbang, repeat it at the top of the bundle
+    return (
+      // If the entry asset included a hashbang, repeat it at the top of the bundle
       (interpreter != null ? `#!${interpreter}\n` : '') + importScripts + PRELUDE
     );
   }
-
   isEntry() {
-    var _this$bundle$getMainE;
-
-    return !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') || this.bundle.env.isIsolated() || !!((_this$bundle$getMainE = this.bundle.getMainEntry()) !== null && _this$bundle$getMainE !== void 0 && _this$bundle$getMainE.isIsolated);
+    return !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') || this.bundle.env.isIsolated() || this.bundle.bundleBehavior === 'isolated';
   }
-
 }
-
 exports.DevPackager = DevPackager;

package/lib/ESMOutputFormat.js

@@ -4,65 +4,49 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ESMOutputFormat = void 0;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class ESMOutputFormat {
   constructor(packager) {
-    _defineProperty(this, "packager", void 0);
-
     this.packager = packager;
   }
-
   buildBundlePrelude() {
     let res = '';
     let lines = 0;
-
     for (let [source, specifiers] of this.packager.externals) {
       let defaultSpecifier = null;
       let namespaceSpecifier = null;
       let namedSpecifiers = [];
-
       for (let [imported, symbol] of specifiers) {
-        if (imported === 'default'
-        /* || isCommonJS*/
-        ) {
-            defaultSpecifier = symbol;
-          } else if (imported === '*') {
+        if (imported === 'default' /* || isCommonJS*/) {
+          defaultSpecifier = symbol;
+        } else if (imported === '*') {
           namespaceSpecifier = `* as ${symbol}`;
         } else {
           let specifier = imported;
-
           if (symbol !== imported) {
             specifier += ` as ${symbol}`;
           }
-
           namedSpecifiers.push(specifier);
         }
-      } // ESModule syntax allows combining default and namespace specifiers, or default and named, but not all three.
+      }
 
+      // ESModule syntax allows combining default and namespace specifiers, or default and named, but not all three.
 
       let imported = '';
-
       if (namespaceSpecifier) {
         let s = namespaceSpecifier;
-
         if (defaultSpecifier) {
           s = `${defaultSpecifier}, ${namespaceSpecifier}`;
         }
-
         res += `import ${s} from ${JSON.stringify(source)};\n`;
         lines++;
       } else if (defaultSpecifier) {
         imported = defaultSpecifier;
-
         if (namedSpecifiers.length > 0) {
           imported += `, {${namedSpecifiers.join(', ')}}`;
         }
       } else if (namedSpecifiers.length > 0) {
         imported = `{${namedSpecifiers.join(', ')}}`;
       }
-
       if (imported.length > 0) {
         res += `import ${imported} from ${JSON.stringify(source)};\n`;
         lines++;
@@ -71,41 +55,45 @@ class ESMOutputFormat {
         lines++;
       }
     }
-
     if (res.length > 0) {
       res += '\n';
       lines++;
     }
-
     return [res, lines];
   }
-
   buildBundlePostlude() {
     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);
       }
     }
-
     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];
   }
-
 }
-
 exports.ESMOutputFormat = ESMOutputFormat;

package/lib/GlobalOutputFormat.js

@@ -4,24 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.GlobalOutputFormat = void 0;
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class GlobalOutputFormat {
   constructor(packager) {
-    _defineProperty(this, "packager", void 0);
-
     this.packager = packager;
   }
-
   buildBundlePrelude() {
-    return ['(function () {\n', 1];
+    let prelude = this.packager.bundle.env.supports('arrow-functions', true) ? '(() => {\n' : '(function () {\n';
+    return [prelude, 1];
   }
-
   buildBundlePostlude() {
-    return '})();';
+    return ['})();', 0];
   }
-
 }
-
 exports.GlobalOutputFormat = GlobalOutputFormat;