@depup/expo__cli 55.0.16-depup.0

package/build/src/run/ensureNativeProject.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureNativeProjectAsync", {
+    enumerable: true,
+    get: function() {
+        return ensureNativeProjectAsync;
+    }
+});
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _clearNativeFolder = require("../prebuild/clearNativeFolder");
+const _prebuildAsync = require("../prebuild/prebuildAsync");
+const _profile = require("../utils/profile");
+function _interop_require_default(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
+            ]
+        });
+    } else {
+        return true;
+    }
+    return false;
+}
+
+//# 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  } else {\n    return true;\n  }\n  return false;\n}\n"],"names":["ensureNativeProjectAsync","projectRoot","platform","install","profile","promptToClearMalformedNativeProjectsAsync","fs","existsSync","path","join","prebuildAsync","platforms"],"mappings":";;;;+BAQsBA;;;eAAAA;;;;gEAPP;;;;;;;gEACE;;;;;;mCAEyC;+BAC5B;yBACN;;;;;;AAEjB,eAAeA,yBACpBC,WAAmB,EACnB,EAAEC,QAAQ,EAAEC,OAAO,EAAgD;IAEnE,oIAAoI;IACpI,uGAAuG;IACvG,MAAMC,IAAAA,gBAAO,EAACC,4DAAyC,EAAEJ,aAAa;QAACC;KAAS;IAEhF,0DAA0D;IAC1D,IAAI,CAACI,aAAE,CAACC,UAAU,CAACC,eAAI,CAACC,IAAI,CAACR,aAAaC,YAAY;QACpD,MAAMQ,IAAAA,4BAAa,EAACT,aAAa;YAC/BE,SAAS,CAAC,CAACA;YACXQ,WAAW;gBAACT;aAAS;QACvB;IACF,OAAO;QACL,OAAO;IACT;IACA,OAAO;AACT"}

package/build/src/run/hints.js

