@donotuse/eas-cli 18.5.0-rc.1

package/build/project/ios/bundleIdentifier.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbiguousBundleIdentifierError = exports.INVALID_BUNDLE_IDENTIFIER_MESSAGE = void 0;
+exports.ensureBundleIdentifierIsDefinedForManagedProjectAsync = ensureBundleIdentifierIsDefinedForManagedProjectAsync;
+exports.getBundleIdentifierAsync = getBundleIdentifierAsync;
+exports.isBundleIdentifierValid = isBundleIdentifierValid;
+exports.warnIfBundleIdentifierDefinedInAppConfigForBareWorkflowProject = warnIfBundleIdentifierDefinedInAppConfigForBareWorkflowProject;
+exports.isWildcardBundleIdentifier = isWildcardBundleIdentifier;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const appJson_1 = require("../../build/utils/appJson");
+const env_1 = tslib_1.__importDefault(require("../../env"));
+const log_1 = tslib_1.__importStar(require("../../log"));
+const prompts_1 = require("../../prompts");
+const projectUtils_1 = require("../projectUtils");
+const workflow_1 = require("../workflow");
+exports.INVALID_BUNDLE_IDENTIFIER_MESSAGE = `Invalid format of iOS bundle identifier. Only alphanumeric characters, '.' and '-' are allowed, and each '.' must be followed by a letter.`;
+async function ensureBundleIdentifierIsDefinedForManagedProjectAsync({ graphqlClient, projectDir, projectId, exp, vcsClient, nonInteractive, }) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.IOS, vcsClient);
+    (0, assert_1.default)(workflow === eas_build_job_1.Workflow.MANAGED, 'This function should be called only for managed projects');
+    try {
+        return await getBundleIdentifierAsync(projectDir, exp, vcsClient);
+    }
+    catch {
+        return await configureBundleIdentifierAsync({
+            graphqlClient,
+            projectDir,
+            exp,
+            projectId,
+            nonInteractive,
+        });
+    }
+}
+class AmbiguousBundleIdentifierError extends Error {
+    constructor(message) {
+        super(message ?? 'Could not resolve bundle identifier.');
+    }
+}
+exports.AmbiguousBundleIdentifierError = AmbiguousBundleIdentifierError;
+async function getBundleIdentifierAsync(projectDir, exp, vcsClient, xcodeContext) {
+    if (env_1.default.overrideIosBundleIdentifier) {
+        return env_1.default.overrideIosBundleIdentifier;
+    }
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.IOS, vcsClient);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        warnIfBundleIdentifierDefinedInAppConfigForBareWorkflowProject(projectDir, exp);
+        const xcodeProject = config_plugins_1.IOSConfig.XcodeUtils.getPbxproj(projectDir);
+        const isMultiScheme = config_plugins_1.IOSConfig.BuildScheme.getSchemesFromXcodeproj(projectDir).length > 1;
+        const isMultiTarget = config_plugins_1.IOSConfig.Target.getNativeTargets(xcodeProject).filter(([, target]) => config_plugins_1.IOSConfig.Target.isTargetOfType(target, config_plugins_1.IOSConfig.Target.TargetType.APPLICATION)).length > 1;
+        if (!xcodeContext && isMultiScheme && isMultiTarget) {
+            throw new AmbiguousBundleIdentifierError("Multiple schemes and targets found in Xcode project, bundle identifier couldn't be resolved.");
+        }
+        const bundleIdentifier = config_plugins_1.IOSConfig.BundleIdentifier.getBundleIdentifierFromPbxproj(projectDir, xcodeContext ?? {});
+        const buildConfigurationDesc = xcodeContext?.targetName && xcodeContext?.buildConfiguration
+            ? ` (target = ${xcodeContext.targetName}, build configuration = ${xcodeContext.buildConfiguration})`
+            : '';
+        (0, assert_1.default)(bundleIdentifier, `Could not read bundle identifier from Xcode project${buildConfigurationDesc}.`);
+        if (!isBundleIdentifierValid(bundleIdentifier)) {
+            throw new Error(`Bundle identifier "${bundleIdentifier}" is not valid${buildConfigurationDesc}. Open the project in Xcode to fix it.`);
+        }
+        return bundleIdentifier;
+    }
+    else {
+        // TODO: the following asserts are only temporary until we support app extensions in managed projects
+        (0, assert_1.default)(!xcodeContext?.targetName ||
+            xcodeContext?.targetName === config_plugins_1.IOSConfig.XcodeUtils.sanitizedName(exp.name), 'targetName cannot be set to an arbitrary value for managed projects.');
+        (0, assert_1.default)(!xcodeContext?.buildConfiguration, 'buildConfiguration cannot be passed for managed projects.');
+        const bundleIdentifier = config_plugins_1.IOSConfig.BundleIdentifier.getBundleIdentifier(exp);
+        if (!bundleIdentifier || !isBundleIdentifierValid(bundleIdentifier)) {
+            if (bundleIdentifier) {
+                log_1.default.warn(exports.INVALID_BUNDLE_IDENTIFIER_MESSAGE);
+            }
+            throw new Error(`Specify "ios.bundleIdentifier" in ${(0, projectUtils_1.getProjectConfigDescription)(projectDir)} and run this command again.`);
+        }
+        else {
+            return bundleIdentifier;
+        }
+    }
+}
+async function configureBundleIdentifierAsync({ graphqlClient, projectDir, projectId, exp, nonInteractive, }) {
+    if (nonInteractive) {
+        throw new Error(`The "ios.bundleIdentifier" is required to be set in app config when running in non-interactive mode. ${(0, log_1.learnMore)('https://docs.expo.dev/versions/latest/config/app/#bundleidentifier')}`);
+    }
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    // we can't automatically update app.config.js
+    if (paths.dynamicConfigPath) {
+        throw new Error(`"ios.bundleIdentifier" is not defined in your app.config.js and we can't update this file programmatically. Add the value on your own and run this command again.`);
+    }
+    (0, assert_1.default)(paths.staticConfigPath, 'app.json must exist');
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(`${chalk_1.default.bold(`📝  iOS Bundle Identifier`)} ${chalk_1.default.dim((0, log_1.learnMore)('https://expo.fyi/bundle-identifier'))}`);
+    const suggestedBundleIdentifier = await getSuggestedBundleIdentifierAsync(graphqlClient, exp, projectId);
+    const { bundleIdentifier } = await (0, prompts_1.promptAsync)({
+        name: 'bundleIdentifier',
+        type: 'text',
+        message: `What would you like your iOS bundle identifier to be?`,
+        initial: suggestedBundleIdentifier,
+        validate: value => (isBundleIdentifierValid(value) ? true : exports.INVALID_BUNDLE_IDENTIFIER_MESSAGE),
+    });
+    const rawStaticConfig = (0, appJson_1.readAppJson)(paths.staticConfigPath);
+    rawStaticConfig.expo = {
+        ...rawStaticConfig.expo,
+        ios: { ...rawStaticConfig.expo?.ios, bundleIdentifier },
+    };
+    await fs_extra_1.default.writeJson(paths.staticConfigPath, rawStaticConfig, { spaces: 2 });
+    exp.ios = { ...exp.ios, bundleIdentifier };
+    return bundleIdentifier;
+}
+function isBundleIdentifierValid(bundleIdentifier) {
+    return /^[a-zA-Z0-9-.]+$/.test(bundleIdentifier);
+}
+let warnPrinted = false;
+function warnIfBundleIdentifierDefinedInAppConfigForBareWorkflowProject(projectDir, exp) {
+    if (config_plugins_1.IOSConfig.BundleIdentifier.getBundleIdentifier(exp) && !warnPrinted) {
+        log_1.default.warn(`Specified value for "ios.bundleIdentifier" in ${(0, projectUtils_1.getProjectConfigDescription)(projectDir)} is ignored because an ${chalk_1.default.bold('ios')} directory was detected in the project.\n` +
+            'EAS Build will use the value found in the native code.');
+        warnPrinted = true;
+    }
+}
+function isWildcardBundleIdentifier(bundleIdentifier) {
+    const wildcardRegex = /^[A-Za-z0-9.-]+\*$/;
+    return wildcardRegex.test(bundleIdentifier);
+}
+async function getSuggestedBundleIdentifierAsync(graphqlClient, exp, projectId) {
+    // Attempt to use the android package name first since it's convenient to have them aligned.
+    const maybeAndroidPackage = config_plugins_1.AndroidConfig.Package.getPackage(exp);
+    if (maybeAndroidPackage && isBundleIdentifierValid(maybeAndroidPackage)) {
+        return maybeAndroidPackage;
+    }
+    else {
+        // the only callsite is heavily interactive
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        let possibleId;
+        // It's common to use dashes in your node project name, strip them from the suggested package name.
+        if (account.name) {
+            possibleId = `com.${account.name}.${exp.slug}`.split('-').join('');
+        }
+        else {
+            possibleId = `com.${exp.slug}`.split('-').join('');
+        }
+        if (isBundleIdentifierValid(possibleId)) {
+            return possibleId;
+        }
+    }
+    return undefined;
+}

