@unofficial-parcel-nightly/parcel-resolver-default/lib/DefaultResolver.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _plugin = require("@unofficial-parcel-nightly/plugin");

var _path = _interopRequireDefault(require("path"));

var _utils = require("@unofficial-parcel-nightly/utils");

var _micromatch = _interopRequireDefault(require("micromatch"));

var _builtins = _interopRequireDefault(require("./builtins"));

var _assert = _interopRequireDefault(require("assert"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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 _objectSpread(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; }

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; }

// Throw user friendly errors on special webpack loader syntax
// ex. `imports-loader?$=jquery!./example.js`
const WEBPACK_IMPORT_REGEX = /\S+-loader\S*!\S+/g;

var _default = new _plugin.Resolver({
  async resolve({
    dependency,
    options,
    filePath
  }) {
    if (WEBPACK_IMPORT_REGEX.test(dependency.moduleSpecifier)) {
      throw new Error(`The import path: ${dependency.moduleSpecifier} is using webpack specific loader import syntax, which isn't supported by Parcel.`);
    }

    const resolver = new NodeResolver({
      extensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'css', 'styl'],
      options
    });
    const resolved = await resolver.resolve({
      filename: filePath,
      isURL: dependency.isURL,
      parent: dependency.sourcePath,
      env: dependency.env
    });

    if (!resolved) {
      return null;
    }

    if (resolved.isExcluded != null) {
      return {
        isExcluded: true
      };
    }

    (0, _assert.default)(resolved.path != null);
    let result = {
      filePath: resolved.path
    };

    if (resolved.pkg && !hasSideEffects(resolved.path, resolved.pkg)) {
      result.sideEffects = false;
    }

    return result;
  }

});

exports.default = _default;

function hasSideEffects(filePath, pkg) {
  switch (typeof pkg.sideEffects) {
    case 'boolean':
      return pkg.sideEffects;

    case 'string':
      return _micromatch.default.isMatch(_path.default.relative(pkg.pkgdir, filePath), pkg.sideEffects, {
        matchBase: true
      });

    case 'object':
      return pkg.sideEffects.some(sideEffects => hasSideEffects(filePath, _objectSpread({}, pkg, {
        sideEffects
      })));
  }

  return true;
}

const EMPTY_SHIM = require.resolve('./_empty');

/**
 * This resolver implements a modified version of the node_modules resolution algorithm:
 * https://nodejs.org/api/modules.html#modules_all_together
 *
 * In addition to the standard algorithm, Parcel supports:
 *   - All file extensions supported by Parcel.
 *   - Glob file paths
 *   - Absolute paths (e.g. /foo) resolved relative to the project root.
 *   - Tilde paths (e.g. ~/foo) resolved relative to the nearest module root in node_modules.
 *   - The package.json module, jsnext:main, and browser field as replacements for package.main.
 *   - The package.json browser and alias fields as an alias map within a local module.
 *   - The package.json alias field in the root package for global aliases across all modules.
 */
class NodeResolver {
  constructor(opts) {
    _defineProperty(this, "options", void 0);

    _defineProperty(this, "extensions", void 0);

    _defineProperty(this, "packageCache", void 0);

    _defineProperty(this, "rootPackage", void 0);

    this.extensions = opts.extensions.map(ext => ext.startsWith('.') ? ext : '.' + ext);
    this.options = opts.options;
    this.packageCache = new Map();
    this.rootPackage = null;
  }

  async resolve({
    filename,
    parent,
    isURL,
    env
  }) {
    // Check if this is a glob
    if ((0, _utils.isGlob)(filename)) {
      if (parent == null) {
        throw new Error('Globs can only be required from a parent file');
      }

      return {
        path: _path.default.resolve(_path.default.dirname(parent), filename)
      };
    } // Get file extensions to search


    let extensions = this.extensions.slice();

    if (parent) {
      // parent's extension given high priority
      let parentExt = _path.default.extname(parent);

      extensions = [parentExt, ...extensions.filter(ext => ext !== parentExt)];
    }

    extensions.unshift(''); // Resolve the module directory or local file path

    let module = await this.resolveModule({
      filename,
      parent,
      isURL,
      env
    });

    if (!module) {
      return {
        isExcluded: true
      };
    }

    if (module.moduleDir) {
      return this.loadNodeModules(module, extensions, env);
    } else if (module.filePath) {
      return this.loadRelative(module.filePath, extensions, env);
    } else {
      return null;
    }
  }

