@depup/expo__cli 55.0.16-depup.0

package/build/src/serve/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "expoServe", {
+    enumerable: true,
+    get: function() {
+        return expoServe;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _args = require("../utils/args");
+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 expoServe = async (argv)=>{
+    const args = (0, _args.assertArgs)({
+        // Types
+        '--help': Boolean,
+        '--port': Number,
+        // Aliases
+        '-h': '--help'
+    }, argv);
+    if (args['--help']) {
+        (0, _args.printHelp)(`Host the production server locally`, (0, _chalk().default)`npx expo serve {dim <dir>}`, [
+            (0, _chalk().default)`<dir>            Directory of the Expo project. {dim Default: Current working directory}`,
+            `--port <number>  Port to host the server on`,
+            `-h, --help       Usage info`
+        ].join('\n'));
+    }
+    // Load modules after the help prompt so `npx expo config -h` shows as fast as possible.
+    const [// ./configAsync
+    { serveAsync }, // ../utils/errors
+    { logCmdError }] = await Promise.all([
+        Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./serveAsync.js"))),
+        Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../utils/errors.js")))
+    ]);
+    return serveAsync((0, _args.getProjectRoot)(args), {
+        isDefaultDirectory: !args._[0],
+        // Parsed options
+        port: args['--port']
+    }).catch(logCmdError);
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/serve/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport chalk from 'chalk';\n\nimport { Command } from '../../bin/cli';\nimport { assertArgs, getProjectRoot, printHelp } from '../utils/args';\n\nexport const expoServe: Command = async (argv) => {\n  const args = assertArgs(\n    {\n      // Types\n      '--help': Boolean,\n      '--port': Number,\n\n      // Aliases\n      '-h': '--help',\n    },\n    argv\n  );\n\n  if (args['--help']) {\n    printHelp(\n      `Host the production server locally`,\n      chalk`npx expo serve {dim <dir>}`,\n      [\n        chalk`<dir>            Directory of the Expo project. {dim Default: Current working directory}`,\n        `--port <number>  Port to host the server on`,\n        `-h, --help       Usage info`,\n      ].join('\\n')\n    );\n  }\n\n  // Load modules after the help prompt so `npx expo config -h` shows as fast as possible.\n  const [\n    // ./configAsync\n    { serveAsync },\n    // ../utils/errors\n    { logCmdError },\n  ] = await Promise.all([import('./serveAsync.js'), import('../utils/errors.js')]);\n\n  return serveAsync(getProjectRoot(args), {\n    isDefaultDirectory: !args._[0],\n    // Parsed options\n    port: args['--port'],\n  }).catch(logCmdError);\n};\n"],"names":["expoServe","argv","args","assertArgs","Boolean","Number","printHelp","chalk","join","serveAsync","logCmdError","Promise","all","getProjectRoot","isDefaultDirectory","_","port","catch"],"mappings":";;;;;+BAMaA;;;eAAAA;;;;gEALK;;;;;;sBAGoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/C,MAAMA,YAAqB,OAAOC;IACvC,MAAMC,OAAOC,IAAAA,gBAAU,EACrB;QACE,QAAQ;QACR,UAAUC;QACV,UAAUC;QAEV,UAAU;QACV,MAAM;IACR,GACAJ;IAGF,IAAIC,IAAI,CAAC,SAAS,EAAE;QAClBI,IAAAA,eAAS,EACP,CAAC,kCAAkC,CAAC,EACpCC,IAAAA,gBAAK,CAAA,CAAC,0BAA0B,CAAC,EACjC;YACEA,IAAAA,gBAAK,CAAA,CAAC,wFAAwF,CAAC;YAC/F,CAAC,2CAA2C,CAAC;YAC7C,CAAC,2BAA2B,CAAC;SAC9B,CAACC,IAAI,CAAC;IAEX;IAEA,wFAAwF;IACxF,MAAM,CACJ,gBAAgB;IAChB,EAAEC,UAAU,EAAE,EACd,kBAAkB;IAClB,EAAEC,WAAW,EAAE,CAChB,GAAG,MAAMC,QAAQC,GAAG,CAAC;QAAC,mEAAA,QAAO;QAAoB,mEAAA,QAAO;KAAsB;IAE/E,OAAOH,WAAWI,IAAAA,oBAAc,EAACX,OAAO;QACtCY,oBAAoB,CAACZ,KAAKa,CAAC,CAAC,EAAE;QAC9B,iBAAiB;QACjBC,MAAMd,IAAI,CAAC,SAAS;IACtB,GAAGe,KAAK,CAACP;AACX"}

package/build/src/serve/serveAsync.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serveAsync", {
+    enumerable: true,
+    get: function() {
+        return serveAsync;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _connect() {
+    const data = /*#__PURE__*/ _interop_require_default(require("connect"));
+    _connect = function() {
+        return data;
+    };
+    return data;
+}
+function _http() {
+    const data = require("expo-server/adapter/http");
+    _http = function() {
+        return data;
+    };
+    return data;
+}
+function _http1() {
+    const data = /*#__PURE__*/ _interop_require_default(require("http"));
+    _http1 = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _send() {
+    const data = /*#__PURE__*/ _interop_require_default(require("send"));
+    _send = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../log"));
+const _dir = require("../utils/dir");
+const _errors = require("../utils/errors");
+const _findUp = require("../utils/findUp");
+const _nodeEnv = require("../utils/nodeEnv");
+const _port = require("../utils/port");
+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:serve');
+async function serveAsync(inputDir, options) {
+    const projectRoot = (0, _findUp.findUpProjectRootOrAssert)(inputDir);
+    (0, _nodeEnv.setNodeEnv)('production');
+    (0, _nodeEnv.loadEnvFiles)(projectRoot);
+    const port = await (0, _port.resolvePortAsync)(projectRoot, {
+        defaultPort: options.port,
+        fallbackPort: 8081
+    });
+    if (port == null) {
+        throw new _errors.CommandError('Could not start server. Port is not available.');
+    }
+    options.port = port;
+    const serverDist = options.isDefaultDirectory ? _path().default.join(inputDir, 'dist') : inputDir;
+    //  TODO: `.expo/server/ios`, `.expo/server/android`, etc.
+    if (!await (0, _dir.directoryExistsAsync)(serverDist)) {
+        throw new _errors.CommandError(`The server directory ${serverDist} does not exist. Run \`npx expo export\` first.`);
+    }
+    const isStatic = await isStaticExportAsync(serverDist);
+    _log.log(_chalk().default.dim(`Starting ${isStatic ? 'static ' : ''}server in ${serverDist}`));
+    if (isStatic) {
+        await startStaticServerAsync(serverDist, options);
+    } else {
+        await startDynamicServerAsync(serverDist, options);
+    }
+    _log.log(`Server running at http://localhost:${options.port}`);
+// Detect the type of server we need to setup:
+}
+async function startStaticServerAsync(dist, options) {
+    const server = _http1().default.createServer((req, res)=>{
+        var _req_url;
+        // Remove query strings and decode URI
+        const filePath = decodeURI(((_req_url = req.url) == null ? void 0 : _req_url.split('?')[0]) ?? '');
+        (0, _send().default)(req, filePath, {
+            root: dist,
+            index: 'index.html',
+            extensions: [
+                'html'
+            ]
+        }).on('error', (err)=>{
+            if (err.status === 404) {
+                res.statusCode = 404;
+                res.end('Not Found');
+                return;
+            }
+            res.statusCode = err.status || 500;
+            res.end('Internal Server Error');
+        }).pipe(res);
+    });
+    server.listen(options.port);
+}
+async function startDynamicServerAsync(dist, options) {
+    const middleware = (0, _connect().default)();
+    const staticDirectory = _path().default.join(dist, 'client');
+    const serverDirectory = _path().default.join(dist, 'server');
+    const serverHandler = (0, _http().createRequestHandler)({
+        build: serverDirectory
+    });
+    // DOM component CORS support
+    middleware.use((req, res, next)=>{
+        // TODO: Only when origin is `file://` (iOS), and Android equivalent.
+        // Required for DOM components security in release builds.
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, expo-platform');
+        // Handle OPTIONS preflight requests
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 200;
+            res.end();
+            return;
+        }
+        next();
+    });
+    middleware.use((req, res, next)=>{
+        if (!(req == null ? void 0 : req.url) || req.method !== 'GET' && req.method !== 'HEAD') {
+            return next();
+        }
+        const pathname = canParseURL(req.url) ? new URL(req.url).pathname : req.url;
+        if (!pathname) {
+            return next();
+        }
+        debug(`Maybe serve static:`, pathname);
+        const stream = (0, _send().default)(req, pathname, {
+            root: staticDirectory,
+            extensions: [
+                'html'
+            ]
+        });
+        // add file listener for fallthrough
+        let forwardError = false;
+        stream.on('file', function onFile() {
+            // once file is determined, always forward error
+            forwardError = true;
+        });
+        // forward errors
+        stream.on('error', function error(err) {
+            if (forwardError || !(err.statusCode < 500)) {
+                next(err);
+                return;
+            }
+            next();
+        });
+        // pipe
+        stream.pipe(res);
+    });
+    middleware.use(serverHandler);
+    middleware.listen(options.port);
+}
+function canParseURL(url) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(url);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function isStaticExportAsync(dist) {
+    const routesFile = _path().default.join(dist, `server/_expo/routes.json`);
+    return !await (0, _dir.fileExistsAsync)(routesFile);
+}
+
+//# sourceMappingURL=serveAsync.js.map

package/build/src/serve/serveAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/serve/serveAsync.ts"],"sourcesContent":["import chalk from 'chalk';\nimport connect from 'connect';\nimport { createRequestHandler } from 'expo-server/adapter/http';\nimport http from 'http';\nimport path from 'path';\nimport send from 'send';\n\nimport * as Log from '../log';\nimport { directoryExistsAsync, fileExistsAsync } from '../utils/dir';\nimport { CommandError } from '../utils/errors';\nimport { findUpProjectRootOrAssert } from '../utils/findUp';\nimport { setNodeEnv, loadEnvFiles } from '../utils/nodeEnv';\nimport { resolvePortAsync } from '../utils/port';\n\ntype Options = {\n  port?: number;\n  isDefaultDirectory: boolean;\n};\n\nconst debug = require('debug')('expo:serve') as typeof console.log;\n\n// Start a basic http server\nexport async function serveAsync(inputDir: string, options: Options) {\n  const projectRoot = findUpProjectRootOrAssert(inputDir);\n\n  setNodeEnv('production');\n  loadEnvFiles(projectRoot);\n\n  const port = await resolvePortAsync(projectRoot, {\n    defaultPort: options.port,\n    fallbackPort: 8081,\n  });\n\n  if (port == null) {\n    throw new CommandError('Could not start server. Port is not available.');\n  }\n  options.port = port;\n\n  const serverDist = options.isDefaultDirectory ? path.join(inputDir, 'dist') : inputDir;\n  //  TODO: `.expo/server/ios`, `.expo/server/android`, etc.\n\n  if (!(await directoryExistsAsync(serverDist))) {\n    throw new CommandError(\n      `The server directory ${serverDist} does not exist. Run \\`npx expo export\\` first.`\n    );\n  }\n\n  const isStatic = await isStaticExportAsync(serverDist);\n\n  Log.log(chalk.dim(`Starting ${isStatic ? 'static ' : ''}server in ${serverDist}`));\n\n  if (isStatic) {\n    await startStaticServerAsync(serverDist, options);\n  } else {\n    await startDynamicServerAsync(serverDist, options);\n  }\n  Log.log(`Server running at http://localhost:${options.port}`);\n  // Detect the type of server we need to setup:\n}\n\nasync function startStaticServerAsync(dist: string, options: Options) {\n  const server = http.createServer((req, res) => {\n    // Remove query strings and decode URI\n    const filePath = decodeURI(req.url?.split('?')[0] ?? '');\n\n    send(req, filePath, {\n      root: dist,\n      index: 'index.html',\n      extensions: ['html'],\n    })\n      .on('error', (err: any) => {\n        if (err.status === 404) {\n          res.statusCode = 404;\n          res.end('Not Found');\n          return;\n        }\n        res.statusCode = err.status || 500;\n        res.end('Internal Server Error');\n      })\n      .pipe(res);\n  });\n\n  server.listen(options.port!);\n}\n\nasync function startDynamicServerAsync(dist: string, options: Options) {\n  const middleware = connect();\n\n  const staticDirectory = path.join(dist, 'client');\n  const serverDirectory = path.join(dist, 'server');\n\n  const serverHandler = createRequestHandler({ build: serverDirectory });\n\n  // DOM component CORS support\n  middleware.use((req, res, next) => {\n    // TODO: Only when origin is `file://` (iOS), and Android equivalent.\n\n    // Required for DOM components security in release builds.\n\n    res.setHeader('Access-Control-Allow-Origin', '*');\n    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');\n    res.setHeader(\n      'Access-Control-Allow-Headers',\n      'Origin, X-Requested-With, Content-Type, Accept, expo-platform'\n    );\n\n    // Handle OPTIONS preflight requests\n    if (req.method === 'OPTIONS') {\n      res.statusCode = 200;\n      res.end();\n      return;\n    }\n    next();\n  });\n\n  middleware.use((req, res, next) => {\n    if (!req?.url || (req.method !== 'GET' && req.method !== 'HEAD')) {\n      return next();\n    }\n\n    const pathname = canParseURL(req.url) ? new URL(req.url).pathname : req.url;\n    if (!pathname) {\n      return next();\n    }\n\n    debug(`Maybe serve static:`, pathname);\n\n    const stream = send(req, pathname, {\n      root: staticDirectory,\n      extensions: ['html'],\n    });\n\n    // add file listener for fallthrough\n    let forwardError = false;\n    stream.on('file', function onFile() {\n      // once file is determined, always forward error\n      forwardError = true;\n    });\n\n    // forward errors\n    stream.on('error', function error(err: any) {\n      if (forwardError || !(err.statusCode < 500)) {\n        next(err);\n        return;\n      }\n\n      next();\n    });\n\n    // pipe\n    stream.pipe(res);\n  });\n\n  middleware.use(serverHandler);\n\n  middleware.listen(options.port!);\n}\n\nfunction canParseURL(url: string): boolean {\n  try {\n    // eslint-disable-next-line no-new\n    new URL(url);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function isStaticExportAsync(dist: string): Promise<boolean> {\n  const routesFile = path.join(dist, `server/_expo/routes.json`);\n  return !(await fileExistsAsync(routesFile));\n}\n"],"names":["serveAsync","debug","require","inputDir","options","projectRoot","findUpProjectRootOrAssert","setNodeEnv","loadEnvFiles","port","resolvePortAsync","defaultPort","fallbackPort","CommandError","serverDist","isDefaultDirectory","path","join","directoryExistsAsync","isStatic","isStaticExportAsync","Log","log","chalk","dim","startStaticServerAsync","startDynamicServerAsync","dist","server","http","createServer","req","res","filePath","decodeURI","url","split","send","root","index","extensions","on","err","status","statusCode","end","pipe","listen","middleware","connect","staticDirectory","serverDirectory","serverHandler","createRequestHandler","build","use","next","setHeader","method","pathname","canParseURL","URL","stream","forwardError","onFile","error","routesFile","fileExistsAsync"],"mappings":"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"}

package/build/src/start/detectDevClient.js

@@ -0,0 +1,53 @@
+"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, {
+    canResolveDevClient: function() {
+        return canResolveDevClient;
+    },
+    hasDirectDevClientDependency: function() {
+        return hasDirectDevClientDependency;
+    }
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
+    _resolvefrom = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function hasDirectDevClientDependency(projectRoot) {
+    const { dependencies = {}, devDependencies = {} } = (0, _config().getPackageJson)(projectRoot);
+    return !!dependencies['expo-dev-client'] || !!devDependencies['expo-dev-client'];
+}
+function canResolveDevClient(projectRoot) {
+    try {
+        // we check if `expo-dev-launcher` is installed instead of `expo-dev-client`
+        // because someone could install only launcher.
+        (0, _resolvefrom().default)(projectRoot, 'expo-dev-launcher');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=detectDevClient.js.map

package/build/src/start/detectDevClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/start/detectDevClient.ts"],"sourcesContent":["import { getPackageJson } from '@expo/config';\nimport resolveFrom from 'resolve-from';\n\nexport function hasDirectDevClientDependency(projectRoot: string): boolean {\n  const { dependencies = {}, devDependencies = {} } = getPackageJson(projectRoot);\n  return !!dependencies['expo-dev-client'] || !!devDependencies['expo-dev-client'];\n}\n\nexport function canResolveDevClient(projectRoot: string): boolean {\n  try {\n    // we check if `expo-dev-launcher` is installed instead of `expo-dev-client`\n    // because someone could install only launcher.\n    resolveFrom(projectRoot, 'expo-dev-launcher');\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"names":["canResolveDevClient","hasDirectDevClientDependency","projectRoot","dependencies","devDependencies","getPackageJson","resolveFrom"],"mappings":";;;;;;;;;;;IAQgBA,mBAAmB;eAAnBA;;IALAC,4BAA4B;eAA5BA;;;;yBAHe;;;;;;;gEACP;;;;;;;;;;;AAEjB,SAASA,6BAA6BC,WAAmB;IAC9D,MAAM,EAAEC,eAAe,CAAC,CAAC,EAAEC,kBAAkB,CAAC,CAAC,EAAE,GAAGC,IAAAA,wBAAc,EAACH;IACnE,OAAO,CAAC,CAACC,YAAY,CAAC,kBAAkB,IAAI,CAAC,CAACC,eAAe,CAAC,kBAAkB;AAClF;AAEO,SAASJ,oBAAoBE,WAAmB;IACrD,IAAI;QACF,4EAA4E;QAC5E,+CAA+C;QAC/CI,IAAAA,sBAAW,EAACJ,aAAa;QACzB,OAAO;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/build/src/start/doctor/Prerequisite.js

@@ -0,0 +1,60 @@
+"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, {
+    Prerequisite: function() {
+        return Prerequisite;
+    },
+    PrerequisiteCommandError: function() {
+        return PrerequisiteCommandError;
+    },
+    ProjectPrerequisite: function() {
+        return ProjectPrerequisite;
+    }
+});
+const _errors = require("../../utils/errors");
+const _fn = require("../../utils/fn");
+class PrerequisiteCommandError extends _errors.CommandError {
+    constructor(code, message = ''){
+        super(message ? 'VALIDATE_' + code : code, message);
+    }
+}
+class Prerequisite {
+    constructor(){
+        this._assertAsync = (0, _fn.memoize)(this.assertImplementation.bind(this));
+    }
+    /** Reset the assertion memo and warning message. */ resetAssertion(props) {
+        this.cachedError = undefined;
+        this._assertAsync = (0, _fn.memoize)(this.assertImplementation.bind(this));
+    }
+    async assertAsync(props) {
+        if (this.cachedError) {
+            throw this.cachedError;
+        }
+        try {
+            return await this._assertAsync(props);
+        } catch (error) {
+            if (error instanceof PrerequisiteCommandError) {
+                this.cachedError = error;
+            }
+            throw error;
+        }
+    }
+    /** Exposed for testing. */ async assertImplementation(props) {
+        throw new _errors.UnimplementedError();
+    }
+}
+class ProjectPrerequisite extends Prerequisite {
+    constructor(projectRoot){
+        super(), this.projectRoot = projectRoot;
+    }
+}
+
+//# sourceMappingURL=Prerequisite.js.map

package/build/src/start/doctor/Prerequisite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/start/doctor/Prerequisite.ts"],"sourcesContent":["import { CommandError, UnimplementedError } from '../../utils/errors';\nimport { memoize } from '../../utils/fn';\n\n/** An error that is memoized and asserted whenever a Prerequisite.assertAsync is subsequently called. */\nexport class PrerequisiteCommandError extends CommandError {\n  constructor(code: string, message: string = '') {\n    super(message ? 'VALIDATE_' + code : code, message);\n  }\n}\n\nexport class Prerequisite<T = void, TProps = void> {\n  /** Memoized results of `assertImplementation` */\n  private _assertAsync: (props: TProps) => Promise<T>;\n\n  constructor() {\n    this._assertAsync = memoize(this.assertImplementation.bind(this));\n  }\n\n  /** An optional warning to call before running the memoized assertion.  */\n  protected cachedError?: PrerequisiteCommandError;\n\n  /** Reset the assertion memo and warning message. */\n  public resetAssertion(props: TProps) {\n    this.cachedError = undefined;\n    this._assertAsync = memoize(this.assertImplementation.bind(this));\n  }\n\n  async assertAsync(props: TProps): Promise<T> {\n    if (this.cachedError) {\n      throw this.cachedError;\n    }\n    try {\n      return await this._assertAsync(props);\n    } catch (error) {\n      if (error instanceof PrerequisiteCommandError) {\n        this.cachedError = error;\n      }\n      throw error;\n    }\n  }\n\n  /** Exposed for testing. */\n  async assertImplementation(props: TProps): Promise<T> {\n    throw new UnimplementedError();\n  }\n}\n\n/** A prerequisite that is project specific. */\nexport class ProjectPrerequisite<T = void, TProps = void> extends Prerequisite<T, TProps> {\n  constructor(protected projectRoot: string) {\n    super();\n  }\n}\n"],"names":["Prerequisite","PrerequisiteCommandError","ProjectPrerequisite","CommandError","constructor","code","message","_assertAsync","memoize","assertImplementation","bind","resetAssertion","props","cachedError","undefined","assertAsync","error","UnimplementedError","projectRoot"],"mappings":";;;;;;;;;;;IAUaA,YAAY;eAAZA;;IANAC,wBAAwB;eAAxBA;;IA4CAC,mBAAmB;eAAnBA;;;wBAhDoC;oBACzB;AAGjB,MAAMD,iCAAiCE,oBAAY;IACxDC,YAAYC,IAAY,EAAEC,UAAkB,EAAE,CAAE;QAC9C,KAAK,CAACA,UAAU,cAAcD,OAAOA,MAAMC;IAC7C;AACF;AAEO,MAAMN;IAIXI,aAAc;QACZ,IAAI,CAACG,YAAY,GAAGC,IAAAA,WAAO,EAAC,IAAI,CAACC,oBAAoB,CAACC,IAAI,CAAC,IAAI;IACjE;IAKA,kDAAkD,GAClD,AAAOC,eAAeC,KAAa,EAAE;QACnC,IAAI,CAACC,WAAW,GAAGC;QACnB,IAAI,CAACP,YAAY,GAAGC,IAAAA,WAAO,EAAC,IAAI,CAACC,oBAAoB,CAACC,IAAI,CAAC,IAAI;IACjE;IAEA,MAAMK,YAAYH,KAAa,EAAc;QAC3C,IAAI,IAAI,CAACC,WAAW,EAAE;YACpB,MAAM,IAAI,CAACA,WAAW;QACxB;QACA,IAAI;YACF,OAAO,MAAM,IAAI,CAACN,YAAY,CAACK;QACjC,EAAE,OAAOI,OAAO;YACd,IAAIA,iBAAiBf,0BAA0B;gBAC7C,IAAI,CAACY,WAAW,GAAGG;YACrB;YACA,MAAMA;QACR;IACF;IAEA,yBAAyB,GACzB,MAAMP,qBAAqBG,KAAa,EAAc;QACpD,MAAM,IAAIK,0BAAkB;IAC9B;AACF;AAGO,MAAMf,4BAAqDF;IAChEI,YAAY,AAAUc,WAAmB,CAAE;QACzC,KAAK,SADeA,cAAAA;IAEtB;AACF"}

package/build/src/start/doctor/SecurityBinPrerequisite.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SecurityBinPrerequisite", {
+    enumerable: true,
+    get: function() {
+        return SecurityBinPrerequisite;
+    }
+});
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = function() {
+        return data;
+    };
+    return data;
+}
+const _Prerequisite = require("./Prerequisite");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class SecurityBinPrerequisite extends _Prerequisite.Prerequisite {
+    static #_ = this.instance = new SecurityBinPrerequisite();
+    async assertImplementation() {
+        try {
+            // make sure we can run security
+            await (0, _spawnasync().default)('which', [
+                'security'
+            ]);
+        } catch  {
+            throw new _Prerequisite.PrerequisiteCommandError('SECURITY_BIN', "Cannot code sign project because the CLI `security` is not available on your computer.\nEnsure it's installed and try again.");
+        }
+    }
+}
+
+//# sourceMappingURL=SecurityBinPrerequisite.js.map

package/build/src/start/doctor/SecurityBinPrerequisite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/start/doctor/SecurityBinPrerequisite.ts"],"sourcesContent":["import spawnAsync from '@expo/spawn-async';\n\nimport { Prerequisite, PrerequisiteCommandError } from './Prerequisite';\n\nexport class SecurityBinPrerequisite extends Prerequisite {\n  static instance = new SecurityBinPrerequisite();\n\n  async assertImplementation(): Promise<void> {\n    try {\n      // make sure we can run security\n      await spawnAsync('which', ['security']);\n    } catch {\n      throw new PrerequisiteCommandError(\n        'SECURITY_BIN',\n        \"Cannot code sign project because the CLI `security` is not available on your computer.\\nEnsure it's installed and try again.\"\n      );\n    }\n  }\n}\n"],"names":["SecurityBinPrerequisite","Prerequisite","instance","assertImplementation","spawnAsync","PrerequisiteCommandError"],"mappings":";;;;+BAIaA;;;eAAAA;;;;gEAJU;;;;;;8BAEgC;;;;;;AAEhD,MAAMA,gCAAgCC,0BAAY;qBAChDC,WAAW,IAAIF;IAEtB,MAAMG,uBAAsC;QAC1C,IAAI;YACF,gCAAgC;YAChC,MAAMC,IAAAA,qBAAU,EAAC,SAAS;gBAAC;aAAW;QACxC,EAAE,OAAM;YACN,MAAM,IAAIC,sCAAwB,CAChC,gBACA;QAEJ;IACF;AACF"}

package/build/src/start/doctor/apple/SimulatorAppPrerequisite.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SimulatorAppPrerequisite", {
+    enumerable: true,
+    get: function() {
+        return SimulatorAppPrerequisite;
+    }
+});
+function _osascript() {
+    const data = require("@expo/osascript");
+    _osascript = function() {
+        return data;
+    };
+    return data;
+}
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = 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 _Prerequisite = require("../Prerequisite");
+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:doctor:apple:simulatorApp');
+/**
+ * Get the bundle ID of the Simulator.app via AppleScript / LaunchServices.
+ * May return null if the Simulator.app is not registered in LaunchServices
+ * (e.g. when Xcode lives on an external or renamed volume).
+ */ async function getSimulatorAppIdViaAppleScriptAsync() {
+    try {
+        return (await (0, _osascript().execAsync)('id of app "Simulator"')).trim();
+    } catch  {
+    // This error may occur in CI where the user intends to install just the simulators but no
+    // Xcode, or when Simulator.app is not registered in LaunchServices (e.g. Xcode on an
+    // external or renamed volume).
+    }
+    return null;
+}
+/**
+ * Fallback: locate Simulator.app via the active Xcode developer directory and read its
+ * CFBundleIdentifier directly from the app bundle's Info.plist.
+ * This works even when LaunchServices hasn't indexed Simulator.app.
+ */ async function getSimulatorAppIdFromBundleAsync() {
+    try {
+        const { stdout: developerDir } = await (0, _spawnasync().default)('xcode-select', [
+            '--print-path'
+        ]);
+        const simulatorInfoPlist = _path().default.join(developerDir.trim(), 'Applications', 'Simulator.app', 'Contents', 'Info.plist');
+        const { stdout: bundleId } = await (0, _spawnasync().default)('defaults', [
+            'read',
+            simulatorInfoPlist,
+            'CFBundleIdentifier'
+        ]);
+        return bundleId.trim() || null;
+    } catch  {
+    // Simulator.app not found at the expected path or xcode-select is unavailable.
+    }
+    return null;
+}
+async function getSimulatorAppIdAsync() {
+    return await getSimulatorAppIdViaAppleScriptAsync() ?? await getSimulatorAppIdFromBundleAsync();
+}
+class SimulatorAppPrerequisite extends _Prerequisite.Prerequisite {
+    static #_ = this.instance = new SimulatorAppPrerequisite();
+    async assertImplementation() {
+        const result = await getSimulatorAppIdAsync();
+        if (!result) {
+            // This error may occur in CI where the users intends to install just the simulators but no Xcode.
+            throw new _Prerequisite.PrerequisiteCommandError('SIMULATOR_APP', "Can't determine id of Simulator app; the Simulator is most likely not installed on this machine. Run `sudo xcode-select -s /Applications/Xcode.app`");
+        }
+        if (result !== 'com.apple.iphonesimulator' && result !== 'com.apple.CoreSimulator.SimulatorTrampoline') {
+            throw new _Prerequisite.PrerequisiteCommandError('SIMULATOR_APP', "Simulator is installed but is identified as '" + result + "'; don't know what that is.");
+        }
+        debug(`Simulator app id: ${result}`);
+        try {
+            // make sure we can run simctl
+            await (0, _spawnasync().default)('xcrun', [
+                'simctl',
+                'help'
+            ]);
+        } catch (error) {
+            _log.warn(`Unable to run simctl:\n${error.toString()}`);
+            throw new _Prerequisite.PrerequisiteCommandError('SIMCTL', 'xcrun is not configured correctly. Ensure `sudo xcode-select --reset` works before running this command again.');
+        }
+    }
+}
+
+//# sourceMappingURL=SimulatorAppPrerequisite.js.map