@depup/expo__cli 55.0.16-depup.0

package/build/src/run/ios/codeSigning/Security.js

@@ -0,0 +1,116 @@
+"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, {
+    extractCodeSigningInfo: function() {
+        return extractCodeSigningInfo;
+    },
+    extractSigningId: function() {
+        return extractSigningId;
+    },
+    findIdentitiesAsync: function() {
+        return findIdentitiesAsync;
+    },
+    getCertificateForSigningIdAsync: function() {
+        return getCertificateForSigningIdAsync;
+    },
+    getSecurityPemAsync: function() {
+        return getSecurityPemAsync;
+    },
+    resolveCertificateSigningInfoAsync: function() {
+        return resolveCertificateSigningInfoAsync;
+    },
+    resolveIdentitiesAsync: function() {
+        return resolveIdentitiesAsync;
+    }
+});
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = function() {
+        return data;
+    };
+    return data;
+}
+function _nodeforge() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node-forge"));
+    _nodeforge = function() {
+        return data;
+    };
+    return data;
+}
+const _SecurityBinPrerequisite = require("../../../start/doctor/SecurityBinPrerequisite");
+const _errors = require("../../../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getSecurityPemAsync(id) {
+    var _stdout_trim, _stdout;
+    const pem = (_stdout = (await (0, _spawnasync().default)('security', [
+        'find-certificate',
+        '-c',
+        id,
+        '-p'
+    ])).stdout) == null ? void 0 : (_stdout_trim = _stdout.trim) == null ? void 0 : _stdout_trim.call(_stdout);
+    if (!pem) {
+        throw new _errors.CommandError(`Failed to get PEM certificate for ID "${id}" using the 'security' bin`);
+    }
+    return pem;
+}
+async function getCertificateForSigningIdAsync(id) {
+    const pem = await getSecurityPemAsync(id);
+    return _nodeforge().default.pki.certificateFromPem(pem);
+}
+async function findIdentitiesAsync() {
+    var _stdout_trim, _stdout;
+    await _SecurityBinPrerequisite.SecurityBinPrerequisite.instance.assertAsync();
+    const results = (_stdout_trim = (_stdout = (await (0, _spawnasync().default)('security', [
+        'find-identity',
+        '-p',
+        'codesigning',
+        '-v'
+    ])).stdout).trim) == null ? void 0 : _stdout_trim.call(_stdout);
+    // Returns a string like:
+    // 1) 12222234253761286351826735HGKDHAJGF45283 "Apple Development: Evan Bacon (AA00AABB0A)" (CSSMERR_TP_CERT_REVOKED)
+    // 2) 12312234253761286351826735HGKDHAJGF45283 "Apple Development: bacon@expo.io (BB00AABB0A)"
+    // 3) 12442234253761286351826735HGKDHAJGF45283 "iPhone Distribution: Evan Bacon (CC00AABB0B)" (CSSMERR_TP_CERT_REVOKED)
+    // 4) 15672234253761286351826735HGKDHAJGF45283 "Apple Development: Evan Bacon (AA00AABB0A)"
+    //  4 valid identities found
+    const parsed = results.split('\n').map((line)=>extractCodeSigningInfo(line)).filter(Boolean);
+    // Remove duplicates
+    return [
+        ...new Set(parsed)
+    ];
+}
+function extractCodeSigningInfo(value) {
+    var _value_match;
+    return ((_value_match = value.match(/^\s*\d+\).+"(.+Develop(ment|er).+)"$/)) == null ? void 0 : _value_match[1]) ?? null;
+}
+async function resolveIdentitiesAsync(identities) {
+    const values = identities.map(extractSigningId).filter(Boolean);
+    return Promise.all(values.map(resolveCertificateSigningInfoAsync));
+}
+async function resolveCertificateSigningInfoAsync(signingCertificateId) {
+    var _certificate_subject_getField, _certificate_subject_getField1, _certificate_subject_getField2;
+    const certificate = await getCertificateForSigningIdAsync(signingCertificateId);
+    return {
+        signingCertificateId,
+        codeSigningInfo: (_certificate_subject_getField = certificate.subject.getField('CN')) == null ? void 0 : _certificate_subject_getField.value,
+        appleTeamName: (_certificate_subject_getField1 = certificate.subject.getField('O')) == null ? void 0 : _certificate_subject_getField1.value,
+        appleTeamId: (_certificate_subject_getField2 = certificate.subject.getField('OU')) == null ? void 0 : _certificate_subject_getField2.value
+    };
+}
+function extractSigningId(codeSigningInfo) {
+    var _codeSigningInfo_match;
+    return ((_codeSigningInfo_match = codeSigningInfo.match(/.*\(([a-zA-Z0-9]+)\)/)) == null ? void 0 : _codeSigningInfo_match[1]) ?? null;
+}
+
+//# sourceMappingURL=Security.js.map