  async resolveModule({
    filename,
    parent,
    isURL,
    env
  }) {
    let dir = parent ? _path.default.dirname(parent) : this.options.inputFS.cwd(); // If this isn't the entrypoint, resolve the input file to an absolute path

    if (parent) {
      filename = await this.resolveFilename(filename, dir, isURL);
    } // Resolve aliases in the parent module for this file.


    filename = await this.loadAlias(filename, dir, env); // Return just the file path if this is a file, not in node_modules

    if (_path.default.isAbsolute(filename)) {
      return {
        filePath: filename
      };
    }

    if (!this.shouldIncludeNodeModule(env, filename)) {
      return null;
    }

    let builtin = this.findBuiltin(filename, env);

    if (builtin || builtin === null) {
      return builtin;
    } // Resolve the module in node_modules


    let resolved;

    try {
      resolved = await this.findNodeModulePath(filename, dir);
    } catch (err) {} // ignore
    // If we couldn't resolve the node_modules path, just return the module name info


    if (resolved === undefined) {
      let parts = this.getModuleParts(filename);
      resolved = {
        moduleName: parts[0],
        subPath: parts[1]
      };
    }

    return resolved;
  }

  shouldIncludeNodeModule({
    includeNodeModules
  }, name) {
    if (includeNodeModules === false) {
      return false;
    }

    if (Array.isArray(includeNodeModules)) {
      let parts = this.getModuleParts(name);
      return includeNodeModules.includes(parts[0]);
    }

    return true;
  }

  getCacheKey(filename, parent) {
    return (parent ? _path.default.dirname(parent) : '') + ':' + filename;
  }

  async resolveFilename(filename, dir, isURL) {
    switch (filename[0]) {
      case '/':
        {
          // Absolute path. Resolve relative to project root.
          return _path.default.resolve(this.options.rootDir, filename.slice(1));
        }

      case '~':
        {
          // Tilde path. Resolve relative to nearest node_modules directory,
          // the nearest directory with package.json or the project root - whichever comes first.
          const insideNodeModules = dir.includes('node_modules');

          while (dir !== this.options.projectRoot && _path.default.basename(_path.default.dirname(dir)) !== 'node_modules' && (insideNodeModules || !(await this.options.inputFS.exists(_path.default.join(dir, 'package.json'))))) {
            dir = _path.default.dirname(dir);

            if (dir === _path.default.dirname(dir)) {
              dir = this.options.rootDir;
              break;
            }
          }

          return _path.default.join(dir, filename.slice(1));
        }

      case '.':
        {
          // Relative path.
          return _path.default.resolve(dir, filename);
        }

      default:
        {
          if (isURL) {
            return _path.default.resolve(dir, filename);
          } // Module


          return filename;
        }
    }
  }

  async loadRelative(filename, extensions, env) {
    // Find a package.json file in the current package.
    let pkg = await this.findPackage(_path.default.dirname(filename)); // First try as a file, then as a directory.

    return (await this.loadAsFile({
      file: filename,
      extensions,
      env,
      pkg
    })) || (await this.loadDirectory({
      dir: filename,
      extensions,
      env,
      pkg
    })) // eslint-disable-line no-return-await
    ;
  }

  findBuiltin(filename, env) {
    if (_builtins.default[filename]) {
      if (env.isNode()) {
        return null;
      }

      return {
        filePath: _builtins.default[filename]
      };
    }
  }

