@akylas/nativescript-cli 8.7.2

package/lib/services/ios/ios-signing-service.js

@@ -0,0 +1,265 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSSigningService = void 0;
+const path = require("path");
+const constants_1 = require("../../constants");
+const helpers = require("../../common/helpers");
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+const constants = require("../../constants");
+class IOSSigningService {
+    constructor($errors, $fs, $iOSProvisionService, $logger, $pbxprojDomXcode, $prompter, $xcconfigService, $xcprojService) {
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$iOSProvisionService = $iOSProvisionService;
+        this.$logger = $logger;
+        this.$pbxprojDomXcode = $pbxprojDomXcode;
+        this.$prompter = $prompter;
+        this.$xcconfigService = $xcconfigService;
+        this.$xcprojService = $xcprojService;
+    }
+    setupSigningForDevice(projectRoot, projectData, iOSBuildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const xcode = this.$pbxprojDomXcode.Xcode.open(this.getPbxProjPath(projectData, projectRoot));
+            const signing = xcode.getSigning(projectData.projectName);
+            const hasProvisioningProfileInXCConfig = this.readXCConfigProvisioningProfileSpecifierForIPhoneOs(projectData) ||
+                this.readXCConfigProvisioningProfileSpecifier(projectData) ||
+                this.readXCConfigProvisioningProfileForIPhoneOs(projectData) ||
+                this.readXCConfigProvisioningProfile(projectData);
+            if (hasProvisioningProfileInXCConfig &&
+                (!signing || signing.style !== "Manual")) {
+                xcode.setManualSigningStyle(projectData.projectName);
+                this.getExtensionNames(projectData).forEach((name) => {
+                    xcode.setManualSigningStyle(name);
+                });
+                xcode.save();
+            }
+            else if (!iOSBuildData.provision &&
+                !(signing && signing.style === "Manual" && !iOSBuildData.teamId)) {
+                const teamId = yield this.getDevelopmentTeam(projectData, projectRoot, iOSBuildData.teamId);
+                yield this.setupSigningFromTeam(projectRoot, projectData, teamId);
+            }
+        });
+    }
+    setupSigningFromTeam(projectRoot, projectData, teamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const xcode = this.$pbxprojDomXcode.Xcode.open(this.getPbxProjPath(projectData, projectRoot));
+            const signing = xcode.getSigning(projectData.projectName);
+            let shouldUpdateXcode = false;
+            if (signing && signing.style === "Automatic") {
+                if (signing.team !== teamId) {
+                    const teamIdsForName = yield this.$iOSProvisionService.getTeamIdsWithName(teamId);
+                    if (!teamIdsForName.some((id) => id === signing.team)) {
+                        shouldUpdateXcode = true;
+                    }
+                }
+            }
+            else {
+                shouldUpdateXcode = true;
+            }
+            if (shouldUpdateXcode) {
+                const teamIdsForName = yield this.$iOSProvisionService.getTeamIdsWithName(teamId);
+                if (teamIdsForName.length > 0) {
+                    this.$logger.trace(`Team id ${teamIdsForName[0]} will be used for team name "${teamId}".`);
+                    teamId = teamIdsForName[0];
+                }
+                xcode.setAutomaticSigningStyle(projectData.projectName, teamId);
+                xcode.setAutomaticSigningStyleByTargetProductTypesList([
+                    constants_1.IOSNativeTargetProductTypes.appExtension,
+                    constants_1.IOSNativeTargetProductTypes.watchApp,
+                    constants_1.IOSNativeTargetProductTypes.watchExtension,
+                ], teamId);
+                this.getExtensionNames(projectData).forEach((name) => {
+                    xcode.setAutomaticSigningStyle(name, teamId);
+                });
+                xcode.save();
+                this.$logger.trace(`Set Automatic signing style and team id ${teamId}.`);
+            }
+            else {
+                this.$logger.trace(`The specified ${teamId} is already set in the Xcode.`);
+            }
+        });
+    }
+    setupSigningFromProvision(projectRoot, projectData, provision, mobileProvisionData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!provision) {
+                return;
+            }
+            const xcode = this.$pbxprojDomXcode.Xcode.open(this.getPbxProjPath(projectData, projectRoot));
+            const signing = xcode.getSigning(projectData.projectName);
+            let shouldUpdateXcode = false;
+            if (signing && signing.style === "Manual") {
+                for (const config in signing.configurations) {
+                    const options = signing.configurations[config];
+                    if (options.name !== provision && options.uuid !== provision) {
+                        shouldUpdateXcode = true;
+                        break;
+                    }
+                }
+            }
+            else {
+                shouldUpdateXcode = true;
+            }
+            if (shouldUpdateXcode) {
+                const projectSigningConfig = yield this.getManualSigningConfiguration(projectData, provision, mobileProvisionData);
+                xcode.setManualSigningStyle(projectData.projectName, projectSigningConfig);
+                xcode.setManualSigningStyleByTargetProductTypesList([
+                    constants_1.IOSNativeTargetProductTypes.appExtension,
+                    constants_1.IOSNativeTargetProductTypes.watchApp,
+                    constants_1.IOSNativeTargetProductTypes.watchExtension,
+                ], projectSigningConfig);
+                this.$logger.trace(`Set Manual signing style and provisioning profile: ${projectSigningConfig.name} (${projectSigningConfig.uuid})`);
+                const extensionSigningConfig = yield Promise.all(this.getExtensionsManualSigningConfiguration(projectData));
+                extensionSigningConfig.forEach(({ name, configuration }) => {
+                    xcode.setManualSigningStyle(name, configuration);
+                    this.$logger.trace(`Set Manual signing style and provisioning profile: ${configuration.name} (${configuration.uuid})`);
+                });
+                xcode.save();
+            }
+            else {
+                this.$logger.trace(`The specified provisioning profile is already set in the Xcode: ${provision}`);
+            }
+        });
+    }
+    getExtensionNames(projectData) {
+        const extensionFolderPath = path.join(projectData.getAppResourcesDirectoryPath(), constants.iOSAppResourcesFolderName, constants.NATIVE_EXTENSION_FOLDER);
+        if (this.$fs.exists(extensionFolderPath)) {
+            const extensionNames = this.$fs
+                .readDirectory(extensionFolderPath)
+                .filter((fileName) => {
+                const extensionPath = path.join(extensionFolderPath, fileName);
+                const stats = this.$fs.getFsStats(extensionPath);
+                return stats.isDirectory() && !fileName.startsWith(".");
+            });
+            return extensionNames;
+        }
+        return [];
+    }
+    getExtensionsManualSigningConfiguration(projectData) {
+        const provisioningJSONPath = path.join(projectData.getAppResourcesDirectoryPath(), constants.iOSAppResourcesFolderName, constants.NATIVE_EXTENSION_FOLDER, constants.EXTENSION_PROVISIONING_FILENAME);
+        if (this.$fs.exists(provisioningJSONPath)) {
+            const provisioningJSON = this.$fs.readJson(provisioningJSONPath);
+            const extensionNames = this.getExtensionNames(projectData);
+            const provisioning = Object.entries(provisioningJSON).map(([id, provision]) => __awaiter(this, void 0, void 0, function* () {
+                const name = id.split(".").at(-1);
+                if (extensionNames.includes(name)) {
+                    const configuration = yield this.getManualSigningConfiguration(projectData, provision);
+                    return { name, configuration };
+                }
+                return null;
+            }));
+            return provisioning;
+        }
+        return [];
+    }
+    getManualSigningConfiguration(projectData, provision, mobileProvisionData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pickStart = Date.now();
+            const mobileprovision = mobileProvisionData ||
+                (yield this.$iOSProvisionService.pick(provision, projectData.projectIdentifiers.ios));
+            const pickEnd = Date.now();
+            this.$logger.trace("Searched and " +
+                (mobileprovision ? "found" : "failed to find ") +
+                " matching provisioning profile. (" +
+                (pickEnd - pickStart) +
+                "ms.)");
+            if (!mobileprovision) {
+                this.$errors.fail("Failed to find mobile provision with UUID or Name: " + provision);
+            }
+            const configuration = {
+                team: mobileprovision.TeamIdentifier &&
+                    mobileprovision.TeamIdentifier.length > 0
+                    ? mobileprovision.TeamIdentifier[0]
+                    : undefined,
+                uuid: mobileprovision.UUID,
+                name: mobileprovision.Name,
+                identity: mobileprovision.Type === "Development"
+                    ? "iPhone Developer"
+                    : "iPhone Distribution",
+            };
+            return configuration;
+        });
+    }
+    getBuildXCConfigFilePath(projectData) {
+        return path.join(projectData.appResourcesDirectoryPath, constants_1.iOSAppResourcesFolderName, constants_1.BUILD_XCCONFIG_FILE_NAME);
+    }
+    getPbxProjPath(projectData, projectRoot) {
+        return path.join(this.$xcprojService.getXcodeprojPath(projectData, projectRoot), "project.pbxproj");
+    }
+    getDevelopmentTeam(projectData, projectRoot, teamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            teamId = teamId || this.readXCConfigDevelopmentTeam(projectData);
+            if (!teamId) {
+                const teams = yield this.$iOSProvisionService.getDevelopmentTeams();
+                this.$logger.warn("Xcode requires a team id to be specified when building for device.");
+                this.$logger.warn("You can specify the team id by setting the DEVELOPMENT_TEAM setting in build.xcconfig file located in App_Resources folder of your app, or by using the --teamId option when calling run, debug or livesync commands.");
+                if (teams.length === 1) {
+                    teamId = teams[0].id;
+                    this.$logger.warn("Found and using the following development team installed on your system: " +
+                        teams[0].name +
+                        " (" +
+                        teams[0].id +
+                        ")");
+                }
+                else if (teams.length > 0) {
+                    if (!helpers.isInteractive()) {
+                        this.$errors.fail(`Unable to determine default development team. Available development teams are: ${_.map(teams, (team) => team.id)}. Specify team in app/App_Resources/iOS/build.xcconfig file in the following way: DEVELOPMENT_TEAM = <team id>`);
+                    }
+                    const choices = [];
+                    for (const team of teams) {
+                        choices.push(team.name + " (" + team.id + ")");
+                    }
+                    const choice = yield this.$prompter.promptForChoice("Found multiple development teams, select one:", choices);
+                    teamId = teams[choices.indexOf(choice)].id;
+                    const choicesPersist = [
+                        "Yes, set the DEVELOPMENT_TEAM setting in build.xcconfig file.",
+                        "Yes, persist the team id in platforms folder.",
+                        "No, don't persist this setting.",
+                    ];
+                    const choicePersist = yield this.$prompter.promptForChoice("Do you want to make teamId: " +
+                        teamId +
+                        " a persistent choice for your app?", choicesPersist);
+                    switch (choicesPersist.indexOf(choicePersist)) {
+                        case 0:
+                            const xcconfigFile = path.join(projectData.appResourcesDirectoryPath, "iOS", constants_1.BUILD_XCCONFIG_FILE_NAME);
+                            this.$fs.appendFile(xcconfigFile, "\nDEVELOPMENT_TEAM = " + teamId + "\n");
+                            break;
+                        case 1:
+                            this.$fs.writeFile(path.join(projectRoot, "teamid"), teamId);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+            this.$logger.trace(`Selected teamId is '${teamId}'.`);
+            return teamId;
+        });
+    }
+    readXCConfigDevelopmentTeam(projectData) {
+        return this.$xcconfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "DEVELOPMENT_TEAM");
+    }
+    readXCConfigProvisioningProfile(projectData) {
+        return this.$xcconfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "PROVISIONING_PROFILE");
+    }
+    readXCConfigProvisioningProfileForIPhoneOs(projectData) {
+        return this.$xcconfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "PROVISIONING_PROFILE[sdk=iphoneos*]");
+    }
+    readXCConfigProvisioningProfileSpecifier(projectData) {
+        return this.$xcconfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "PROVISIONING_PROFILE_SPECIFIER");
+    }
+    readXCConfigProvisioningProfileSpecifierForIPhoneOs(projectData) {
+        return this.$xcconfigService.readPropertyValue(this.getBuildXCConfigFilePath(projectData), "PROVISIONING_PROFILE_SPECIFIER[sdk=iphoneos*]");
+    }
+}
+exports.IOSSigningService = IOSSigningService;
+yok_1.injector.register("iOSSigningService", IOSSigningService);

