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

package/src/{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/src/helpers.js

@@ -0,0 +1,75 @@
+// @flow strict-local
+export const prelude = (
+  parcelRequireName: string,
+): string => `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;
+}
+`;
+
+export 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});
+}
+`,
+};

package/src/index.js

@@ -0,0 +1,102 @@
+// @flow strict-local
+import type {Async} from '@parcel/types';
+import type SourceMap from '@parcel/source-map';
+import {Packager} from '@parcel/plugin';
+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({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 config.getConfigFrom(
+      path.join(options.projectRoot, 'index'),
+      ['package.json'],
+    );
+    let name = pkg?.contents?.name ?? '';
+    return {
+      parcelRequireName: 'parcelRequire' + 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(
+            options,
+            bundleGraph,
+            bundle,
+            nullthrows(config).parcelRequireName,
+          )
+        : new DevPackager(
+            options,
+            bundleGraph,
+            bundle,
+            nullthrows(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} = replaceURLReferences({
+        bundle,
+        bundleGraph,
+        contents,
+        map,
+      }));
+    }
+
+    return replaceInlineReferences({
+      bundle,
+      bundleGraph,
+      contents,
+      getInlineReplacement: (dependency, inlineType, content) => ({
+        from: `"${dependency.id}"`,
+        to: inlineType === 'string' ? JSON.stringify(content) : content,
+      }),
+      getInlineBundleContents,
+      map,
+    });
+  },
+}): Packager);
+
+async function getSourceMapSuffix(
+  getSourceMapReference: (?SourceMap) => Async<?string>,
+  map: ?SourceMap,
+): Promise<string> {
+  let sourcemapReference = await getSourceMapReference(map);
+  if (sourcemapReference != null) {
+    return '//# sourceMappingURL=' + sourcemapReference + '\n';
+  } else {
+    return '';
+  }
+}

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

package/lib/JSPackager.js

@@ -1,174 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _assert = _interopRequireDefault(require("assert"));
-
-var _plugin = require("@parcel/plugin");
-
-var _fs = _interopRequireDefault(require("fs"));
-
-var _scopeHoisting = require("@parcel/scope-hoisting");
-
-var _sourceMap = _interopRequireDefault(require("@parcel/source-map"));
-
-var _utils = require("@parcel/utils");
-
-var _path = _interopRequireDefault(require("path"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const PRELUDE = _fs.default.readFileSync(_path.default.join(__dirname, 'prelude.js'), 'utf8').trim().replace(/;$/, '');
-
-var _default = new _plugin.Packager({
-  async package({
-    bundle,
-    bundleGraph,
-    getInlineBundleContents,
-    getSourceMapReference,
-    options
-  }) {
-    function replaceReferences({
-      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
-      });
-    } // If scope hoisting is enabled, we use a different code path.
-
-
-    if (options.scopeHoist) {
-      let ast = await (0, _scopeHoisting.concat)(bundle, bundleGraph);
-      ast = (0, _scopeHoisting.link)({
-        bundle,
-        bundleGraph,
-        ast,
-        options
-      });
-      return replaceReferences({
-        contents: (0, _scopeHoisting.generate)(bundleGraph, bundle, ast, options).contents,
-        map: null
-      });
-    }
-
-    if (bundle.env.outputFormat === 'esmodule') {
-      throw new Error(`esmodule output is not supported without scope hoisting.`);
-    } // For development, we just concatenate all of the code together
-    // rather then enabling scope hoisting, which would be too slow.
-
-
-    let codeQueue = new _utils.PromiseQueue({
-      maxConcurrent: 32
-    });
-    let mapQueue = new _utils.PromiseQueue({
-      maxConcurrent: 32
-    });
-    bundle.traverse(node => {
-      if (node.type === 'asset') {
-        codeQueue.add(() => node.value.getCode());
-        mapQueue.add(() => node.value.getMap());
-      }
-    });
-    let [code, maps] = await Promise.all([codeQueue.run(), mapQueue.run()]);
-    let assets = '';
-    let i = 0;
-    let first = true;
-    let map = new _sourceMap.default();
-    let lineOffset = (0, _utils.countLines)(PRELUDE);
-    let stubsWritten = new Set();
-    bundle.traverse(node => {
-      let wrapped = first ? '' : ',';
-
-      if (node.type === 'dependency') {
-        let resolved = bundleGraph.getDependencyResolution(node.value);
-
-        if (resolved && resolved.type !== 'js' && !stubsWritten.has(resolved.id)) {
-          // if this is a reference to another javascript asset, we should not include
-          // its output, as its contents should already be loaded.
-          (0, _assert.default)(!bundle.hasAsset(resolved));
-          wrapped += JSON.stringify(resolved.id) + ':[function() {},{}]';
-        } else {
-          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');
-        let deps = {};
-        let dependencies = bundleGraph.getDependencies(asset);
-
-        for (let dep of dependencies) {
-          let resolved = bundleGraph.getDependencyResolution(dep);
-
-          if (resolved) {
-            deps[dep.moduleSpecifier] = resolved.id;
-          }
-        }
-
-        let output = code[i] || '';
-        wrapped += JSON.stringify(asset.id) + ':[function(require,module,exports) {\n' + output + '\n},';
-        wrapped += JSON.stringify(deps);
-        wrapped += ']';
-
-        if (options.sourceMaps) {
-          var _maps$i;
-
-          let assetMap = (_maps$i = maps[i]) !== null && _maps$i !== void 0 ? _maps$i : _sourceMap.default.generateEmptyMap(_path.default.relative(options.projectRoot, asset.filePath).replace(/\\+/g, '/'), output);
-          map.addMap(assetMap, lineOffset);
-          lineOffset += (0, _utils.countLines)(output) + 1;
-        }
-
-        i++;
-      }
-
-      assets += wrapped;
-      first = false;
-    });
-    let entries = bundle.getEntryAssets();
-    let interpreter = null;
-    let isEntry = !bundleGraph.hasParentBundleOfType(bundle, 'js') || bundle.env.isIsolated();
-
-    if (isEntry) {
-      let entryAsset = entries[entries.length - 1]; // $FlowFixMe
-
-      interpreter = bundle.target.env.isBrowser() ? null : entryAsset.meta.interpreter;
-    } else if (bundle.env.outputFormat === 'global') {
-      // The last entry is the main entry, but in async bundles we don't want it to execute until we require it
-      // as there might be dependencies in a sibling bundle that hasn't loaded yet.
-      entries.pop();
-    }
-
-    let importScripts = '';
-
-    if (bundle.env.isWorker()) {
-      let bundles = bundleGraph.getSiblingBundles(bundle);
-
-      for (let b of bundles) {
-        importScripts += `importScripts("${(0, _utils.relativeBundlePath)(bundle, b)}");\n`;
-      }
-    }
-
-    let sourceMapReference = await getSourceMapReference(map);
-    return replaceReferences({
-      contents: // If the entry asset included a hashbang, repeat it at the top of the bundle
-      (interpreter != null ? `#!${interpreter}\n` : '') + importScripts + (PRELUDE + '({' + assets + '},{},' + JSON.stringify(entries.map(asset => asset.id)) + ', ' + 'null' + ')\n\n' + '//# sourceMappingURL=' + sourceMapReference + '\n'),
-      map
-    });
-  }
-
-});
-
-exports.default = _default;