  async findNodeModulePath(filename, dir) {
    let parts = this.getModuleParts(filename);

    let root = _path.default.parse(dir).root;

    while (dir !== root) {
      // Skip node_modules directories
      if (_path.default.basename(dir) === 'node_modules') {
        dir = _path.default.dirname(dir);
      }

      try {
        // First, check if the module directory exists. This prevents a lot of unnecessary checks later.
        let moduleDir = _path.default.join(dir, 'node_modules', parts[0]);

        let stats = await this.options.inputFS.stat(moduleDir);

        if (stats.isDirectory()) {
          return {
            moduleName: parts[0],
            subPath: parts[1],
            moduleDir: moduleDir,
            filePath: _path.default.join(dir, 'node_modules', filename)
          };
        }
      } catch (err) {} // ignore
      // Move up a directory


      dir = _path.default.dirname(dir);
    }

    return undefined;
  }

  async loadNodeModules(module, extensions, env) {
    try {
      // If a module was specified as a module sub-path (e.g. some-module/some/path),
      // it is likely a file. Try loading it as a file first.
      if (module.subPath) {
        let pkg = await this.readPackage(module.moduleDir);
        let res = await this.loadAsFile({
          file: module.filePath,
          extensions,
          env,
          pkg
        });

        if (res) {
          return res;
        }
      } // Otherwise, load as a directory.


      return await this.loadDirectory({
        dir: module.filePath,
        extensions,
        env
      });
    } catch (e) {// ignore
    }
  }

  async isFile(file) {
    try {
      let stat = await this.options.inputFS.stat(file);
      return stat.isFile() || stat.isFIFO();
    } catch (err) {
      return false;
    }
  }

  async loadDirectory({
    dir,
    extensions,
    env,
    pkg
  }) {
    try {
      pkg = await this.readPackage(dir); // Get a list of possible package entry points.

      let entries = this.getPackageEntries(pkg, env);

      for (let file of entries) {
        // First try loading package.main as a file, then try as a directory.
        const res = (await this.loadAsFile({
          file,
          extensions,
          env,
          pkg
        })) || (await this.loadDirectory({
          dir: file,
          extensions,
          env,
          pkg
        }));

        if (res) {
          return res;
        }
      }
    } catch (err) {} // ignore
    // Fall back to an index file inside the directory.


    return this.loadAsFile({
      file: _path.default.join(dir, 'index'),
      extensions,
      env,
      pkg: pkg || null
    });
  }

  async readPackage(dir) {
    let file = _path.default.join(dir, 'package.json');

    let cached = this.packageCache.get(file);

    if (cached) {
      return cached;
    }

    let json = await this.options.inputFS.readFile(file, 'utf8');
    let pkg = JSON.parse(json);
    pkg.pkgfile = file;
    pkg.pkgdir = dir; // If the package has a `source` field, check if it is behind a symlink.
    // If so, we treat the module as source code rather than a pre-compiled module.

    if (pkg.source) {
      let realpath = await this.options.inputFS.realpath(file);

      if (realpath === file) {
        delete pkg.source;
      }
    }

    this.packageCache.set(file, pkg);
    return pkg;
  }

  getPackageEntries(pkg, env) {
    let browser;

    if (env.isBrowser() && pkg.browser != null) {
      if (typeof pkg.browser === 'string') {
        browser = pkg.browser;
      } else if (typeof pkg.browser === 'object' && pkg.browser[pkg.name]) {
        browser = pkg.browser[pkg.name];
      }
    }

    let mainFields = [pkg.source, browser]; // If scope hoisting is enabled, we can get smaller builds using esmodule input, so choose `module` over `main`.
    // Otherwise, we'd be wasting time transforming esmodules to commonjs, so choose `main` over `module`.

    if (this.options.scopeHoist) {
      mainFields.push(pkg.module, pkg.main);
    } else {
      mainFields.push(pkg.main, pkg.module);
    } // libraries like d3.js specifies node.js specific files in the "main" which breaks the build
    // we use the "browser" or "module" field to get the full dependency tree if available.
    // If this is a linked module with a `source` field, use that as the entry point.


    return mainFields.filter(entry => typeof entry === 'string').map(main => {
      // Default to index file if no main field find
      if (!main || main === '.' || main === './') {
        main = 'index';
      }

      if (typeof main !== 'string') {
        throw new Error('invariant: expected string');
      }

      return _path.default.resolve(pkg.pkgdir, main);
    });
  }