package/build/src/run/ios/codeSigning/Security.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/codeSigning/Security.ts"],"sourcesContent":["import spawnAsync from '@expo/spawn-async';\nimport forge from 'node-forge';\n\nimport { SecurityBinPrerequisite } from '../../../start/doctor/SecurityBinPrerequisite';\nimport { CommandError } from '../../../utils/errors';\n\nexport type CertificateSigningInfo = {\n  /**\n   * @example 'AA00AABB0A'\n   */\n  signingCertificateId: string;\n  /**\n   * @example 'Apple Development: Evan Bacon (AA00AABB0A)'\n   */\n  codeSigningInfo?: string;\n  /**\n   * @example '650 Industries, Inc.'\n   */\n  appleTeamName?: string;\n  /**\n   * @example 'A1BCDEF234'\n   */\n  appleTeamId?: string;\n};\n\nexport async function getSecurityPemAsync(id: string) {\n  const pem = (await spawnAsync('security', ['find-certificate', '-c', id, '-p'])).stdout?.trim?.();\n  if (!pem) {\n    throw new CommandError(`Failed to get PEM certificate for ID \"${id}\" using the 'security' bin`);\n  }\n  return pem;\n}\n\nexport async function getCertificateForSigningIdAsync(id: string): Promise<forge.pki.Certificate> {\n  const pem = await getSecurityPemAsync(id);\n  return forge.pki.certificateFromPem(pem);\n}\n\n/**\n * Get the signing identities from the security bin. Return a list of parsed values with duplicates removed.\n * @returns A list like ['Apple Development: bacon@expo.io (BB00AABB0A)', 'Apple Developer: Evan Bacon (AA00AABB0A)']\n */\nexport async function findIdentitiesAsync(): Promise<string[]> {\n  await SecurityBinPrerequisite.instance.assertAsync();\n\n  const results = (\n    await spawnAsync('security', ['find-identity', '-p', 'codesigning', '-v'])\n  ).stdout.trim?.();\n  // Returns a string like:\n  // 1) 12222234253761286351826735HGKDHAJGF45283 \"Apple Development: Evan Bacon (AA00AABB0A)\" (CSSMERR_TP_CERT_REVOKED)\n  // 2) 12312234253761286351826735HGKDHAJGF45283 \"Apple Development: bacon@expo.io (BB00AABB0A)\"\n  // 3) 12442234253761286351826735HGKDHAJGF45283 \"iPhone Distribution: Evan Bacon (CC00AABB0B)\" (CSSMERR_TP_CERT_REVOKED)\n  // 4) 15672234253761286351826735HGKDHAJGF45283 \"Apple Development: Evan Bacon (AA00AABB0A)\"\n  //  4 valid identities found\n\n  const parsed = results\n    .split('\\n')\n    .map((line) => extractCodeSigningInfo(line))\n    .filter(Boolean) as string[];\n\n  // Remove duplicates\n  return [...new Set(parsed)];\n}\n\n/**\n * @param value '  2) 12312234253761286351826735HGKDHAJGF45283 \"Apple Development: bacon@expo.io (BB00AABB0A)\"'\n * @returns 'Apple Development: Evan Bacon (PH75MDXG4H)'\n */\nexport function extractCodeSigningInfo(value: string): string | null {\n  return value.match(/^\\s*\\d+\\).+\"(.+Develop(ment|er).+)\"$/)?.[1] ?? null;\n}\n\nexport async function resolveIdentitiesAsync(\n  identities: string[]\n): Promise<CertificateSigningInfo[]> {\n  const values = identities.map(extractSigningId).filter(Boolean) as string[];\n  return Promise.all(values.map(resolveCertificateSigningInfoAsync));\n}\n\n/**\n * @param signingCertificateId 'AA00AABB0A'\n */\nexport async function resolveCertificateSigningInfoAsync(\n  signingCertificateId: string\n): Promise<CertificateSigningInfo> {\n  const certificate = await getCertificateForSigningIdAsync(signingCertificateId);\n  return {\n    signingCertificateId,\n    codeSigningInfo: certificate.subject.getField('CN')?.value,\n    appleTeamName: certificate.subject.getField('O')?.value,\n    appleTeamId: certificate.subject.getField('OU')?.value,\n  };\n}\n\n/**\n * @param codeSigningInfo 'Apple Development: Evan Bacon (AA00AABB0A)'\n * @returns 'AA00AABB0A'\n */\nexport function extractSigningId(codeSigningInfo: string): string | null {\n  return codeSigningInfo.match(/.*\\(([a-zA-Z0-9]+)\\)/)?.[1] ?? null;\n}\n"],"names":["extractCodeSigningInfo","extractSigningId","findIdentitiesAsync","getCertificateForSigningIdAsync","getSecurityPemAsync","resolveCertificateSigningInfoAsync","resolveIdentitiesAsync","id","pem","spawnAsync","stdout","trim","CommandError","forge","pki","certificateFromPem","SecurityBinPrerequisite","instance","assertAsync","results","parsed","split","map","line","filter","Boolean","Set","value","match","identities","values","Promise","all","signingCertificateId","certificate","codeSigningInfo","subject","getField","appleTeamName","appleTeamId"],"mappings":";;;;;;;;;;;IAoEgBA,sBAAsB;eAAtBA;;IA8BAC,gBAAgB;eAAhBA;;IAxDMC,mBAAmB;eAAnBA;;IATAC,+BAA+B;eAA/BA;;IARAC,mBAAmB;eAAnBA;;IAyDAC,kCAAkC;eAAlCA;;IAVAC,sBAAsB;eAAtBA;;;;gEAxEC;;;;;;;gEACL;;;;;;yCAEsB;wBACX;;;;;;AAqBtB,eAAeF,oBAAoBG,EAAU;QACtC,cAAA;IAAZ,MAAMC,OAAM,UAAA,AAAC,CAAA,MAAMC,IAAAA,qBAAU,EAAC,YAAY;QAAC;QAAoB;QAAMF;QAAI;KAAK,CAAA,EAAGG,MAAM,sBAA3E,eAAA,QAA6EC,IAAI,qBAAjF,kBAAA;IACZ,IAAI,CAACH,KAAK;QACR,MAAM,IAAII,oBAAY,CAAC,CAAC,sCAAsC,EAAEL,GAAG,0BAA0B,CAAC;IAChG;IACA,OAAOC;AACT;AAEO,eAAeL,gCAAgCI,EAAU;IAC9D,MAAMC,MAAM,MAAMJ,oBAAoBG;IACtC,OAAOM,oBAAK,CAACC,GAAG,CAACC,kBAAkB,CAACP;AACtC;AAMO,eAAeN;QAGJ,cAAA;IAFhB,MAAMc,gDAAuB,CAACC,QAAQ,CAACC,WAAW;IAElD,MAAMC,WAAU,eAAA,CAAA,UAAA,AACd,CAAA,MAAMV,IAAAA,qBAAU,EAAC,YAAY;QAAC;QAAiB;QAAM;QAAe;KAAK,CAAA,EACzEC,MAAM,EAACC,IAAI,qBAFG,kBAAA;IAGhB,yBAAyB;IACzB,qHAAqH;IACrH,8FAA8F;IAC9F,uHAAuH;IACvH,2FAA2F;IAC3F,4BAA4B;IAE5B,MAAMS,SAASD,QACZE,KAAK,CAAC,MACNC,GAAG,CAAC,CAACC,OAASvB,uBAAuBuB,OACrCC,MAAM,CAACC;IAEV,oBAAoB;IACpB,OAAO;WAAI,IAAIC,IAAIN;KAAQ;AAC7B;AAMO,SAASpB,uBAAuB2B,KAAa;QAC3CA;IAAP,OAAOA,EAAAA,eAAAA,MAAMC,KAAK,CAAC,4DAAZD,YAAqD,CAAC,EAAE,KAAI;AACrE;AAEO,eAAerB,uBACpBuB,UAAoB;IAEpB,MAAMC,SAASD,WAAWP,GAAG,CAACrB,kBAAkBuB,MAAM,CAACC;IACvD,OAAOM,QAAQC,GAAG,CAACF,OAAOR,GAAG,CAACjB;AAChC;AAKO,eAAeA,mCACpB4B,oBAA4B;QAKTC,+BACFA,gCACFA;IALf,MAAMA,cAAc,MAAM/B,gCAAgC8B;IAC1D,OAAO;QACLA;QACAE,eAAe,GAAED,gCAAAA,YAAYE,OAAO,CAACC,QAAQ,CAAC,0BAA7BH,8BAAoCP,KAAK;QAC1DW,aAAa,GAAEJ,iCAAAA,YAAYE,OAAO,CAACC,QAAQ,CAAC,yBAA7BH,+BAAmCP,KAAK;QACvDY,WAAW,GAAEL,iCAAAA,YAAYE,OAAO,CAACC,QAAQ,CAAC,0BAA7BH,+BAAoCP,KAAK;IACxD;AACF;AAMO,SAAS1B,iBAAiBkC,eAAuB;QAC/CA;IAAP,OAAOA,EAAAA,yBAAAA,gBAAgBP,KAAK,CAAC,4CAAtBO,sBAA+C,CAAC,EAAE,KAAI;AAC/D"}

package/build/src/run/ios/codeSigning/configureCodeSigning.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureDeviceIsCodeSignedForDeploymentAsync", {
+    enumerable: true,
+    get: function() {
+        return ensureDeviceIsCodeSignedForDeploymentAsync;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _Security = /*#__PURE__*/ _interop_require_wildcard(require("./Security"));
+const _resolveCertificateSigningIdentity = require("./resolveCertificateSigningIdentity");
+const _xcodeCodeSigning = require("./xcodeCodeSigning");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+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;
+}
+async function ensureDeviceIsCodeSignedForDeploymentAsync(projectRoot) {
+    if (isCodeSigningConfigured(projectRoot)) {
+        return null;
+    }
+    return configureCodeSigningAsync(projectRoot);
+}
+function isCodeSigningConfigured(projectRoot) {
+    // Check if the app already has a development team defined.
+    const signingInfo = (0, _xcodeCodeSigning.getCodeSigningInfoForPbxproj)(projectRoot);
+    const allTargetsHaveTeams = Object.values(signingInfo).reduce((prev, curr)=>{
+        return prev && !!curr.developmentTeams.length;
+    }, true);
+    if (allTargetsHaveTeams) {
+        const teamList = Object.values(signingInfo).reduce((prev, curr)=>{
+            return prev.concat([
+                curr.developmentTeams[0]
+            ]);
+        }, []);
+        _log.log(_chalk().default.dim`\u203A Auto signing app using team(s): ${teamList.join(', ')}`);
+        return true;
+    }
+    const allTargetsHaveProfiles = Object.values(signingInfo).reduce((prev, curr)=>{
+        return prev && !!curr.provisioningProfiles.length;
+    }, true);
+    if (allTargetsHaveProfiles) {
+        // this indicates that the user has manual code signing setup (possibly for production).
+        return true;
+    }
+    return false;
+}
+async function configureCodeSigningAsync(projectRoot) {
+    const ids = await _Security.findIdentitiesAsync();
+    const id = await (0, _resolveCertificateSigningIdentity.resolveCertificateSigningIdentityAsync)(projectRoot, ids);
+    _log.log(`\u203A Signing and building iOS app with: ${id.codeSigningInfo}`);
+    (0, _xcodeCodeSigning.setAutoCodeSigningInfoForPbxproj)(projectRoot, {
+        appleTeamId: id.appleTeamId
+    });
+    return id.appleTeamId;
+}
+
+//# sourceMappingURL=configureCodeSigning.js.map

package/build/src/run/ios/codeSigning/configureCodeSigning.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/codeSigning/configureCodeSigning.ts"],"sourcesContent":["import chalk from 'chalk';\n\nimport * as Security from './Security';\nimport { resolveCertificateSigningIdentityAsync } from './resolveCertificateSigningIdentity';\nimport { getCodeSigningInfoForPbxproj, setAutoCodeSigningInfoForPbxproj } from './xcodeCodeSigning';\nimport * as Log from '../../../log';\n\nexport async function ensureDeviceIsCodeSignedForDeploymentAsync(\n  projectRoot: string\n): Promise<string | null> {\n  if (isCodeSigningConfigured(projectRoot)) {\n    return null;\n  }\n  return configureCodeSigningAsync(projectRoot);\n}\n\nfunction isCodeSigningConfigured(projectRoot: string): boolean {\n  // Check if the app already has a development team defined.\n  const signingInfo = getCodeSigningInfoForPbxproj(projectRoot);\n\n  const allTargetsHaveTeams = Object.values(signingInfo).reduce((prev, curr) => {\n    return prev && !!curr.developmentTeams.length;\n  }, true);\n\n  if (allTargetsHaveTeams) {\n    const teamList = Object.values(signingInfo).reduce<string[]>((prev, curr) => {\n      return prev.concat([curr.developmentTeams[0]]);\n    }, []);\n    Log.log(chalk.dim`\\u203A Auto signing app using team(s): ${teamList.join(', ')}`);\n    return true;\n  }\n\n  const allTargetsHaveProfiles = Object.values(signingInfo).reduce((prev, curr) => {\n    return prev && !!curr.provisioningProfiles.length;\n  }, true);\n\n  if (allTargetsHaveProfiles) {\n    // this indicates that the user has manual code signing setup (possibly for production).\n    return true;\n  }\n  return false;\n}\n\nasync function configureCodeSigningAsync(projectRoot: string) {\n  const ids = await Security.findIdentitiesAsync();\n\n  const id = await resolveCertificateSigningIdentityAsync(projectRoot, ids);\n\n  Log.log(`\\u203A Signing and building iOS app with: ${id.codeSigningInfo}`);\n\n  setAutoCodeSigningInfoForPbxproj(projectRoot, {\n    appleTeamId: id.appleTeamId!,\n  });\n  return id.appleTeamId!;\n}\n"],"names":["ensureDeviceIsCodeSignedForDeploymentAsync","projectRoot","isCodeSigningConfigured","configureCodeSigningAsync","signingInfo","getCodeSigningInfoForPbxproj","allTargetsHaveTeams","Object","values","reduce","prev","curr","developmentTeams","length","teamList","concat","Log","log","chalk","dim","join","allTargetsHaveProfiles","provisioningProfiles","ids","Security","findIdentitiesAsync","id","resolveCertificateSigningIdentityAsync","codeSigningInfo","setAutoCodeSigningInfoForPbxproj","appleTeamId"],"mappings":";;;;+BAOsBA;;;eAAAA;;;;gEAPJ;;;;;;kEAEQ;mDAC6B;kCACwB;6DAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEd,eAAeA,2CACpBC,WAAmB;IAEnB,IAAIC,wBAAwBD,cAAc;QACxC,OAAO;IACT;IACA,OAAOE,0BAA0BF;AACnC;AAEA,SAASC,wBAAwBD,WAAmB;IAClD,2DAA2D;IAC3D,MAAMG,cAAcC,IAAAA,8CAA4B,EAACJ;IAEjD,MAAMK,sBAAsBC,OAAOC,MAAM,CAACJ,aAAaK,MAAM,CAAC,CAACC,MAAMC;QACnE,OAAOD,QAAQ,CAAC,CAACC,KAAKC,gBAAgB,CAACC,MAAM;IAC/C,GAAG;IAEH,IAAIP,qBAAqB;QACvB,MAAMQ,WAAWP,OAAOC,MAAM,CAACJ,aAAaK,MAAM,CAAW,CAACC,MAAMC;YAClE,OAAOD,KAAKK,MAAM,CAAC;gBAACJ,KAAKC,gBAAgB,CAAC,EAAE;aAAC;QAC/C,GAAG,EAAE;QACLI,KAAIC,GAAG,CAACC,gBAAK,CAACC,GAAG,CAAC,uCAAuC,EAAEL,SAASM,IAAI,CAAC,MAAM,CAAC;QAChF,OAAO;IACT;IAEA,MAAMC,yBAAyBd,OAAOC,MAAM,CAACJ,aAAaK,MAAM,CAAC,CAACC,MAAMC;QACtE,OAAOD,QAAQ,CAAC,CAACC,KAAKW,oBAAoB,CAACT,MAAM;IACnD,GAAG;IAEH,IAAIQ,wBAAwB;QAC1B,wFAAwF;QACxF,OAAO;IACT;IACA,OAAO;AACT;AAEA,eAAelB,0BAA0BF,WAAmB;IAC1D,MAAMsB,MAAM,MAAMC,UAASC,mBAAmB;IAE9C,MAAMC,KAAK,MAAMC,IAAAA,yEAAsC,EAAC1B,aAAasB;IAErEP,KAAIC,GAAG,CAAC,CAAC,0CAA0C,EAAES,GAAGE,eAAe,EAAE;IAEzEC,IAAAA,kDAAgC,EAAC5B,aAAa;QAC5C6B,aAAaJ,GAAGI,WAAW;IAC7B;IACA,OAAOJ,GAAGI,WAAW;AACvB"}

package/build/src/run/ios/codeSigning/resolveCertificateSigningIdentity.js

@@ -0,0 +1,165 @@
+"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, {
+    resolveCertificateSigningIdentityAsync: function() {
+        return resolveCertificateSigningIdentityAsync;
+    },
+    selectDevelopmentTeamAsync: function() {
+        return selectDevelopmentTeamAsync;
+    },
+    sortDefaultIdToBeginningAsync: function() {
+        return sortDefaultIdToBeginningAsync;
+    }
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _Security = /*#__PURE__*/ _interop_require_wildcard(require("./Security"));
+const _settings = require("./settings");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../log"));
+const _errors = require("../../../utils/errors");
+const _interactive = require("../../../utils/interactive");
+const _link = require("../../../utils/link");
+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;
+}
+async function sortDefaultIdToBeginningAsync(identities) {
+    const lastSelected = await (0, _settings.getLastDeveloperCodeSigningIdAsync)();
+    if (lastSelected) {
+        let iterations = 0;
+        while(identities[0].signingCertificateId !== lastSelected && iterations < identities.length){
+            identities.push(identities.shift());
+            iterations++;
+        }
+    }
+    return [
+        identities,
+        lastSelected
+    ];
+}
+/**
+ * Assert that the computer needs code signing setup.
+ * This links to an FYI page that was user tested internally.
+ */ function assertCodeSigningSetup() {
+    // TODO: We can probably do this too automatically.
+    _log.log(`\u203A Your computer requires some additional setup before you can build onto physical iOS devices.\n  ${_chalk().default.bold((0, _link.learnMore)('https://expo.fyi/setup-xcode-signing'))}`);
+    throw new _errors.CommandError('No code signing certificates are available to use.');
+}
+async function resolveCertificateSigningIdentityAsync(projectRoot, ids) {
+    var _exp_ios;
+    // The user has no valid code signing identities.
+    if (!ids.length) {
+        assertCodeSigningSetup();
+    }
+    //  One ID available 🤝 Program is not interactive
+    //
+    //     using the the first available option
+    if (ids.length === 1 || !(0, _interactive.isInteractive)()) {
+        // This method is cheaper than `resolveIdentitiesAsync` and checking the
+        // cached user preference so we should use this as early as possible.
+        return _Security.resolveCertificateSigningInfoAsync(ids[0]);
+    }
+    // Get identities and sort by the one that the user is most likely to choose.
+    const [identities, preferred] = await sortDefaultIdToBeginningAsync(await _Security.resolveIdentitiesAsync(ids));
+    // Read the config to interact with the `ios.appleTeamId` property
+    const { exp } = (0, _config().getConfig)(projectRoot, {
+        // We don't need very many fields here, just use the lightest possible read.
+        skipSDKVersionRequirement: true,
+        skipPlugins: true
+    });
+    const configuredTeamId = (_exp_ios = exp.ios) == null ? void 0 : _exp_ios.appleTeamId;
+    const configuredIdentity = configuredTeamId ? identities.find((identity)=>identity.appleTeamId === configuredTeamId) : undefined;
+    const selectedIdentity = configuredIdentity ?? await selectDevelopmentTeamAsync(identities, preferred);
+    await Promise.all([
+        // Store the last used value and suggest it as the first value
+        // next time the user has to select a code signing identity.
+        (0, _settings.setLastDeveloperCodeSigningIdAsync)(selectedIdentity.signingCertificateId),
+        // Store the last used team id in the app manifest, when no team id has been configured yet
+        configuredTeamId || !selectedIdentity.appleTeamId ? Promise.resolve() : (0, _config().modifyConfigAsync)(projectRoot, {
+            ios: {
+                appleTeamId: selectedIdentity.appleTeamId
+            }
+        })
+    ]);
+    return selectedIdentity;
+}
+async function selectDevelopmentTeamAsync(identities, preferredId) {
+    const index = await (0, _prompts.selectAsync)('Development team for signing the app', identities.map((value, i)=>{
+        const format = value.signingCertificateId === preferredId ? _chalk().default.bold : (message)=>message;
+        return {
+            // Formatted like: `650 Industries, Inc. (A1BCDEF234) - Apple Development: Evan Bacon (AA00AABB0A)`
+            title: format([
+                value.appleTeamName,
+                `(${value.appleTeamId}) -`,
+                value.codeSigningInfo
+            ].join(' ')),
+            value: i
+        };
+    }));
+    return identities[index];
+}
+
+//# sourceMappingURL=resolveCertificateSigningIdentity.js.map

package/build/src/run/ios/codeSigning/resolveCertificateSigningIdentity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/codeSigning/resolveCertificateSigningIdentity.ts"],"sourcesContent":["import { getConfig, modifyConfigAsync } from '@expo/config';\nimport chalk from 'chalk';\n\nimport * as Security from './Security';\nimport { getLastDeveloperCodeSigningIdAsync, setLastDeveloperCodeSigningIdAsync } from './settings';\nimport * as Log from '../../../log';\nimport { CommandError } from '../../../utils/errors';\nimport { isInteractive } from '../../../utils/interactive';\nimport { learnMore } from '../../../utils/link';\nimport { selectAsync } from '../../../utils/prompts';\n\n/**\n * Sort the code signing items so the last selected item (user's default) is the first suggested.\n */\nexport async function sortDefaultIdToBeginningAsync(\n  identities: Security.CertificateSigningInfo[]\n): Promise<[Security.CertificateSigningInfo[], string | null]> {\n  const lastSelected = await getLastDeveloperCodeSigningIdAsync();\n\n  if (lastSelected) {\n    let iterations = 0;\n    while (identities[0].signingCertificateId !== lastSelected && iterations < identities.length) {\n      identities.push(identities.shift()!);\n      iterations++;\n    }\n  }\n  return [identities, lastSelected];\n}\n\n/**\n * Assert that the computer needs code signing setup.\n * This links to an FYI page that was user tested internally.\n */\nfunction assertCodeSigningSetup(): never {\n  // TODO: We can probably do this too automatically.\n  Log.log(\n    `\\u203A Your computer requires some additional setup before you can build onto physical iOS devices.\\n  ${chalk.bold(\n      learnMore('https://expo.fyi/setup-xcode-signing')\n    )}`\n  );\n\n  throw new CommandError('No code signing certificates are available to use.');\n}\n\n/**\n * Resolve the best certificate signing identity from a given list of IDs.\n * - If no IDs: Assert that the user has to setup code signing.\n * - If one ID: Return the first ID.\n * - If multiple IDs: Ask the user to select one, then store the value to be suggested first next time (since users generally use the same ID).\n */\nexport async function resolveCertificateSigningIdentityAsync(\n  projectRoot: string,\n  ids: string[]\n): Promise<Security.CertificateSigningInfo> {\n  // The user has no valid code signing identities.\n  if (!ids.length) {\n    assertCodeSigningSetup();\n  }\n\n  //  One ID available 🤝 Program is not interactive\n  //\n  //     using the the first available option\n  if (ids.length === 1 || !isInteractive()) {\n    // This method is cheaper than `resolveIdentitiesAsync` and checking the\n    // cached user preference so we should use this as early as possible.\n    return Security.resolveCertificateSigningInfoAsync(ids[0]);\n  }\n\n  // Get identities and sort by the one that the user is most likely to choose.\n  const [identities, preferred] = await sortDefaultIdToBeginningAsync(\n    await Security.resolveIdentitiesAsync(ids)\n  );\n\n  // Read the config to interact with the `ios.appleTeamId` property\n  const { exp } = getConfig(projectRoot, {\n    // We don't need very many fields here, just use the lightest possible read.\n    skipSDKVersionRequirement: true,\n    skipPlugins: true,\n  });\n  const configuredTeamId = exp.ios?.appleTeamId;\n\n  const configuredIdentity = configuredTeamId\n    ? identities.find((identity) => identity.appleTeamId === configuredTeamId)\n    : undefined;\n\n  const selectedIdentity =\n    configuredIdentity ?? (await selectDevelopmentTeamAsync(identities, preferred));\n\n  await Promise.all([\n    // Store the last used value and suggest it as the first value\n    // next time the user has to select a code signing identity.\n    setLastDeveloperCodeSigningIdAsync(selectedIdentity.signingCertificateId),\n    // Store the last used team id in the app manifest, when no team id has been configured yet\n    configuredTeamId || !selectedIdentity.appleTeamId\n      ? Promise.resolve()\n      : modifyConfigAsync(projectRoot, { ios: { appleTeamId: selectedIdentity.appleTeamId } }),\n  ]);\n\n  return selectedIdentity;\n}\n\n/** Prompt the user to select a development team, highlighting the preferred value based on the user history. */\nexport async function selectDevelopmentTeamAsync(\n  identities: Security.CertificateSigningInfo[],\n  preferredId: string | null\n): Promise<Security.CertificateSigningInfo> {\n  const index = await selectAsync(\n    'Development team for signing the app',\n    identities.map((value, i) => {\n      const format =\n        value.signingCertificateId === preferredId ? chalk.bold : (message: string) => message;\n      return {\n        // Formatted like: `650 Industries, Inc. (A1BCDEF234) - Apple Development: Evan Bacon (AA00AABB0A)`\n        title: format(\n          [value.appleTeamName, `(${value.appleTeamId}) -`, value.codeSigningInfo].join(' ')\n        ),\n        value: i,\n      };\n    })\n  );\n\n  return identities[index];\n}\n"],"names":["resolveCertificateSigningIdentityAsync","selectDevelopmentTeamAsync","sortDefaultIdToBeginningAsync","identities","lastSelected","getLastDeveloperCodeSigningIdAsync","iterations","signingCertificateId","length","push","shift","assertCodeSigningSetup","Log","log","chalk","bold","learnMore","CommandError","projectRoot","ids","exp","isInteractive","Security","resolveCertificateSigningInfoAsync","preferred","resolveIdentitiesAsync","getConfig","skipSDKVersionRequirement","skipPlugins","configuredTeamId","ios","appleTeamId","configuredIdentity","find","identity","undefined","selectedIdentity","Promise","all","setLastDeveloperCodeSigningIdAsync","resolve","modifyConfigAsync","preferredId","index","selectAsync","map","value","i","format","message","title","appleTeamName","codeSigningInfo","join"],"mappings":";;;;;;;;;;;IAkDsBA,sCAAsC;eAAtCA;;IAoDAC,0BAA0B;eAA1BA;;IAxFAC,6BAA6B;eAA7BA;;;;yBAduB;;;;;;;gEAC3B;;;;;;kEAEQ;0BAC6D;6DAClE;wBACQ;6BACC;sBACJ;yBACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKrB,eAAeA,8BACpBC,UAA6C;IAE7C,MAAMC,eAAe,MAAMC,IAAAA,4CAAkC;IAE7D,IAAID,cAAc;QAChB,IAAIE,aAAa;QACjB,MAAOH,UAAU,CAAC,EAAE,CAACI,oBAAoB,KAAKH,gBAAgBE,aAAaH,WAAWK,MAAM,CAAE;YAC5FL,WAAWM,IAAI,CAACN,WAAWO,KAAK;YAChCJ;QACF;IACF;IACA,OAAO;QAACH;QAAYC;KAAa;AACnC;AAEA;;;CAGC,GACD,SAASO;IACP,mDAAmD;IACnDC,KAAIC,GAAG,CACL,CAAC,uGAAuG,EAAEC,gBAAK,CAACC,IAAI,CAClHC,IAAAA,eAAS,EAAC,0CACT;IAGL,MAAM,IAAIC,oBAAY,CAAC;AACzB;AAQO,eAAejB,uCACpBkB,WAAmB,EACnBC,GAAa;QA2BYC;IAzBzB,iDAAiD;IACjD,IAAI,CAACD,IAAIX,MAAM,EAAE;QACfG;IACF;IAEA,kDAAkD;IAClD,EAAE;IACF,2CAA2C;IAC3C,IAAIQ,IAAIX,MAAM,KAAK,KAAK,CAACa,IAAAA,0BAAa,KAAI;QACxC,wEAAwE;QACxE,qEAAqE;QACrE,OAAOC,UAASC,kCAAkC,CAACJ,GAAG,CAAC,EAAE;IAC3D;IAEA,6EAA6E;IAC7E,MAAM,CAAChB,YAAYqB,UAAU,GAAG,MAAMtB,8BACpC,MAAMoB,UAASG,sBAAsB,CAACN;IAGxC,kEAAkE;IAClE,MAAM,EAAEC,GAAG,EAAE,GAAGM,IAAAA,mBAAS,EAACR,aAAa;QACrC,4EAA4E;QAC5ES,2BAA2B;QAC3BC,aAAa;IACf;IACA,MAAMC,oBAAmBT,WAAAA,IAAIU,GAAG,qBAAPV,SAASW,WAAW;IAE7C,MAAMC,qBAAqBH,mBACvB1B,WAAW8B,IAAI,CAAC,CAACC,WAAaA,SAASH,WAAW,KAAKF,oBACvDM;IAEJ,MAAMC,mBACJJ,sBAAuB,MAAM/B,2BAA2BE,YAAYqB;IAEtE,MAAMa,QAAQC,GAAG,CAAC;QAChB,8DAA8D;QAC9D,4DAA4D;QAC5DC,IAAAA,4CAAkC,EAACH,iBAAiB7B,oBAAoB;QACxE,2FAA2F;QAC3FsB,oBAAoB,CAACO,iBAAiBL,WAAW,GAC7CM,QAAQG,OAAO,KACfC,IAAAA,2BAAiB,EAACvB,aAAa;YAAEY,KAAK;gBAAEC,aAAaK,iBAAiBL,WAAW;YAAC;QAAE;KACzF;IAED,OAAOK;AACT;AAGO,eAAenC,2BACpBE,UAA6C,EAC7CuC,WAA0B;IAE1B,MAAMC,QAAQ,MAAMC,IAAAA,oBAAW,EAC7B,wCACAzC,WAAW0C,GAAG,CAAC,CAACC,OAAOC;QACrB,MAAMC,SACJF,MAAMvC,oBAAoB,KAAKmC,cAAc5B,gBAAK,CAACC,IAAI,GAAG,CAACkC,UAAoBA;QACjF,OAAO;YACL,mGAAmG;YACnGC,OAAOF,OACL;gBAACF,MAAMK,aAAa;gBAAE,CAAC,CAAC,EAAEL,MAAMf,WAAW,CAAC,GAAG,CAAC;gBAAEe,MAAMM,eAAe;aAAC,CAACC,IAAI,CAAC;YAEhFP,OAAOC;QACT;IACF;IAGF,OAAO5C,UAAU,CAACwC,MAAM;AAC1B"}

package/build/src/run/ios/codeSigning/settings.js

@@ -0,0 +1,27 @@
+"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, {
+    getLastDeveloperCodeSigningIdAsync: function() {
+        return getLastDeveloperCodeSigningIdAsync;
+    },
+    setLastDeveloperCodeSigningIdAsync: function() {
+        return setLastDeveloperCodeSigningIdAsync;
+    }
+});
+const _UserSettings = require("../../../api/user/UserSettings");
+async function getLastDeveloperCodeSigningIdAsync() {
+    return await (0, _UserSettings.getSettings)().getAsync('developmentCodeSigningId', null);
+}
+async function setLastDeveloperCodeSigningIdAsync(id) {
+    await (0, _UserSettings.getSettings)().setAsync('developmentCodeSigningId', id).catch(()=>{});
+}
+
+//# sourceMappingURL=settings.js.map

