@parcel/packager-js 2.0.0-beta.3.1 → 2.0.0-nightly.1006

package/src/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, entry, mainEntry, parcelRequireName, globalName) {
+(function (modules, entry, mainEntry, parcelRequireName, globalName) {
   /* eslint-disable no-undef */
   var globalObject =
     typeof globalThis !== 'undefined'
@@ -73,18 +73,20 @@
         localRequire,
         module,
         module.exports,
-        this,
+        this
       );
     }
 
     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;
     }
   }
 
@@ -99,9 +101,9 @@
   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;
       },
       {},
@@ -109,7 +111,7 @@
   };
 
   Object.defineProperty(newRequire, 'root', {
-    get: function() {
+    get: function () {
       return globalObject[parcelRequireName];
     },
   });
@@ -131,7 +133,7 @@
 
       // RequireJS
     } else if (typeof define === 'function' && define.amd) {
-      define(function() {
+      define(function () {
         return mainExports;
       });
 

package/src/helpers.js

@@ -11,9 +11,9 @@ if (parcelRequire == null) {
       return $parcel$modules[id].exports;
     }
     if (id in $parcel$inits) {
-      let init = $parcel$inits[id];
+      var init = $parcel$inits[id];
       delete $parcel$inits[id];
-      let module = {id, exports: {}};
+      var module = {id: id, exports: {}};
       $parcel$modules[id] = module;
       init.call(module.exports, module, module.exports);
       return module.exports;
@@ -38,7 +38,7 @@ export const helpers = {
 `,
   $parcel$exportWildcard: `function $parcel$exportWildcard(dest, source) {
   Object.keys(source).forEach(function(key) {
-    if (key === 'default' || key === '__esModule') {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
       return;
     }
 
@@ -46,7 +46,7 @@ export const helpers = {
       enumerable: true,
       get: function get() {
         return source[key];
-      },
+      }
     });
   });
 

package/src/index.js

@@ -2,32 +2,24 @@
 import type {Async} from '@parcel/types';
 import type SourceMap from '@parcel/source-map';
 import {Packager} from '@parcel/plugin';
-import {
-  replaceInlineReferences,
-  md5FromString,
-  loadConfig,
-} from '@parcel/utils';
+import {replaceInlineReferences, replaceURLReferences} from '@parcel/utils';
+import {hashString} from '@parcel/hash';
 import path from 'path';
 import nullthrows from 'nullthrows';
 import {DevPackager} from './DevPackager';
 import {ScopeHoistingPackager} from './ScopeHoistingPackager';
 
 export default (new Packager({
-  async loadConfig({options}) {
+  async loadConfig({config, options}) {
     // 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 loadConfig(
-      options.inputFS,
-      path.join(options.entryRoot, 'index'),
+    let pkg = await config.getConfigFrom(
+      path.join(options.projectRoot, 'index'),
       ['package.json'],
-      options.projectRoot,
     );
-    let name = pkg?.config.name ?? '';
+    let name = pkg?.contents?.name ?? '';
     return {
-      config: {
-        parcelRequireName: 'parcelRequire' + md5FromString(name).slice(-4),
-      },
-      files: pkg?.files ?? [],
+      parcelRequireName: 'parcelRequire' + hashString(name).slice(-4),
     };
   },
   async package({
@@ -38,23 +30,51 @@ export default (new Packager({
     config,
     options,
   }) {
-    let packager = bundle.env.shouldScopeHoist
-      ? new ScopeHoistingPackager(
-          options,
-          bundleGraph,
-          bundle,
-          nullthrows(config).parcelRequireName,
-        )
-      : new DevPackager(
-          options,
-          bundleGraph,
-          bundle,
-          nullthrows(config).parcelRequireName,
-        );
+    // 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(
+            options,
+            bundleGraph,
+            bundle,
+            nullthrows(config).parcelRequireName,
+          )
+        : new DevPackager(
+            options,
+            bundleGraph,
+            bundle,
+            nullthrows(config).parcelRequireName,
+          );
+
+      ({contents, map} = await packager.package());
+    }
 
-    let {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} = replaceURLReferences({
+        bundle,
+        bundleGraph,
+        contents,
+        map,
+      }));
+    }
+
     return replaceInlineReferences({
       bundle,
       bundleGraph,

package/src/utils.js

@@ -0,0 +1,57 @@
+// @flow
+import type {BundleGraph, Dependency, NamedBundle} from '@parcel/types';
+import type SourceMap from '@parcel/source-map';
+import nullthrows from 'nullthrows';
+
+// 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.
+export function replaceScriptDependencies(
+  bundleGraph: BundleGraph<NamedBundle>,
+  bundle: NamedBundle,
+  code: string,
+  map: ?SourceMap,
+  parcelRequireName: string,
+): string {
+  let entry = nullthrows(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 = nullthrows(dependencies.find(d => getSpecifier(d) === s));
+    let resolved = nullthrows(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;
+}
+
+export function getSpecifier(dep: Dependency): string {
+  if (typeof dep.meta.placeholder === 'string') {
+    return dep.meta.placeholder;
+  }
+
+  return dep.specifier;
+}