@expo/cli 0.1.0 → 0.1.3

package/build/src/run/android/resolveDevice.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveDeviceAsync = resolveDeviceAsync;
+var _androidDeviceManager = require("../../start/platforms/android/AndroidDeviceManager");
+var _hints = require("../hints");
+const debug = require("debug")("expo:android:resolveDevice");
+async function resolveDeviceAsync(device) {
+    if (!device) {
+        const manager = await _androidDeviceManager.AndroidDeviceManager.resolveAsync();
+        debug(`Resolved default device (name: ${manager.device.name}, pid: ${manager.device.pid})`);
+        return manager;
+    }
+    debug(`Resolving device from argument: ${device}`);
+    const manager = device === true ? await _androidDeviceManager.AndroidDeviceManager.resolveAsync({
+        shouldPrompt: true
+    }) : await _androidDeviceManager.AndroidDeviceManager.resolveFromNameAsync(device);
+    (0, _hints).logDeviceArgument(manager.device.name);
+    return manager;
+}
+
+//# sourceMappingURL=resolveDevice.js.map

package/build/src/run/android/resolveDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveDevice.ts"],"sourcesContent":["import { AndroidDeviceManager } from '../../start/platforms/android/AndroidDeviceManager';\nimport { logDeviceArgument } from '../hints';\n\nconst debug = require('debug')('expo:android:resolveDevice');\n\n/** Given a `device` argument from the CLI, parse and prompt our way to a usable device for building. */\nexport async function resolveDeviceAsync(device?: string | boolean) {\n  if (!device) {\n    const manager = await AndroidDeviceManager.resolveAsync();\n    debug(`Resolved default device (name: ${manager.device.name}, pid: ${manager.device.pid})`);\n    return manager;\n  }\n\n  debug(`Resolving device from argument: ${device}`);\n  const manager =\n    device === true\n      ? // `--device` (no props after)\n        await AndroidDeviceManager.resolveAsync({ shouldPrompt: true })\n      : // `--device <name>`\n        await AndroidDeviceManager.resolveFromNameAsync(device);\n  logDeviceArgument(manager.device.name);\n  return manager;\n}\n"],"names":["resolveDeviceAsync","debug","require","device","manager","AndroidDeviceManager","resolveAsync","name","pid","shouldPrompt","resolveFromNameAsync","logDeviceArgument"],"mappings":"AAAA;;;;QAMsBA,kBAAkB,GAAlBA,kBAAkB;AANH,IAAA,qBAAoD,WAApD,oDAAoD,CAAA;AACvD,IAAA,MAAU,WAAV,UAAU,CAAA;AAE5C,MAAMC,KAAK,GAAGC,OAAO,CAAC,OAAO,CAAC,CAAC,4BAA4B,CAAC,AAAC;AAGtD,eAAeF,kBAAkB,CAACG,MAAyB,EAAE;IAClE,IAAI,CAACA,MAAM,EAAE;QACX,MAAMC,OAAO,GAAG,MAAMC,qBAAoB,qBAAA,CAACC,YAAY,EAAE,AAAC;QAC1DL,KAAK,CAAC,CAAC,+BAA+B,EAAEG,OAAO,CAACD,MAAM,CAACI,IAAI,CAAC,OAAO,EAAEH,OAAO,CAACD,MAAM,CAACK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5F,OAAOJ,OAAO,CAAC;KAChB;IAEDH,KAAK,CAAC,CAAC,gCAAgC,EAAEE,MAAM,CAAC,CAAC,CAAC,CAAC;IACnD,MAAMC,OAAO,GACXD,MAAM,KAAK,IAAI,GAEX,MAAME,qBAAoB,qBAAA,CAACC,YAAY,CAAC;QAAEG,YAAY,EAAE,IAAI;KAAE,CAAC,GAE/D,MAAMJ,qBAAoB,qBAAA,CAACK,oBAAoB,CAACP,MAAM,CAAC,AAAC;IAC9DQ,CAAAA,GAAAA,MAAiB,AAAqB,CAAA,kBAArB,CAACP,OAAO,CAACD,MAAM,CAACI,IAAI,CAAC,CAAC;IACvC,OAAOH,OAAO,CAAC;CAChB"}

package/build/src/run/android/resolveGradleProps.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveGradleProps = resolveGradleProps;
+var _path = _interopRequireDefault(require("path"));
+var _errors = require("../../utils/errors");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function assertVariant(variant) {
+    if (variant && typeof variant !== "string") {
+        throw new _errors.CommandError("BAD_ARGS", "--variant must be a string");
+    }
+    return variant != null ? variant : "debug";
+}
+function resolveGradleProps(projectRoot, options) {
+    const variant = assertVariant(options.variant);
+    // NOTE(EvanBacon): Why would this be different? Can we get the different name?
+    const appName = "app";
+    const apkDirectory = _path.default.join(projectRoot, "android", appName, "build", "outputs", "apk");
+    // buildDeveloperTrust -> build, developer, trust (where developer, and trust are flavors).
+    // This won't work for non-standard flavor names like "myFlavor" would be treated as "my", "flavor".
+    const [buildType, ...flavors] = variant.split(/(?=[A-Z])/).map((v)=>v.toLowerCase()
+    );
+    const apkVariantDirectory = _path.default.join(apkDirectory, ...flavors, buildType);
+    return {
+        appName,
+        buildType,
+        flavors,
+        apkVariantDirectory
+    };
+}
+
+//# sourceMappingURL=resolveGradleProps.js.map

package/build/src/run/android/resolveGradleProps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveGradleProps.ts"],"sourcesContent":["import path from 'path';\n\nimport { CommandError } from '../../utils/errors';\n\nexport type GradleProps = {\n  /** Directory for the APK based on the `variant`. */\n  apkVariantDirectory: string;\n  /** Name of the app, used in the `apkVariantDirectory`. */\n  appName: string;\n  /** First section of the provided `variant`, indicates the last part of the file name for the output APK. */\n  buildType: string;\n  /** Used to assemble the APK, also included in the output APK filename. */\n  flavors?: string[];\n};\n\nfunction assertVariant(variant?: string) {\n  if (variant && typeof variant !== 'string') {\n    throw new CommandError('BAD_ARGS', '--variant must be a string');\n  }\n  return variant ?? 'debug';\n}\n\nexport function resolveGradleProps(\n  projectRoot: string,\n  options: { variant?: string }\n): GradleProps {\n  const variant = assertVariant(options.variant);\n  // NOTE(EvanBacon): Why would this be different? Can we get the different name?\n  const appName = 'app';\n\n  const apkDirectory = path.join(projectRoot, 'android', appName, 'build', 'outputs', 'apk');\n\n  // buildDeveloperTrust -> build, developer, trust (where developer, and trust are flavors).\n  // This won't work for non-standard flavor names like \"myFlavor\" would be treated as \"my\", \"flavor\".\n  const [buildType, ...flavors] = variant.split(/(?=[A-Z])/).map((v) => v.toLowerCase());\n  const apkVariantDirectory = path.join(apkDirectory, ...flavors, buildType);\n\n  return {\n    appName,\n    buildType,\n    flavors,\n    apkVariantDirectory,\n  };\n}\n"],"names":["resolveGradleProps","assertVariant","variant","CommandError","projectRoot","options","appName","apkDirectory","path","join","buildType","flavors","split","map","v","toLowerCase","apkVariantDirectory"],"mappings":"AAAA;;;;QAsBgBA,kBAAkB,GAAlBA,kBAAkB;AAtBjB,IAAA,KAAM,kCAAN,MAAM,EAAA;AAEM,IAAA,OAAoB,WAApB,oBAAoB,CAAA;;;;;;AAajD,SAASC,aAAa,CAACC,OAAgB,EAAE;IACvC,IAAIA,OAAO,IAAI,OAAOA,OAAO,KAAK,QAAQ,EAAE;QAC1C,MAAM,IAAIC,OAAY,aAAA,CAAC,UAAU,EAAE,4BAA4B,CAAC,CAAC;KAClE;IACD,OAAOD,OAAO,WAAPA,OAAO,GAAI,OAAO,CAAC;CAC3B;AAEM,SAASF,kBAAkB,CAChCI,WAAmB,EACnBC,OAA6B,EAChB;IACb,MAAMH,OAAO,GAAGD,aAAa,CAACI,OAAO,CAACH,OAAO,CAAC,AAAC;IAC/C,+EAA+E;IAC/E,MAAMI,OAAO,GAAG,KAAK,AAAC;IAEtB,MAAMC,YAAY,GAAGC,KAAI,QAAA,CAACC,IAAI,CAACL,WAAW,EAAE,SAAS,EAAEE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,AAAC;IAE3F,2FAA2F;IAC3F,oGAAoG;IACpG,MAAM,CAACI,SAAS,EAAE,GAAGC,OAAO,CAAC,GAAGT,OAAO,CAACU,KAAK,aAAa,CAACC,GAAG,CAAC,CAACC,CAAC,GAAKA,CAAC,CAACC,WAAW,EAAE;IAAA,CAAC,AAAC;IACvF,MAAMC,mBAAmB,GAAGR,KAAI,QAAA,CAACC,IAAI,CAACF,YAAY,KAAKI,OAAO,EAAED,SAAS,CAAC,AAAC;IAE3E,OAAO;QACLJ,OAAO;QACPI,SAAS;QACTC,OAAO;QACPK,mBAAmB;KACpB,CAAC;CACH"}

package/build/src/run/android/resolveInstallApkName.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveInstallApkNameAsync = resolveInstallApkNameAsync;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var Log = _interopRequireWildcard(require("../../log"));
+var _adb = require("../../start/platforms/android/adb");
+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 resolveInstallApkNameAsync(device, { appName , buildType , flavors , apkVariantDirectory  }) {
+    const availableCPUs = await (0, _adb).getDeviceABIsAsync(device);
+    availableCPUs.push(_adb.DeviceABI.universal);
+    Log.debug("Supported ABIs: " + availableCPUs.join(", "));
+    Log.debug("Searching for APK: " + apkVariantDirectory);
+    // Check for cpu specific builds first
+    for (const availableCPU of availableCPUs){
+        const apkName = getApkFileName(appName, buildType, flavors, availableCPU);
+        const apkPath = _path.default.join(apkVariantDirectory, apkName);
+        Log.debug("Checking for APK at:", apkPath);
+        if (_fs.default.existsSync(apkPath)) {
+            return apkName;
+        }
+    }
+    // Otherwise use the default apk named after the variant: app-debug.apk
+    const apkName = getApkFileName(appName, buildType, flavors);
+    const apkPath = _path.default.join(apkVariantDirectory, apkName);
+    Log.debug("Checking for fallback APK at:", apkPath);
+    if (_fs.default.existsSync(apkPath)) {
+        return apkName;
+    }
+    return null;
+}
+function getApkFileName(appName, buildType, flavors, cpuArch) {
+    let apkName = `${appName}-`;
+    if (flavors) {
+        apkName += flavors.reduce((rest, flavor)=>`${rest}${flavor}-`
+        , "");
+    }
+    if (cpuArch) {
+        apkName += `${cpuArch}-`;
+    }
+    apkName += `${buildType}.apk`;
+    return apkName;
+}
+
+//# sourceMappingURL=resolveInstallApkName.js.map

package/build/src/run/android/resolveInstallApkName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveInstallApkName.ts"],"sourcesContent":["import fs from 'fs';\nimport path from 'path';\n\nimport * as Log from '../../log';\nimport { Device, DeviceABI, getDeviceABIsAsync } from '../../start/platforms/android/adb';\nimport { GradleProps } from './resolveGradleProps';\n\nexport async function resolveInstallApkNameAsync(\n  device: Pick<Device, 'name' | 'pid'>,\n  { appName, buildType, flavors, apkVariantDirectory }: GradleProps\n) {\n  const availableCPUs = await getDeviceABIsAsync(device);\n  availableCPUs.push(DeviceABI.universal);\n\n  Log.debug('Supported ABIs: ' + availableCPUs.join(', '));\n  Log.debug('Searching for APK: ' + apkVariantDirectory);\n\n  // Check for cpu specific builds first\n  for (const availableCPU of availableCPUs) {\n    const apkName = getApkFileName(appName, buildType, flavors, availableCPU);\n    const apkPath = path.join(apkVariantDirectory, apkName);\n    Log.debug('Checking for APK at:', apkPath);\n    if (fs.existsSync(apkPath)) {\n      return apkName;\n    }\n  }\n\n  // Otherwise use the default apk named after the variant: app-debug.apk\n  const apkName = getApkFileName(appName, buildType, flavors);\n  const apkPath = path.join(apkVariantDirectory, apkName);\n  Log.debug('Checking for fallback APK at:', apkPath);\n  if (fs.existsSync(apkPath)) {\n    return apkName;\n  }\n\n  return null;\n}\n\nfunction getApkFileName(\n  appName: string,\n  buildType: string,\n  flavors?: string[] | null,\n  cpuArch?: string | null\n) {\n  let apkName = `${appName}-`;\n  if (flavors) {\n    apkName += flavors.reduce((rest, flavor) => `${rest}${flavor}-`, '');\n  }\n  if (cpuArch) {\n    apkName += `${cpuArch}-`;\n  }\n  apkName += `${buildType}.apk`;\n\n  return apkName;\n}\n"],"names":["resolveInstallApkNameAsync","Log","device","appName","buildType","flavors","apkVariantDirectory","availableCPUs","getDeviceABIsAsync","push","DeviceABI","universal","debug","join","availableCPU","apkName","getApkFileName","apkPath","path","fs","existsSync","cpuArch","reduce","rest","flavor"],"mappings":"AAAA;;;;QAOsBA,0BAA0B,GAA1BA,0BAA0B;AAPjC,IAAA,GAAI,kCAAJ,IAAI,EAAA;AACF,IAAA,KAAM,kCAAN,MAAM,EAAA;AAEXC,IAAAA,GAAG,mCAAM,WAAW,EAAjB;AACuC,IAAA,IAAmC,WAAnC,mCAAmC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,eAAeD,0BAA0B,CAC9CE,MAAoC,EACpC,EAAEC,OAAO,CAAA,EAAEC,SAAS,CAAA,EAAEC,OAAO,CAAA,EAAEC,mBAAmB,CAAA,EAAe,EACjE;IACA,MAAMC,aAAa,GAAG,MAAMC,CAAAA,GAAAA,IAAkB,AAAQ,CAAA,mBAAR,CAACN,MAAM,CAAC,AAAC;IACvDK,aAAa,CAACE,IAAI,CAACC,IAAS,UAAA,CAACC,SAAS,CAAC,CAAC;IAExCV,GAAG,CAACW,KAAK,CAAC,kBAAkB,GAAGL,aAAa,CAACM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACzDZ,GAAG,CAACW,KAAK,CAAC,qBAAqB,GAAGN,mBAAmB,CAAC,CAAC;IAEvD,sCAAsC;IACtC,KAAK,MAAMQ,YAAY,IAAIP,aAAa,CAAE;QACxC,MAAMQ,OAAO,GAAGC,cAAc,CAACb,OAAO,EAAEC,SAAS,EAAEC,OAAO,EAAES,YAAY,CAAC,AAAC;QAC1E,MAAMG,OAAO,GAAGC,KAAI,QAAA,CAACL,IAAI,CAACP,mBAAmB,EAAES,OAAO,CAAC,AAAC;QACxDd,GAAG,CAACW,KAAK,CAAC,sBAAsB,EAAEK,OAAO,CAAC,CAAC;QAC3C,IAAIE,GAAE,QAAA,CAACC,UAAU,CAACH,OAAO,CAAC,EAAE;YAC1B,OAAOF,OAAO,CAAC;SAChB;KACF;IAED,uEAAuE;IACvE,MAAMA,OAAO,GAAGC,cAAc,CAACb,OAAO,EAAEC,SAAS,EAAEC,OAAO,CAAC,AAAC;IAC5D,MAAMY,OAAO,GAAGC,KAAI,QAAA,CAACL,IAAI,CAACP,mBAAmB,EAAES,OAAO,CAAC,AAAC;IACxDd,GAAG,CAACW,KAAK,CAAC,+BAA+B,EAAEK,OAAO,CAAC,CAAC;IACpD,IAAIE,GAAE,QAAA,CAACC,UAAU,CAACH,OAAO,CAAC,EAAE;QAC1B,OAAOF,OAAO,CAAC;KAChB;IAED,OAAO,IAAI,CAAC;CACb;AAED,SAASC,cAAc,CACrBb,OAAe,EACfC,SAAiB,EACjBC,OAAyB,EACzBgB,OAAuB,EACvB;IACA,IAAIN,OAAO,GAAG,CAAC,EAAEZ,OAAO,CAAC,CAAC,CAAC,AAAC;IAC5B,IAAIE,OAAO,EAAE;QACXU,OAAO,IAAIV,OAAO,CAACiB,MAAM,CAAC,CAACC,IAAI,EAAEC,MAAM,GAAK,CAAC,EAAED,IAAI,CAAC,EAAEC,MAAM,CAAC,CAAC,CAAC;QAAA,EAAE,EAAE,CAAC,CAAC;KACtE;IACD,IAAIH,OAAO,EAAE;QACXN,OAAO,IAAI,CAAC,EAAEM,OAAO,CAAC,CAAC,CAAC,CAAC;KAC1B;IACDN,OAAO,IAAI,CAAC,EAAEX,SAAS,CAAC,IAAI,CAAC,CAAC;IAE9B,OAAOW,OAAO,CAAC;CAChB"}

package/build/src/run/android/resolveLaunchProps.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveLaunchPropsAsync = resolveLaunchPropsAsync;
+var _configPlugins = require("@expo/config-plugins");
+var _androidAppIdResolver = require("../../start/platforms/android/AndroidAppIdResolver");
+var _errors = require("../../utils/errors");
+async function getMainActivityAsync(projectRoot) {
+    const filePath = await _configPlugins.AndroidConfig.Paths.getAndroidManifestAsync(projectRoot);
+    const androidManifest = await _configPlugins.AndroidConfig.Manifest.readAndroidManifestAsync(filePath);
+    // Assert MainActivity defined.
+    const activity = await _configPlugins.AndroidConfig.Manifest.getRunnableActivity(androidManifest);
+    if (!activity) {
+        throw new _errors.CommandError("ANDROID_MALFORMED", `${filePath} is missing a runnable activity element.`);
+    }
+    // Often this is ".MainActivity"
+    return activity.$["android:name"];
+}
+async function resolveLaunchPropsAsync(projectRoot) {
+    // Often this is ".MainActivity"
+    const mainActivity = await getMainActivityAsync(projectRoot);
+    const packageName = await new _androidAppIdResolver.AndroidAppIdResolver(projectRoot).getAppIdFromNativeAsync();
+    const launchActivity = `${packageName}/${mainActivity}`;
+    return {
+        mainActivity,
+        launchActivity,
+        packageName
+    };
+}
+
+//# sourceMappingURL=resolveLaunchProps.js.map

package/build/src/run/android/resolveLaunchProps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveLaunchProps.ts"],"sourcesContent":["import { AndroidConfig } from '@expo/config-plugins';\n\nimport { AndroidAppIdResolver } from '../../start/platforms/android/AndroidAppIdResolver';\nimport { CommandError } from '../../utils/errors';\n\nexport interface LaunchProps {\n  packageName: string;\n  mainActivity: string;\n  launchActivity: string;\n}\n\nasync function getMainActivityAsync(projectRoot: string): Promise<string> {\n  const filePath = await AndroidConfig.Paths.getAndroidManifestAsync(projectRoot);\n  const androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(filePath);\n\n  // Assert MainActivity defined.\n  const activity = await AndroidConfig.Manifest.getRunnableActivity(androidManifest);\n  if (!activity) {\n    throw new CommandError(\n      'ANDROID_MALFORMED',\n      `${filePath} is missing a runnable activity element.`\n    );\n  }\n  // Often this is \".MainActivity\"\n  return activity.$['android:name'];\n}\n\nexport async function resolveLaunchPropsAsync(projectRoot: string): Promise<LaunchProps> {\n  // Often this is \".MainActivity\"\n  const mainActivity = await getMainActivityAsync(projectRoot);\n\n  const packageName = await new AndroidAppIdResolver(projectRoot).getAppIdFromNativeAsync();\n  const launchActivity = `${packageName}/${mainActivity}`;\n\n  return {\n    mainActivity,\n    launchActivity,\n    packageName,\n  };\n}\n"],"names":["resolveLaunchPropsAsync","getMainActivityAsync","projectRoot","filePath","AndroidConfig","Paths","getAndroidManifestAsync","androidManifest","Manifest","readAndroidManifestAsync","activity","getRunnableActivity","CommandError","$","mainActivity","packageName","AndroidAppIdResolver","getAppIdFromNativeAsync","launchActivity"],"mappings":"AAAA;;;;QA2BsBA,uBAAuB,GAAvBA,uBAAuB;AA3Bf,IAAA,cAAsB,WAAtB,sBAAsB,CAAA;AAEf,IAAA,qBAAoD,WAApD,oDAAoD,CAAA;AAC5D,IAAA,OAAoB,WAApB,oBAAoB,CAAA;AAQjD,eAAeC,oBAAoB,CAACC,WAAmB,EAAmB;IACxE,MAAMC,QAAQ,GAAG,MAAMC,cAAa,cAAA,CAACC,KAAK,CAACC,uBAAuB,CAACJ,WAAW,CAAC,AAAC;IAChF,MAAMK,eAAe,GAAG,MAAMH,cAAa,cAAA,CAACI,QAAQ,CAACC,wBAAwB,CAACN,QAAQ,CAAC,AAAC;IAExF,+BAA+B;IAC/B,MAAMO,QAAQ,GAAG,MAAMN,cAAa,cAAA,CAACI,QAAQ,CAACG,mBAAmB,CAACJ,eAAe,CAAC,AAAC;IACnF,IAAI,CAACG,QAAQ,EAAE;QACb,MAAM,IAAIE,OAAY,aAAA,CACpB,mBAAmB,EACnB,CAAC,EAAET,QAAQ,CAAC,wCAAwC,CAAC,CACtD,CAAC;KACH;IACD,gCAAgC;IAChC,OAAOO,QAAQ,CAACG,CAAC,CAAC,cAAc,CAAC,CAAC;CACnC;AAEM,eAAeb,uBAAuB,CAACE,WAAmB,EAAwB;IACvF,gCAAgC;IAChC,MAAMY,YAAY,GAAG,MAAMb,oBAAoB,CAACC,WAAW,CAAC,AAAC;IAE7D,MAAMa,WAAW,GAAG,MAAM,IAAIC,qBAAoB,qBAAA,CAACd,WAAW,CAAC,CAACe,uBAAuB,EAAE,AAAC;IAC1F,MAAMC,cAAc,GAAG,CAAC,EAAEH,WAAW,CAAC,CAAC,EAAED,YAAY,CAAC,CAAC,AAAC;IAExD,OAAO;QACLA,YAAY;QACZI,cAAc;QACdH,WAAW;KACZ,CAAC;CACH"}

package/build/src/run/android/resolveOptions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveOptionsAsync = resolveOptionsAsync;
+var _resolveBundlerProps = require("../resolveBundlerProps");
+var _resolveDevice = require("./resolveDevice");
+var _resolveGradleProps = require("./resolveGradleProps");
+var _resolveLaunchProps = require("./resolveLaunchProps");
+async function resolveOptionsAsync(projectRoot, options) {
+    var _variant;
+    return {
+        ...await (0, _resolveBundlerProps).resolveBundlerPropsAsync(projectRoot, options),
+        ...(0, _resolveGradleProps).resolveGradleProps(projectRoot, options),
+        ...await (0, _resolveLaunchProps).resolveLaunchPropsAsync(projectRoot),
+        variant: (_variant = options.variant) != null ? _variant : "debug",
+        // Resolve the device based on the provided device id or prompt
+        // from a list of devices (connected or simulated) that are filtered by the scheme.
+        device: await (0, _resolveDevice).resolveDeviceAsync(options.device),
+        buildCache: !!options.buildCache,
+        install: !!options.install
+    };
+}
+
+//# sourceMappingURL=resolveOptions.js.map

package/build/src/run/android/resolveOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/resolveOptions.ts"],"sourcesContent":["import { AndroidDeviceManager } from '../../start/platforms/android/AndroidDeviceManager';\nimport { BundlerProps, resolveBundlerPropsAsync } from '../resolveBundlerProps';\nimport { resolveDeviceAsync } from './resolveDevice';\nimport { GradleProps, resolveGradleProps } from './resolveGradleProps';\nimport { LaunchProps, resolveLaunchPropsAsync } from './resolveLaunchProps';\n\nexport type Options = {\n  variant?: string;\n  device?: boolean | string;\n  port?: number;\n  bundler?: boolean;\n  install?: boolean;\n  buildCache?: boolean;\n};\n\nexport type ResolvedOptions = GradleProps &\n  BundlerProps &\n  LaunchProps & {\n    variant: string;\n    buildCache: boolean;\n    device: AndroidDeviceManager;\n    install: boolean;\n  };\n\nexport async function resolveOptionsAsync(\n  projectRoot: string,\n  options: Options\n): Promise<ResolvedOptions> {\n  return {\n    ...(await resolveBundlerPropsAsync(projectRoot, options)),\n    ...resolveGradleProps(projectRoot, options),\n    ...(await resolveLaunchPropsAsync(projectRoot)),\n    variant: options.variant ?? 'debug',\n    // Resolve the device based on the provided device id or prompt\n    // from a list of devices (connected or simulated) that are filtered by the scheme.\n    device: await resolveDeviceAsync(options.device),\n    buildCache: !!options.buildCache,\n    install: !!options.install,\n  };\n}\n"],"names":["resolveOptionsAsync","projectRoot","options","resolveBundlerPropsAsync","resolveGradleProps","resolveLaunchPropsAsync","variant","device","resolveDeviceAsync","buildCache","install"],"mappings":"AAAA;;;;QAwBsBA,mBAAmB,GAAnBA,mBAAmB;AAvBc,IAAA,oBAAwB,WAAxB,wBAAwB,CAAA;AAC5C,IAAA,cAAiB,WAAjB,iBAAiB,CAAA;AACJ,IAAA,mBAAsB,WAAtB,sBAAsB,CAAA;AACjB,IAAA,mBAAsB,WAAtB,sBAAsB,CAAA;AAoBpE,eAAeA,mBAAmB,CACvCC,WAAmB,EACnBC,OAAgB,EACU;QAKfA,QAAe;IAJ1B,OAAO;QACL,GAAI,MAAMC,CAAAA,GAAAA,oBAAwB,AAAsB,CAAA,yBAAtB,CAACF,WAAW,EAAEC,OAAO,CAAC;QACxD,GAAGE,CAAAA,GAAAA,mBAAkB,AAAsB,CAAA,mBAAtB,CAACH,WAAW,EAAEC,OAAO,CAAC;QAC3C,GAAI,MAAMG,CAAAA,GAAAA,mBAAuB,AAAa,CAAA,wBAAb,CAACJ,WAAW,CAAC;QAC9CK,OAAO,EAAEJ,CAAAA,QAAe,GAAfA,OAAO,CAACI,OAAO,YAAfJ,QAAe,GAAI,OAAO;QACnC,+DAA+D;QAC/D,mFAAmF;QACnFK,MAAM,EAAE,MAAMC,CAAAA,GAAAA,cAAkB,AAAgB,CAAA,mBAAhB,CAACN,OAAO,CAACK,MAAM,CAAC;QAChDE,UAAU,EAAE,CAAC,CAACP,OAAO,CAACO,UAAU;QAChCC,OAAO,EAAE,CAAC,CAACR,OAAO,CAACQ,OAAO;KAC3B,CAAC;CACH"}

package/build/src/run/android/runAndroidAsync.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.runAndroidAsync = runAndroidAsync;
+var _path = _interopRequireDefault(require("path"));
+var _log = require("../../log");
+var _gradle = require("../../start/platforms/android/gradle");
+var _scheme = require("../../utils/scheme");
+var _ensureNativeProject = require("../ensureNativeProject");
+var _hints = require("../hints");
+var _startBundler = require("../startBundler");
+var _resolveInstallApkName = require("./resolveInstallApkName");
+var _resolveOptions = require("./resolveOptions");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require("debug")("expo:run:android");
+async function runAndroidAsync(projectRoot, { install , ...options }) {
+    var ref;
+    await (0, _ensureNativeProject).ensureNativeProjectAsync(projectRoot, {
+        platform: "android",
+        install
+    });
+    const props = await (0, _resolveOptions).resolveOptionsAsync(projectRoot, options);
+    debug("Package name: " + props.packageName);
+    _log.Log.log("\u203A Building app...");
+    const androidProjectRoot = _path.default.join(projectRoot, "android");
+    await (0, _gradle).assembleAsync(androidProjectRoot, {
+        variant: props.variant,
+        port: props.port,
+        appName: props.appName,
+        buildCache: props.buildCache
+    });
+    const manager = await (0, _startBundler).startBundlerAsync(projectRoot, {
+        port: props.port,
+        headless: !props.shouldStartBundler
+    });
+    await installAppAsync(androidProjectRoot, props);
+    await manager.getDefaultDevServer().openCustomRuntimeAsync("emulator", {
+        applicationId: props.packageName,
+        // If a scheme is specified then use that instead of the package name.
+        scheme: (ref = await (0, _scheme).getSchemesForAndroidAsync(projectRoot)) == null ? void 0 : ref[0]
+    }, {
+        device: props.device.device
+    });
+    if (props.shouldStartBundler) {
+        (0, _hints).logProjectLogsLocation();
+    }
+}
+async function installAppAsync(androidProjectRoot, props) {
+    // Find the APK file path
+    const apkFile = await (0, _resolveInstallApkName).resolveInstallApkNameAsync(props.device.device, props);
+    if (apkFile) {
+        // Attempt to install the APK from the file path
+        const binaryPath = _path.default.join(props.apkVariantDirectory, apkFile);
+        debug("Installing:", binaryPath);
+        await props.device.installAppAsync(binaryPath);
+    } else {
+        // If we cannot resolve the APK file path then we can attempt to install using Gradle.
+        // This offers more advanced resolution that we may not have first class support for.
+        _log.Log.log("\u203A Failed to locate binary file, installing with Gradle...");
+        var _variant, _appName;
+        await (0, _gradle).installAsync(androidProjectRoot, {
+            variant: (_variant = props.variant) != null ? _variant : "debug",
+            appName: (_appName = props.appName) != null ? _appName : "app",
+            port: props.port
+        });
+    }
+}
+
+//# sourceMappingURL=runAndroidAsync.js.map

package/build/src/run/android/runAndroidAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/run/android/runAndroidAsync.ts"],"sourcesContent":["import path from 'path';\n\nimport { Log } from '../../log';\nimport { assembleAsync, installAsync } from '../../start/platforms/android/gradle';\nimport { getSchemesForAndroidAsync } from '../../utils/scheme';\nimport { ensureNativeProjectAsync } from '../ensureNativeProject';\nimport { logProjectLogsLocation } from '../hints';\nimport { startBundlerAsync } from '../startBundler';\nimport { resolveInstallApkNameAsync } from './resolveInstallApkName';\nimport { Options, ResolvedOptions, resolveOptionsAsync } from './resolveOptions';\n\nconst debug = require('debug')('expo:run:android');\n\nexport async function runAndroidAsync(projectRoot: string, { install, ...options }: Options) {\n  await ensureNativeProjectAsync(projectRoot, { platform: 'android', install });\n\n  const props = await resolveOptionsAsync(projectRoot, options);\n\n  debug('Package name: ' + props.packageName);\n  Log.log('› Building app...');\n\n  const androidProjectRoot = path.join(projectRoot, 'android');\n\n  await assembleAsync(androidProjectRoot, {\n    variant: props.variant,\n    port: props.port,\n    appName: props.appName,\n    buildCache: props.buildCache,\n  });\n\n  const manager = await startBundlerAsync(projectRoot, {\n    port: props.port,\n    headless: !props.shouldStartBundler,\n  });\n\n  await installAppAsync(androidProjectRoot, props);\n\n  await manager.getDefaultDevServer().openCustomRuntimeAsync(\n    'emulator',\n    {\n      applicationId: props.packageName,\n      // If a scheme is specified then use that instead of the package name.\n      scheme: (await getSchemesForAndroidAsync(projectRoot))?.[0],\n    },\n    { device: props.device.device }\n  );\n\n  if (props.shouldStartBundler) {\n    logProjectLogsLocation();\n  }\n}\n\nasync function installAppAsync(androidProjectRoot: string, props: ResolvedOptions) {\n  // Find the APK file path\n  const apkFile = await resolveInstallApkNameAsync(props.device.device, props);\n\n  if (apkFile) {\n    // Attempt to install the APK from the file path\n    const binaryPath = path.join(props.apkVariantDirectory, apkFile);\n    debug('Installing:', binaryPath);\n    await props.device.installAppAsync(binaryPath);\n  } else {\n    // If we cannot resolve the APK file path then we can attempt to install using Gradle.\n    // This offers more advanced resolution that we may not have first class support for.\n    Log.log('› Failed to locate binary file, installing with Gradle...');\n    await installAsync(androidProjectRoot, {\n      variant: props.variant ?? 'debug',\n      appName: props.appName ?? 'app',\n      port: props.port,\n    });\n  }\n}\n"],"names":["runAndroidAsync","debug","require","projectRoot","install","options","ensureNativeProjectAsync","platform","props","resolveOptionsAsync","packageName","Log","log","androidProjectRoot","path","join","assembleAsync","variant","port","appName","buildCache","manager","startBundlerAsync","headless","shouldStartBundler","installAppAsync","getDefaultDevServer","openCustomRuntimeAsync","applicationId","scheme","getSchemesForAndroidAsync","device","logProjectLogsLocation","apkFile","resolveInstallApkNameAsync","binaryPath","apkVariantDirectory","installAsync"],"mappings":"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"}

package/build/src/run/ensureNativeProject.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.ensureNativeProjectAsync = ensureNativeProjectAsync;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _clearNativeFolder = require("../prebuild/clearNativeFolder");
+var _prebuildAsync = require("../prebuild/prebuildAsync");
+var _profile = require("../utils/profile");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function ensureNativeProjectAsync(projectRoot, { platform , install  }) {
+    // If the user has an empty android folder then the project won't build, this can happen when they delete the prebuild files in git.
+    // Check to ensure most of the core files are in place, and prompt to remove the folder if they aren't.
+    await (0, _profile).profile(_clearNativeFolder.promptToClearMalformedNativeProjectsAsync)(projectRoot, [
+        platform
+    ]);
+    // If the project doesn't have native code, prebuild it...
+    if (!_fs.default.existsSync(_path.default.join(projectRoot, platform))) {
+        await (0, _prebuildAsync).prebuildAsync(projectRoot, {
+            install: !!install,
+            platforms: [
+                platform
+            ]
+        });
+    }
+}
+
+//# sourceMappingURL=ensureNativeProject.js.map

package/build/src/run/ensureNativeProject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/run/ensureNativeProject.ts"],"sourcesContent":["import { ModPlatform } from '@expo/config-plugins';\nimport fs from 'fs';\nimport path from 'path';\n\nimport { promptToClearMalformedNativeProjectsAsync } from '../prebuild/clearNativeFolder';\nimport { prebuildAsync } from '../prebuild/prebuildAsync';\nimport { profile } from '../utils/profile';\n\nexport async function ensureNativeProjectAsync(\n  projectRoot: string,\n  { platform, install }: { platform: ModPlatform; install?: boolean }\n) {\n  // If the user has an empty android folder then the project won't build, this can happen when they delete the prebuild files in git.\n  // Check to ensure most of the core files are in place, and prompt to remove the folder if they aren't.\n  await profile(promptToClearMalformedNativeProjectsAsync)(projectRoot, [platform]);\n\n  // If the project doesn't have native code, prebuild it...\n  if (!fs.existsSync(path.join(projectRoot, platform))) {\n    await prebuildAsync(projectRoot, {\n      install: !!install,\n      platforms: [platform],\n    });\n  }\n}\n"],"names":["ensureNativeProjectAsync","projectRoot","platform","install","profile","promptToClearMalformedNativeProjectsAsync","fs","existsSync","path","join","prebuildAsync","platforms"],"mappings":"AAAA;;;;QAQsBA,wBAAwB,GAAxBA,wBAAwB;AAP/B,IAAA,GAAI,kCAAJ,IAAI,EAAA;AACF,IAAA,KAAM,kCAAN,MAAM,EAAA;AAEmC,IAAA,kBAA+B,WAA/B,+BAA+B,CAAA;AAC3D,IAAA,cAA2B,WAA3B,2BAA2B,CAAA;AACjC,IAAA,QAAkB,WAAlB,kBAAkB,CAAA;;;;;;AAEnC,eAAeA,wBAAwB,CAC5CC,WAAmB,EACnB,EAAEC,QAAQ,CAAA,EAAEC,OAAO,CAAA,EAAgD,EACnE;IACA,oIAAoI;IACpI,uGAAuG;IACvG,MAAMC,CAAAA,GAAAA,QAAO,AAA2C,CAAA,QAA3C,CAACC,kBAAyC,0CAAA,CAAC,CAACJ,WAAW,EAAE;QAACC,QAAQ;KAAC,CAAC,CAAC;IAElF,0DAA0D;IAC1D,IAAI,CAACI,GAAE,QAAA,CAACC,UAAU,CAACC,KAAI,QAAA,CAACC,IAAI,CAACR,WAAW,EAAEC,QAAQ,CAAC,CAAC,EAAE;QACpD,MAAMQ,CAAAA,GAAAA,cAAa,AAGjB,CAAA,cAHiB,CAACT,WAAW,EAAE;YAC/BE,OAAO,EAAE,CAAC,CAACA,OAAO;YAClBQ,SAAS,EAAE;gBAACT,QAAQ;aAAC;SACtB,CAAC,CAAC;KACJ;CACF"}

package/build/src/run/hints.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.logDeviceArgument = logDeviceArgument;
+exports.logProjectLogsLocation = logProjectLogsLocation;
+var _chalk = _interopRequireDefault(require("chalk"));
+var _log = require("../log");
+var _env = require("../utils/env");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function logDeviceArgument(id) {
+    _log.Log.log(_chalk.default.dim`› Using --device ${id}`);
+}
+function logProjectLogsLocation() {
+    _log.Log.log(_chalk.default`› Logs for your project will appear below.${_env.env.CI ? "" : _chalk.default.dim(` Press Ctrl+C to exit.`)}`);
+}
+
+//# sourceMappingURL=hints.js.map

package/build/src/run/hints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/run/hints.ts"],"sourcesContent":["import chalk from 'chalk';\n\nimport { Log } from '../log';\nimport { env } from '../utils/env';\n\n/** Log the device argument to use for the next run: `Using --device foobar` */\nexport function logDeviceArgument(id: string) {\n  Log.log(chalk.dim`› Using --device ${id}`);\n}\n\nexport function logProjectLogsLocation() {\n  Log.log(\n    chalk`› Logs for your project will appear below.${\n      env.CI ? '' : chalk.dim(` Press Ctrl+C to exit.`)\n    }`\n  );\n}\n"],"names":["logDeviceArgument","logProjectLogsLocation","id","Log","log","chalk","dim","env","CI"],"mappings":"AAAA;;;;QAMgBA,iBAAiB,GAAjBA,iBAAiB;QAIjBC,sBAAsB,GAAtBA,sBAAsB;AAVpB,IAAA,MAAO,kCAAP,OAAO,EAAA;AAEL,IAAA,IAAQ,WAAR,QAAQ,CAAA;AACR,IAAA,IAAc,WAAd,cAAc,CAAA;;;;;;AAG3B,SAASD,iBAAiB,CAACE,EAAU,EAAE;IAC5CC,IAAG,IAAA,CAACC,GAAG,CAACC,MAAK,QAAA,CAACC,GAAG,CAAC,mBAAmB,EAAEJ,EAAE,CAAC,CAAC,CAAC,CAAC;CAC9C;AAEM,SAASD,sBAAsB,GAAG;IACvCE,IAAG,IAAA,CAACC,GAAG,CACLC,MAAK,QAAA,CAAC,4CAA0C,EAC9CE,IAAG,IAAA,CAACC,EAAE,GAAG,EAAE,GAAGH,MAAK,QAAA,CAACC,GAAG,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAClD,CAAC,CACH,CAAC;CACH"}

package/build/src/run/resolveBundlerProps.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.resolveBundlerPropsAsync = resolveBundlerPropsAsync;
+var _errors = require("../utils/errors");
+var _port = require("../utils/port");
+async function resolveBundlerPropsAsync(projectRoot, options) {
+    const skipBundler = options.bundler === false;
+    if (// If the user disables the bundler then they should not pass in the port property.
+    skipBundler && options.port) {
+        throw new _errors.CommandError("BAD_ARGS", "--port and --no-bundler are mutually exclusive arguments");
+    }
+    // Resolve the port if the bundler is used.
+    let port = skipBundler ? null : await (0, _port).resolvePortAsync(projectRoot, {
+        reuseExistingPort: true,
+        defaultPort: options.port
+    });
+    // Skip bundling if the port is null
+    options.bundler = !!port;
+    if (!port) {
+        // any random number
+        port = 8081;
+    }
+    return {
+        shouldStartBundler: !skipBundler,
+        port
+    };
+}
+
+//# sourceMappingURL=resolveBundlerProps.js.map

package/build/src/run/resolveBundlerProps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/run/resolveBundlerProps.ts"],"sourcesContent":["import { CommandError } from '../utils/errors';\nimport { resolvePortAsync } from '../utils/port';\n\nexport interface BundlerProps {\n  port: number;\n  shouldStartBundler: boolean;\n}\n\nexport async function resolveBundlerPropsAsync(\n  projectRoot: string,\n  options: {\n    port?: number;\n    bundler?: boolean;\n  }\n): Promise<BundlerProps> {\n  const skipBundler = options.bundler === false;\n\n  if (\n    // If the user disables the bundler then they should not pass in the port property.\n    skipBundler &&\n    options.port\n  ) {\n    throw new CommandError('BAD_ARGS', '--port and --no-bundler are mutually exclusive arguments');\n  }\n\n  // Resolve the port if the bundler is used.\n  let port = skipBundler\n    ? null\n    : await resolvePortAsync(projectRoot, { reuseExistingPort: true, defaultPort: options.port });\n\n  // Skip bundling if the port is null\n  options.bundler = !!port;\n  if (!port) {\n    // any random number\n    port = 8081;\n  }\n\n  return {\n    shouldStartBundler: !skipBundler,\n    port,\n  };\n}\n"],"names":["resolveBundlerPropsAsync","projectRoot","options","skipBundler","bundler","port","CommandError","resolvePortAsync","reuseExistingPort","defaultPort","shouldStartBundler"],"mappings":"AAAA;;;;QAQsBA,wBAAwB,GAAxBA,wBAAwB;AARjB,IAAA,OAAiB,WAAjB,iBAAiB,CAAA;AACb,IAAA,KAAe,WAAf,eAAe,CAAA;AAOzC,eAAeA,wBAAwB,CAC5CC,WAAmB,EACnBC,OAGC,EACsB;IACvB,MAAMC,WAAW,GAAGD,OAAO,CAACE,OAAO,KAAK,KAAK,AAAC;IAE9C,IACE,mFAAmF;IACnFD,WAAW,IACXD,OAAO,CAACG,IAAI,EACZ;QACA,MAAM,IAAIC,OAAY,aAAA,CAAC,UAAU,EAAE,0DAA0D,CAAC,CAAC;KAChG;IAED,2CAA2C;IAC3C,IAAID,IAAI,GAAGF,WAAW,GAClB,IAAI,GACJ,MAAMI,CAAAA,GAAAA,KAAgB,AAAqE,CAAA,iBAArE,CAACN,WAAW,EAAE;QAAEO,iBAAiB,EAAE,IAAI;QAAEC,WAAW,EAAEP,OAAO,CAACG,IAAI;KAAE,CAAC,AAAC;IAEhG,oCAAoC;IACpCH,OAAO,CAACE,OAAO,GAAG,CAAC,CAACC,IAAI,CAAC;IACzB,IAAI,CAACA,IAAI,EAAE;QACT,oBAAoB;QACpBA,IAAI,GAAG,IAAI,CAAC;KACb;IAED,OAAO;QACLK,kBAAkB,EAAE,CAACP,WAAW;QAChCE,IAAI;KACL,CAAC;CACH"}

package/build/src/run/startBundler.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.startBundlerAsync = startBundlerAsync;
+var _config = require("@expo/config");
+var _chalk = _interopRequireDefault(require("chalk"));
+var Log = _interopRequireWildcard(require("../log"));
+var _startInterface = require("../start/interface/startInterface");
+var _devServerManager = require("../start/server/DevServerManager");
+var _env = require("../utils/env");
+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 startBundlerAsync(projectRoot, { port , headless  }) {
+    const options = {
+        port,
+        headless,
+        devClient: true,
+        location: {}
+    };
+    const devServerManager = new _devServerManager.DevServerManager(projectRoot, options);
+    await devServerManager.startAsync([
+        {
+            // TODO: Allow swapping this value for another bundler.
+            type: "metro",
+            options
+        }, 
+    ]);
+    // Present the Terminal UI.
+    if (!headless && !_env.env.CI) {
+        // Only read the config if we are going to use the results.
+        const { exp  } = (0, _config).getConfig(projectRoot, {
+            // We don't need very many fields here, just use the lightest possible read.
+            skipSDKVersionRequirement: true,
+            skipPlugins: true
+        });
+        var _platforms;
+        await (0, _startInterface).startInterfaceAsync(devServerManager, {
+            platforms: (_platforms = exp.platforms) != null ? _platforms : []
+        });
+    } else {
+        var ref;
+        // Display the server location in CI...
+        const url = (ref = devServerManager.getDefaultDevServer()) == null ? void 0 : ref.getDevServerUrl();
+        if (url) {
+            Log.log(_chalk.default`Waiting on {underline ${url}}`);
+        }
+    }
+    return devServerManager;
+}
+
+//# sourceMappingURL=startBundler.js.map

package/build/src/run/startBundler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/run/startBundler.ts"],"sourcesContent":["import { getConfig } from '@expo/config';\nimport chalk from 'chalk';\n\nimport * as Log from '../log';\nimport { startInterfaceAsync } from '../start/interface/startInterface';\nimport { DevServerManager } from '../start/server/DevServerManager';\nimport { env } from '../utils/env';\n\nexport async function startBundlerAsync(\n  projectRoot: string,\n  {\n    port,\n    headless,\n  }: {\n    port: number;\n    headless?: boolean;\n  }\n): Promise<DevServerManager> {\n  const options = {\n    port,\n    headless,\n    devClient: true,\n    location: {},\n  };\n\n  const devServerManager = new DevServerManager(projectRoot, options);\n\n  await devServerManager.startAsync([\n    {\n      // TODO: Allow swapping this value for another bundler.\n      type: 'metro',\n      options,\n    },\n  ]);\n\n  // Present the Terminal UI.\n  if (!headless && !env.CI) {\n    // Only read the config if we are going to use the results.\n    const { exp } = getConfig(projectRoot, {\n      // We don't need very many fields here, just use the lightest possible read.\n      skipSDKVersionRequirement: true,\n      skipPlugins: true,\n    });\n    await startInterfaceAsync(devServerManager, {\n      platforms: exp.platforms ?? [],\n    });\n  } else {\n    // Display the server location in CI...\n    const url = devServerManager.getDefaultDevServer()?.getDevServerUrl();\n    if (url) {\n      Log.log(chalk`Waiting on {underline ${url}}`);\n    }\n  }\n  return devServerManager;\n}\n"],"names":["startBundlerAsync","Log","projectRoot","port","headless","options","devClient","location","devServerManager","DevServerManager","startAsync","type","env","CI","exp","getConfig","skipSDKVersionRequirement","skipPlugins","startInterfaceAsync","platforms","url","getDefaultDevServer","getDevServerUrl","log","chalk"],"mappings":"AAAA;;;;QAQsBA,iBAAiB,GAAjBA,iBAAiB;AARb,IAAA,OAAc,WAAd,cAAc,CAAA;AACtB,IAAA,MAAO,kCAAP,OAAO,EAAA;AAEbC,IAAAA,GAAG,mCAAM,QAAQ,EAAd;AACqB,IAAA,eAAmC,WAAnC,mCAAmC,CAAA;AACtC,IAAA,iBAAkC,WAAlC,kCAAkC,CAAA;AAC/C,IAAA,IAAc,WAAd,cAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3B,eAAeD,iBAAiB,CACrCE,WAAmB,EACnB,EACEC,IAAI,CAAA,EACJC,QAAQ,CAAA,EAIT,EAC0B;IAC3B,MAAMC,OAAO,GAAG;QACdF,IAAI;QACJC,QAAQ;QACRE,SAAS,EAAE,IAAI;QACfC,QAAQ,EAAE,EAAE;KACb,AAAC;IAEF,MAAMC,gBAAgB,GAAG,IAAIC,iBAAgB,iBAAA,CAACP,WAAW,EAAEG,OAAO,CAAC,AAAC;IAEpE,MAAMG,gBAAgB,CAACE,UAAU,CAAC;QAChC;YACE,uDAAuD;YACvDC,IAAI,EAAE,OAAO;YACbN,OAAO;SACR;KACF,CAAC,CAAC;IAEH,2BAA2B;IAC3B,IAAI,CAACD,QAAQ,IAAI,CAACQ,IAAG,IAAA,CAACC,EAAE,EAAE;QACxB,2DAA2D;QAC3D,MAAM,EAAEC,GAAG,CAAA,EAAE,GAAGC,CAAAA,GAAAA,OAAS,AAIvB,CAAA,UAJuB,CAACb,WAAW,EAAE;YACrC,4EAA4E;YAC5Ec,yBAAyB,EAAE,IAAI;YAC/BC,WAAW,EAAE,IAAI;SAClB,CAAC,AAAC;YAEUH,UAAa;QAD1B,MAAMI,CAAAA,GAAAA,eAAmB,AAEvB,CAAA,oBAFuB,CAACV,gBAAgB,EAAE;YAC1CW,SAAS,EAAEL,CAAAA,UAAa,GAAbA,GAAG,CAACK,SAAS,YAAbL,UAAa,GAAI,EAAE;SAC/B,CAAC,CAAC;KACJ,MAAM;YAEON,GAAsC;QADlD,uCAAuC;QACvC,MAAMY,GAAG,GAAGZ,CAAAA,GAAsC,GAAtCA,gBAAgB,CAACa,mBAAmB,EAAE,SAAiB,GAAvDb,KAAAA,CAAuD,GAAvDA,GAAsC,CAAEc,eAAe,EAAE,AAAC;QACtE,IAAIF,GAAG,EAAE;YACPnB,GAAG,CAACsB,GAAG,CAACC,MAAK,QAAA,CAAC,sBAAsB,EAAEJ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/C;KACF;IACD,OAAOZ,gBAAgB,CAAC;CACzB"}

package/build/src/start/index.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.expoStart = void 0;
 var _chalk = _interopRequireDefault(require("chalk"));
-var Log = _interopRequireWildcard(require("../log"));
 var _args = require("../utils/args");
 var _errors = require("../utils/errors");
 function _interopRequireDefault(obj) {
@@ -66,44 +65,35 @@ const expoStart = async (argv)=>{
         "-m": "--host"
     }, argv);
     if (args["--help"]) {
-        Log.exit(_chalk.default`
-  {bold Description}
-    Start a local dev server for the app
-
-  {bold Usage}
-    $ npx expo start <dir>
-
-  <dir> is the directory of the Expo project.
-  Defaults to the current working directory.
-
-  {bold Options}
-    -a, --android                          Opens your app in Expo Go on a connected Android device
-    -i, --ios                              Opens your app in Expo Go in a currently running iOS simulator on your computer
-    -w, --web                              Opens your app in a web browser
-
-    -c, --clear                            Clear the bundler cache
-    --max-workers <num>                    Maximum number of tasks to allow Metro to spawn
-    --no-dev                               Bundle in production mode
-    --minify                               Minify JavaScript
-
-    -m, --host <mode>                      lan, tunnel, localhost. Dev server hosting type. Default: lan.
-                                           - lan: Use the local network
-                                           - tunnel: Use any network by tunnel through ngrok
-                                           - localhost: Connect to the dev server over localhost
-    --tunnel                               Same as --host tunnel
-    --lan                                  Same as --host lan
-    --localhost                            Same as --host localhost
-
-    --offline                              Skip network requests and use anonymous manifest signatures
-    --https                                Start the dev server with https protocol
-    --scheme <scheme>                      Custom URI protocol to use when launching an app
-    -p, --port <port>                      Port to start the dev server on (does not apply to web or tunnel). Default: 19000
-
-    --dev-client                           Experimental: Starts the bundler for use with the expo-development-client
-    --force-manifest-type <manifest-type>  Override auto detection of manifest type
-    --private-key-path <path>              Path to private key for code signing. Default: "private-key.pem" in the same directory as the certificate specified by the expo-updates configuration in app.json.
-    -h, --help                             output usage information
-`, 0);
+        (0, _args).printHelp(`Start a local dev server for the app`, _chalk.default`npx expo start {dim <dir>}`, [
+            _chalk.default`<dir>                                  Directory of the Expo project. {dim Default: Current working directory}`,
+            `-a, --android                          Opens your app in Expo Go on a connected Android device`,
+            `-i, --ios                              Opens your app in Expo Go in a currently running iOS simulator on your computer`,
+            `-w, --web                              Opens your app in a web browser`,
+            ``,
+            `-c, --clear                            Clear the bundler cache`,
+            `--max-workers <num>                    Maximum number of tasks to allow Metro to spawn`,
+            `--no-dev                               Bundle in production mode`,
+            `--minify                               Minify JavaScript`,
+            ``,
+            _chalk.default`-m, --host <mode>                      Dev server hosting type. {dim Default: lan}`,
+            _chalk.default`                                       {bold lan}: Use the local network`,
+            _chalk.default`                                       {bold tunnel}: Use any network by tunnel through ngrok`,
+            _chalk.default`                                       {bold localhost}: Connect to the dev server over localhost`,
+            `--tunnel                               Same as --host tunnel`,
+            `--lan                                  Same as --host lan`,
+            `--localhost                            Same as --host localhost`,
+            ``,
+            `--offline                              Skip network requests and use anonymous manifest signatures`,
+            `--https                                Start the dev server with https protocol`,
+            `--scheme <scheme>                      Custom URI protocol to use when launching an app`,
+            _chalk.default`-p, --port <port>                      Port to start the dev server on (does not apply to web or tunnel). {dim Default: 19000}`,
+            ``,
+            _chalk.default`--dev-client                           {yellow Experimental:} Starts the bundler for use with the expo-development-client`,
+            `--force-manifest-type <manifest-type>  Override auto detection of manifest type`,
+            `--private-key-path <path>              Path to private key for code signing. Default: "private-key.pem" in the same directory as the certificate specified by the expo-updates configuration in app.json.`,
+            `-h, --help                             Usage info`, 
+        ].join("\n"));
     }
     const projectRoot = (0, _args).getProjectRoot(args);
     const { resolveOptionsAsync  } = await Promise.resolve().then(function() {