@depup/expo__cli 55.0.16-depup.0

package/build/src/run/ios/options/resolveDevice.js

@@ -0,0 +1,151 @@
+// import { resolveDestinationsAsync } from './appleDestinations';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isSimulatorDevice: function() {
+        return isSimulatorDevice;
+    },
+    resolveDeviceAsync: function() {
+        return resolveDeviceAsync;
+    }
+});
+const _promptDevice = require("./promptDevice");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _AppleDeviceManager = require("../../../start/platforms/ios/AppleDeviceManager");
+const _promptAppleDevice = require("../../../start/platforms/ios/promptAppleDevice");
+const _simctl = /*#__PURE__*/ _interop_require_wildcard(require("../../../start/platforms/ios/simctl"));
+const _array = require("../../../utils/array");
+const _errors = require("../../../utils/errors");
+const _profile = require("../../../utils/profile");
+const _hints = require("../../hints");
+const _AppleDevice = /*#__PURE__*/ _interop_require_wildcard(require("../appleDevice/AppleDevice"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && 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;
+}
+/** Get a list of devices (called destinations) that are connected to the host machine. Filter by `osType` if defined. */ async function getDevicesAsync({ osType }) {
+    const devices = await (0, _promptAppleDevice.sortDefaultDeviceToBeginningAsync)((0, _array.uniqBy)((await Promise.all([
+        _AppleDevice.getConnectedDevicesAsync(),
+        await (0, _profile.profile)(_simctl.getDevicesAsync)()
+    ])).flat(), (item)=>item.udid), osType);
+    // Sort devices to top of front of the list
+    const physical = [];
+    const simulators = devices.filter((device)=>{
+        if ('isAvailable' in device) {
+            return true;
+        } else {
+            physical.push(device);
+            return false;
+        }
+    });
+    const isPhone = (a)=>a.osType === 'iOS';
+    const sorted = [
+        ...physical.sort((a, b)=>{
+            const aPhone = isPhone(a);
+            const bPhone = isPhone(b);
+            if (aPhone && !bPhone) return -1;
+            if (!aPhone && bPhone) return 1;
+            return 0;
+        }),
+        ...simulators
+    ];
+    // If osType is defined, then filter out ineligible simulators.
+    // Only do this inside of the device selection so users who pass the entire device udid can attempt to select any simulator (even if it's invalid).
+    return osType ? filterDevicesForOsType(sorted, osType) : sorted;
+}
+/** @returns a list of devices, filtered by the provided `osType`. */ function filterDevicesForOsType(devices, osType) {
+    return devices.filter((device)=>{
+        if (osType === 'iOS') {
+            // Compatible devices for iOS builds
+            return [
+                'iOS',
+                'macOS',
+                'xrOS'
+            ].includes(device.osType);
+        }
+        return device.osType === osType;
+    });
+}
+async function resolveDeviceAsync(device, buildProps) {
+    await _AppleDeviceManager.AppleDeviceManager.assertSystemRequirementsAsync();
+    if (!device) {
+        /** Finds the first possible device and returns in a booted state. */ const manager = await _AppleDeviceManager.AppleDeviceManager.resolveAsync({
+            device: {
+                osType: buildProps.osType
+            }
+        });
+        _log.debug(`Resolved default device (name: ${manager.device.name}, udid: ${manager.device.udid}, osType: ${buildProps.osType})`);
+        return manager.device;
+    }
+    const devices = await getDevicesAsync(buildProps);
+    const resolved = device === true ? await (0, _promptDevice.promptDeviceAsync)(devices) : findDeviceFromSearchValue(devices, device.toLowerCase());
+    return ensureBootedAsync(resolved);
+}
+function isSimulatorDevice(device) {
+    var _device_deviceType_startsWith, _device_deviceType;
+    return !('deviceType' in device) || !!((_device_deviceType = device.deviceType) == null ? void 0 : (_device_deviceType_startsWith = _device_deviceType.startsWith) == null ? void 0 : _device_deviceType_startsWith.call(_device_deviceType, 'com.apple.CoreSimulator.SimDeviceType.'));
+}
+/** @returns device matching the `searchValue` against name or UDID. */ function findDeviceFromSearchValue(devices, searchValue) {
+    const device = devices.find((device)=>device.udid.toLowerCase() === searchValue || device.name.toLowerCase() === searchValue);
+    if (!device) {
+        throw new _errors.CommandError('BAD_ARGS', `No device UDID or name matching "${searchValue}"`);
+    }
+    return device;
+}
+/** Ensures the device is booted if it's a simulator. */ async function ensureBootedAsync(device) {
+    // --device with no props after
+    (0, _hints.logDeviceArgument)(device.udid);
+    if (isSimulatorDevice(device)) {
+        return (0, _AppleDeviceManager.ensureSimulatorOpenAsync)({
+            udid: device.udid
+        });
+    }
+    return device;
+}
+
+//# sourceMappingURL=resolveDevice.js.map

package/build/src/run/ios/options/resolveDevice.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/options/resolveDevice.ts"],"sourcesContent":["// import { resolveDestinationsAsync } from './appleDestinations';\nimport { promptDeviceAsync } from './promptDevice';\nimport * as Log from '../../../log';\nimport {\n  AppleDeviceManager,\n  ensureSimulatorOpenAsync,\n} from '../../../start/platforms/ios/AppleDeviceManager';\nimport { sortDefaultDeviceToBeginningAsync } from '../../../start/platforms/ios/promptAppleDevice';\nimport { OSType } from '../../../start/platforms/ios/simctl';\nimport * as SimControl from '../../../start/platforms/ios/simctl';\nimport { uniqBy } from '../../../utils/array';\nimport { CommandError } from '../../../utils/errors';\nimport { profile } from '../../../utils/profile';\nimport { logDeviceArgument } from '../../hints';\nimport { BuildProps } from '../XcodeBuild.types';\nimport * as AppleDevice from '../appleDevice/AppleDevice';\n\ntype AnyDevice = SimControl.Device | AppleDevice.ConnectedDevice;\n\n/** Get a list of devices (called destinations) that are connected to the host machine. Filter by `osType` if defined. */\nasync function getDevicesAsync({\n  osType,\n  // ...buildProps\n}: { osType?: OSType } & Pick<BuildProps, 'xcodeProject' | 'scheme' | 'configuration'>): Promise<\n  AnyDevice[]\n> {\n  const devices = await sortDefaultDeviceToBeginningAsync(\n    uniqBy(\n      (\n        await Promise.all([\n          AppleDevice.getConnectedDevicesAsync(),\n          await profile(SimControl.getDevicesAsync)(),\n          // resolveDestinationsAsync(buildProps),\n        ])\n      ).flat(),\n      (item) => item.udid\n    ),\n    osType\n  );\n\n  // Sort devices to top of front of the list\n\n  const physical: AnyDevice[] = [];\n\n  const simulators = devices.filter((device) => {\n    if ('isAvailable' in device) {\n      return true;\n    } else {\n      physical.push(device);\n      return false;\n    }\n  });\n\n  const isPhone = (a: any) => a.osType === 'iOS';\n  const sorted = [\n    ...physical.sort((a, b) => {\n      const aPhone = isPhone(a);\n      const bPhone = isPhone(b);\n      if (aPhone && !bPhone) return -1;\n      if (!aPhone && bPhone) return 1;\n\n      return 0;\n    }),\n    ...simulators,\n  ];\n\n  // If osType is defined, then filter out ineligible simulators.\n  // Only do this inside of the device selection so users who pass the entire device udid can attempt to select any simulator (even if it's invalid).\n  return osType ? filterDevicesForOsType(sorted, osType) : sorted;\n}\n\n/** @returns a list of devices, filtered by the provided `osType`. */\nfunction filterDevicesForOsType<TDevice extends { osType: OSType }>(\n  devices: TDevice[],\n  osType: OSType\n): TDevice[] {\n  return devices.filter((device) => {\n    if (osType === 'iOS') {\n      // Compatible devices for iOS builds\n      return ['iOS', 'macOS', 'xrOS'].includes(device.osType);\n    }\n    return device.osType === osType;\n  });\n}\n\n/** Given a `device` argument from the CLI, parse and prompt our way to a usable device for building. */\nexport async function resolveDeviceAsync(\n  device: string | boolean | undefined,\n  buildProps: { osType?: OSType } & Pick<BuildProps, 'xcodeProject' | 'scheme' | 'configuration'>\n): Promise<AnyDevice> {\n  await AppleDeviceManager.assertSystemRequirementsAsync();\n\n  if (!device) {\n    /** Finds the first possible device and returns in a booted state. */\n    const manager = await AppleDeviceManager.resolveAsync({\n      device: {\n        osType: buildProps.osType,\n      },\n    });\n    Log.debug(\n      `Resolved default device (name: ${manager.device.name}, udid: ${manager.device.udid}, osType: ${buildProps.osType})`\n    );\n    return manager.device;\n  }\n\n  const devices = await getDevicesAsync(buildProps);\n\n  const resolved =\n    device === true\n      ? // `--device` (no props after)\n        await promptDeviceAsync(devices)\n      : // `--device <name|udid>`\n        findDeviceFromSearchValue(devices, device.toLowerCase());\n\n  return ensureBootedAsync(resolved);\n}\n\n/** @returns `true` if the given device is a simulator. */\nexport function isSimulatorDevice(device: AnyDevice): boolean {\n  return (\n    !('deviceType' in device) ||\n    !!device.deviceType?.startsWith?.('com.apple.CoreSimulator.SimDeviceType.')\n  );\n}\n\n/** @returns device matching the `searchValue` against name or UDID. */\nfunction findDeviceFromSearchValue(devices: AnyDevice[], searchValue: string): AnyDevice {\n  const device = devices.find(\n    (device) =>\n      device.udid.toLowerCase() === searchValue || device.name.toLowerCase() === searchValue\n  );\n  if (!device) {\n    throw new CommandError('BAD_ARGS', `No device UDID or name matching \"${searchValue}\"`);\n  }\n  return device;\n}\n\n/** Ensures the device is booted if it's a simulator. */\nasync function ensureBootedAsync(device: AnyDevice): Promise<AnyDevice> {\n  // --device with no props after\n  logDeviceArgument(device.udid);\n  if (isSimulatorDevice(device)) {\n    return ensureSimulatorOpenAsync({ udid: device.udid });\n  }\n  return device;\n}\n"],"names":["isSimulatorDevice","resolveDeviceAsync","getDevicesAsync","osType","devices","sortDefaultDeviceToBeginningAsync","uniqBy","Promise","all","AppleDevice","getConnectedDevicesAsync","profile","SimControl","flat","item","udid","physical","simulators","filter","device","push","isPhone","a","sorted","sort","b","aPhone","bPhone","filterDevicesForOsType","includes","buildProps","AppleDeviceManager","assertSystemRequirementsAsync","manager","resolveAsync","Log","debug","name","resolved","promptDeviceAsync","findDeviceFromSearchValue","toLowerCase","ensureBootedAsync","deviceType","startsWith","searchValue","find","CommandError","logDeviceArgument","ensureSimulatorOpenAsync"],"mappings":"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"}

package/build/src/run/ios/options/resolveNativeScheme.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getDefaultNativeScheme: function() {
+        return getDefaultNativeScheme;
+    },
+    promptOrQueryNativeSchemeAsync: function() {
+        return promptOrQueryNativeSchemeAsync;
+    },
+    resolveNativeSchemePropsAsync: function() {
+        return resolveNativeSchemePropsAsync;
+    }
+});
+function _configplugins() {
+    const data = require("@expo/config-plugins");
+    _configplugins = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _errors = require("../../../utils/errors");
+const _profile = require("../../../utils/profile");
+const _prompts = require("../../../utils/prompts");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && 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;
+}
+const debug = require('debug')('expo:run:ios:options:resolveNativeScheme');
+async function resolveNativeSchemePropsAsync(projectRoot, options, xcodeProject) {
+    return await promptOrQueryNativeSchemeAsync(projectRoot, options) ?? getDefaultNativeScheme(projectRoot, options, xcodeProject);
+}
+async function promptOrQueryNativeSchemeAsync(projectRoot, { scheme, configuration }) {
+    const schemes = _configplugins().IOSConfig.BuildScheme.getRunnableSchemesFromXcodeproj(projectRoot, {
+        configuration
+    });
+    if (!schemes.length) {
+        throw new _errors.CommandError('IOS_MALFORMED', 'No native iOS build schemes found');
+    }
+    if (scheme === true) {
+        if (schemes.length === 1) {
+            _log.log(`Auto selecting only available scheme: ${schemes[0].name}`);
+            return schemes[0];
+        }
+        const resolvedSchemeName = await (0, _prompts.selectAsync)('Select a scheme', schemes.map((value)=>{
+            const isApp = value.type === _configplugins().IOSConfig.Target.TargetType.APPLICATION && value.osType === 'iOS';
+            return {
+                value: value.name,
+                title: isApp ? _chalk().default.bold(value.name) + _chalk().default.gray(' (app)') : value.name
+            };
+        }), {
+            nonInteractiveHelp: `--scheme: argument must be provided with a string in non-interactive mode. Valid choices are: ${schemes.join(', ')}`
+        });
+        return schemes.find(({ name })=>resolvedSchemeName === name) ?? null;
+    }
+    // Attempt to match the schemes up so we can open the correct simulator
+    return scheme ? schemes.find(({ name })=>name === scheme) || {
+        name: scheme
+    } : null;
+}
+function getDefaultNativeScheme(projectRoot, options, xcodeProject) {
+    // If the resolution failed then we should just use the first runnable scheme that
+    // matches the provided configuration.
+    const resolvedSchemes = (0, _profile.profile)(_configplugins().IOSConfig.BuildScheme.getRunnableSchemesFromXcodeproj)(projectRoot, {
+        configuration: options.configuration
+    });
+    // If there are multiple schemes, then the default should be the application.
+    if (resolvedSchemes.length > 1) {
+        const scheme = resolvedSchemes.find(({ type })=>type === _configplugins().IOSConfig.Target.TargetType.APPLICATION) ?? resolvedSchemes[0];
+        debug(`Using default scheme: ${scheme.name}`);
+        return scheme;
+    }
+    // If we couldn't find the scheme, then we'll guess at it,
+    // this is needed for cases where the native code hasn't been generated yet.
+    if (resolvedSchemes[0]) {
+        return resolvedSchemes[0];
+    }
+    return {
+        name: _path().default.basename(xcodeProject.name, _path().default.extname(xcodeProject.name))
+    };
+}
+
+//# sourceMappingURL=resolveNativeScheme.js.map

