@parcel/packager-js 2.0.0-nightly.97 → 2.1.0

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,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.helpers = exports.prelude = 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,149 @@
+"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
+      }));
+    }
+
+    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,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceScriptDependencies = replaceScriptDependencies;
+exports.getSpecifier = getSpecifier;
+
+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.97+a63f3fc9",
+  "version": "2.1.0",
   "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.1.0"
   },
   "dependencies": {
-    "@parcel/plugin": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/scope-hoisting": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/source-map": "2.0.0-nightly.97+a63f3fc9",
-    "@parcel/utils": "2.0.0-nightly.97+a63f3fc9"
+    "@parcel/diagnostic": "^2.1.0",
+    "@parcel/hash": "^2.1.0",
+    "@parcel/plugin": "^2.1.0",
+    "@parcel/source-map": "^2.0.0",
+    "@parcel/utils": "^2.1.0",
+    "globals": "^13.2.0",
+    "nullthrows": "^1.1.1"
   },
-  "gitHead": "a63f3fc9726483219412920faeb255e035f90747"
+  "gitHead": "5a80fbe4af8797d0aab248a66f5254f42f00e83e"
 }

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];
+  }
+}