package/lib/services/ios/spm-service.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPMService = void 0;
+const yok_1 = require("../../common/yok");
+const trapezedev_project_1 = require("@rigor789/trapezedev-project");
+const path = require("path");
+class SPMService {
+    constructor($logger, $projectConfigService, $xcodebuildCommandService, $xcodebuildArgsService) {
+        this.$logger = $logger;
+        this.$projectConfigService = $projectConfigService;
+        this.$xcodebuildCommandService = $xcodebuildCommandService;
+        this.$xcodebuildArgsService = $xcodebuildArgsService;
+    }
+    getSPMPackages(projectData, platform) {
+        const spmPackages = this.$projectConfigService.getValue(`${platform}.SPMPackages`, []);
+        return spmPackages;
+    }
+    applySPMPackages(platformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const spmPackages = this.getSPMPackages(projectData, platformData.platformNameLowerCase);
+                if (!spmPackages.length) {
+                    this.$logger.trace("SPM: no SPM packages to apply.");
+                    return;
+                }
+                const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
+                    ios: {
+                        path: ".",
+                    },
+                    enableAndroid: false,
+                });
+                yield project.load();
+                if (!project.ios) {
+                    this.$logger.trace("SPM: no iOS project found via trapeze.");
+                    return;
+                }
+                for (const pkg of spmPackages) {
+                    if ("path" in pkg) {
+                        this.$logger.trace("SPM: resolving path for package: ", pkg.path);
+                        pkg.path = path.resolve(projectData.projectDir, pkg.path);
+                    }
+                    this.$logger.trace(`SPM: adding package ${pkg.name} to project.`, pkg);
+                    yield project.ios.addSPMPackage(projectData.projectName, pkg);
+                }
+                yield project.commit();
+                yield this.resolveSPMDependencies(platformData, projectData);
+            }
+            catch (err) {
+                this.$logger.trace("SPM: error applying SPM packages: ", err);
+            }
+        });
+    }
+    resolveSPMDependencies(platformData, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$xcodebuildCommandService.executeCommand(this.$xcodebuildArgsService
+                .getXcodeProjectArgs(platformData, projectData)
+                .concat([
+                "-destination",
+                "generic/platform=iOS",
+                "-resolvePackageDependencies",
+            ]), {
+                cwd: projectData.projectDir,
+                message: "Resolving SPM dependencies...",
+            });
+        });
+    }
+}
+exports.SPMService = SPMService;
+yok_1.injector.register("spmService", SPMService);

