eslint-import-resolver-parcel/dist-node/index.js

Parcel import resolution plugin for eslint-plugin-import.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var path = _interopDefault(require('path'));
var fs = _interopDefault(require('fs'));
var resolve$1 = require('resolve');

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

const defaultExtensions = ['.js', '.jsx'];
const interfaceVersion = 2;

function findAliases() {
  let currentPath = path.resolve();
  let packagePath = path.resolve(currentPath, 'package.json');

  while (!fs.existsSync(packagePath)) {
    currentPath = path.resolve(currentPath, '..');
    packagePath = path.resolve(currentPath, 'package.json');
  }

  const packageJson = fs.readFileSync(packagePath);
  return JSON.parse(packageJson).alias || {};
}

function resolvePackageLevel(source, file, rootDirectory) {
  let packageDirectory = path.dirname(file);

  for (;;) {
    if (fs.existsSync(path.resolve(packageDirectory, 'node_modules'))) {
      // found node_modules
      break;
    } else if (path.parse(packageDirectory).root === packageDirectory) {
      // reached the drive root, just return null
      return null;
    }

    packageDirectory = path.resolve(packageDirectory, '..');
  }

  return path.join( // return rootDirectory if it is nested inside the packageDirectory
  rootDirectory.startsWith(packageDirectory) ? rootDirectory : packageDirectory, // Get rid of the tilde
  source.slice(1));
}

function resolve(source, file, possibleConfig = {}) {
  if (resolve$1.isCore(source)) return {
    found: true,
    path: null
  };

  const config = _objectSpread2({
    rootDir: '',
    extensions: []
  }, possibleConfig);

  const [startSource] = source.split('/');
  const aliases = findAliases();
  const foundAlias = Object.keys(aliases).find(alias => alias === startSource);
  let newSource = source.replace(foundAlias, aliases[foundAlias]);
  const rootDirectory = path.resolve(config.rootDir);

  switch (newSource[0]) {
    case '.':
      newSource = path.resolve(path.dirname(file), newSource);
      break;

    case '~':
      newSource = resolvePackageLevel(newSource, file, rootDirectory);
      break;

    case '/':
      newSource = path.join(rootDirectory, newSource);
      break;
    // no default
  }

  try {
    return {
      found: true,
      path: resolve$1.sync(newSource, {
        basedir: path.resolve(),
        extensions: [...defaultExtensions, ...config.extensions]
      })
    };
  } catch (_) {
    return {
      found: false
    };
  }
}

exports.interfaceVersion = interfaceVersion;
exports.resolve = resolve;
//# sourceMappingURL=index.js.map