Feat: warn when the package from resolved alias is not available

package.json

@@ -61,7 +61,8 @@
   "jest": {
     "testRegex": "/test/.*\\.test\\.js$",
     "collectCoverageFrom": [
-      "src/**/*.js"
+      "src/**/*.js",
+      "!src/log.js"
     ]
   },
   "greenkeeper": {

src/getRealPath.js

@@ -1,10 +1,13 @@
 import path from 'path';
 
 import resolve from 'resolve';
+import { warn } from './log';
 import mapToRelative from './mapToRelative';
 import { toLocalPath, toPosixPath, replaceExtension } from './utils';
 
 
+const nodeExtensions = ['.js', '.json'];
+
 function findPathInRoots(sourcePath, { extensions, root }) {
   // Search the source path inside every custom root directory
   let resolvedSourceFile;
@@ -43,40 +46,21 @@ function getRealPathFromRootConfig(sourcePath, currentFile, opts) {
   )));
 }
 
-function getRealPathFromAliasConfig(sourcePath, currentFile, { alias, cwd }) {
-  const moduleSplit = sourcePath.split('/');
-  let aliasPath;
-
-  while (moduleSplit.length) {
-    const m = moduleSplit.join('/');
-    if ({}.hasOwnProperty.call(alias, m)) {
-      aliasPath = alias[m];
-      break;
-    }
-    moduleSplit.pop();
-  }
-
-  // no alias mapping found
-  if (!aliasPath) {
-    return null;
-  }
-
-  // remove legacy "npm:" prefix for npm packages
-  aliasPath = aliasPath.replace(/^(npm:)/, '');
-  const newPath = sourcePath.replace(moduleSplit.join('/'), aliasPath);
-
-  // alias to npm module don't need relative mapping
-  if (aliasPath[0] !== '.') {
-    return newPath;
+function checkIfPackageExists(modulePath, currentFile) {
+  try {
+    resolve.sync(modulePath, {
+      basedir: currentFile,
+      extensions: nodeExtensions,
+    });
+  } catch (e) {
+    warn(`Could not resolve "${modulePath}" in file ${currentFile}.`);
   }
-
-  return toLocalPath(toPosixPath(mapToRelative(cwd, currentFile, newPath)));
 }
 
-function getRealPathFromRegExpConfig(sourcePath, currentFile, { regExps }) {
+function getRealPathFromAliasConfig(sourcePath, currentFile, opts) {
   let aliasedSourceFile;
 
-  regExps.find(([regExp, substitute]) => {
+  opts.alias.find(([regExp, substitute]) => {
     const execResult = regExp.exec(sourcePath);
 
     if (execResult === null) {
@@ -87,13 +71,26 @@ function getRealPathFromRegExpConfig(sourcePath, currentFile, { regExps }) {
     return true;
   });
 
+  if (!aliasedSourceFile) {
+    return null;
+  }
+
+  if (aliasedSourceFile[0] === '.') {
+    return toLocalPath(toPosixPath(
+      mapToRelative(opts.cwd, currentFile, aliasedSourceFile)),
+    );
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    checkIfPackageExists(aliasedSourceFile, currentFile);
+  }
+
   return aliasedSourceFile;
 }
 
 const resolvers = [
   getRealPathFromRootConfig,
   getRealPathFromAliasConfig,
-  getRealPathFromRegExpConfig,
 ];
 
 export default function getRealPath(sourcePath, { file, opts }) {

src/log.js

@@ -0,0 +1,7 @@
+// This module exists only for abstracting logging away and making testing easier
+
+// eslint-disable-next-line import/prefer-default-export
+export function warn(...args) {
+  // eslint-disable-next-line no-console
+  console.warn(...args);
+}

src/normalizeOptions.js

@@ -51,29 +51,42 @@ function normalizeRoot(opts) {
   }
 }
 
-function normalizeAlias(opts) {
-  opts.regExps = [];
-
-  if (opts.alias) {
-    Object.keys(opts.alias)
-      .filter(isRegExp)
-      .forEach((key) => {
-        const parts = opts.alias[key].split('\\\\');
-
-        function substitute(execResult) {
-          return parts
-            .map(part =>
-              part.replace(/\\\d+/g, number => execResult[number.slice(1)] || ''),
-            )
-            .join('\\');
-        }
+function getAliasPair(key, value) {
+  const parts = value.split('\\\\');
+
+  function substitute(execResult) {
+    return parts
+      .map(part =>
+        part.replace(/\\\d+/g, number => execResult[number.slice(1)] || ''),
+      )
+      .join('\\');
+  }
 
-        opts.regExps.push([new RegExp(key), substitute]);
+  return [new RegExp(key), substitute];
+}
 
-        delete opts.alias[key];
-      });
+function normalizeAlias(opts) {
+  if (opts.alias) {
+    const { alias } = opts;
+    const aliasKeys = Object.keys(alias);
+    const nonRegExpAliases = [];
+    const regExpAliases = [];
+
+    aliasKeys.forEach((key) => {
+      if (isRegExp(key)) {
+        regExpAliases.push(
+          getAliasPair(key, alias[key]),
+        );
+      } else {
+        nonRegExpAliases.push(
+          getAliasPair(`^${key}((?:/|).*)`, `${alias[key]}\\1`),
+        );
+      }
+    });
+
+    opts.alias = [...nonRegExpAliases, ...regExpAliases];
   } else {
-    opts.alias = {};
+    opts.alias = [];
   }
 }
 

test/import.test.js

@@ -84,6 +84,7 @@ describe('import and export statement', () => {
         root: './test/testproject/src',
         alias: {
           test: './test/testproject/test',
+          'babel-core': 'babel-core/lib',
         },
       }],
     ],
@@ -121,6 +122,15 @@ describe('import and export statement', () => {
     );
   });
 
+  describe('should only apply the alias once', () => {
+    // If this test breaks, consider selecting another package used by the plugin
+    testImports(
+      'babel-core/store',
+      'babel-core/lib/store',
+      transformerOpts,
+    );
+  });
+
   describe('should ignore the call if a non-import statement is used', () => {
     const code = stripIndent`
       function test() {