package/build/src/run/ios/codeSigning/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/codeSigning/settings.ts"],"sourcesContent":["import { getSettings } from '../../../api/user/UserSettings';\n\n/** Get the cached code signing ID from the last time a user configured code signing via the CLI. */\nexport async function getLastDeveloperCodeSigningIdAsync(): Promise<string | null> {\n  return await getSettings().getAsync('developmentCodeSigningId', null);\n}\n\n/** Cache the code signing ID that the user chose for their project, we'll recommend this value for the next project they code sign. */\nexport async function setLastDeveloperCodeSigningIdAsync(id: string): Promise<void> {\n  await getSettings()\n    .setAsync('developmentCodeSigningId', id)\n    .catch(() => {});\n}\n"],"names":["getLastDeveloperCodeSigningIdAsync","setLastDeveloperCodeSigningIdAsync","getSettings","getAsync","id","setAsync","catch"],"mappings":";;;;;;;;;;;IAGsBA,kCAAkC;eAAlCA;;IAKAC,kCAAkC;eAAlCA;;;8BARM;AAGrB,eAAeD;IACpB,OAAO,MAAME,IAAAA,yBAAW,IAAGC,QAAQ,CAAC,4BAA4B;AAClE;AAGO,eAAeF,mCAAmCG,EAAU;IACjE,MAAMF,IAAAA,yBAAW,IACdG,QAAQ,CAAC,4BAA4BD,IACrCE,KAAK,CAAC,KAAO;AAClB"}