package/build/project/ios/entitlements.d.ts

@@ -0,0 +1,9 @@
+import { JSONObject } from '@expo/json-file';
+import { Client } from '../../vcs/vcs';
+interface Target {
+    buildConfiguration?: string;
+    targetName: string;
+}
+export declare function getManagedApplicationTargetEntitlementsAsync(projectDir: string, env: Record<string, string>, vcsClient: Client): Promise<JSONObject>;
+export declare function getNativeTargetEntitlementsAsync(projectDir: string, target: Target): Promise<JSONObject | null>;
+export {};

package/build/project/ios/entitlements.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManagedApplicationTargetEntitlementsAsync = getManagedApplicationTargetEntitlementsAsync;
+exports.getNativeTargetEntitlementsAsync = getNativeTargetEntitlementsAsync;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const prebuild_config_1 = require("@expo/prebuild-config");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const plist_1 = require("../../utils/plist");
+const workflow_1 = require("../workflow");
+let wasExpoConfigPluginsWarnPrinted = false;
+async function getManagedApplicationTargetEntitlementsAsync(projectDir, env, vcsClient) {
+    const originalProcessEnv = process.env;
+    try {
+        process.env = {
+            ...process.env,
+            ...env,
+        };
+        let expWithMods;
+        try {
+            const { stdout } = await (0, spawn_async_1.default)('npx', ['expo', 'config', '--json', '--type', 'introspect'], {
+                cwd: projectDir,
+                env: {
+                    ...process.env,
+                    ...env,
+                    EXPO_NO_DOTENV: '1',
+                },
+            });
+            expWithMods = JSON.parse(stdout);
+        }
+        catch (err) {
+            if (!wasExpoConfigPluginsWarnPrinted) {
+                log_1.default.warn(`Failed to read the app config from the project using "npx expo config" command: ${err.message}.`);
+                log_1.default.warn('Falling back to the version of "@expo/config" shipped with the EAS CLI.');
+                wasExpoConfigPluginsWarnPrinted = true;
+            }
+            const { exp } = await (0, prebuild_config_1.getPrebuildConfigAsync)(projectDir, { platforms: ['ios'] });
+            expWithMods = await (0, config_plugins_1.compileModsAsync)(exp, {
+                projectRoot: projectDir,
+                platforms: ['ios'],
+                introspect: true,
+                ignoreExistingNativeFiles: await (0, workflow_1.hasIgnoredIosProjectAsync)(projectDir, vcsClient),
+            });
+        }
+        return expWithMods.ios?.entitlements ?? {};
+    }
+    finally {
+        process.env = originalProcessEnv;
+    }
+}
+async function getNativeTargetEntitlementsAsync(projectDir, target) {
+    const entitlementsPath = config_plugins_1.IOSConfig.Entitlements.getEntitlementsPath(projectDir, target);
+    if (entitlementsPath) {
+        const plist = await (0, plist_1.readPlistAsync)(entitlementsPath);
+        return plist ? plist : null;
+    }
+    else {
+        return null;
+    }
+}