  async loadAsFile({
    file,
    extensions,
    env,
    pkg
  }) {
    // Try all supported extensions
    for (let f of await this.expandFile(file, extensions, env, pkg)) {
      if (await this.isFile(f)) {
        return {
          path: f,
          pkg
        };
      }
    }
  }

  async expandFile(file, extensions, env, pkg, expandAliases = true) {
    // Expand extensions and aliases
    let res = [];

    for (let ext of extensions) {
      let f = file + ext;

      if (expandAliases) {
        let alias = await this.resolveAliases(file + ext, env, pkg);

        if (alias !== f) {
          res = res.concat((await this.expandFile(alias, extensions, env, pkg, false)));
        }
      }

      res.push(f);
    }

    return res;
  }

  async resolveAliases(filename, env, pkg) {
    // First resolve local package aliases, then project global ones.
    return this.resolvePackageAliases((await this.resolvePackageAliases(filename, env, pkg)), env, this.rootPackage);
  }

  async resolvePackageAliases(filename, env, pkg) {
    if (!pkg) {
      return filename;
    } // Resolve aliases in the package.source, package.alias, and package.browser fields.


    return (await this.getAlias(filename, pkg.pkgdir, pkg.source)) || (await this.getAlias(filename, pkg.pkgdir, pkg.alias)) || env.isBrowser() && (await this.getAlias(filename, pkg.pkgdir, pkg.browser)) || filename;
  }

  async getAlias(filename, dir, aliases) {
    if (!filename || !aliases || typeof aliases !== 'object') {
      return null;
    }

    let alias; // If filename is an absolute path, get one relative to the package.json directory.

    if (_path.default.isAbsolute(filename)) {
      filename = _path.default.relative(dir, filename);

      if (filename[0] !== '.') {
        filename = './' + filename;
      }

      alias = await this.lookupAlias(aliases, filename, dir);
    } else {
      // It is a node_module. First try the entire filename as a key.
      alias = await this.lookupAlias(aliases, filename, dir);

      if (alias == null) {
        // If it didn't match, try only the module name.
        let parts = this.getModuleParts(filename);
        alias = await this.lookupAlias(aliases, parts[0], dir);

        if (typeof alias === 'string') {
          // Append the filename back onto the aliased module.
          alias = _path.default.join(alias, ...parts.slice(1));
        }
      }
    } // If the alias is set to `false`, return an empty file.


    if (alias === false) {
      return EMPTY_SHIM;
    }

    return alias;
  }

  lookupAlias(aliases, filename, dir) {
    // First, try looking up the exact filename
    let alias = aliases[filename];

    if (alias == null) {
      // Otherwise, try replacing glob keys
      for (let key in aliases) {
        let val = aliases[key];

        if (typeof val === 'string' && (0, _utils.isGlob)(key)) {
          let re = _micromatch.default.makeRe(key, {
            capture: true
          });

          if (re.test(filename)) {
            alias = filename.replace(re, val);
            break;
          }
        }
      }
    }

    if (typeof alias === 'string') {
      return this.resolveFilename(alias, dir);
    } else if (alias === false) {
      return false;
    }

    return null;
  }

  async findPackage(dir) {
    // Find the nearest package.json file within the current node_modules folder
    let root = _path.default.parse(dir).root;

    while (dir !== root && _path.default.basename(dir) !== 'node_modules') {
      try {
        return await this.readPackage(dir);
      } catch (err) {// ignore
      }

      dir = _path.default.dirname(dir);
    }

    return null;
  }

  async loadAlias(filename, dir, env) {
    // Load the root project's package.json file if we haven't already
    if (!this.rootPackage) {
      this.rootPackage = await this.findPackage(this.options.rootDir);
    } // Load the local package, and resolve aliases


    let pkg = await this.findPackage(dir);
    return this.resolveAliases(filename, env, pkg);
  }

  getModuleParts(name) {
    let parts = _path.default.normalize(name).split(_path.default.sep);

    if (parts[0].charAt(0) === '@') {
      // Scoped module (e.g. @scope/module). Merge the first two parts back together.
      parts.splice(0, 2, `${parts[0]}/${parts[1]}`);
    }

    return parts;
  }

}