package/build/src/run/ios/options/resolveNativeScheme.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/options/resolveNativeScheme.ts"],"sourcesContent":["import { IOSConfig } from '@expo/config-plugins';\nimport chalk from 'chalk';\nimport path from 'path';\n\nimport * as Log from '../../../log';\nimport { CommandError } from '../../../utils/errors';\nimport { profile } from '../../../utils/profile';\nimport { selectAsync } from '../../../utils/prompts';\nimport { Options, ProjectInfo, XcodeConfiguration } from '../XcodeBuild.types';\n\nconst debug = require('debug')('expo:run:ios:options:resolveNativeScheme') as typeof console.log;\n\ntype NativeSchemeProps = {\n  name: string;\n  osType?: string;\n};\n\nexport async function resolveNativeSchemePropsAsync(\n  projectRoot: string,\n  options: Pick<Options, 'scheme' | 'configuration'>,\n  xcodeProject: ProjectInfo\n): Promise<NativeSchemeProps> {\n  return (\n    (await promptOrQueryNativeSchemeAsync(projectRoot, options)) ??\n    getDefaultNativeScheme(projectRoot, options, xcodeProject)\n  );\n}\n\n/** Resolve the native iOS build `scheme` for a given `configuration`. If the `scheme` isn't provided then the user will be prompted to select one. */\nexport async function promptOrQueryNativeSchemeAsync(\n  projectRoot: string,\n  { scheme, configuration }: { scheme?: string | boolean; configuration?: XcodeConfiguration }\n): Promise<NativeSchemeProps | null> {\n  const schemes = IOSConfig.BuildScheme.getRunnableSchemesFromXcodeproj(projectRoot, {\n    configuration,\n  });\n\n  if (!schemes.length) {\n    throw new CommandError('IOS_MALFORMED', 'No native iOS build schemes found');\n  }\n\n  if (scheme === true) {\n    if (schemes.length === 1) {\n      Log.log(`Auto selecting only available scheme: ${schemes[0].name}`);\n      return schemes[0];\n    }\n    const resolvedSchemeName = await selectAsync(\n      'Select a scheme',\n      schemes.map((value) => {\n        const isApp =\n          value.type === IOSConfig.Target.TargetType.APPLICATION && value.osType === 'iOS';\n        return {\n          value: value.name,\n          title: isApp ? chalk.bold(value.name) + chalk.gray(' (app)') : value.name,\n        };\n      }),\n      {\n        nonInteractiveHelp: `--scheme: argument must be provided with a string in non-interactive mode. Valid choices are: ${schemes.join(\n          ', '\n        )}`,\n      }\n    );\n    return schemes.find(({ name }) => resolvedSchemeName === name) ?? null;\n  }\n  // Attempt to match the schemes up so we can open the correct simulator\n  return scheme ? schemes.find(({ name }) => name === scheme) || { name: scheme } : null;\n}\n\nexport function getDefaultNativeScheme(\n  projectRoot: string,\n  options: Pick<Options, 'configuration'>,\n  xcodeProject: Pick<ProjectInfo, 'name'>\n): NativeSchemeProps {\n  // If the resolution failed then we should just use the first runnable scheme that\n  // matches the provided configuration.\n  const resolvedSchemes = profile(IOSConfig.BuildScheme.getRunnableSchemesFromXcodeproj)(\n    projectRoot,\n    {\n      configuration: options.configuration,\n    }\n  );\n\n  // If there are multiple schemes, then the default should be the application.\n  if (resolvedSchemes.length > 1) {\n    const scheme =\n      resolvedSchemes.find(({ type }) => type === IOSConfig.Target.TargetType.APPLICATION) ??\n      resolvedSchemes[0];\n    debug(`Using default scheme: ${scheme.name}`);\n    return scheme;\n  }\n\n  // If we couldn't find the scheme, then we'll guess at it,\n  // this is needed for cases where the native code hasn't been generated yet.\n  if (resolvedSchemes[0]) {\n    return resolvedSchemes[0];\n  }\n  return {\n    name: path.basename(xcodeProject.name, path.extname(xcodeProject.name)),\n  };\n}\n"],"names":["getDefaultNativeScheme","promptOrQueryNativeSchemeAsync","resolveNativeSchemePropsAsync","debug","require","projectRoot","options","xcodeProject","scheme","configuration","schemes","IOSConfig","BuildScheme","getRunnableSchemesFromXcodeproj","length","CommandError","Log","log","name","resolvedSchemeName","selectAsync","map","value","isApp","type","Target","TargetType","APPLICATION","osType","title","chalk","bold","gray","nonInteractiveHelp","join","find","resolvedSchemes","profile","path","basename","extname"],"mappings":";;;;;;;;;;;IAoEgBA,sBAAsB;eAAtBA;;IAvCMC,8BAA8B;eAA9BA;;IAZAC,6BAA6B;eAA7BA;;;;yBAjBI;;;;;;;gEACR;;;;;;;gEACD;;;;;;6DAEI;wBACQ;yBACL;yBACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5B,MAAMC,QAAQC,QAAQ,SAAS;AAOxB,eAAeF,8BACpBG,WAAmB,EACnBC,OAAkD,EAClDC,YAAyB;IAEzB,OACE,AAAC,MAAMN,+BAA+BI,aAAaC,YACnDN,uBAAuBK,aAAaC,SAASC;AAEjD;AAGO,eAAeN,+BACpBI,WAAmB,EACnB,EAAEG,MAAM,EAAEC,aAAa,EAAqE;IAE5F,MAAMC,UAAUC,0BAAS,CAACC,WAAW,CAACC,+BAA+B,CAACR,aAAa;QACjFI;IACF;IAEA,IAAI,CAACC,QAAQI,MAAM,EAAE;QACnB,MAAM,IAAIC,oBAAY,CAAC,iBAAiB;IAC1C;IAEA,IAAIP,WAAW,MAAM;QACnB,IAAIE,QAAQI,MAAM,KAAK,GAAG;YACxBE,KAAIC,GAAG,CAAC,CAAC,sCAAsC,EAAEP,OAAO,CAAC,EAAE,CAACQ,IAAI,EAAE;YAClE,OAAOR,OAAO,CAAC,EAAE;QACnB;QACA,MAAMS,qBAAqB,MAAMC,IAAAA,oBAAW,EAC1C,mBACAV,QAAQW,GAAG,CAAC,CAACC;YACX,MAAMC,QACJD,MAAME,IAAI,KAAKb,0BAAS,CAACc,MAAM,CAACC,UAAU,CAACC,WAAW,IAAIL,MAAMM,MAAM,KAAK;YAC7E,OAAO;gBACLN,OAAOA,MAAMJ,IAAI;gBACjBW,OAAON,QAAQO,gBAAK,CAACC,IAAI,CAACT,MAAMJ,IAAI,IAAIY,gBAAK,CAACE,IAAI,CAAC,YAAYV,MAAMJ,IAAI;YAC3E;QACF,IACA;YACEe,oBAAoB,CAAC,8FAA8F,EAAEvB,QAAQwB,IAAI,CAC/H,OACC;QACL;QAEF,OAAOxB,QAAQyB,IAAI,CAAC,CAAC,EAAEjB,IAAI,EAAE,GAAKC,uBAAuBD,SAAS;IACpE;IACA,uEAAuE;IACvE,OAAOV,SAASE,QAAQyB,IAAI,CAAC,CAAC,EAAEjB,IAAI,EAAE,GAAKA,SAASV,WAAW;QAAEU,MAAMV;IAAO,IAAI;AACpF;AAEO,SAASR,uBACdK,WAAmB,EACnBC,OAAuC,EACvCC,YAAuC;IAEvC,kFAAkF;IAClF,sCAAsC;IACtC,MAAM6B,kBAAkBC,IAAAA,gBAAO,EAAC1B,0BAAS,CAACC,WAAW,CAACC,+BAA+B,EACnFR,aACA;QACEI,eAAeH,QAAQG,aAAa;IACtC;IAGF,6EAA6E;IAC7E,IAAI2B,gBAAgBtB,MAAM,GAAG,GAAG;QAC9B,MAAMN,SACJ4B,gBAAgBD,IAAI,CAAC,CAAC,EAAEX,IAAI,EAAE,GAAKA,SAASb,0BAAS,CAACc,MAAM,CAACC,UAAU,CAACC,WAAW,KACnFS,eAAe,CAAC,EAAE;QACpBjC,MAAM,CAAC,sBAAsB,EAAEK,OAAOU,IAAI,EAAE;QAC5C,OAAOV;IACT;IAEA,0DAA0D;IAC1D,4EAA4E;IAC5E,IAAI4B,eAAe,CAAC,EAAE,EAAE;QACtB,OAAOA,eAAe,CAAC,EAAE;IAC3B;IACA,OAAO;QACLlB,MAAMoB,eAAI,CAACC,QAAQ,CAAChC,aAAaW,IAAI,EAAEoB,eAAI,CAACE,OAAO,CAACjC,aAAaW,IAAI;IACvE;AACF"}

package/build/src/run/ios/options/resolveOptions.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveOptionsAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveOptionsAsync;
+    }
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+const _resolveDevice = require("./resolveDevice");
+const _resolveNativeScheme = require("./resolveNativeScheme");
+const _resolveXcodeProject = require("./resolveXcodeProject");
+const _simctl = require("../../../start/platforms/ios/simctl");
+const _buildcacheproviders = require("../../../utils/build-cache-providers");
+const _profile = require("../../../utils/profile");
+const _resolveBundlerProps = require("../../resolveBundlerProps");
+async function resolveOptionsAsync(projectRoot, options) {
+    var _projectConfig_exp, _projectConfig_exp_experiments;
+    const xcodeProject = (0, _resolveXcodeProject.resolveXcodeProject)(projectRoot);
+    const bundlerProps = await (0, _resolveBundlerProps.resolveBundlerPropsAsync)(projectRoot, options);
+    // Resolve the scheme before the device so we can filter devices based on
+    // whichever scheme is selected (i.e. don't present TV devices if the scheme cannot be run on a TV).
+    const { osType, name: scheme } = await (0, _resolveNativeScheme.resolveNativeSchemePropsAsync)(projectRoot, options, xcodeProject);
+    // Use the configuration or `Debug` if none is provided.
+    const configuration = options.configuration || '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.
+    const device = await (0, _profile.profile)(_resolveDevice.resolveDeviceAsync)(options.device, {
+        // It's unclear if there's any value to asserting that we haven't hardcoded the os type in the CLI.
+        osType: (0, _simctl.isOSType)(osType) ? osType : undefined,
+        xcodeProject,
+        scheme,
+        configuration
+    });
+    const isSimulator = (0, _resolveDevice.isSimulatorDevice)(device);
+    const projectConfig = (0, _config().getConfig)(projectRoot);
+    const buildCacheProvider = await (0, _buildcacheproviders.resolveBuildCacheProvider)(((_projectConfig_exp = projectConfig.exp) == null ? void 0 : _projectConfig_exp.buildCacheProvider) ?? ((_projectConfig_exp_experiments = projectConfig.exp.experiments) == null ? void 0 : _projectConfig_exp_experiments.buildCacheProvider), projectRoot);
+    // This optimization skips resetting the Metro cache needlessly.
+    // The cache is reset in `../node_modules/react-native/scripts/react-native-xcode.sh` when the
+    // project is running in Debug and built onto a physical device. It seems that this is done because
+    // the script is run from Xcode and unaware of the CLI instance.
+    const shouldSkipInitialBundling = configuration === 'Debug' && !isSimulator;
+    return {
+        ...bundlerProps,
+        shouldStartBundler: options.configuration === 'Debug' || bundlerProps.shouldStartBundler,
+        projectRoot,
+        isSimulator,
+        xcodeProject,
+        device,
+        configuration,
+        shouldSkipInitialBundling,
+        buildCache: options.buildCache !== false,
+        scheme,
+        buildCacheProvider
+    };
+}
+
+//# sourceMappingURL=resolveOptions.js.map