package/lib/services/ios/xcodebuild-args-service.js

@@ -0,0 +1,163 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XcodebuildArgsService = void 0;
+const path = require("path");
+const constants = require("../../constants");
+const constants_1 = require("../../common/constants");
+const yok_1 = require("../../common/yok");
+const _ = require("lodash");
+const ios_project_service_1 = require("../ios-project-service");
+class XcodebuildArgsService {
+    constructor($devicePlatformsConstants, $devicesService, $fs, $iOSWatchAppService, $logger, $xcconfigService) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$devicesService = $devicesService;
+        this.$fs = $fs;
+        this.$iOSWatchAppService = $iOSWatchAppService;
+        this.$logger = $logger;
+        this.$xcconfigService = $xcconfigService;
+    }
+    getBuildForSimulatorArgs(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let args = yield this.getArchitecturesArgs(buildConfig);
+            if (this.$iOSWatchAppService.hasWatchApp(platformData, projectData)) {
+                args = args.concat(["CODE_SIGNING_ALLOWED=NO"]);
+            }
+            else {
+                args = args.concat(["CODE_SIGN_IDENTITY="]);
+            }
+            let destination = "generic/platform=iOS Simulator";
+            let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
+            if (isvisionOS) {
+                destination = "platform=visionOS Simulator";
+                if (buildConfig._device) {
+                    destination += `,id=${buildConfig._device.deviceInfo.identifier}`;
+                }
+            }
+            args = args
+                .concat([
+                "-destination",
+                destination,
+                "build",
+                "-configuration",
+                buildConfig.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug,
+            ])
+                .concat(this.getBuildCommonArgs(platformData, projectData, isvisionOS ? ios_project_service_1.VisionSimulatorPlatformSdkName : ios_project_service_1.SimulatorPlatformSdkName))
+                .concat(this.getBuildLoggingArgs())
+                .concat(this.getXcodeProjectArgs(platformData, projectData));
+            return args;
+        });
+    }
+    getBuildForDeviceArgs(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const architectures = yield this.getArchitecturesArgs(buildConfig);
+            const archivePath = path.join(platformData.getBuildOutputPath(buildConfig), projectData.projectName + ".xcarchive");
+            let destination = "generic/platform=iOS";
+            let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
+            if (isvisionOS) {
+                destination = "platform=visionOS";
+                if (buildConfig._device) {
+                    destination += `,id=${buildConfig._device.deviceInfo.identifier}`;
+                }
+            }
+            const args = [
+                "-destination",
+                destination,
+                "archive",
+                "-archivePath",
+                archivePath,
+                "-configuration",
+                buildConfig.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug,
+                "-allowProvisioningUpdates",
+            ]
+                .concat(this.getXcodeProjectArgs(platformData, projectData))
+                .concat(architectures)
+                .concat(this.getBuildCommonArgs(platformData, projectData, ios_project_service_1.DevicePlatformSdkName))
+                .concat(this.getBuildLoggingArgs());
+            return args;
+        });
+    }
+    getArchitecturesArgs(buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = [];
+            if (this.$devicePlatformsConstants.isvisionOS(buildConfig.platform)) {
+                args.push("ONLY_ACTIVE_ARCH=YES");
+                return args;
+            }
+            const devicesArchitectures = buildConfig.buildForDevice
+                ? yield this.getArchitecturesFromConnectedDevices(buildConfig)
+                : [];
+            if (!buildConfig.buildForDevice || devicesArchitectures.length > 1) {
+                args.push("ONLY_ACTIVE_ARCH=NO");
+            }
+            return args;
+        });
+    }
+    getXcodeProjectArgs(platformData, projectData) {
+        const xcworkspacePath = path.join(platformData.projectRoot, `${projectData.projectName}.xcworkspace`);
+        const skipPackageValidation = "-skipPackagePluginValidation";
+        const extraArgs = [
+            "-scheme",
+            projectData.projectName,
+            skipPackageValidation,
+        ];
+        const BUILD_SETTINGS_FILE_PATH = path.join(projectData.appResourcesDirectoryPath, platformData.normalizedPlatformName, constants.BUILD_XCCONFIG_FILE_NAME);
+        const deployTargetProperty = "IPHONEOS_DEPLOYMENT_TARGET";
+        const deployTargetVersion = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, deployTargetProperty);
+        if (deployTargetVersion) {
+            extraArgs.push(`${deployTargetProperty}=${deployTargetVersion}`);
+        }
+        const swiftUIBootProperty = "NS_SWIFTUI_BOOT";
+        const swiftUIBootValue = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, swiftUIBootProperty);
+        if (swiftUIBootValue) {
+            extraArgs.push(`${swiftUIBootProperty}=${swiftUIBootValue}`);
+        }
+        if (this.$fs.exists(xcworkspacePath)) {
+            return ["-workspace", xcworkspacePath, ...extraArgs];
+        }
+        const xcodeprojPath = path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`);
+        return ["-project", xcodeprojPath, ...extraArgs];
+    }
+    getBuildLoggingArgs() {
+        return this.$logger.getLevel() === "INFO" ? ["-quiet"] : [];
+    }
+    getBuildCommonArgs(platformData, projectData, platformSdkName) {
+        let args = [];
+        if (!this.$iOSWatchAppService.hasWatchApp(platformData, projectData)) {
+            args = args.concat(["-sdk", platformSdkName]);
+        }
+        args = args.concat([
+            "BUILD_DIR=" + path.join(platformData.projectRoot, constants.BUILD_DIR),
+            "SHARED_PRECOMPS_DIR=" +
+                path.join(platformData.projectRoot, constants.BUILD_DIR, "sharedpch"),
+        ]);
+        return args;
+    }
+    getArchitecturesFromConnectedDevices(buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = this.$devicePlatformsConstants.iOS.toLowerCase();
+            yield this.$devicesService.initialize({
+                platform,
+                deviceId: buildConfig.device,
+                skipEmulatorStart: true,
+            });
+            const instances = this.$devicesService.getDevicesForPlatform(platform);
+            const architectures = _(instances)
+                .map((d) => d.deviceInfo.activeArchitecture)
+                .filter((d) => !!d)
+                .uniq()
+                .value();
+            return architectures;
+        });
+    }
+}
+exports.XcodebuildArgsService = XcodebuildArgsService;
+yok_1.injector.register("xcodebuildArgsService", XcodebuildArgsService);

package/lib/services/ios/xcodebuild-command-service.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XcodebuildCommandService = void 0;
+const constants = require("../../constants");
+const yok_1 = require("../../common/yok");
+class XcodebuildCommandService {
+    constructor($childProcess, $errors, $logger) {
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$logger = $logger;
+    }
+    executeCommand(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message, cwd, stdio, spawnOptions } = options;
+            this.$logger.info(message || "Xcode build...");
+            const childProcessOptions = { cwd, stdio: stdio || "inherit" };
+            try {
+                const commandResult = yield this.$childProcess.spawnFromEvent("xcodebuild", args, "exit", childProcessOptions, spawnOptions || {
+                    emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
+                    throwError: true,
+                });
+                return commandResult;
+            }
+            catch (err) {
+                this.$errors.fail(err.message);
+            }
+        });
+    }
+}
+exports.XcodebuildCommandService = XcodebuildCommandService;
+yok_1.injector.register("xcodebuildCommandService", XcodebuildCommandService);

package/lib/services/ios/xcodebuild-service.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XcodebuildService = void 0;
+const path = require("path");
+const yok_1 = require("../../common/yok");
+class XcodebuildService {
+    constructor($exportOptionsPlistService, $xcodebuildArgsService, $xcodebuildCommandService) {
+        this.$exportOptionsPlistService = $exportOptionsPlistService;
+        this.$xcodebuildArgsService = $xcodebuildArgsService;
+        this.$xcodebuildCommandService = $xcodebuildCommandService;
+    }
+    buildForDevice(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = yield this.$xcodebuildArgsService.getBuildForDeviceArgs(platformData, projectData, buildConfig);
+            yield this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: platformData.projectRoot,
+                stdio: buildConfig && buildConfig.buildOutputStdio,
+            });
+            const archivePath = yield this.createDevelopmentArchive(platformData, projectData, buildConfig);
+            return archivePath;
+        });
+    }
+    buildForSimulator(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = yield this.$xcodebuildArgsService.getBuildForSimulatorArgs(platformData, projectData, buildConfig);
+            yield this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: platformData.projectRoot,
+                stdio: buildConfig.buildOutputStdio,
+            });
+        });
+    }
+    buildForAppStore(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = yield this.$xcodebuildArgsService.getBuildForDeviceArgs(platformData, projectData, buildConfig);
+            yield this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: platformData.projectRoot,
+                stdio: buildConfig && buildConfig.buildOutputStdio,
+            });
+            const archivePath = yield this.createDistributionArchive(platformData, projectData, buildConfig);
+            return archivePath;
+        });
+    }
+    createDevelopmentArchive(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const archivePath = path.join(platformData.getBuildOutputPath(buildConfig), projectData.projectName + ".xcarchive");
+            const output = yield this.$exportOptionsPlistService.createDevelopmentExportOptionsPlist(archivePath, projectData, buildConfig);
+            const args = [
+                "-exportArchive",
+                "-archivePath",
+                archivePath,
+                "-exportPath",
+                output.exportFileDir,
+                "-exportOptionsPlist",
+                output.exportOptionsPlistFilePath,
+            ];
+            yield this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: platformData.projectRoot,
+                stdio: buildConfig.buildOutputStdio,
+            });
+            return output.exportFilePath;
+        });
+    }
+    createDistributionArchive(platformData, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const archivePath = path.join(platformData.getBuildOutputPath(buildConfig), projectData.projectName + ".xcarchive");
+            const output = yield this.$exportOptionsPlistService.createDistributionExportOptionsPlist(archivePath, projectData, buildConfig);
+            const args = [
+                "-exportArchive",
+                "-archivePath",
+                archivePath,
+                "-exportPath",
+                output.exportFileDir,
+                "-exportOptionsPlist",
+                output.exportOptionsPlistFilePath,
+            ];
+            yield this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: platformData.projectRoot,
+            });
+            return output.exportFilePath;
+        });
+    }
+}
+exports.XcodebuildService = XcodebuildService;
+yok_1.injector.register("xcodebuildService", XcodebuildService);