"use strict";

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

function ConfigUtils() {
  const data = _interopRequireWildcard(require("@expo/config"));

  ConfigUtils = function () {
    return data;
  };

  return data;
}

function _fs() {
  const data = _interopRequireDefault(require("fs"));

  _fs = function () {
    return data;
  };

  return data;
}

function _inflection() {
  const data = require("inflection");

  _inflection = function () {
    return data;
  };

  return data;
}

function _jsonFile() {
  const data = _interopRequireDefault(require("@expo/json-file"));

  _jsonFile = function () {
    return data;
  };

  return data;
}

function _npmPackageArg() {
  const data = _interopRequireDefault(require("npm-package-arg"));

  _npmPackageArg = function () {
    return data;
  };

  return data;
}

function _path() {
  const data = _interopRequireDefault(require("path"));

  _path = function () {
    return data;
  };

  return data;
}

function _xdl() {
  const data = require("@expo/xdl");

  _xdl = function () {
    return data;
  };

  return data;
}

function _CommandError() {
  const data = _interopRequireDefault(require("../CommandError"));

  _CommandError = function () {
    return data;
  };

  return data;
}

function PackageManager() {
  const data = _interopRequireWildcard(require("../PackageManager"));

  PackageManager = function () {
    return data;
  };

  return data;
}

function _ProjectUtils() {
  const data = require("./utils/ProjectUtils");

  _ProjectUtils = function () {
    return data;
  };

  return data;
}

function _log() {
  const data = _interopRequireDefault(require("../log"));

  _log = function () {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

async function installAsync(packages, options) {
  const {
    projectRoot,
    workflow
  } = await (0, _ProjectUtils().findProjectRootAsync)(process.cwd());
  const packageManager = PackageManager().createForProject(projectRoot, {
    npm: options.npm,
    yarn: options.yarn
  });

  if (workflow === 'bare') {
    return await packageManager.addAsync(...packages);
  }

  const {
    exp
  } = await ConfigUtils().readConfigJsonAsync(projectRoot);

  if (!_xdl().Versions.gteSdkVersion(exp, '33.0.0')) {
    throw new (_CommandError().default)('UNSUPPORTED_SDK_VERSION', `expo install is only available for managed apps using Expo SDK version 33 or higher. Current version: ${exp.sdkVersion}.`);
  }

  if (!_fs().default.existsSync(_path().default.join(exp.nodeModulesPath || projectRoot, 'node_modules'))) {
    _log().default.warn(`node_modules not found, running ${packageManager.name} install command.`);

    await packageManager.installAsync();
  }

  const bundledNativeModules = await _jsonFile().default.readAsync(ConfigUtils().resolveModule('expo/bundledNativeModules.json', projectRoot, exp));
  const nativeModules = [];
  const others = [];
  const versionedPackages = packages.map(arg => {
    const spec = (0, _npmPackageArg().default)(arg);
    const {
      name
    } = spec;

    if (['tag', 'version', 'range'].includes(spec.type) && name && bundledNativeModules[name]) {
      // Unimodule packages from npm registry are modified to use the bundled version.
      const version = bundledNativeModules[name];
      const modifiedSpec = `${name}@${version}`;
      nativeModules.push(modifiedSpec);
      return modifiedSpec;
    } else {
      // Other packages are passed through unmodified.
      others.push(spec.raw);
      return spec.raw;
    }
  });
  const messages = [];

  if (nativeModules.length > 0) {
    messages.push(`${nativeModules.length} SDK ${exp.sdkVersion} compatible native ${(0, _inflection().inflect)('modules', nativeModules.length)}`);
  }

  if (others.length > 0) {
    messages.push(`${others.length} other ${(0, _inflection().inflect)('packages', others.length)}`);
  }

  (0, _log().default)(`Installing ${messages.join(' and ')} using ${packageManager.name}.`);
  await packageManager.addAsync(...versionedPackages);
}

var _default = program => {
  program.command('install [packages...]').alias('add').option('--npm', 'Use npm to install dependencies. (default when package-lock.json exists)').option('--yarn', 'Use Yarn to install dependencies. (default when yarn.lock exists)').description('Installs a unimodule or other package to a project.').asyncAction(installAsync);
};

exports.default = _default;
//# sourceMappingURL=../__sourcemaps__/commands/install.js.map