"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.readAsync = readAsync;
exports.setAsync = setAsync;
exports.readPackagerInfoAsync = readPackagerInfoAsync;
exports.setPackagerInfoAsync = setPackagerInfoAsync;
exports.dotExpoProjectDirectory = dotExpoProjectDirectory;
exports.dotExpoProjectDirectoryExists = dotExpoProjectDirectoryExists;
exports.getPackagerOptsAsync = getPackagerOptsAsync;

function _defaults() {
  const data = _interopRequireDefault(require("lodash/defaults"));

  _defaults = function () {
    return data;
  };

  return data;
}

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

  _jsonFile = function () {
    return data;
  };

  return data;
}

function _fsExtra() {
  const data = _interopRequireDefault(require("fs-extra"));

  _fsExtra = function () {
    return data;
  };

  return data;
}

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

  _path = function () {
    return data;
  };

  return data;
}

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

const projectSettingsFile = 'settings.json';
const projectSettingsDefaults = {
  hostType: 'lan',
  lanType: 'ip',
  dev: true,
  minify: false,
  urlRandomness: null,
  https: false
};
const packagerInfoFile = 'packager-info.json';

function projectSettingsJsonFile(projectRoot) {
  return new (_jsonFile().default)(_path().default.join(dotExpoProjectDirectory(projectRoot), projectSettingsFile));
}

function packagerInfoJsonFile(projectRoot) {
  return new (_jsonFile().default)(_path().default.join(dotExpoProjectDirectory(projectRoot), packagerInfoFile));
}

async function readAsync(projectRoot) {
  let projectSettings;

  try {
    projectSettings = await projectSettingsJsonFile(projectRoot).readAsync();
  } catch (e) {
    projectSettings = await projectSettingsJsonFile(projectRoot).writeAsync(projectSettingsDefaults);
  }

  migrateDeprecatedSettings(projectSettings); // Set defaults for any missing fields

  (0, _defaults().default)(projectSettings, projectSettingsDefaults);
  return projectSettings;
}

function migrateDeprecatedSettings(projectSettings) {
  if (projectSettings.hostType === 'ngrok') {
    // 'ngrok' is deprecated
    projectSettings.hostType = 'tunnel';
  }

  if (projectSettings.urlType) {
    // urlType is deprecated as a project setting
    delete projectSettings.urlType;
  }

  if ('strict' in projectSettings) {
    // strict mode is not supported at the moment
    delete projectSettings.strict;
  }
}

async function setAsync(projectRoot, json) {
  try {
    return await projectSettingsJsonFile(projectRoot).mergeAsync(json, {
      cantReadFileDefault: projectSettingsDefaults
    });
  } catch (e) {
    return await projectSettingsJsonFile(projectRoot).writeAsync((0, _defaults().default)(json, projectSettingsDefaults));
  }
}

async function readPackagerInfoAsync(projectRoot) {
  try {
    return await packagerInfoJsonFile(projectRoot).readAsync({
      cantReadFileDefault: {}
    });
  } catch (e) {
    return await packagerInfoJsonFile(projectRoot).writeAsync({});
  }
}

async function setPackagerInfoAsync(projectRoot, json) {
  try {
    return await packagerInfoJsonFile(projectRoot).mergeAsync(json, {
      cantReadFileDefault: {}
    });
  } catch (e) {
    return await packagerInfoJsonFile(projectRoot).writeAsync(json);
  }
}

function dotExpoProjectDirectory(projectRoot) {
  let dirPath = _path().default.join(projectRoot, '.expo');

  try {
    // move .exponent to .expo
    let oldDirPath = _path().default.join(projectRoot, '.exponent');

    if (_fsExtra().default.statSync(oldDirPath).isDirectory()) {
      _fsExtra().default.renameSync(oldDirPath, dirPath);
    }
  } catch (e) {// no old directory, continue
  }

  _fsExtra().default.mkdirpSync(dirPath);

  return dirPath;
}

function dotExpoProjectDirectoryExists(projectRoot) {
  let dirPath = _path().default.join(projectRoot, '.expo');

  try {
    if (_fsExtra().default.statSync(dirPath).isDirectory()) {
      return true;
    }
  } catch (e) {// file doesn't exist
  }

  return false;
}

async function getPackagerOptsAsync(projectRoot) {
  let projectSettings = await readAsync(projectRoot);
  return projectSettings;
}
//# sourceMappingURL=__sourcemaps__/ProjectSettings.js.map