package/build/project/ios/exemptEncryption.d.ts

@@ -0,0 +1,7 @@
+import { ExpoConfig } from '@expo/config';
+/** Non-exempt encryption must be set on every build in App Store Connect, we move it to before the build process to attempt only setting it once for the entire life-cycle of the project. */
+export declare function ensureNonExemptEncryptionIsDefinedForManagedProjectAsync({ projectDir, exp, nonInteractive, }: {
+    projectDir: string;
+    exp: ExpoConfig;
+    nonInteractive: boolean;
+}): Promise<void>;

package/build/project/ios/exemptEncryption.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNonExemptEncryptionIsDefinedForManagedProjectAsync = ensureNonExemptEncryptionIsDefinedForManagedProjectAsync;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importStar(require("../../log"));
+const prompts_1 = require("../../prompts");
+/** Non-exempt encryption must be set on every build in App Store Connect, we move it to before the build process to attempt only setting it once for the entire life-cycle of the project. */
+async function ensureNonExemptEncryptionIsDefinedForManagedProjectAsync({ projectDir, exp, nonInteractive, }) {
+    // TODO: We could add bare workflow support in the future.
+    // TODO: We could add wizard support for non-exempt encryption in the future.
+    const ITSAppUsesNonExemptEncryption = exp.ios?.infoPlist?.ITSAppUsesNonExemptEncryption ?? exp.ios?.config?.usesNonExemptEncryption;
+    if (ITSAppUsesNonExemptEncryption == null) {
+        await configureNonExemptEncryptionAsync({
+            projectDir,
+            exp,
+            nonInteractive,
+        });
+    }
+    else {
+        log_1.default.debug(`ITSAppUsesNonExemptEncryption is defined in the app config.`);
+    }
+}
+async function configureNonExemptEncryptionAsync({ projectDir, exp, nonInteractive, }) {
+    const description = (0, config_1.getProjectConfigDescription)(projectDir);
+    if (nonInteractive) {
+        log_1.default.warn((0, chalk_1.default) `${description} is missing {bold ios.infoPlist.ITSAppUsesNonExemptEncryption} boolean. Manual configuration is required in App Store Connect before the app can be tested.`);
+        return;
+    }
+    let onlyExemptEncryption = await (0, prompts_1.confirmAsync)({
+        message: `iOS app only uses standard/exempt encryption? ${chalk_1.default.dim((0, log_1.learnMore)('https://developer.apple.com/documentation/Security/complying-with-encryption-export-regulations'))}`,
+        initial: true,
+    });
+    if (!onlyExemptEncryption) {
+        const confirm = await (0, prompts_1.confirmAsync)({
+            message: `Are you sure your app uses non-exempt encryption? Selecting 'Yes' will require annual self-classification reports for the US government.`,
+            initial: true,
+        });
+        if (!confirm) {
+            log_1.default.warn((0, chalk_1.default) `Set {bold ios.infoPlist.ITSAppUsesNonExemptEncryption} in ${description} to release Apple builds faster.`);
+            onlyExemptEncryption = true;
+        }
+    }
+    const ITSAppUsesNonExemptEncryption = !onlyExemptEncryption;
+    // Only set this value if the answer is no, this enables developers to see the more in-depth prompt in App Store Connect. They can set the value manually in the app.json to avoid the EAS prompt in subsequent builds.
+    if (ITSAppUsesNonExemptEncryption) {
+        log_1.default.warn(`You'll need to manually configure the encryption status in App Store Connect before your build can be tested.`);
+        return;
+    }
+    // NOTE: Is is it possible to assert that the config needs to be modifiable before building the app?
+    const modification = await (0, config_1.modifyConfigAsync)(projectDir, {
+        ios: {
+            ...(exp.ios ?? {}),
+            infoPlist: {
+                ...(exp.ios?.infoPlist ?? {}),
+                ITSAppUsesNonExemptEncryption,
+            },
+        },
+    }, {
+        skipSDKVersionRequirement: true,
+    });
+    if (modification.type !== 'success') {
+        log_1.default.log();
+        if (modification.type === 'warn') {
+            // The project is using a dynamic config, give the user a helpful log and bail out.
+            log_1.default.log(chalk_1.default.yellow(modification.message));
+        }
+        const edits = {
+            ios: {
+                infoPlist: {
+                    ITSAppUsesNonExemptEncryption,
+                },
+            },
+        };
+        log_1.default.log(chalk_1.default.cyan(`Add the following to ${description}:`));
+        log_1.default.log();
+        log_1.default.log(JSON.stringify(edits, null, 2));
+        log_1.default.log();
+    }
+}

