Working version

Author: Ives van Hoorne

src/index.ts

@@ -4,28 +4,61 @@ import * as path from "path";
 import installDependencies from "./dependencies/install-dependencies";
 import parseDependency from "./dependencies/parse-dependency";
 
+import findPackageInfos from "./packages/find-package-infos";
 import findRequires from "./packages/find-requires";
 
 import getHash from "./utils/get-hash";
 
 export async function http(req: Request, res: Response) {
-  const dependency = await parseDependency(req.url);
-  const hash = getHash(dependency);
+  try {
+    const dependency = await parseDependency(req.url);
+    const hash = getHash(dependency);
 
-  const a = Date.now();
+    const a = Date.now();
 
-  if (!hash) {
-    return;
-  }
+    if (!hash) {
+      return;
+    }
+
+    const packagePath = path.join("/tmp", hash);
+
+    await installDependencies(dependency, packagePath);
 
-  const packagePath = path.join("/tmp", hash);
+    const packageInfos = await findPackageInfos(dependency.name, packagePath);
 
-  await installDependencies(dependency, packagePath);
+    const aliases = Object.keys(packageInfos).reduce(
+      (total, name) => ({
+        ...total,
+        [name]: packageInfos[name].main,
+        ...packageInfos[name].aliases,
+      }),
+      {},
+    );
 
-  const requires = await findRequires(dependency.name, packagePath);
+    const { contents, aliases: newAliases } = await findRequires(
+      dependency.name,
+      packagePath,
+      packageInfos,
+      aliases,
+    );
 
-  console.log("Done - " + (Date.now() - a) + " - " + packagePath);
-  res.json(requires);
+    const packages = Object.keys(packageInfos).reduce(
+      (total, packageName) => ({
+        ...total,
+        [packageName]: packageInfos[packageName].package,
+      }),
+      {},
+    );
+
+    console.log("Done - " + (Date.now() - a) + " - " + packagePath);
+    res.json({
+      aliases: newAliases,
+      contents,
+      dependency,
+    });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
 }
 
 if (process.env.LOCAL) {
@@ -36,6 +69,6 @@ if (process.env.LOCAL) {
   app.get("/*", http);
 
   app.listen(8080, () => {
-    console.log("listening");
+    console.log("Listening on port 8080");
   });
 }

src/packages/find-aliases.ts src/packages/find-package-infos.tssrc/packages/find-aliases.ts renamed to src/packages/find-package-infos.ts

@@ -13,7 +13,7 @@ interface IPackage {
 export interface IPackageInfo {
   package: IPackage;
   main: string | undefined;
-  name: string;
+  aliases: { [key: string]: string };
 }
 
 function getDirectories(path: string) {

src/packages/find-requires.ts

@@ -1,14 +1,14 @@
 import { fs } from "mz";
 import { dirname, join } from "path";
 
-import findAliases from "./find-aliases";
+import { IPackageInfo } from "./find-package-infos";
 import resolveRequiredFiles from "./resolve-required-files";
 import extractRequires from "./utils/extract-requires";
 import getAliasedPath from "./utils/get-aliased-path";
 import nodeResolvePath from "./utils/node-resolve-path";
 
 interface IAliases {
-  [alias: string]: string;
+  [alias: string]: string | false | null;
 }
 
 function rewritePath(
@@ -27,7 +27,16 @@ function rewritePath(
     return null;
   }
 
-  return aliases[newPath] || newPath;
+  if (aliases[path]) {
+    return aliases[path];
+  }
+
+  const nodeResolvedNewPath = nodeResolvePath(newPath);
+  if (nodeResolvedNewPath && aliases[nodeResolvedNewPath]) {
+    return aliases[nodeResolvedNewPath];
+  }
+
+  return newPath;
 }
 
 function buildRequireObject(
@@ -65,6 +74,7 @@ function buildRequireObject(
       aliases,
     );
 
+    // If something was added to the total
     if (requiredContents !== existingContents) {
       return { ...total, ...requiredContents };
     }
@@ -80,7 +90,7 @@ function getRequiresFromFile(
 ) {
   const resolvedPath = nodeResolvePath(filePath);
   if (!resolvedPath) {
-    console.log('Warning: could not find "' + filePath + '"');
+    // console.log('Warning: could not find "' + filePath + '"');
     return null;
   }
 
@@ -97,11 +107,11 @@ function getRequiresFromFile(
 export default async function findRequires(
   packageName: string,
   rootPath: string,
+  packageInfos: { [dep: string]: IPackageInfo },
+  aliases: IAliases,
 ) {
-  const packageInfos = await findAliases(packageName, rootPath);
-
   if (!packageInfos[packageName]) {
-    return;
+    return { contents: {}, aliases: {} };
   }
 
   const packagePath = join(rootPath, "node_modules", packageName);
@@ -111,17 +121,7 @@ export default async function findRequires(
     packageInfos[packageName],
   );
 
-  const aliases = Object.keys(packageInfos).reduce((total, name) => {
-    const browserField = packageInfos[name].package.browser;
-    const browserAliases = typeof browserField === "object" ? browserField : {};
-    return {
-      ...total,
-      [name]: packageInfos[name].main,
-      ...browserAliases,
-    };
-  }, {});
-
-  let files = {};
+  let files: { [path: string]: string } = {};
 
   for (const file of requiredFiles) {
     if (file) {
@@ -135,5 +135,23 @@ export default async function findRequires(
     }
   }
 
-  return files;
+  const nodeModulesPath = join(rootPath, "node_modules") + "/";
+  const relativeFiles = Object.keys(files).reduce(
+    (total, next) => ({
+      ...total,
+      [next.replace(nodeModulesPath, "")]: files[next],
+    }),
+    {},
+  );
+
+  const relativeAliases = Object.keys(aliases).reduce((total, next) => {
+    const aliasPath = aliases[next];
+    return {
+      ...total,
+      [next.replace(nodeModulesPath, "")]:
+        aliasPath && aliasPath.replace(nodeModulesPath, ""),
+    };
+  }, {});
+
+  return { contents: relativeFiles, aliases: relativeAliases };
 }

src/packages/resolve-required-files.ts

@@ -1,9 +1,26 @@
 import { flatten } from "lodash";
 import { fs } from "mz";
 import { basename, dirname, join } from "path";
-import { IPackageInfo } from "./find-aliases";
+import { IPackageInfo } from "./find-package-infos";
 
-const BLACKLISTED_DIRS = ["umd", "tests"];
+const BLACKLISTED_DIRS = [
+  "demo",
+  "docs",
+  "benchmark",
+  "es6",
+  "es",
+  "flow-typed",
+  "src",
+  "bundles",
+  "examples",
+  "scripts",
+  "tests",
+  "test",
+  "testing",
+  "umd",
+  "min",
+  "node_modules",
+];
 
 async function getFilePathsInDirectory(path: string): Promise<string[]> {
   const entries = await fs.readdir(path);
@@ -32,6 +49,30 @@ async function getFilePathsInDirectory(path: string): Promise<string[]> {
   return files;
 }
 
+const DISALLOWED_EXTENSIONS = ["min.js", "umd.js", "node.js", "test.js"];
+const ALLOWED_EXTENSIONS = [
+  "json",
+  "js",
+  "css",
+  "scss",
+  "styl",
+  "less",
+  "vue",
+  "html",
+];
+
+function isValidFile(filePath: string) {
+  if (DISALLOWED_EXTENSIONS.some(ex => filePath.endsWith(ex))) {
+    return false;
+  }
+
+  if (ALLOWED_EXTENSIONS.some(ex => filePath.endsWith(ex))) {
+    return true;
+  }
+
+  return false;
+}
+
 const FALLBACK_DIRS = ["dist", "lib", "build"];
 
 export default async function resolveRequiredFiles(
@@ -56,7 +97,5 @@ export default async function resolveRequiredFiles(
 
   const files = await getFilePathsInDirectory(entryDir);
 
-  return files
-    .filter(p => p.endsWith(".js"))
-    .filter(p => !p.endsWith(".min.js"));
+  return files.filter(isValidFile);
 }