@expo/xdl/build/start/startAsync.js

The Expo Development Library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.startAsync = startAsync;
exports.stopAsync = stopAsync;

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

  _config = function () {
    return data;
  };

  return data;
}

function _Analytics() {
  const data = _interopRequireDefault(require("../Analytics"));

  _Analytics = function () {
    return data;
  };

  return data;
}

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

  Android = function () {
    return data;
  };

  return data;
}

function _Config() {
  const data = _interopRequireDefault(require("../Config"));

  _Config = function () {
    return data;
  };

  return data;
}

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

  DevSession = function () {
    return data;
  };

  return data;
}

function _Env() {
  const data = require("../Env");

  _Env = function () {
    return data;
  };

  return data;
}

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

  ProjectSettings = function () {
    return data;
  };

  return data;
}

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

  Webpack = function () {
    return data;
  };

  return data;
}

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

  ProjectUtils = function () {
    return data;
  };

  return data;
}

function _errors() {
  const data = require("../project/errors");

  _errors = function () {
    return data;
  };

  return data;
}

function _ngrok() {
  const data = require("./ngrok");

  _ngrok = function () {
    return data;
  };

  return data;
}

function _startDevServerAsync() {
  const data = require("./startDevServerAsync");

  _startDevServerAsync = function () {
    return data;
  };

  return data;
}

function _startLegacyExpoServerAsync() {
  const data = require("./startLegacyExpoServerAsync");

  _startLegacyExpoServerAsync = function () {
    return data;
  };

  return data;
}

function _startLegacyReactNativeServerAsync() {
  const data = require("./startLegacyReactNativeServerAsync");

  _startLegacyReactNativeServerAsync = function () {
    return data;
  };

  return data;
}

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

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

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

let serverInstance = null;

async function startAsync(projectRoot, {
  exp = (0, _config().getConfig)(projectRoot).exp,
  ...options
} = {}, verbose = true) {
  var _exp$sdkVersion;

  (0, _errors().assertValidProjectRoot)(projectRoot);

  _Analytics().default.logEvent('Start Project', {
    projectRoot,
    developerTool: _Config().default.developerTool,
    sdkVersion: (_exp$sdkVersion = exp.sdkVersion) !== null && _exp$sdkVersion !== void 0 ? _exp$sdkVersion : null
  });

  if (options.webOnly) {
    await Webpack().restartAsync(projectRoot, options);
    DevSession().startSession(projectRoot, exp, 'web');
    return exp;
  } else if ((0, _Env().shouldUseDevServer)(exp) || options.devClient) {
    serverInstance = await (0, _startDevServerAsync().startDevServerAsync)(projectRoot, options);
    DevSession().startSession(projectRoot, exp, 'native');
  } else {
    await (0, _startLegacyExpoServerAsync().startExpoServerAsync)(projectRoot);
    await (0, _startLegacyReactNativeServerAsync().startReactNativeServerAsync)({
      projectRoot,
      exp,
      options,
      verbose
    });
    DevSession().startSession(projectRoot, exp, 'native');
  }

  const {
    hostType
  } = await ProjectSettings().readAsync(projectRoot);

  if (!_Config().default.offline && hostType === 'tunnel') {
    try {
      await (0, _ngrok().startTunnelsAsync)(projectRoot);
    } catch (e) {
      ProjectUtils().logDebug(projectRoot, 'expo', `Error starting tunnel ${e.message}`);
    }
  }

  return exp;
}

async function stopInternalAsync(projectRoot) {
  DevSession().stopSession();
  await Promise.all([Webpack().stopAsync(projectRoot), new Promise((resolve, reject) => {
    if (serverInstance) {
      serverInstance.close(error => {
        if (error) {
          reject(error);
        } else {
          resolve();
        }
      });
    }
  }), (0, _startLegacyExpoServerAsync().stopExpoServerAsync)(projectRoot), (0, _startLegacyReactNativeServerAsync().stopReactNativeServerAsync)(projectRoot), async () => {
    if (!_Config().default.offline) {
      try {
        await (0, _ngrok().stopTunnelsAsync)(projectRoot);
      } catch (e) {
        ProjectUtils().logDebug(projectRoot, 'expo', `Error stopping ngrok ${e.message}`);
      }
    }
  }, await Android().maybeStopAdbDaemonAsync()]);
}

async function forceQuitAsync(projectRoot) {
  // find RN packager and ngrok pids, attempt to kill them manually
  const {
    packagerPid,
    ngrokPid
  } = await ProjectSettings().readPackagerInfoAsync(projectRoot);

  if (packagerPid) {
    try {
      process.kill(packagerPid);
    } catch (e) {}
  }

  if (ngrokPid) {
    try {
      process.kill(ngrokPid);
    } catch (e) {}
  }

  await ProjectSettings().setPackagerInfoAsync(projectRoot, {
    expoServerPort: null,
    packagerPort: null,
    packagerPid: null,
    expoServerNgrokUrl: null,
    packagerNgrokUrl: null,
    ngrokPid: null,
    webpackServerPort: null
  });
}

async function stopAsync(projectRoot) {
  try {
    const result = await Promise.race([stopInternalAsync(projectRoot), new Promise(resolve => setTimeout(resolve, 2000, 'stopFailed'))]);

    if (result === 'stopFailed') {
      await forceQuitAsync(projectRoot);
    }
  } catch (error) {
    await forceQuitAsync(projectRoot);
    throw error;
  }
}
//# sourceMappingURL=../__sourcemaps__/start/startAsync.js.map