package/build/src/run/ios/options/resolveOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/options/resolveOptions.ts"],"sourcesContent":["import { getConfig } from '@expo/config';\n\nimport { isSimulatorDevice, resolveDeviceAsync } from './resolveDevice';\nimport { resolveNativeSchemePropsAsync } from './resolveNativeScheme';\nimport { resolveXcodeProject } from './resolveXcodeProject';\nimport { isOSType } from '../../../start/platforms/ios/simctl';\nimport { resolveBuildCacheProvider } from '../../../utils/build-cache-providers';\nimport { profile } from '../../../utils/profile';\nimport { resolveBundlerPropsAsync } from '../../resolveBundlerProps';\nimport { BuildProps, Options } from '../XcodeBuild.types';\n\n/** Resolve arguments for the `run:ios` command. */\nexport async function resolveOptionsAsync(\n  projectRoot: string,\n  options: Options\n): Promise<BuildProps> {\n  const xcodeProject = resolveXcodeProject(projectRoot);\n\n  const bundlerProps = await resolveBundlerPropsAsync(projectRoot, options);\n\n  // Resolve the scheme before the device so we can filter devices based on\n  // whichever scheme is selected (i.e. don't present TV devices if the scheme cannot be run on a TV).\n  const { osType, name: scheme } = await resolveNativeSchemePropsAsync(\n    projectRoot,\n    options,\n    xcodeProject\n  );\n\n  // Use the configuration or `Debug` if none is provided.\n  const configuration = options.configuration || 'Debug';\n\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  const device = await profile(resolveDeviceAsync)(options.device, {\n    // It's unclear if there's any value to asserting that we haven't hardcoded the os type in the CLI.\n    osType: isOSType(osType) ? osType : undefined,\n    xcodeProject,\n    scheme,\n    configuration,\n  });\n\n  const isSimulator = isSimulatorDevice(device);\n\n  const projectConfig = getConfig(projectRoot);\n  const buildCacheProvider = await resolveBuildCacheProvider(\n    projectConfig.exp?.buildCacheProvider ?? projectConfig.exp.experiments?.buildCacheProvider,\n    projectRoot\n  );\n\n  // This optimization skips resetting the Metro cache needlessly.\n  // The cache is reset in `../node_modules/react-native/scripts/react-native-xcode.sh` when the\n  // project is running in Debug and built onto a physical device. It seems that this is done because\n  // the script is run from Xcode and unaware of the CLI instance.\n  const shouldSkipInitialBundling = configuration === 'Debug' && !isSimulator;\n\n  return {\n    ...bundlerProps,\n    shouldStartBundler: options.configuration === 'Debug' || bundlerProps.shouldStartBundler,\n    projectRoot,\n    isSimulator,\n    xcodeProject,\n    device,\n    configuration,\n    shouldSkipInitialBundling,\n    buildCache: options.buildCache !== false,\n    scheme,\n    buildCacheProvider,\n  };\n}\n"],"names":["resolveOptionsAsync","projectRoot","options","projectConfig","xcodeProject","resolveXcodeProject","bundlerProps","resolveBundlerPropsAsync","osType","name","scheme","resolveNativeSchemePropsAsync","configuration","device","profile","resolveDeviceAsync","isOSType","undefined","isSimulator","isSimulatorDevice","getConfig","buildCacheProvider","resolveBuildCacheProvider","exp","experiments","shouldSkipInitialBundling","shouldStartBundler","buildCache"],"mappings":";;;;+BAYsBA;;;eAAAA;;;;yBAZI;;;;;;+BAE4B;qCACR;qCACV;wBACX;qCACiB;yBAClB;qCACiB;AAIlC,eAAeA,oBACpBC,WAAmB,EACnBC,OAAgB;QA+BdC,oBAAyCA;IA7B3C,MAAMC,eAAeC,IAAAA,wCAAmB,EAACJ;IAEzC,MAAMK,eAAe,MAAMC,IAAAA,6CAAwB,EAACN,aAAaC;IAEjE,yEAAyE;IACzE,oGAAoG;IACpG,MAAM,EAAEM,MAAM,EAAEC,MAAMC,MAAM,EAAE,GAAG,MAAMC,IAAAA,kDAA6B,EAClEV,aACAC,SACAE;IAGF,wDAAwD;IACxD,MAAMQ,gBAAgBV,QAAQU,aAAa,IAAI;IAE/C,+DAA+D;IAC/D,mFAAmF;IACnF,MAAMC,SAAS,MAAMC,IAAAA,gBAAO,EAACC,iCAAkB,EAAEb,QAAQW,MAAM,EAAE;QAC/D,mGAAmG;QACnGL,QAAQQ,IAAAA,gBAAQ,EAACR,UAAUA,SAASS;QACpCb;QACAM;QACAE;IACF;IAEA,MAAMM,cAAcC,IAAAA,gCAAiB,EAACN;IAEtC,MAAMV,gBAAgBiB,IAAAA,mBAAS,EAACnB;IAChC,MAAMoB,qBAAqB,MAAMC,IAAAA,8CAAyB,EACxDnB,EAAAA,qBAAAA,cAAcoB,GAAG,qBAAjBpB,mBAAmBkB,kBAAkB,OAAIlB,iCAAAA,cAAcoB,GAAG,CAACC,WAAW,qBAA7BrB,+BAA+BkB,kBAAkB,GAC1FpB;IAGF,gEAAgE;IAChE,8FAA8F;IAC9F,mGAAmG;IACnG,gEAAgE;IAChE,MAAMwB,4BAA4Bb,kBAAkB,WAAW,CAACM;IAEhE,OAAO;QACL,GAAGZ,YAAY;QACfoB,oBAAoBxB,QAAQU,aAAa,KAAK,WAAWN,aAAaoB,kBAAkB;QACxFzB;QACAiB;QACAd;QACAS;QACAD;QACAa;QACAE,YAAYzB,QAAQyB,UAAU,KAAK;QACnCjB;QACAW;IACF;AACF"}

package/build/src/run/ios/options/resolveXcodeProject.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveXcodeProject", {
+    enumerable: true,
+    get: function() {
+        return resolveXcodeProject;
+    }
+});
+function _glob() {
+    const data = require("glob");
+    _glob = function() {
+        return data;
+    };
+    return data;
+}
+const _errors = require("../../../utils/errors");
+const ignoredPaths = [
+    '**/@(Carthage|Pods|vendor|node_modules)/**'
+];
+function findXcodeProjectPaths(projectRoot, extension) {
+    return (0, _glob().sync)(`ios/*.${extension}`, {
+        absolute: true,
+        cwd: projectRoot,
+        ignore: ignoredPaths
+    });
+}
+function resolveXcodeProject(projectRoot) {
+    let paths = findXcodeProjectPaths(projectRoot, 'xcworkspace');
+    if (paths.length) {
+        return {
+            // Use full path instead of relative project root so that warnings and errors contain full paths as well, this helps with filtering.
+            // Also helps keep things consistent in monorepos.
+            name: paths[0],
+            // name: path.relative(projectRoot, paths[0]),
+            isWorkspace: true
+        };
+    }
+    paths = findXcodeProjectPaths(projectRoot, 'xcodeproj');
+    if (paths.length) {
+        return {
+            name: paths[0],
+            isWorkspace: false
+        };
+    }
+    throw new _errors.CommandError('IOS_MALFORMED', `Xcode project not found in project: ${projectRoot}. You can generate a project with \`npx expo prebuild\``);
+}
+
+//# sourceMappingURL=resolveXcodeProject.js.map

