module -> asset

packages/core/parcel-bundler/src/Asset.js

@@ -13,7 +13,7 @@ class Asset {
     this.contents = null;
     this.ast = null;
     this.dependencies = new Set;
-    this.modules = new Map;
+    this.depAssets = new Map;
   }
 
   async loadIfNeeded() {

packages/core/parcel-bundler/src/Bundle.js

@@ -11,48 +11,48 @@ class Bundle {
     this.resolver = new Resolver(options);
     this.parser = new Parser(options);
 
-    this.loadedModules = new Map;
+    this.loadedAssets = new Map;
     this.loading = new Set;
 
     this.farm = new WorkerFarm(require.resolve('./worker.js'), {autoStart: true});
   }
 
   async collectDependencies() {
-    let main = await this.resolveModule(this.mainFile);
-    await this.loadModule(main);
+    let main = await this.resolveAsset(this.mainFile);
+    await this.loadAsset(main);
     this.farm.end();
     return main;
   }
 
-  async resolveModule(name, parent) {
+  async resolveAsset(name, parent) {
     let {path, pkg} = await this.resolver.resolve(name, parent);
-    if (this.loadedModules.has(path)) {
-      return this.loadedModules.get(path);
+    if (this.loadedAssets.has(path)) {
+      return this.loadedAssets.get(path);
     }
 
-    let module = this.parser.getAsset(path, pkg, this.options);
-    this.loadedModules.set(path, module);
-    return module;
+    let asset = this.parser.getAsset(path, pkg, this.options);
+    this.loadedAssets.set(path, asset);
+    return asset;
   }
 
-  async loadModule(module) {
-    if (this.loading.has(module)) {
+  async loadAsset(asset) {
+    if (this.loading.has(asset)) {
       return;
     }
 
-    this.loading.add(module);
+    this.loading.add(asset);
 
-    let {deps, contents, ast} = await this.farm.run(module.name, module.package, this.options);
-    // let {deps, contents, ast} = await worker(module.name, module.package, this.options);
+    let {deps, contents, ast} = await this.farm.run(asset.name, asset.package, this.options);
+    // let {deps, contents, ast} = await worker(asset.name, asset.package, this.options);
 
-    module.dependencies = deps;
-    module.contents = contents;
-    module.ast = ast;
+    asset.dependencies = deps;
+    asset.contents = contents;
+    asset.ast = ast;
 
     await Promise.all(deps.map(async dep => {
-      let mod = await this.resolveModule(dep, module.name);
-      module.modules.set(dep, mod);
-      await this.loadModule(mod);
+      let assetDep = await this.resolveAsset(dep, asset.name);
+      asset.depAssets.set(dep, assetDep);
+      await this.loadAsset(assetDep);
     }));
   }
 }

packages/core/parcel-bundler/src/packagers/JSPackager.js

@@ -25,7 +25,7 @@ class JSPackager extends Readable {
     let id = this.id++;
     this.includedAssets.set(asset, id);
 
-    for (let mod of asset.modules.values()) {
+    for (let mod of asset.depAssets.values()) {
       this.addAsset(mod);
     }
 
@@ -35,7 +35,7 @@ class JSPackager extends Readable {
     wrapped += id + ':[function(require,module,exports) {\n' + asset.contents + '\n},';
 
     let deps = {};
-    for (let [dep, mod] of asset.modules) {
+    for (let [dep, mod] of asset.depAssets) {
       deps[dep] = this.includedAssets.get(mod);
     }
 

packages/core/parcel-bundler/src/visitors/dependencies.js

@@ -1,21 +1,21 @@
 const types = require('babel-types');
 
 module.exports = {
-  ImportDeclaration(node, module) {
-    module.dependencies.add(node.source.value);
+  ImportDeclaration(node, asset) {
+    asset.dependencies.add(node.source.value);
   },
 
-  ExportNamedDeclaration(node, module) {
+  ExportNamedDeclaration(node, asset) {
     if (node.source) {
-      module.dependencies.add(node.source.value);
+      asset.dependencies.add(node.source.value);
     }
   },
 
-  ExportAllDeclaration(node, module) {
-    module.dependencies.add(node.source.value);
+  ExportAllDeclaration(node, asset) {
+    asset.dependencies.add(node.source.value);
   },
 
-  CallExpression(node, module) {
+  CallExpression(node, asset) {
     let {callee, arguments: args} = node;
 
     let isRequire = types.isIdentifier(callee)
@@ -27,6 +27,6 @@ module.exports = {
       return;
     }
 
-    module.dependencies.add(args[0].value);
+    asset.dependencies.add(args[0].value);
   }
 };

packages/core/parcel-bundler/src/visitors/globals.js

@@ -3,36 +3,36 @@ const Path = require('path');
 const types = require('babel-types');
 
 const VARS = {
-  process: (module) => {
-    module.dependencies.add('process');
+  process: (asset) => {
+    asset.dependencies.add('process');
     return 'var process = require("process");';
   },
   global: () => 'var global = typeof global !== "undefined" ? global : '
             + 'typeof self !== "undefined" ? self : '
             + 'typeof window !== "undefined" ? window : {};',
-  __dirname: (module) => `var __dirname = ${JSON.stringify(Path.dirname(module.name))};`,
-  __filename: (module) => `var __filename = ${JSON.stringify(module.name)};`,
-  Buffer: (module) => {
-    module.dependencies.add('buffer');
+  __dirname: (asset) => `var __dirname = ${JSON.stringify(Path.dirname(asset.name))};`,
+  __filename: (asset) => `var __filename = ${JSON.stringify(asset.name)};`,
+  Buffer: (asset) => {
+    asset.dependencies.add('buffer');
     return 'var Buffer = require("buffer").Buffer;';
   }
 };
 
 module.exports = {
-  Identifier(node, module, ancestors) {
+  Identifier(node, asset, ancestors) {
     let parent = ancestors[ancestors.length - 2];
-    if (VARS.hasOwnProperty(node.name) && !module.globals.has(node.name) && types.isReferenced(node, parent)) {
-      module.globals.set(node.name, VARS[node.name](module));
+    if (VARS.hasOwnProperty(node.name) && !asset.globals.has(node.name) && types.isReferenced(node, parent)) {
+      asset.globals.set(node.name, VARS[node.name](asset));
     }
   },
 
-  Declaration(node, module, ancestors) {
+  Declaration(node, asset, ancestors) {
     // If there is a global declaration of one of the variables, remove our declaration
     let identifiers = types.getBindingIdentifiers(node);
     for (let id in identifiers) {
       if (VARS.hasOwnProperty(id) && !inScope(ancestors)) {
         // Don't delete entirely, so we don't add it again when the declaration is referenced
-        module.globals.set(id, '');
+        asset.globals.set(id, '');
       }
     }
   }

test.js

@@ -12,24 +12,24 @@ async function run() {
 
   console.profile();
 
-  let module = await bundle.collectDependencies();
-  // printDeps(module);
+  let main = await bundle.collectDependencies();
+  // printDeps(main);
 
   console.profileEnd();
   console.log('here')
 
   let packager = new JSPackager;
   packager.pipe(require('fs').createWriteStream('out.js'));
-  packager.addAsset(module);
+  packager.addAsset(main);
   packager.end();
 }
 
-function printDeps(module, indent = '', deps = new Set) {
-  for (let [file, mod] of module.modules) {
+function printDeps(asset, indent = '', deps = new Set) {
+  for (let [file, a] of asset.depAssets) {
     console.log(indent + file);
-    if (!deps.has(mod.name)) {
-      deps.add(mod.name);
-      printDeps(mod, indent + '  ', deps);
+    if (!deps.has(a.name)) {
+      deps.add(a.name);
+      printDeps(a, indent + '  ', deps);
     }
   }
 }