package/build/src/run/ios/codeSigning/simulatorCodeSigning.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "simulatorBuildRequiresCodeSigning", {
+    enumerable: true,
+    get: function() {
+        return simulatorBuildRequiresCodeSigning;
+    }
+});
+function _configplugins() {
+    const data = require("@expo/config-plugins");
+    _configplugins = function() {
+        return data;
+    };
+    return data;
+}
+function _plist() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/plist"));
+    _plist = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:run:ios:codeSigning:simulator');
+// NOTE(EvanBacon): These are entitlements that work in a simulator
+// but still require the project to have development code signing setup.
+// There may be more, but this is fine for now.
+const ENTITLEMENTS_THAT_REQUIRE_CODE_SIGNING = [
+    'com.apple.developer.associated-domains',
+    'com.apple.developer.applesignin'
+];
+function getEntitlements(projectRoot) {
+    try {
+        const entitlementsPath = _configplugins().IOSConfig.Entitlements.getEntitlementsPath(projectRoot);
+        if (!entitlementsPath || !_fs().default.existsSync(entitlementsPath)) {
+            return null;
+        }
+        const entitlementsContents = _fs().default.readFileSync(entitlementsPath, 'utf8');
+        const entitlements = _plist().default.parse(entitlementsContents);
+        return entitlements;
+    } catch (error) {
+        debug('Failed to read entitlements', error);
+    }
+    return null;
+}
+function simulatorBuildRequiresCodeSigning(projectRoot) {
+    const entitlements = getEntitlements(projectRoot);
+    if (!entitlements) {
+        return false;
+    }
+    return ENTITLEMENTS_THAT_REQUIRE_CODE_SIGNING.some((entitlement)=>entitlement in entitlements);
+}
+
+//# sourceMappingURL=simulatorCodeSigning.js.map