package/build/project/ios/scheme.d.ts

@@ -0,0 +1,18 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { Client } from '../../vcs/vcs';
+export interface XcodeBuildContext {
+    buildScheme: string;
+    buildConfiguration?: string;
+}
+export declare function resolveXcodeBuildContextAsync({ exp, projectDir, nonInteractive, vcsClient, }: {
+    exp: ExpoConfig;
+    projectDir: string;
+    nonInteractive: boolean;
+    vcsClient: Client;
+}, buildProfile: BuildProfile<Platform.IOS>): Promise<XcodeBuildContext>;
+export declare function selectSchemeAsync({ projectDir, nonInteractive, }: {
+    projectDir: string;
+    nonInteractive: boolean;
+}): Promise<string>;

package/build/project/ios/scheme.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveXcodeBuildContextAsync = resolveXcodeBuildContextAsync;
+exports.selectSchemeAsync = selectSchemeAsync;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const sortBy_1 = tslib_1.__importDefault(require("../../utils/expodash/sortBy"));
+const workflow_1 = require("../workflow");
+async function resolveXcodeBuildContextAsync({ exp, projectDir, nonInteractive, vcsClient, }, buildProfile) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(projectDir, eas_build_job_1.Platform.IOS, vcsClient);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        const buildScheme = buildProfile.scheme ??
+            (await selectSchemeAsync({
+                projectDir,
+                nonInteractive,
+            }));
+        return {
+            buildScheme,
+            buildConfiguration: buildProfile.buildConfiguration ??
+                (await config_plugins_1.IOSConfig.BuildScheme.getArchiveBuildConfigurationForSchemeAsync(projectDir, buildScheme)),
+        };
+    }
+    else {
+        const expoName = exp.name;
+        if (!expoName) {
+            throw new Error('"expo.name" is required in your app.json');
+        }
+        const sanitizedExpoName = config_plugins_1.IOSConfig.XcodeUtils.sanitizedName(expoName);
+        if (!sanitizedExpoName) {
+            throw new Error('"expo.name" needs to contain some alphanumeric characters');
+        }
+        return {
+            buildScheme: sanitizedExpoName,
+        };
+    }
+}
+async function selectSchemeAsync({ projectDir, nonInteractive = false, }) {
+    const schemes = config_plugins_1.IOSConfig.BuildScheme.getSchemesFromXcodeproj(projectDir);
+    if (schemes.length === 0) {
+        throw new Error(`We did not find any schemes in the Xcode project, make sure that at least one scheme is marked as "shared" in Xcode, and that it's listed in the output of "xcodebuild -list" command`);
+    }
+    if (schemes.length === 1) {
+        return schemes[0];
+    }
+    const sortedSchemes = (0, sortBy_1.default)(schemes);
+    log_1.default.newLine();
+    log_1.default.log(`We've found multiple schemes in your Xcode project: ${chalk_1.default.bold(sortedSchemes.join(', '))}`);
+    if (nonInteractive) {
+        const withoutTvOS = sortedSchemes.filter(i => !i.includes('tvOS'));
+        const scheme = withoutTvOS.length > 0 ? withoutTvOS[0] : sortedSchemes[0];
+        log_1.default.log(`You've run EAS CLI in non-interactive mode, choosing the ${chalk_1.default.bold(scheme)} scheme.`);
+        log_1.default.newLine();
+        return scheme;
+    }
+    else {
+        const { selectedScheme } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'selectedScheme',
+            message: 'Which scheme would you like to use?',
+            choices: sortedSchemes.map(scheme => ({ title: scheme, value: scheme })),
+        });
+        log_1.default.newLine();
+        return selectedScheme;
+    }
+}