package/build/src/run/ios/options/resolveXcodeProject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/options/resolveXcodeProject.ts"],"sourcesContent":["import { sync as globSync } from 'glob';\n\nimport { CommandError } from '../../../utils/errors';\nimport { ProjectInfo } from '../XcodeBuild.types';\n\nconst ignoredPaths = ['**/@(Carthage|Pods|vendor|node_modules)/**'];\n\nfunction findXcodeProjectPaths(\n  projectRoot: string,\n  extension: 'xcworkspace' | 'xcodeproj'\n): string[] {\n  return globSync(`ios/*.${extension}`, {\n    absolute: true,\n    cwd: projectRoot,\n    ignore: ignoredPaths,\n  });\n}\n\n/** Return the path and type of Xcode project in the given folder. */\nexport function resolveXcodeProject(projectRoot: string): ProjectInfo {\n  let paths = findXcodeProjectPaths(projectRoot, 'xcworkspace');\n  if (paths.length) {\n    return {\n      // Use full path instead of relative project root so that warnings and errors contain full paths as well, this helps with filtering.\n      // Also helps keep things consistent in monorepos.\n      name: paths[0],\n      // name: path.relative(projectRoot, paths[0]),\n      isWorkspace: true,\n    };\n  }\n  paths = findXcodeProjectPaths(projectRoot, 'xcodeproj');\n  if (paths.length) {\n    return { name: paths[0], isWorkspace: false };\n  }\n  throw new CommandError(\n    'IOS_MALFORMED',\n    `Xcode project not found in project: ${projectRoot}. You can generate a project with \\`npx expo prebuild\\``\n  );\n}\n"],"names":["resolveXcodeProject","ignoredPaths","findXcodeProjectPaths","projectRoot","extension","globSync","absolute","cwd","ignore","paths","length","name","isWorkspace","CommandError"],"mappings":";;;;+BAmBgBA;;;eAAAA;;;;yBAnBiB;;;;;;wBAEJ;AAG7B,MAAMC,eAAe;IAAC;CAA6C;AAEnE,SAASC,sBACPC,WAAmB,EACnBC,SAAsC;IAEtC,OAAOC,IAAAA,YAAQ,EAAC,CAAC,MAAM,EAAED,WAAW,EAAE;QACpCE,UAAU;QACVC,KAAKJ;QACLK,QAAQP;IACV;AACF;AAGO,SAASD,oBAAoBG,WAAmB;IACrD,IAAIM,QAAQP,sBAAsBC,aAAa;IAC/C,IAAIM,MAAMC,MAAM,EAAE;QAChB,OAAO;YACL,oIAAoI;YACpI,kDAAkD;YAClDC,MAAMF,KAAK,CAAC,EAAE;YACd,8CAA8C;YAC9CG,aAAa;QACf;IACF;IACAH,QAAQP,sBAAsBC,aAAa;IAC3C,IAAIM,MAAMC,MAAM,EAAE;QAChB,OAAO;YAAEC,MAAMF,KAAK,CAAC,EAAE;YAAEG,aAAa;QAAM;IAC9C;IACA,MAAM,IAAIC,oBAAY,CACpB,iBACA,CAAC,oCAAoC,EAAEV,YAAY,uDAAuD,CAAC;AAE/G"}