package/build/src/run/ios/codeSigning/simulatorCodeSigning.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/run/ios/codeSigning/simulatorCodeSigning.ts"],"sourcesContent":["import { IOSConfig } from '@expo/config-plugins';\nimport plist from '@expo/plist';\nimport fs from 'fs';\n\nconst debug = require('debug')('expo:run:ios:codeSigning:simulator');\n\n// NOTE(EvanBacon): These are entitlements that work in a simulator\n// but still require the project to have development code signing setup.\n// There may be more, but this is fine for now.\nconst ENTITLEMENTS_THAT_REQUIRE_CODE_SIGNING = [\n  'com.apple.developer.associated-domains',\n  'com.apple.developer.applesignin',\n];\n\nfunction getEntitlements(projectRoot: string): Record<string, any> | null {\n  try {\n    const entitlementsPath = IOSConfig.Entitlements.getEntitlementsPath(projectRoot);\n    if (!entitlementsPath || !fs.existsSync(entitlementsPath)) {\n      return null;\n    }\n\n    const entitlementsContents = fs.readFileSync(entitlementsPath, 'utf8');\n    const entitlements = plist.parse(entitlementsContents);\n    return entitlements;\n  } catch (error) {\n    debug('Failed to read entitlements', error);\n  }\n  return null;\n}\n\n/** @returns true if the simulator build should be code signed for development. */\nexport function simulatorBuildRequiresCodeSigning(projectRoot: string): boolean {\n  const entitlements = getEntitlements(projectRoot);\n  if (!entitlements) {\n    return false;\n  }\n  return ENTITLEMENTS_THAT_REQUIRE_CODE_SIGNING.some((entitlement) => entitlement in entitlements);\n}\n"],"names":["simulatorBuildRequiresCodeSigning","debug","require","ENTITLEMENTS_THAT_REQUIRE_CODE_SIGNING","getEntitlements","projectRoot","entitlementsPath","IOSConfig","Entitlements","getEntitlementsPath","fs","existsSync","entitlementsContents","readFileSync","entitlements","plist","parse","error","some","entitlement"],"mappings":";;;;+BA+BgBA;;;eAAAA;;;;yBA/BU;;;;;;;gEACR;;;;;;;gEACH;;;;;;;;;;;AAEf,MAAMC,QAAQC,QAAQ,SAAS;AAE/B,mEAAmE;AACnE,wEAAwE;AACxE,+CAA+C;AAC/C,MAAMC,yCAAyC;IAC7C;IACA;CACD;AAED,SAASC,gBAAgBC,WAAmB;IAC1C,IAAI;QACF,MAAMC,mBAAmBC,0BAAS,CAACC,YAAY,CAACC,mBAAmB,CAACJ;QACpE,IAAI,CAACC,oBAAoB,CAACI,aAAE,CAACC,UAAU,CAACL,mBAAmB;YACzD,OAAO;QACT;QAEA,MAAMM,uBAAuBF,aAAE,CAACG,YAAY,CAACP,kBAAkB;QAC/D,MAAMQ,eAAeC,gBAAK,CAACC,KAAK,CAACJ;QACjC,OAAOE;IACT,EAAE,OAAOG,OAAO;QACdhB,MAAM,+BAA+BgB;IACvC;IACA,OAAO;AACT;AAGO,SAASjB,kCAAkCK,WAAmB;IACnE,MAAMS,eAAeV,gBAAgBC;IACrC,IAAI,CAACS,cAAc;QACjB,OAAO;IACT;IACA,OAAOX,uCAAuCe,IAAI,CAAC,CAACC,cAAgBA,eAAeL;AACrF"}