@@ -0,0 +1,46 @@
+"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, {
+    logDeviceArgument: function() {
+        return logDeviceArgument;
+    },
+    logPlatformRunCommand: function() {
+        return logPlatformRunCommand;
+    },
+    logProjectLogsLocation: function() {
+        return logProjectLogsLocation;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _log = require("../log");
+const _interactive = require("../utils/interactive");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function logDeviceArgument(id) {
+    _log.Log.log(_chalk().default.dim`› Using --device ${id}`);
+}
+function logPlatformRunCommand(platform, argv = []) {
+    _log.Log.log(_chalk().default.dim(`› Using expo run:${platform} ${argv.join(' ')}`));
+}
+function logProjectLogsLocation() {
+    _log.Log.log((0, _chalk().default)`\n› Logs for your project will appear below.${(0, _interactive.isInteractive)() ? _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 { isInteractive } from '../utils/interactive';\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 logPlatformRunCommand(platform: string, argv: string[] = []) {\n  Log.log(chalk.dim(`› Using expo run:${platform} ${argv.join(' ')}`));\n}\n\nexport function logProjectLogsLocation() {\n  Log.log(\n    chalk`\\n› Logs for your project will appear below.${\n      isInteractive() ? chalk.dim(` Press Ctrl+C to exit.`) : ''\n    }`\n  );\n}\n"],"names":["logDeviceArgument","logPlatformRunCommand","logProjectLogsLocation","id","Log","log","chalk","dim","platform","argv","join","isInteractive"],"mappings":";;;;;;;;;;;IAMgBA,iBAAiB;eAAjBA;;IAIAC,qBAAqB;eAArBA;;IAIAC,sBAAsB;eAAtBA;;;;gEAdE;;;;;;qBAEE;6BACU;;;;;;AAGvB,SAASF,kBAAkBG,EAAU;IAC1CC,QAAG,CAACC,GAAG,CAACC,gBAAK,CAACC,GAAG,CAAC,iBAAiB,EAAEJ,GAAG,CAAC;AAC3C;AAEO,SAASF,sBAAsBO,QAAgB,EAAEC,OAAiB,EAAE;IACzEL,QAAG,CAACC,GAAG,CAACC,gBAAK,CAACC,GAAG,CAAC,CAAC,iBAAiB,EAAEC,SAAS,CAAC,EAAEC,KAAKC,IAAI,CAAC,MAAM;AACpE;AAEO,SAASR;IACdE,QAAG,CAACC,GAAG,CACLC,IAAAA,gBAAK,CAAA,CAAC,4CAA4C,EAChDK,IAAAA,0BAAa,MAAKL,gBAAK,CAACC,GAAG,CAAC,CAAC,sBAAsB,CAAC,IAAI,GACzD,CAAC;AAEN"}

package/build/src/run/index.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "expoRun", {
+    enumerable: true,
+    get: function() {
+        return expoRun;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _hints = require("./hints");
+const _args = require("../utils/args");
+const _errors = require("../utils/errors");
+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 expoRun = async (argv)=>{
+    const args = (0, _args.assertWithOptionsArgs)({
+        // Types
+        '--help': Boolean,
+        // Aliases
+        '-h': '--help'
+    }, {
+        argv,
+        // Allow additional flags for both android and ios commands
+        permissive: true
+    });
+    try {
+        let [platform] = args._ ?? [];
+        // Workaround, filter `--flag` as platform
+        if (platform == null ? void 0 : platform.startsWith('-')) {
+            platform = '';
+        }
+        // Remove the platform from raw arguments, when provided
+        const argsWithoutPlatform = !platform ? argv : argv == null ? void 0 : argv.splice(1);
+        // Do not capture `--help` when platform is provided
+        if (!platform && args['--help']) {
+            (0, _args.printHelp)('Run the native app locally', `npx expo run <android|ios>`, (0, _chalk().default)`{dim $} npx expo run <android|ios> --help  Output usage information`);
+        }
+        if (!platform) {
+            const { selectAsync } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../utils/prompts.js")));
+            platform = await selectAsync('Select the platform to run', [
+                {
+                    title: 'Android',
+                    value: 'android'
+                },
+                {
+                    title: 'iOS',
+                    value: 'ios'
+                }
+            ]);
+        }
+        (0, _hints.logPlatformRunCommand)(platform, argsWithoutPlatform);
+        switch(platform){
+            case 'android':
+                {
+                    const { expoRunAndroid } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./android/index.js")));
+                    return expoRunAndroid(argsWithoutPlatform);
+                }
+            case 'ios':
+                {
+                    const { expoRunIos } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./ios/index.js")));
+                    return expoRunIos(argsWithoutPlatform);
+                }
+            default:
+                throw new _errors.CommandError('UNSUPPORTED_PLATFORM', `Unsupported platform: ${platform}`);
+        }
+    } catch (error) {
+        (0, _errors.logCmdError)(error);
+    }
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/run/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport chalk from 'chalk';\n\nimport { logPlatformRunCommand } from './hints';\nimport { Command } from '../../bin/cli';\nimport { assertWithOptionsArgs, printHelp } from '../utils/args';\nimport { CommandError, logCmdError } from '../utils/errors';\n\nexport const expoRun: Command = async (argv) => {\n  const args = assertWithOptionsArgs(\n    {\n      // Types\n      '--help': Boolean,\n      // Aliases\n      '-h': '--help',\n    },\n    {\n      argv,\n      // Allow additional flags for both android and ios commands\n      permissive: true,\n    }\n  );\n\n  try {\n    let [platform] = args._ ?? [];\n\n    // Workaround, filter `--flag` as platform\n    if (platform?.startsWith('-')) {\n      platform = '';\n    }\n\n    // Remove the platform from raw arguments, when provided\n    const argsWithoutPlatform = !platform ? argv : argv?.splice(1);\n\n    // Do not capture `--help` when platform is provided\n    if (!platform && args['--help']) {\n      printHelp(\n        'Run the native app locally',\n        `npx expo run <android|ios>`,\n        chalk`{dim $} npx expo run <android|ios> --help  Output usage information`\n      );\n    }\n\n    if (!platform) {\n      const { selectAsync } = await import('../utils/prompts.js');\n      platform = await selectAsync('Select the platform to run', [\n        { title: 'Android', value: 'android' },\n        { title: 'iOS', value: 'ios' },\n      ]);\n    }\n\n    logPlatformRunCommand(platform, argsWithoutPlatform);\n\n    switch (platform) {\n      case 'android': {\n        const { expoRunAndroid } = await import('./android/index.js');\n        return expoRunAndroid(argsWithoutPlatform);\n      }\n\n      case 'ios': {\n        const { expoRunIos } = await import('./ios/index.js');\n        return expoRunIos(argsWithoutPlatform);\n      }\n\n      default:\n        throw new CommandError('UNSUPPORTED_PLATFORM', `Unsupported platform: ${platform}`);\n    }\n  } catch (error: any) {\n    logCmdError(error);\n  }\n};\n"],"names":["expoRun","argv","args","assertWithOptionsArgs","Boolean","permissive","platform","_","startsWith","argsWithoutPlatform","splice","printHelp","chalk","selectAsync","title","value","logPlatformRunCommand","expoRunAndroid","expoRunIos","CommandError","error","logCmdError"],"mappings":";;;;;+BAQaA;;;eAAAA;;;;gEAPK;;;;;;uBAEoB;sBAEW;wBACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnC,MAAMA,UAAmB,OAAOC;IACrC,MAAMC,OAAOC,IAAAA,2BAAqB,EAChC;QACE,QAAQ;QACR,UAAUC;QACV,UAAU;QACV,MAAM;IACR,GACA;QACEH;QACA,2DAA2D;QAC3DI,YAAY;IACd;IAGF,IAAI;QACF,IAAI,CAACC,SAAS,GAAGJ,KAAKK,CAAC,IAAI,EAAE;QAE7B,0CAA0C;QAC1C,IAAID,4BAAAA,SAAUE,UAAU,CAAC,MAAM;YAC7BF,WAAW;QACb;QAEA,wDAAwD;QACxD,MAAMG,sBAAsB,CAACH,WAAWL,OAAOA,wBAAAA,KAAMS,MAAM,CAAC;QAE5D,oDAAoD;QACpD,IAAI,CAACJ,YAAYJ,IAAI,CAAC,SAAS,EAAE;YAC/BS,IAAAA,eAAS,EACP,8BACA,CAAC,0BAA0B,CAAC,EAC5BC,IAAAA,gBAAK,CAAA,CAAC,mEAAmE,CAAC;QAE9E;QAEA,IAAI,CAACN,UAAU;YACb,MAAM,EAAEO,WAAW,EAAE,GAAG,MAAM,mEAAA,QAAO;YACrCP,WAAW,MAAMO,YAAY,8BAA8B;gBACzD;oBAAEC,OAAO;oBAAWC,OAAO;gBAAU;gBACrC;oBAAED,OAAO;oBAAOC,OAAO;gBAAM;aAC9B;QACH;QAEAC,IAAAA,4BAAqB,EAACV,UAAUG;QAEhC,OAAQH;YACN,KAAK;gBAAW;oBACd,MAAM,EAAEW,cAAc,EAAE,GAAG,MAAM,mEAAA,QAAO;oBACxC,OAAOA,eAAeR;gBACxB;YAEA,KAAK;gBAAO;oBACV,MAAM,EAAES,UAAU,EAAE,GAAG,MAAM,mEAAA,QAAO;oBACpC,OAAOA,WAAWT;gBACpB;YAEA;gBACE,MAAM,IAAIU,oBAAY,CAAC,wBAAwB,CAAC,sBAAsB,EAAEb,UAAU;QACtF;IACF,EAAE,OAAOc,OAAY;QACnBC,IAAAA,mBAAW,EAACD;IACd;AACF"}

package/build/src/run/ios/XcodeBuild.js

@@ -0,0 +1,382 @@
+"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, {
+    _assertXcodeBuildResults: function() {
+        return _assertXcodeBuildResults;
+    },
+    buildAsync: function() {
+        return buildAsync;
+    },
+    extractEnvVariableFromBuild: function() {
+        return extractEnvVariableFromBuild;
+    },
+    getAppBinaryPath: function() {
+        return getAppBinaryPath;
+    },
+    getEscapedPath: function() {
+        return getEscapedPath;
+    },
+    getProcessOptions: function() {
+        return getProcessOptions;
+    },
+    getXcodeBuildArgsAsync: function() {
+        return getXcodeBuildArgsAsync;
+    },
+    logPrettyItem: function() {
+        return logPrettyItem;
+    },
+    matchEstimatedBinaryPath: function() {
+        return matchEstimatedBinaryPath;
+    }
+});
+function _xcpretty() {
+    const data = require("@expo/xcpretty");
+    _xcpretty = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _child_process() {
+    const data = require("child_process");
+    _child_process = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _os() {
+    const data = /*#__PURE__*/ _interop_require_default(require("os"));
+    _os = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _configureCodeSigning = require("./codeSigning/configureCodeSigning");
+const _simulatorCodeSigning = require("./codeSigning/simulatorCodeSigning");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../log"));
+const _dir = require("../../utils/dir");
+const _env = require("../../utils/env");
+const _errors = require("../../utils/errors");
+const _terminal = require("../../utils/terminal");
+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;
+}
+function logPrettyItem(message) {
+    _log.log((0, _chalk().default)`{whiteBright \u203A} ${message}`);
+}
+function matchEstimatedBinaryPath(buildOutput) {
+    // Match the full path that contains `/(.*)/Developer/Xcode/DerivedData/(.*)/Build/Products/(.*)/(.*).app`
+    const appBinaryPathMatch = buildOutput.match(/(\/(?:\\\s|[^ ])+\/Developer\/Xcode\/DerivedData\/(?:\\\s|[^ ])+\/Build\/Products\/(?:Debug|Release)-(?:[^\s/]+)\/(?:\\\s|[^ ])+\.app)/);
+    if (!(appBinaryPathMatch == null ? void 0 : appBinaryPathMatch.length)) {
+        throw new _errors.CommandError('XCODE_BUILD', `Malformed xcodebuild results: app binary path was not generated in build output. Report this issue and run your project with Xcode instead.`);
+    } else {
+        // Sort for the shortest
+        const shortestPath = appBinaryPathMatch.filter((a)=>typeof a === 'string' && a).sort((a, b)=>a.length - b.length)[0].trim();
+        _log.debug(`Found app binary path: ${shortestPath}`);
+        return shortestPath;
+    }
+}
+function getAppBinaryPath(buildOutput) {
+    // Matches what's used in "Bundle React Native code and images" script.
+    // Requires that `-hideShellScriptEnvironment` is not included in the build command (extra logs).
+    try {
+        // Like `\=/Users/evanbacon/Library/Developer/Xcode/DerivedData/Exponent-anpuosnglkxokahjhfszejloqfvo/Build/Products/Debug-iphonesimulator`
+        const CONFIGURATION_BUILD_DIR = extractEnvVariableFromBuild(buildOutput, 'CONFIGURATION_BUILD_DIR').sort(// Longer name means more suffixes, we want the shortest possible one to be first.
+        // Massive projects (like Expo Go) can sometimes print multiple different sets of environment variables.
+        // This can become an issue with some
+        (a, b)=>a.length - b.length);
+        // Like `Exponent.app`
+        const UNLOCALIZED_RESOURCES_FOLDER_PATH = extractEnvVariableFromBuild(buildOutput, 'UNLOCALIZED_RESOURCES_FOLDER_PATH');
+        const binaryPath = _path().default.join(// Use the shortest defined env variable (usually there's just one).
+        CONFIGURATION_BUILD_DIR[0], // Use the last defined env variable.
+        UNLOCALIZED_RESOURCES_FOLDER_PATH[UNLOCALIZED_RESOURCES_FOLDER_PATH.length - 1]);
+        // If the app has a space in the name it'll fail because it isn't escaped properly by Xcode.
+        return getEscapedPath(binaryPath);
+    } catch (error) {
+        if (error instanceof _errors.CommandError && error.code === 'XCODE_BUILD') {
+            const possiblePath = matchEstimatedBinaryPath(buildOutput);
+            if (possiblePath) {
+                return possiblePath;
+            }
+        }
+        throw error;
+    }
+}
+function getEscapedPath(filePath) {
+    if (_fs().default.existsSync(filePath)) {
+        return filePath;
+    }
+    const unescapedPath = filePath.split(/\\ /).join(' ');
+    if (_fs().default.existsSync(unescapedPath)) {
+        return unescapedPath;
+    }
+    throw new _errors.CommandError('XCODE_BUILD', `Unexpected: Generated app at path "${filePath}" cannot be read, the app cannot be installed. Report this and build onto a simulator.`);
+}
+function extractEnvVariableFromBuild(buildOutput, variableName) {
+    // Xcode can sometimes escape `=` with a backslash or put the value in quotes
+    const reg = new RegExp(`export ${variableName}\\\\?=(.*)$`, 'mg');
+    const matched = [
+        ...buildOutput.matchAll(reg)
+    ];
+    if (!matched || !matched.length) {
+        throw new _errors.CommandError('XCODE_BUILD', `Malformed xcodebuild results: "${variableName}" variable was not generated in build output. Report this issue and run your project with Xcode instead.`);
+    }
+    return matched.map((value)=>value[1]).filter(Boolean);
+}
+function getProcessOptions({ packager, shouldSkipInitialBundling, terminal, port, eagerBundleOptions }) {
+    const SKIP_BUNDLING = shouldSkipInitialBundling ? '1' : undefined;
+    if (packager) {
+        return {
+            env: {
+                ...process.env,
+                RCT_TERMINAL: terminal,
+                SKIP_BUNDLING,
+                RCT_METRO_PORT: port.toString(),
+                __EXPO_EAGER_BUNDLE_OPTIONS: eagerBundleOptions
+            }
+        };
+    }
+    return {
+        env: {
+            ...process.env,
+            RCT_TERMINAL: terminal,
+            SKIP_BUNDLING,
+            __EXPO_EAGER_BUNDLE_OPTIONS: eagerBundleOptions,
+            // Always skip launching the packager from a build script.
+            // The script is used for people building their project directly from Xcode.
+            // This essentially means "› Running script 'Start Packager'" does nothing.
+            RCT_NO_LAUNCH_PACKAGER: 'true'
+        }
+    };
+}
+async function getXcodeBuildArgsAsync(props) {
+    const args = [
+        props.xcodeProject.isWorkspace ? '-workspace' : '-project',
+        props.xcodeProject.name,
+        '-configuration',
+        props.configuration,
+        '-scheme',
+        props.scheme,
+        '-destination',
+        `id=${props.device.udid}`
+    ];
+    if (!props.isSimulator || (0, _simulatorCodeSigning.simulatorBuildRequiresCodeSigning)(props.projectRoot)) {
+        const developmentTeamId = await (0, _configureCodeSigning.ensureDeviceIsCodeSignedForDeploymentAsync)(props.projectRoot);
+        if (developmentTeamId) {
+            args.push(`DEVELOPMENT_TEAM=${developmentTeamId}`, '-allowProvisioningUpdates', '-allowProvisioningDeviceRegistration');
+        }
+    }
+    // Add last
+    if (props.buildCache === false) {
+        args.push(// Will first clean the derived data folder.
+        'clean', // Then build step must be added otherwise the process will simply clean and exit.
+        'build');
+    }
+    return args;
+}
+function spawnXcodeBuild(args, options, { onData }) {
+    const buildProcess = (0, _child_process().spawn)('xcodebuild', args, options);
+    let results = '';
+    let error = '';
+    buildProcess.stdout.on('data', (data)=>{
+        const stringData = data.toString();
+        results += stringData;
+        onData(stringData);
+    });
+    buildProcess.stderr.on('data', (data)=>{
+        const stringData = data instanceof Buffer ? data.toString() : data;
+        error += stringData;
+    });
+    return new Promise(async (resolve, reject)=>{
+        buildProcess.on('close', (code)=>{
+            resolve({
+                code,
+                results,
+                error
+            });
+        });
+    });
+}
+async function spawnXcodeBuildWithFlush(args, options, { onFlush }) {
+    let currentBuffer = '';
+    // Data can be sent in chunks that would have no relevance to our regex
+    // this can cause massive slowdowns, so we need to ensure the data is complete before attempting to parse it.
+    function flushBuffer() {
+        if (!currentBuffer) {
+            return;
+        }
+        const data = currentBuffer;
+        // Reset buffer.
+        currentBuffer = '';
+        // Process data.
+        onFlush(data);
+    }
+    const data = await spawnXcodeBuild(args, options, {
+        onData (stringData) {
+            currentBuffer += stringData;
+            // Only flush the data if we have a full line.
+            if (currentBuffer.endsWith(_os().default.EOL)) {
+                flushBuffer();
+            }
+        }
+    });
+    // Flush log data at the end just in case we missed something.
+    flushBuffer();
+    return data;
+}
+async function spawnXcodeBuildWithFormat(args, options, { projectRoot, xcodeProject }) {
+    _log.debug(`  xcodebuild ${args.join(' ')}`);
+    logPrettyItem(_chalk().default.bold`Planning build`);
+    const formatter = _xcpretty().ExpoRunFormatter.create(projectRoot, {
+        xcodeProject,
+        isDebug: _env.env.EXPO_DEBUG
+    });
+    const results = await spawnXcodeBuildWithFlush(args, options, {
+        onFlush (data) {
+            // Process data.
+            for (const line of formatter.pipe(data)){
+                // Log parsed results.
+                _log.log(line);
+            }
+        }
+    });
+    _log.debug(`Exited with code: ${results.code}`);
+    if (// User cancelled with ctrl-c
+    results.code === null || // Build interrupted
+    results.code === 75) {
+        throw new _errors.AbortCommandError();
+    }
+    _log.log(formatter.getBuildSummary());
+    return {
+        ...results,
+        formatter
+    };
+}
+async function buildAsync(props) {
+    const args = await getXcodeBuildArgsAsync(props);
+    const { projectRoot, xcodeProject, shouldSkipInitialBundling, port, eagerBundleOptions } = props;
+    const { code, results, formatter, error } = await spawnXcodeBuildWithFormat(args, getProcessOptions({
+        packager: false,
+        terminal: (0, _terminal.getUserTerminal)(),
+        shouldSkipInitialBundling,
+        port,
+        eagerBundleOptions
+    }), {
+        projectRoot,
+        xcodeProject
+    });
+    const logFilePath = writeBuildLogs(projectRoot, results, error);
+    if (code !== 0) {
+        // Determine if the logger found any errors;
+        const wasErrorPresented = !!formatter.errors.length;
+        if (wasErrorPresented) {
+            // This has a flaw, if the user is missing a file, and there is a script error, only the missing file error will be shown.
+            // They will only see the script error if they fix the missing file and rerun.
+            // The flaw can be fixed by catching script errors in the custom logger.
+            throw new _errors.CommandError(`Failed to build iOS project. "xcodebuild" exited with error code ${code}.`);
+        }
+        _assertXcodeBuildResults(code, results, error, xcodeProject, logFilePath);
+    }
+    return results;
+}
+function _assertXcodeBuildResults(code, results, error, xcodeProject, logFilePath) {
+    var _error_match;
+    const errorTitle = `Failed to build iOS project. "xcodebuild" exited with error code ${code}.`;
+    const throwWithMessage = (message)=>{
+        throw new _errors.CommandError(`${errorTitle}\nTo view more error logs, try building the app with Xcode directly, by opening ${xcodeProject.name}.\n\n` + message + `Build logs written to ${_chalk().default.underline(logFilePath)}`);
+    };
+    const localizedError = (_error_match = error.match(/NSLocalizedFailure = "(.*)"/)) == null ? void 0 : _error_match[1];
+    if (localizedError) {
+        throwWithMessage(_chalk().default.bold(localizedError) + '\n\n');
+    }
+    // Show all the log info because often times the error is coming from a shell script,
+    // that invoked a node script, that started metro, which threw an error.
+    throwWithMessage(results + '\n\n' + error);
+}
+function writeBuildLogs(projectRoot, buildOutput, errorOutput) {
+    const [logFilePath, errorFilePath] = getErrorLogFilePath(projectRoot);
+    _fs().default.writeFileSync(logFilePath, buildOutput);
+    _fs().default.writeFileSync(errorFilePath, errorOutput);
+    return logFilePath;
+}
+function getErrorLogFilePath(projectRoot) {
+    const folder = _path().default.join(projectRoot, '.expo');
+    (0, _dir.ensureDirectory)(folder);
+    return [
+        _path().default.join(folder, 'xcodebuild.log'),
+        _path().default.join(folder, 'xcodebuild-error.log')
+    ];
+}
+
+//# sourceMappingURL=XcodeBuild.js.map