@parcel/packager-js 2.0.0-beta.3.1 → 2.0.0-canary.1521

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

@@ -1,19 +1,21 @@
 // @flow strict-local
-export const prelude = (
-  parcelRequireName: string,
-): string => `var $parcel$modules = {};
+import type {Environment} from '@parcel/types';
+
+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) {
-      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;
@@ -29,16 +31,88 @@ if (parcelRequire == null) {
 
   $parcel$global[${JSON.stringify(parcelRequireName)}] = parcelRequire;
 }
+
+var parcelRegister = parcelRequire.register;
 `;
 
-export const helpers = {
-  $parcel$export: `function $parcel$export(e, n, v, s) {
+export const fnExpr = (
+  env: Environment,
+  params: Array<string>,
+  body: Array<string>,
+): string => {
+  let block = `{ ${body.join(' ')} }`;
+
+  if (env.supports('arrow-functions')) {
+    return `(${params.join(', ')}) => ${block}`;
+  }
+
+  return `function (${params.join(', ')}) ${block}`;
+};
+
+export const bundleQueuePrelude = (env: Environment): string => `
+if (!$parcel$global.lb) {
+  // Set of loaded bundles
+  $parcel$global.lb = new Set();
+  // Queue of bundles to execute once they're dep bundles are loaded
+  $parcel$global.bq = [];
+
+  // Register loaded bundle
+  $parcel$global.rlb = ${fnExpr(
+    env,
+    ['bundle'],
+    ['$parcel$global.lb.add(bundle);', '$parcel$global.pq();'],
+  )}
+
+  // Run when ready
+  $parcel$global.rwr = ${fnExpr(
+    env,
+    // b = bundle public id
+    // r = run function to execute the bundle entry
+    // d = list of dependent bundles this bundle requires before executing
+    ['b', 'r', 'd'],
+    ['$parcel$global.bq.push({b, r, d});', '$parcel$global.pq();'],
+  )}
+
+  // Process queue
+  $parcel$global.pq = ${fnExpr(
+    env,
+    [],
+    [
+      `var runnableEntry = $parcel$global.bq.find(${fnExpr(
+        env,
+        ['i'],
+        [
+          `return i.d.every(${fnExpr(
+            env,
+            ['dep'],
+            ['return $parcel$global.lb.has(dep);'],
+          )});`,
+        ],
+      )});`,
+      'if (runnableEntry) {',
+      `$parcel$global.bq = $parcel$global.bq.filter(${fnExpr(
+        env,
+        ['i'],
+        ['return i.b !== runnableEntry.b;'],
+      )});`,
+      'runnableEntry.r();',
+      '$parcel$global.pq();',
+      '}',
+    ],
+  )}
+}
+`;
+
+const $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) {
+`;
+
+const $parcel$exportWildcard = `
+function $parcel$exportWildcard(dest, source) {
   Object.keys(source).forEach(function(key) {
-    if (key === 'default' || key === '__esModule') {
+    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
       return;
     }
 
@@ -46,30 +120,50 @@ export const helpers = {
       enumerable: true,
       get: function get() {
         return source[key];
-      },
+      }
     });
   });
 
   return dest;
 }
-`,
-  $parcel$interopDefault: `function $parcel$interopDefault(a) {
+`;
+
+const $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) {
+`;
+
+const $parcel$global = (env: Environment): string => {
+  if (env.supports('global-this')) {
+    return `
+      var $parcel$global = globalThis;
+    `;
+  }
+  return `
+      var $parcel$global =
+        typeof globalThis !== 'undefined'
+          ? globalThis
+          : typeof self !== 'undefined'
+          ? self
+          : typeof window !== 'undefined'
+          ? window
+          : typeof global !== 'undefined'
+          ? global
+          : {};
+  `;
+};
+
+const $parcel$defineInteropFlag = `
+function $parcel$defineInteropFlag(a) {
   Object.defineProperty(a, '__esModule', {value: true, configurable: true});
 }
-`,
+`;
+
+export const helpers = {
+  $parcel$export,
+  $parcel$exportWildcard,
+  $parcel$interopDefault,
+  $parcel$global,
+  $parcel$defineInteropFlag,
 };

package/src/index.js

@@ -4,30 +4,63 @@ import type SourceMap from '@parcel/source-map';
 import {Packager} from '@parcel/plugin';
 import {
   replaceInlineReferences,
-  md5FromString,
-  loadConfig,
+  replaceURLReferences,
+  validateSchema,
+  type SchemaEntity,
 } from '@parcel/utils';
+import {encodeJSONKeyComponent} from '@parcel/diagnostic';
+import {hashString} from '@parcel/rust';
 import path from 'path';
 import nullthrows from 'nullthrows';
 import {DevPackager} from './DevPackager';
 import {ScopeHoistingPackager} from './ScopeHoistingPackager';
 
+type JSPackagerConfig = {|
+  parcelRequireName: string,
+  unstable_asyncBundleRuntime: boolean,
+|};
+
+const CONFIG_SCHEMA: SchemaEntity = {
+  type: 'object',
+  properties: {
+    unstable_asyncBundleRuntime: {
+      type: 'boolean',
+    },
+  },
+  additionalProperties: false,
+};
+
 export default (new Packager({
-  async loadConfig({options}) {
+  async loadConfig({config, options}): Promise<JSPackagerConfig> {
     // 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 packageKey = '@parcel/packager-js';
+
+    if (pkg?.contents[packageKey]) {
+      validateSchema.diagnostic(
+        CONFIG_SCHEMA,
+        {
+          data: pkg?.contents[packageKey],
+          source: await options.inputFS.readFile(pkg.filePath, 'utf8'),
+          filePath: pkg.filePath,
+          prependKey: `/${encodeJSONKeyComponent(packageKey)}`,
+        },
+        packageKey,
+        `Invalid config for ${packageKey}`,
+      );
+    }
+
+    let name = pkg?.contents?.name ?? '';
     return {
-      config: {
-        parcelRequireName: 'parcelRequire' + md5FromString(name).slice(-4),
-      },
-      files: pkg?.files ?? [],
+      parcelRequireName: 'parcelRequire' + hashString(name).slice(-4),
+      unstable_asyncBundleRuntime: Boolean(
+        pkg?.contents[packageKey]?.unstable_asyncBundleRuntime,
+      ),
     };
   },
   async package({
@@ -38,23 +71,53 @@ 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,
+            nullthrows(config).unstable_asyncBundleRuntime,
+          )
+        : 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,
+        getReplacement: s => JSON.stringify(s).slice(1, -1),
+      }));
+    }
+
     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;
+}