package/build/src/run/ios/codeSigning/xcodeCodeSigning.js

@@ -0,0 +1,103 @@
+"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, {
+    getCodeSigningInfoForPbxproj: function() {
+        return getCodeSigningInfoForPbxproj;
+    },
+    mutateXcodeProjectWithAutoCodeSigningInfo: function() {
+        return mutateXcodeProjectWithAutoCodeSigningInfo;
+    },
+    setAutoCodeSigningInfoForPbxproj: function() {
+        return setAutoCodeSigningInfoForPbxproj;
+    }
+});
+function _configplugins() {
+    const data = require("@expo/config-plugins");
+    _configplugins = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getCodeSigningInfoForPbxproj(projectRoot) {
+    const project = _configplugins().IOSConfig.XcodeUtils.getPbxproj(projectRoot);
+    const targets = _configplugins().IOSConfig.Target.findSignableTargets(project);
+    const signingInfo = {};
+    for (const [nativeTargetId, nativeTarget] of targets){
+        const developmentTeams = [];
+        const provisioningProfiles = [];
+        _configplugins().IOSConfig.XcodeUtils.getBuildConfigurationsForListId(project, nativeTarget.buildConfigurationList).filter(([, item])=>item.buildSettings.PRODUCT_NAME).forEach(([, item])=>{
+            const { DEVELOPMENT_TEAM, PROVISIONING_PROFILE } = item.buildSettings;
+            if (typeof DEVELOPMENT_TEAM === 'string' && // If the user selects "Team: none" in Xcode, it'll be an empty string.
+            !!DEVELOPMENT_TEAM && // xcode package sometimes reads an empty string as a quoted empty string.
+            DEVELOPMENT_TEAM !== '""') {
+                developmentTeams.push(DEVELOPMENT_TEAM);
+            }
+            if (typeof PROVISIONING_PROFILE === 'string' && !!PROVISIONING_PROFILE) {
+                provisioningProfiles.push(PROVISIONING_PROFILE);
+            }
+        });
+        signingInfo[nativeTargetId] = {
+            developmentTeams,
+            provisioningProfiles
+        };
+    }
+    return signingInfo;
+}
+function mutateXcodeProjectWithAutoCodeSigningInfo({ project, appleTeamId }) {
+    const targets = _configplugins().IOSConfig.Target.findSignableTargets(project);
+    const quotedAppleTeamId = ensureQuotes(appleTeamId);
+    for (const [nativeTargetId, nativeTarget] of targets){
+        _configplugins().IOSConfig.XcodeUtils.getBuildConfigurationsForListId(project, nativeTarget.buildConfigurationList).filter(([, item])=>item.buildSettings.PRODUCT_NAME).forEach(([, item])=>{
+            item.buildSettings.DEVELOPMENT_TEAM = quotedAppleTeamId;
+            item.buildSettings.CODE_SIGN_IDENTITY = '"Apple Development"';
+            item.buildSettings.CODE_SIGN_STYLE = 'Automatic';
+        });
+        Object.entries(_configplugins().IOSConfig.XcodeUtils.getProjectSection(project)).filter(_configplugins().IOSConfig.XcodeUtils.isNotComment).forEach(([, item])=>{
+            if (!item.attributes.TargetAttributes) {
+                item.attributes.TargetAttributes = {};
+            }
+            if (!item.attributes.TargetAttributes[nativeTargetId]) {
+                item.attributes.TargetAttributes[nativeTargetId] = {};
+            }
+            item.attributes.TargetAttributes[nativeTargetId].DevelopmentTeam = quotedAppleTeamId;
+            item.attributes.TargetAttributes[nativeTargetId].ProvisioningStyle = 'Automatic';
+        });
+    }
+    return project;
+}
+function setAutoCodeSigningInfoForPbxproj(projectRoot, { appleTeamId }) {
+    const project = _configplugins().IOSConfig.XcodeUtils.getPbxproj(projectRoot);
+    mutateXcodeProjectWithAutoCodeSigningInfo({
+        project,
+        appleTeamId
+    });
+    _fs().default.writeFileSync(project.filepath, project.writeSync());
+}
+const ensureQuotes = (value)=>{
+    if (!value.match(/^['"]/)) {
+        return `"${value}"`;
+    }
+    return value;
+};
+
+//# sourceMappingURL=xcodeCodeSigning.js.map