index.js

'use strict';

const path = require('path');

const whatwgUrl = require('whatwg-url');
const resolve = require('resolve');
const pathIsInside = require('path-is-inside');
const minimatch = require('minimatch');

const isPathSpecifier = str => /^\.{0,2}[/\\]/.test(str);
const pathToURL = str => {
	/* istanbul ignore next */
	if (path.sep === path.win32.sep) {
		str = str.replace(/\\/g, '/');
	}

	return str;
};

function basedirResolve(importPath, sourceFileName, pluginOptions) {
	const {alwaysRootImport, neverRootImport} = {
		alwaysRootImport: [],
		neverRootImport: [],
		...pluginOptions
	};
	const sourceDirName = path.dirname(sourceFileName);

	if (isPathSpecifier(importPath)) {
		/* Not a bare import. */
		return sourceDirName;
	}

	if (!Array.isArray(alwaysRootImport) || alwaysRootImport.length === 0) {
		return sourceDirName;
	}

	const importPackage = importPath.split('/', importPath[0] === '@' ? 2 : 1).join('/');

	if (alwaysRootImport.some(v => minimatch(importPackage, v)) &&
			!neverRootImport.some(v => minimatch(importPackage, v))) {
		return pluginOptions.rootBaseDir || process.cwd();
	}

	return sourceDirName;
}

function absResolve(importPath, sourceFileName, pluginOptions = {}) {
	if (whatwgUrl.parseURL(importPath) !== null) {
		return importPath;
	}

	return resolve.sync(importPath, {
		basedir: basedirResolve(importPath, sourceFileName, pluginOptions),
		extensions: pluginOptions.extensions || ['.mjs', '.js', 'json'],
		moduleDirectory: pluginOptions.resolveDirectories || 'node_modules',
		preserveSymlinks: pluginOptions.preserveSymlinks !== false,
		packageFilter(packageJson) {
			packageJson.main = packageJson.module ||
				packageJson['jsnext:main'] || packageJson.main;
			return packageJson;
		}
	});
}

function tryResolve(babelPath, importPath, sourceFileName, pluginOptions) {
	if (whatwgUrl.parseURL(importPath) !== null) {
		return importPath;
	}

	if ([].concat(pluginOptions.ignorePrefixes).some(ignore => importPath.startsWith(ignore))) {
		return importPath;
	}

	try {
		const importPathAbs = absResolve(importPath, sourceFileName, pluginOptions);
		const nodeModules = path.resolve(pluginOptions.rootBaseDir || process.cwd(), 'node_modules');
		const isNodeModule = pathIsInside(importPathAbs, nodeModules);
		const fromNodeModule = pathIsInside(path.resolve(sourceFileName), nodeModules);
		let importPathRel = path.relative(path.dirname(sourceFileName), importPathAbs);
		const sep = pluginOptions.fsPath === true ? path.sep : path.posix.sep;

		const {modulesDir} = pluginOptions;
		if (modulesDir && isNodeModule && !fromNodeModule) {
			if (modulesDir.includes('://')) {
				return modulesDir + (modulesDir.endsWith('/') ? '' : '/') + pathToURL(path.relative(nodeModules, importPathAbs));
			}

			importPathRel = path.join(
				modulesDir,
				path.relative(nodeModules, importPathAbs));
		}

		if (pluginOptions.fsPath !== true) {
			importPathRel = pathToURL(importPathRel);
		}

		if (!isPathSpecifier(importPathRel) && !path.isAbsolute(importPathRel)) {
			importPathRel = '.' + sep + importPathRel;
		}

		return importPathRel;
	} catch (_) {
		if (pluginOptions.failOnUnresolved) {
			throw babelPath.buildCodeFrameError(`Could not resolve '${importPath}'.`);
		} else {
			console.error(`Could not resolve '${importPath}' in file '${sourceFileName}'.`);
			return importPath;
		}
	}
}

function getVisitor(t, opts) {
	const visitor = {
		CallExpression(path, {file}) {
			if (path.node.callee.type !== 'Import') {
				return;
			}

			const [source] = path.get('arguments');
			if (source.type !== 'StringLiteral') {
				/* Should never happen */
				return;
			}

			source.replaceWith(t.stringLiteral(tryResolve(path, source.node.value, file.opts.parserOpts.sourceFileName, opts)));
		},
		'ImportDeclaration|ExportNamedDeclaration|ExportAllDeclaration'(path, {file}) {
			const source = path.get('source');

			// An export without a 'from' clause
			if (source.node === null) {
				return;
			}

			source.replaceWith(t.stringLiteral(tryResolve(path, source.node.value, file.opts.parserOpts.sourceFileName, opts)));
		}
	};

	if (!opts.processAtProgramExit) {
		return visitor;
	}

	return {
		Program: {
			exit(path, state) {
				path.traverse(visitor, state);
			}
		}
	};
}

module.exports = ({types: t}, opts) => ({
	visitor: getVisitor(t, opts)
});
module.exports.resolve = absResolve;