@parcel/packager-js 2.0.0-nightly.133 → 2.0.0-nightly.1332

package/lib/{prelude.js → dev-prelude.js}

@@ -6,7 +6,7 @@
 // anything defined in a previous bundle is accessed via the
 // orig method which is the require for previous bundles
 
-(function(modules, cache, entry, globalName) {
+(function (modules, entry, mainEntry, parcelRequireName, globalName) {
   /* eslint-disable no-undef */
   var globalObject =
     typeof globalThis !== 'undefined'
@@ -22,8 +22,10 @@
 
   // Save the require from previous bundle to this closure if any
   var previousRequire =
-    typeof globalObject.parcelRequire === 'function' &&
-    globalObject.parcelRequire;
+    typeof globalObject[parcelRequireName] === 'function' &&
+    globalObject[parcelRequireName];
+
+  var cache = previousRequire.cache || {};
   // Do not use `require` to prevent Webpack from trying to bundle this call
   var nodeRequire =
     typeof module !== 'undefined' &&
@@ -37,7 +39,8 @@
         // cache jump to the current global require ie. the last bundle
         // that was added to the page.
         var currentRequire =
-          typeof parcelRequire === 'function' && parcelRequire;
+          typeof globalObject[parcelRequireName] === 'function' &&
+          globalObject[parcelRequireName];
         if (!jumped && currentRequire) {
           return currentRequire(name, true);
         }
@@ -77,11 +80,13 @@
     return cache[name].exports;
 
     function localRequire(x) {
-      return newRequire(localRequire.resolve(x));
+      var res = localRequire.resolve(x);
+      return res === false ? {} : newRequire(res);
     }
 
     function resolve(x) {
-      return modules[name][1][x] || x;
+      var id = modules[name][1][x];
+      return id != null ? id : x;
     }
   }
 
@@ -96,25 +101,31 @@
   newRequire.modules = modules;
   newRequire.cache = cache;
   newRequire.parent = previousRequire;
-  newRequire.register = function(id, exports) {
+  newRequire.register = function (id, exports) {
     modules[id] = [
-      function(require, module) {
+      function (require, module) {
         module.exports = exports;
       },
       {},
     ];
   };
 
-  globalObject.parcelRequire = newRequire;
+  Object.defineProperty(newRequire, 'root', {
+    get: function () {
+      return globalObject[parcelRequireName];
+    },
+  });
+
+  globalObject[parcelRequireName] = newRequire;
 
   for (var i = 0; i < entry.length; i++) {
     newRequire(entry[i]);
   }
 
-  if (entry.length) {
+  if (mainEntry) {
     // Expose entry point to Node, AMD or browser globals
     // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
-    var mainExports = newRequire(entry[entry.length - 1]);
+    var mainExports = newRequire(mainEntry);
 
     // CommonJS
     if (typeof exports === 'object' && typeof module !== 'undefined') {
@@ -122,7 +133,7 @@
 
       // RequireJS
     } else if (typeof define === 'function' && define.amd) {
-      define(function() {
+      define(function () {
         return mainExports;
       });
 

package/lib/helpers.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prelude = exports.helpers = void 0;
+const prelude = parcelRequireName => `var $parcel$modules = {};
+var $parcel$inits = {};
+
+var parcelRequire = $parcel$global[${JSON.stringify(parcelRequireName)}];
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    if (id in $parcel$modules) {
+      return $parcel$modules[id].exports;
+    }
+    if (id in $parcel$inits) {
+      var init = $parcel$inits[id];
+      delete $parcel$inits[id];
+      var module = {id: id, exports: {}};
+      $parcel$modules[id] = module;
+      init.call(module.exports, module, module.exports);
+      return module.exports;
+    }
+    var err = new Error("Cannot find module '" + id + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  };
+
+  parcelRequire.register = function register(id, init) {
+    $parcel$inits[id] = init;
+  };
+
+  $parcel$global[${JSON.stringify(parcelRequireName)}] = parcelRequire;
+}
+`;
+exports.prelude = prelude;
+const helpers = {
+  $parcel$export: `function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+`,
+  $parcel$exportWildcard: `function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+`,
+  $parcel$interopDefault: `function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+`,
+  $parcel$global: `var $parcel$global =
+typeof globalThis !== 'undefined'
+  ? globalThis
+  : typeof self !== 'undefined'
+  ? self
+  : typeof window !== 'undefined'
+  ? window
+  : typeof global !== 'undefined'
+  ? global
+  : {};
+`,
+  $parcel$defineInteropFlag: `function $parcel$defineInteropFlag(a) {
+  Object.defineProperty(a, '__esModule', {value: true, configurable: true});
+}
+`
+};
+exports.helpers = helpers;

package/lib/index.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _plugin() {
+  const data = require("@parcel/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@parcel/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _hash() {
+  const data = require("@parcel/hash");
+  _hash = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _DevPackager = require("./DevPackager");
+var _ScopeHoistingPackager = require("./ScopeHoistingPackager");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = new (_plugin().Packager)({
+  async loadConfig({
+    config,
+    options
+  }) {
+    var _pkg$contents$name, _pkg$contents;
+    // Generate a name for the global parcelRequire function that is unique to this project.
+    // This allows multiple parcel builds to coexist on the same page.
+    let pkg = await config.getConfigFrom(_path().default.join(options.projectRoot, 'index'), ['package.json']);
+    let name = (_pkg$contents$name = pkg === null || pkg === void 0 ? void 0 : (_pkg$contents = pkg.contents) === null || _pkg$contents === void 0 ? void 0 : _pkg$contents.name) !== null && _pkg$contents$name !== void 0 ? _pkg$contents$name : '';
+    return {
+      parcelRequireName: 'parcelRequire' + (0, _hash().hashString)(name).slice(-4)
+    };
+  },
+  async package({
+    bundle,
+    bundleGraph,
+    getInlineBundleContents,
+    getSourceMapReference,
+    config,
+    options
+  }) {
+    // If this is a non-module script, and there is only one asset with no dependencies,
+    // then we don't need to package at all and can pass through the original code un-wrapped.
+    let contents, map;
+    if (bundle.env.sourceType === 'script') {
+      let entries = bundle.getEntryAssets();
+      if (entries.length === 1 && bundleGraph.getDependencies(entries[0]).length === 0) {
+        contents = await entries[0].getCode();
+        map = await entries[0].getMap();
+      }
+    }
+    if (contents == null) {
+      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName);
+      ({
+        contents,
+        map
+      } = await packager.package());
+    }
+    contents += '\n' + (await getSourceMapSuffix(getSourceMapReference, map));
+
+    // For library builds, we need to replace URL references with their final resolved paths.
+    // For non-library builds, this is handled in the JS runtime.
+    if (bundle.env.isLibrary) {
+      ({
+        contents,
+        map
+      } = (0, _utils().replaceURLReferences)({
+        bundle,
+        bundleGraph,
+        contents,
+        map,
+        getReplacement: s => JSON.stringify(s).slice(1, -1)
+      }));
+    }
+    return (0, _utils().replaceInlineReferences)({
+      bundle,
+      bundleGraph,
+      contents,
+      getInlineReplacement: (dependency, inlineType, content) => ({
+        from: `"${dependency.id}"`,
+        to: inlineType === 'string' ? JSON.stringify(content) : content
+      }),
+      getInlineBundleContents,
+      map
+    });
+  }
+});
+exports.default = _default;
+async function getSourceMapSuffix(getSourceMapReference, map) {
+  let sourcemapReference = await getSourceMapReference(map);
+  if (sourcemapReference != null) {
+    return '//# sourceMappingURL=' + sourcemapReference + '\n';
+  } else {
+    return '';
+  }
+}

package/lib/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSpecifier = getSpecifier;
+exports.replaceScriptDependencies = replaceScriptDependencies;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This replaces __parcel__require__ references left by the transformer with
+// parcelRequire calls of the resolved asset id. This lets runtimes work within
+// script bundles, which must be outside the bundle wrapper so their variables are global.
+function replaceScriptDependencies(bundleGraph, bundle, code, map, parcelRequireName) {
+  let entry = (0, _nullthrows().default)(bundle.getMainEntry());
+  let dependencies = bundleGraph.getDependencies(entry);
+  let lineCount = 0;
+  let offset = 0;
+  let columnStartIndex = 0;
+  code = code.replace(/\n|__parcel__require__\(['"](.*?)['"]\)/g, (m, s, i) => {
+    if (m === '\n') {
+      columnStartIndex = i + offset + 1;
+      lineCount++;
+      return '\n';
+    }
+    let dep = (0, _nullthrows().default)(dependencies.find(d => getSpecifier(d) === s));
+    let resolved = (0, _nullthrows().default)(bundleGraph.getResolvedAsset(dep, bundle));
+    let publicId = bundleGraph.getAssetPublicId(resolved);
+    let replacement = `${parcelRequireName}("${publicId}")`;
+    if (map) {
+      let lengthDifference = replacement.length - m.length;
+      if (lengthDifference !== 0) {
+        map.offsetColumns(lineCount + 1, i + offset - columnStartIndex + m.length, lengthDifference);
+        offset += lengthDifference;
+      }
+    }
+    return replacement;
+  });
+  return code;
+}
+function getSpecifier(dep) {
+  if (typeof dep.meta.placeholder === 'string') {
+    return dep.meta.placeholder;
+  }
+  return dep.specifier;
+}

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "@parcel/packager-js",
-  "version": "2.0.0-nightly.133+e8a4b8b7",
+  "version": "2.0.0-nightly.1332+76e710092",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
   },
-  "main": "lib/JSPackager.js",
-  "source": "src/JSPackager.js",
+  "main": "lib/index.js",
+  "source": "src/index.js",
   "engines": {
-    "node": ">= 10.0.0",
-    "parcel": "^2.0.0-alpha.1.1"
+    "node": ">= 12.0.0",
+    "parcel": "2.0.0-nightly.1330+76e710092"
   },
   "dependencies": {
-    "@parcel/plugin": "2.0.0-nightly.133+e8a4b8b7",
-    "@parcel/scope-hoisting": "2.0.0-nightly.133+e8a4b8b7",
-    "@parcel/source-map": "2.0.0-nightly.133+e8a4b8b7",
-    "@parcel/utils": "2.0.0-nightly.133+e8a4b8b7"
+    "@parcel/diagnostic": "2.0.0-nightly.1332+76e710092",
+    "@parcel/hash": "2.9.3-nightly.2955+76e710092",
+    "@parcel/plugin": "2.0.0-nightly.1332+76e710092",
+    "@parcel/source-map": "^2.1.1",
+    "@parcel/utils": "2.0.0-nightly.1332+76e710092",
+    "globals": "^13.2.0",
+    "nullthrows": "^1.1.1"
   },
-  "gitHead": "e8a4b8b7e54c33c38c6702e1c5b03f93af7a58bc"
+  "gitHead": "76e7100922bd0688c1ed3ce56f21c78d8eeb5d65"
 }

package/src/.eslintrc.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@parcel/eslint-config",
+  "overrides": [
+    {
+      "files": ["dev-prelude.js"],
+      "parser": "espree",
+      "parserOptions": {
+        "ecmaVersion": 5,
+        "sourceType": "script"
+      }
+    }
+  ]
+}

package/src/CJSOutputFormat.js

@@ -0,0 +1,42 @@
+// @flow
+import type {
+  ScopeHoistingPackager,
+  OutputFormat,
+} from './ScopeHoistingPackager';
+
+export class CJSOutputFormat implements OutputFormat {
+  packager: ScopeHoistingPackager;
+
+  constructor(packager: ScopeHoistingPackager) {
+    this.packager = packager;
+  }
+
+  buildBundlePrelude(): [string, number] {
+    let res = '';
+    let lines = 0;
+
+    for (let [source, specifiers] of this.packager.externals) {
+      // 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 {
+        res += `require(${JSON.stringify(source)});\n`;
+        lines++;
+      }
+    }
+
+    if (res.length > 0) {
+      res += '\n';
+      lines++;
+    }
+
+    return [res, lines];
+  }
+
+  buildBundlePostlude(): [string, number] {
+    return ['', 0];
+  }
+}

package/src/DevPackager.js

@@ -0,0 +1,252 @@
+// @flow strict-local
+import type {BundleGraph, PluginOptions, NamedBundle} from '@parcel/types';
+
+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')
+  .trim()
+  .replace(/;$/, '');
+
+export class DevPackager {
+  options: PluginOptions;
+  bundleGraph: BundleGraph<NamedBundle>;
+  bundle: NamedBundle;
+  parcelRequireName: string;
+
+  constructor(
+    options: PluginOptions,
+    bundleGraph: BundleGraph<NamedBundle>,
+    bundle: NamedBundle,
+    parcelRequireName: string,
+  ) {
+    this.options = options;
+    this.bundleGraph = bundleGraph;
+    this.bundle = bundle;
+    this.parcelRequireName = parcelRequireName;
+  }
+
+  async package(): Promise<{|contents: string, map: ?SourceMap|}> {
+    // Load assets
+    let queue = new PromiseQueue({maxConcurrent: 32});
+    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 = '';
+    let i = 0;
+    let first = true;
+    let map = new SourceMap(this.options.projectRoot);
+
+    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.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.
+          invariant(!this.bundle.hasAsset(resolved));
+          wrapped +=
+            JSON.stringify(this.bundleGraph.getAssetPublicId(resolved)) +
+            ':[function() {},{}]';
+        } else {
+          return;
+        }
+      }
+
+      if (node.type === 'asset') {
+        let asset = node.value;
+        invariant(
+          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.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;
+          }
+        }
+
+        let {code, mapBuffer} = results[i];
+        let output = code || '';
+        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 = 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);
+          } else {
+            map.addEmptyMap(
+              path
+                .relative(this.options.projectRoot, asset.filePath)
+                .replace(/\\+/g, '/'),
+              output,
+              lineOffset,
+            );
+          }
+
+          lineOffset += 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') ||
+      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);
+      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(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,
+    };
+  }
+
+  getPrefix(): string {
+    let interpreter: ?string;
+    let mainEntry = this.bundle.getMainEntry();
+    if (mainEntry && this.isEntry() && !this.bundle.target.env.isBrowser()) {
+      let _interpreter = mainEntry.meta.interpreter;
+      invariant(_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("${relativeBundlePath(
+          this.bundle,
+          b,
+        )}");\n`;
+      }
+    }
+
+    return (
+      // If the entry asset included a hashbang, repeat it at the top of the bundle
+      (interpreter != null ? `#!${interpreter}\n` : '') +
+      importScripts +
+      PRELUDE
+    );
+  }
+
+  isEntry(): boolean {
+    return (
+      !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') ||
+      this.bundle.env.isIsolated() ||
+      this.bundle.bundleBehavior === 'isolated'
+    );
+  }
+}