package/build/project/ios/target.d.ts

@@ -0,0 +1,38 @@
+import { ExpoConfig } from '@expo/config';
+import { XcodeBuildContext } from './scheme';
+import { ApplePlatform } from '../../credentials/ios/appstore/constants';
+import { Target } from '../../credentials/ios/types';
+import { Client } from '../../vcs/vcs';
+interface ResolveTargetOptions {
+    projectDir: string;
+    exp: ExpoConfig;
+    env?: Record<string, string>;
+    xcodeBuildContext: XcodeBuildContext;
+    vcsClient: Client;
+}
+export declare function resolveManagedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, vcsClient, }: ResolveTargetOptions): Promise<Target[]>;
+export declare function resolveBareProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, vcsClient, }: ResolveTargetOptions): Promise<Target[]>;
+export declare function resolveTargetsAsync(opts: ResolveTargetOptions): Promise<Target[]>;
+export declare function findApplicationTarget(targets: Target[]): Target;
+export declare function findTargetByName(targets: Target[], name: string): Target;
+/**
+ * Get Apple Platform from the Xcode Target where possible.
+ * @returns - Apple Platform when known, defaults to IOS when unknown
+ */
+export declare function getApplePlatformFromTarget(target: Target): ApplePlatform;
+/**
+ * Get Apple Platform from the Xcode SDKROOT where possible.
+ * @returns - Apple Platform when known, defaults to null when unknown
+ */
+export declare function getApplePlatformFromSdkRoot(target: Target): ApplePlatform | null;
+/**
+ * Get Apple Platform from the Xcode TARGETED_DEVICE_FAMILY where possible.
+ *
+ * References:
+ * https://developer-mdn.apple.com/library/archive/documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html
+ * https://stackoverflow.com/questions/39677524/xcode-8-how-to-change-targeted-device-family#comment100316573_39677659
+ *
+ * @returns - Apple Platform when known, defaults to null when unknown
+ */
+export declare function getApplePlatformFromDeviceFamily(target: Target): ApplePlatform | null;
+export {};