package/src/JSPackager.js

@@ -1,190 +0,0 @@
-// @flow strict-local
-
-import invariant from 'assert';
-import {Packager} from '@parcel/plugin';
-import fs from 'fs';
-import {concat, link, generate} from '@parcel/scope-hoisting';
-import SourceMap from '@parcel/source-map';
-import {
-  countLines,
-  PromiseQueue,
-  relativeBundlePath,
-  replaceInlineReferences,
-} from '@parcel/utils';
-import path from 'path';
-
-const PRELUDE = fs
-  .readFileSync(path.join(__dirname, 'prelude.js'), 'utf8')
-  .trim()
-  .replace(/;$/, '');
-
-export default new Packager({
-  async package({
-    bundle,
-    bundleGraph,
-    getInlineBundleContents,
-    getSourceMapReference,
-    options,
-  }) {
-    function replaceReferences({contents, map}) {
-      return replaceInlineReferences({
-        bundle,
-        bundleGraph,
-        contents,
-        getInlineReplacement: (dependency, inlineType, content) => ({
-          from: `"${dependency.id}"`,
-          to: inlineType === 'string' ? JSON.stringify(content) : content,
-        }),
-        getInlineBundleContents,
-        map,
-      });
-    }
-
-    // If scope hoisting is enabled, we use a different code path.
-    if (options.scopeHoist) {
-      let ast = await concat(bundle, bundleGraph);
-      ast = link({bundle, bundleGraph, ast, options});
-      return replaceReferences({
-        contents: generate(bundleGraph, bundle, ast, options).contents,
-        map: null,
-      });
-    }
-
-    if (bundle.env.outputFormat === 'esmodule') {
-      throw new Error(
-        `esmodule output is not supported without scope hoisting.`,
-      );
-    }
-
-    // For development, we just concatenate all of the code together
-    // rather then enabling scope hoisting, which would be too slow.
-    let codeQueue = new PromiseQueue({maxConcurrent: 32});
-    let mapQueue = new PromiseQueue({maxConcurrent: 32});
-    bundle.traverse(node => {
-      if (node.type === 'asset') {
-        codeQueue.add(() => node.value.getCode());
-        mapQueue.add(() => node.value.getMap());
-      }
-    });
-
-    let [code, maps] = await Promise.all([codeQueue.run(), mapQueue.run()]);
-
-    let assets = '';
-    let i = 0;
-    let first = true;
-    let map = new SourceMap();
-    let lineOffset = countLines(PRELUDE);
-
-    let stubsWritten = new Set();
-    bundle.traverse(node => {
-      let wrapped = first ? '' : ',';
-
-      if (node.type === 'dependency') {
-        let resolved = bundleGraph.getDependencyResolution(node.value);
-        if (
-          resolved &&
-          resolved.type !== 'js' &&
-          !stubsWritten.has(resolved.id)
-        ) {
-          // if this is a reference to another javascript asset, we should not include
-          // its output, as its contents should already be loaded.
-          invariant(!bundle.hasAsset(resolved));
-          wrapped += JSON.stringify(resolved.id) + ':[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',
-        );
-
-        let deps = {};
-        let dependencies = bundleGraph.getDependencies(asset);
-        for (let dep of dependencies) {
-          let resolved = bundleGraph.getDependencyResolution(dep);
-          if (resolved) {
-            deps[dep.moduleSpecifier] = resolved.id;
-          }
-        }
-
-        let output = code[i] || '';
-        wrapped +=
-          JSON.stringify(asset.id) +
-          ':[function(require,module,exports) {\n' +
-          output +
-          '\n},';
-        wrapped += JSON.stringify(deps);
-        wrapped += ']';
-
-        if (options.sourceMaps) {
-          let assetMap =
-            maps[i] ??
-            SourceMap.generateEmptyMap(
-              path
-                .relative(options.projectRoot, asset.filePath)
-                .replace(/\\+/g, '/'),
-              output,
-            );
-
-          map.addMap(assetMap, lineOffset);
-          lineOffset += countLines(output) + 1;
-        }
-        i++;
-      }
-
-      assets += wrapped;
-      first = false;
-    });
-
-    let entries = bundle.getEntryAssets();
-    let interpreter: ?string = null;
-
-    let isEntry =
-      !bundleGraph.hasParentBundleOfType(bundle, 'js') ||
-      bundle.env.isIsolated();
-    if (isEntry) {
-      let entryAsset = entries[entries.length - 1];
-      // $FlowFixMe
-      interpreter = bundle.target.env.isBrowser()
-        ? null
-        : entryAsset.meta.interpreter;
-    } else if (bundle.env.outputFormat === 'global') {
-      // The last entry is the main entry, but in async bundles we don't want it to execute until we require it
-      // as there might be dependencies in a sibling bundle that hasn't loaded yet.
-      entries.pop();
-    }
-
-    let importScripts = '';
-    if (bundle.env.isWorker()) {
-      let bundles = bundleGraph.getSiblingBundles(bundle);
-      for (let b of bundles) {
-        importScripts += `importScripts("${relativeBundlePath(bundle, b)}");\n`;
-      }
-    }
-
-    let sourceMapReference = await getSourceMapReference(map);
-
-    return replaceReferences({
-      contents:
-        // If the entry asset included a hashbang, repeat it at the top of the bundle
-        (interpreter != null ? `#!${interpreter}\n` : '') +
-        importScripts +
-        (PRELUDE +
-          '({' +
-          assets +
-          '},{},' +
-          JSON.stringify(entries.map(asset => asset.id)) +
-          ', ' +
-          'null' +
-          ')\n\n' +
-          '//# sourceMappingURL=' +
-          sourceMapReference +
-          '\n'),
-      map,
-    });
-  },
-});