Parcel 2: Simple working JS packager

packages/core/core/src/AssetGraph.js

@@ -131,9 +131,10 @@ export default class AssetGraph extends Graph {
 
     for (let assetNode of assetNodes) {
       // TODO: dep should already have sourcePath
-      let depNodes = assetNode.value.dependencies.map(dep =>
-        nodeFromDep({...dep, sourcePath: file.filePath})
-      );
+      let depNodes = assetNode.value.dependencies.map(dep => {
+        dep.sourcePath = file.filePath;
+        return nodeFromDep(dep);
+      });
       let {removed, added} = this.updateDownStreamNodes(assetNode, depNodes);
       prunedFiles = prunedFiles.concat(getFilesFromGraph(removed));
       newDepNodes = newDepNodes.concat(getDepNodesFromGraph(added));

packages/core/core/src/Parcel.js

@@ -174,6 +174,7 @@ export default class Parcel {
 
     let file = {filePath: resolvedPath};
     if (signal && !signal.aborted) {
+      dep.resolvedPath = resolvedPath;
       let {newFile} = this.graph.updateDependency(dep, file);
 
       if (newFile) {

packages/packagers/js/src/index.js

@@ -2,9 +2,45 @@
 'use strict';
 
 import {Packager} from '@parcel/plugin';
+import fs from 'fs';
+
+const PRELUDE = fs.readFileSync(__dirname + '/prelude.js');
 
 export default new Packager({
   async package(bundle) {
-    return bundle.assets.map(asset => asset.output.code).join('\n\n');
+    let assets = bundle.assets
+      .map((asset, i) => {
+        let deps = {};
+
+        for (let dep of asset.dependencies) {
+          let resolvedAsset = bundle.assets.find(
+            a => a.filePath === dep.resolvedPath
+          );
+          deps[dep.moduleSpecifier] = resolvedAsset.id;
+        }
+
+        let wrapped = i === 0 ? '' : ',';
+        wrapped +=
+          JSON.stringify(asset.id) +
+          ':[function(require,module,exports) {\n' +
+          (asset.output.code || '') +
+          '\n},';
+        wrapped += JSON.stringify(deps);
+        wrapped += ']';
+
+        return wrapped;
+      })
+      .join('');
+
+    return (
+      PRELUDE +
+      '({' +
+      assets +
+      '},{},' +
+      JSON.stringify([bundle.assets[0].id]) +
+      ', ' +
+      'null' +
+      ')'
+    );
   }
 });

packages/packagers/js/src/prelude.js

@@ -0,0 +1,117 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+// eslint-disable-next-line no-global-assign
+parcelRequire = function(modules, cache, entry, globalName) {
+  // Save the require from previous bundle to this closure if any
+  var previousRequire = typeof parcelRequire === 'function' && parcelRequire;
+  var nodeRequire = typeof require === 'function' && require;
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire =
+          typeof parcelRequire === 'function' && parcelRequire;
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error("Cannot find module '" + name + "'");
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+      localRequire.cache = {};
+
+      var module = (cache[name] = new newRequire.Module(name));
+
+      modules[name][0].call(
+        module.exports,
+        localRequire,
+        module,
+        module.exports,
+        this
+      );
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x) {
+      return newRequire(localRequire.resolve(x));
+    }
+
+    function resolve(x) {
+      return modules[name][1][x] || x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+  newRequire.register = function(id, exports) {
+    modules[id] = [
+      function(require, module) {
+        module.exports = exports;
+      },
+      {}
+    ];
+  };
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  if (entry.length) {
+    // 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]);
+
+    // CommonJS
+    if (typeof exports === 'object' && typeof module !== 'undefined') {
+      module.exports = mainExports;
+
+      // RequireJS
+    } else if (typeof define === 'function' && define.amd) {
+      define(function() {
+        return mainExports;
+      });
+
+      // <script>
+    } else if (globalName) {
+      this[globalName] = mainExports;
+    }
+  }
+
+  // Override the current require with this new one
+  return newRequire;
+};