package/build/project/ios/target.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveManagedProjectTargetsAsync = resolveManagedProjectTargetsAsync;
+exports.resolveBareProjectTargetsAsync = resolveBareProjectTargetsAsync;
+exports.resolveTargetsAsync = resolveTargetsAsync;
+exports.findApplicationTarget = findApplicationTarget;
+exports.findTargetByName = findTargetByName;
+exports.getApplePlatformFromTarget = getApplePlatformFromTarget;
+exports.getApplePlatformFromSdkRoot = getApplePlatformFromSdkRoot;
+exports.getApplePlatformFromDeviceFamily = getApplePlatformFromDeviceFamily;
+const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const bundleIdentifier_1 = require("./bundleIdentifier");
+const entitlements_1 = require("./entitlements");
+const constants_1 = require("../../credentials/ios/appstore/constants");
+const workflow_1 = require("../workflow");
+const AppExtensionsConfigSchema = joi_1.default.array().items(joi_1.default.object({
+    targetName: joi_1.default.string().required(),
+    bundleIdentifier: joi_1.default.string().required(),
+    parentBundleIdentifier: joi_1.default.string(),
+    entitlements: joi_1.default.object(),
+}));
+async function resolveManagedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, vcsClient, }) {
+    const { buildScheme, buildConfiguration } = xcodeBuildContext;
+    const applicationTargetName = buildScheme;
+    const applicationTargetBundleIdentifier = await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient, {
+        targetName: applicationTargetName,
+        buildConfiguration,
+    });
+    const applicationTargetEntitlements = await (0, entitlements_1.getManagedApplicationTargetEntitlementsAsync)(projectDir, env ?? {}, vcsClient);
+    const appExtensions = exp.extra?.eas?.build?.experimental?.ios?.appExtensions ?? [];
+    const { error } = AppExtensionsConfigSchema.validate(appExtensions, {
+        allowUnknown: false,
+        abortEarly: false,
+    });
+    if (error) {
+        throw new Error(`Failed to validate "extra.eas.build.experimental.ios.appExtensions" in you app config.\n${error.message}`);
+    }
+    const extensionsTargets = appExtensions.map(extension => ({
+        targetName: extension.targetName,
+        buildConfiguration,
+        bundleIdentifier: extension.bundleIdentifier,
+        parentBundleIdentifier: extension.parentBundleIdentifier ?? applicationTargetBundleIdentifier,
+        entitlements: extension.entitlements ?? {},
+    }));
+    return [
+        {
+            targetName: applicationTargetName,
+            bundleIdentifier: applicationTargetBundleIdentifier,
+            buildConfiguration,
+            entitlements: applicationTargetEntitlements,
+        },
+        ...extensionsTargets,
+    ];
+}
+async function resolveBareProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, vcsClient, }) {
+    const { buildScheme, buildConfiguration } = xcodeBuildContext;
+    const result = [];
+    const pbxProject = config_plugins_1.IOSConfig.XcodeUtils.getPbxproj(projectDir);
+    const applicationTarget = await config_plugins_1.IOSConfig.Target.findApplicationTargetWithDependenciesAsync(projectDir, buildScheme);
+    const bundleIdentifier = await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient, {
+        targetName: applicationTarget.name,
+        buildConfiguration,
+    });
+    const entitlements = await (0, entitlements_1.getNativeTargetEntitlementsAsync)(projectDir, {
+        targetName: applicationTarget.name,
+        buildConfiguration,
+    });
+    result.push({
+        targetName: applicationTarget.name,
+        bundleIdentifier,
+        buildConfiguration,
+        entitlements: entitlements ?? {},
+        buildSettings: resolveBareProjectBuildSettings(pbxProject, applicationTarget.name, buildConfiguration),
+    });
+    const dependencies = await resolveBareProjectDependenciesAsync({
+        exp,
+        projectDir,
+        buildConfiguration,
+        target: applicationTarget,
+        bundleIdentifier,
+        pbxProject,
+        vcsClient,
+    });
+    if (dependencies.length > 0) {
+        result.push(...dependencies);
+    }
+    return result;
+}
+async function resolveTargetsAsync(opts) {
+    const workflow = await (0, workflow_1.resolveWorkflowAsync)(opts.projectDir, eas_build_job_1.Platform.IOS, opts.vcsClient);
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        return await resolveBareProjectTargetsAsync(opts);
+    }
+    else if (workflow === eas_build_job_1.Workflow.MANAGED) {
+        return await resolveManagedProjectTargetsAsync(opts);
+    }
+    else {
+        throw new Error(`Unknown workflow: ${workflow}`);
+    }
+}
+async function resolveBareProjectDependenciesAsync({ exp, projectDir, buildConfiguration, target, bundleIdentifier, pbxProject, vcsClient, }) {
+    const result = [];
+    if (target.dependencies && target.dependencies.length > 0) {
+        for (const dependency of target.dependencies) {
+            if (!dependency.signable) {
+                continue;
+            }
+            const dependencyBundleIdentifier = await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient, {
+                targetName: dependency.name,
+                buildConfiguration,
+            });
+            const entitlements = await (0, entitlements_1.getNativeTargetEntitlementsAsync)(projectDir, {
+                targetName: dependency.name,
+                buildConfiguration,
+            });
+            result.push({
+                targetName: dependency.name,
+                buildConfiguration,
+                bundleIdentifier: dependencyBundleIdentifier,
+                parentBundleIdentifier: bundleIdentifier,
+                entitlements: entitlements ?? {},
+                buildSettings: resolveBareProjectBuildSettings(pbxProject, dependency.name, buildConfiguration),
+            });
+            const dependencyDependencies = await resolveBareProjectDependenciesAsync({
+                exp,
+                projectDir,
+                buildConfiguration,
+                target: dependency,
+                bundleIdentifier: dependencyBundleIdentifier,
+                pbxProject,
+                vcsClient,
+            });
+            if (dependencyDependencies.length > 0) {
+                result.push(...dependencyDependencies);
+            }
+        }
+    }
+    return result;
+}
+function findApplicationTarget(targets) {
+    const applicationTarget = targets.find(({ parentBundleIdentifier }) => !parentBundleIdentifier);
+    if (!applicationTarget) {
+        throw new Error('Could not find the application target');
+    }
+    return applicationTarget;
+}
+function findTargetByName(targets, name) {
+    const target = targets.find(target => target.targetName === name);
+    if (!target) {
+        throw new Error(`Could not find target '${name}'`);
+    }
+    return target;
+}
+function resolveBareProjectBuildSettings(project, targetName, buildConfiguration) {
+    const xcBuildConfiguration = config_plugins_1.IOSConfig.Target.getXCBuildConfigurationFromPbxproj(project, {
+        targetName,
+        buildConfiguration,
+    });
+    return xcBuildConfiguration?.buildSettings ?? {};
+}
+/**
+ * Get Apple Platform from the Xcode Target where possible.
+ * @returns - Apple Platform when known, defaults to IOS when unknown
+ */
+function getApplePlatformFromTarget(target) {
+    return (getApplePlatformFromSdkRoot(target) ??
+        getApplePlatformFromDeviceFamily(target) ??
+        constants_1.ApplePlatform.IOS);
+}
+/**
+ * Get Apple Platform from the Xcode SDKROOT where possible.
+ * @returns - Apple Platform when known, defaults to null when unknown
+ */
+function getApplePlatformFromSdkRoot(target) {
+    const sdkRoot = target.buildSettings?.SDKROOT;
+    if (!sdkRoot) {
+        return null;
+    }
+    if (sdkRoot.includes('iphoneos')) {
+        return constants_1.ApplePlatform.IOS;
+    }
+    else if (sdkRoot.includes('tvos')) {
+        return constants_1.ApplePlatform.TV_OS;
+    }
+    else if (sdkRoot.includes('macosx')) {
+        return constants_1.ApplePlatform.MAC_OS;
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Get Apple Platform from the Xcode TARGETED_DEVICE_FAMILY where possible.
+ *
+ * References:
+ * https://developer-mdn.apple.com/library/archive/documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html
+ * https://stackoverflow.com/questions/39677524/xcode-8-how-to-change-targeted-device-family#comment100316573_39677659
+ *
+ * @returns - Apple Platform when known, defaults to null when unknown
+ */
+function getApplePlatformFromDeviceFamily(target) {
+    const deviceFamily = target.buildSettings?.TARGETED_DEVICE_FAMILY;
+    if (!deviceFamily) {
+        return null;
+    }
+    if (typeof deviceFamily === 'string') {
+        const devices = deviceFamily.split(',');
+        const arbitraryDevice = devices[0];
+        const deviceFamilyNumber = Number(arbitraryDevice);
+        return deviceFamilyToPlatform(deviceFamilyNumber);
+    }
+    else if (typeof deviceFamily === 'number') {
+        return deviceFamilyToPlatform(deviceFamily);
+    }
+    throw new Error(`Unexpected device family type in XCode build settings: ${JSON.stringify(deviceFamily)}`);
+}
+function deviceFamilyToPlatform(deviceFamily) {
+    if (deviceFamily === 1 || deviceFamily === 2) {
+        return constants_1.ApplePlatform.IOS;
+    }
+    else if (deviceFamily === 3) {
+        return constants_1.ApplePlatform.TV_OS;
+    }
+    else {
+        return null;
+    }
+}