@akylas/nativescript-cli 8.7.2

package/lib/commands/add-platform.js

@@ -0,0 +1,49 @@
+"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.AddPlatformCommand = void 0;
+const command_base_1 = require("./command-base");
+const yok_1 = require("../common/yok");
+class AddPlatformCommand extends command_base_1.ValidatePlatformCommandBase {
+    constructor($options, $platformCommandHelper, $platformValidationService, $projectData, $platformsDataService, $errors) {
+        super($options, $platformsDataService, $platformValidationService, $projectData);
+        this.$platformCommandHelper = $platformCommandHelper;
+        this.$errors = $errors;
+        this.allowedParameters = [];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$platformCommandHelper.addPlatforms(args, this.$projectData, this.$options.frameworkPath);
+        });
+    }
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecuteCommandBase: { get: () => super.canExecuteCommandBase }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args || args.length === 0) {
+                this.$errors.failWithHelp("No platform specified. Please specify a platform to add.");
+            }
+            let canExecute = true;
+            for (const arg of args) {
+                this.$platformValidationService.validatePlatform(arg, this.$projectData);
+                if (!this.$platformValidationService.isPlatformSupportedForOS(arg, this.$projectData)) {
+                    this.$errors.fail(`Applications for platform ${arg} cannot be built on this OS`);
+                }
+                canExecute = yield _super.canExecuteCommandBase.call(this, arg);
+            }
+            return canExecute;
+        });
+    }
+}
+exports.AddPlatformCommand = AddPlatformCommand;
+yok_1.injector.registerCommand("platform|add", AddPlatformCommand);

package/lib/commands/apple-login.js

@@ -0,0 +1,52 @@
+"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.AppleLogin = void 0;
+const command_params_1 = require("../common/command-params");
+const yok_1 = require("../common/yok");
+class AppleLogin {
+    constructor($applePortalSessionService, $errors, $injector, $logger, $prompter) {
+        this.$applePortalSessionService = $applePortalSessionService;
+        this.$errors = $errors;
+        this.$injector = $injector;
+        this.$logger = $logger;
+        this.$prompter = $prompter;
+        this.allowedParameters = [
+            new command_params_1.StringCommandParameter(this.$injector),
+            new command_params_1.StringCommandParameter(this.$injector),
+        ];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let username = args[0];
+            if (!username) {
+                username = yield this.$prompter.getString("Apple ID", {
+                    allowEmpty: false,
+                });
+            }
+            let password = args[1];
+            if (!password) {
+                password = yield this.$prompter.getPassword("Apple ID password");
+            }
+            const user = yield this.$applePortalSessionService.createUserSession({
+                username,
+                password,
+            });
+            if (!user.areCredentialsValid) {
+                this.$errors.fail(`Invalid username and password combination. Used '${username}' as the username.`);
+            }
+            const output = Buffer.from(user.userSessionCookie).toString("base64");
+            this.$logger.info(output);
+        });
+    }
+}
+exports.AppleLogin = AppleLogin;
+yok_1.injector.registerCommand("apple-login", AppleLogin);

package/lib/commands/appstore-list.js

@@ -0,0 +1,75 @@
+"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.ListiOSApps = void 0;
+const helpers_1 = require("../common/helpers");
+const command_params_1 = require("../common/command-params");
+const yok_1 = require("../common/yok");
+class ListiOSApps {
+    constructor($injector, $applePortalApplicationService, $applePortalSessionService, $logger, $projectData, $devicePlatformsConstants, $platformValidationService, $errors, $prompter, $options) {
+        this.$injector = $injector;
+        this.$applePortalApplicationService = $applePortalApplicationService;
+        this.$applePortalSessionService = $applePortalSessionService;
+        this.$logger = $logger;
+        this.$projectData = $projectData;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$platformValidationService = $platformValidationService;
+        this.$errors = $errors;
+        this.$prompter = $prompter;
+        this.$options = $options;
+        this.allowedParameters = [
+            new command_params_1.StringCommandParameter(this.$injector),
+            new command_params_1.StringCommandParameter(this.$injector),
+        ];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.iOS, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`);
+            }
+            let username = args[0];
+            let password = args[1];
+            if (!username) {
+                username = yield this.$prompter.getString("Apple ID", {
+                    allowEmpty: false,
+                });
+            }
+            if (!password) {
+                password = yield this.$prompter.getPassword("Apple ID password");
+            }
+            const user = yield this.$applePortalSessionService.createUserSession({ username, password }, {
+                sessionBase64: this.$options.appleSessionBase64,
+            });
+            if (!user.areCredentialsValid) {
+                this.$errors.fail(`Invalid username and password combination. Used '${username}' as the username.`);
+            }
+            const applications = yield this.$applePortalApplicationService.getApplications(user);
+            if (!applications || !applications.length) {
+                this.$logger.info("Seems you don't have any applications yet.");
+            }
+            else {
+                const table = (0, helpers_1.createTable)(["Application Name", "Bundle Identifier", "In Flight Version"], applications.map((application) => {
+                    const version = (application &&
+                        application.versionSets &&
+                        application.versionSets.length &&
+                        application.versionSets[0].inFlightVersion &&
+                        application.versionSets[0].inFlightVersion.version) ||
+                        "";
+                    return [application.name, application.bundleId, version];
+                }));
+                this.$logger.info(table.toString());
+            }
+        });
+    }
+}
+exports.ListiOSApps = ListiOSApps;
+yok_1.injector.registerCommand("appstore|*list", ListiOSApps);

package/lib/commands/appstore-upload.js

@@ -0,0 +1,106 @@
+"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.PublishIOS = void 0;
+const path = require("path");
+const command_params_1 = require("../common/command-params");
+const build_data_1 = require("../data/build-data");
+const yok_1 = require("../common/yok");
+class PublishIOS {
+    constructor($applePortalSessionService, $injector, $itmsTransporterService, $logger, $projectData, $options, $prompter, $devicePlatformsConstants, $hostInfo, $errors, $buildController, $platformValidationService) {
+        this.$applePortalSessionService = $applePortalSessionService;
+        this.$injector = $injector;
+        this.$itmsTransporterService = $itmsTransporterService;
+        this.$logger = $logger;
+        this.$projectData = $projectData;
+        this.$options = $options;
+        this.$prompter = $prompter;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$hostInfo = $hostInfo;
+        this.$errors = $errors;
+        this.$buildController = $buildController;
+        this.$platformValidationService = $platformValidationService;
+        this.allowedParameters = [
+            new command_params_1.StringCommandParameter(this.$injector),
+            new command_params_1.StringCommandParameter(this.$injector),
+            new command_params_1.StringCommandParameter(this.$injector),
+            new command_params_1.StringCommandParameter(this.$injector),
+        ];
+        this.$projectData.initializeProjectData();
+    }
+    execute(args) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$itmsTransporterService.validate(this.$options.appleApplicationSpecificPassword);
+            const username = args[0] ||
+                (yield this.$prompter.getString("Apple ID", { allowEmpty: false }));
+            const password = args[1] || (yield this.$prompter.getPassword("Apple ID password"));
+            const user = yield this.$applePortalSessionService.createUserSession({ username, password }, {
+                applicationSpecificPassword: this.$options
+                    .appleApplicationSpecificPassword,
+                sessionBase64: this.$options.appleSessionBase64,
+                requireInteractiveConsole: true,
+                requireApplicationSpecificPassword: true,
+            });
+            if (!user.areCredentialsValid) {
+                this.$errors.fail(`Invalid username and password combination. Used '${username}' as the username.`);
+            }
+            const mobileProvisionIdentifier = (_a = this.$options.provision) !== null && _a !== void 0 ? _a : args[2];
+            let ipaFilePath = this.$options.ipa
+                ? path.resolve(this.$options.ipa)
+                : null;
+            if (!mobileProvisionIdentifier && !ipaFilePath) {
+                this.$logger.warn("No mobile provision identifier set. A default mobile provision will be used. You can set one in app/App_Resources/iOS/build.xcconfig");
+            }
+            this.$options.release = true;
+            if (!ipaFilePath) {
+                const platform = this.$devicePlatformsConstants.iOS.toLowerCase();
+                if (mobileProvisionIdentifier) {
+                    this.$logger.info("Building .ipa with the selected mobile provision and/or certificate. " +
+                        mobileProvisionIdentifier);
+                    this.$options.forDevice = true;
+                    this.$options.provision = mobileProvisionIdentifier;
+                    const buildData = new build_data_1.IOSBuildData(this.$projectData.projectDir, platform, Object.assign(Object.assign({}, this.$options.argv), { watch: false }));
+                    ipaFilePath = yield this.$buildController.prepareAndBuild(buildData);
+                }
+                else {
+                    this.$logger.info("No .ipa, mobile provision or certificate set. Perfect! Now we'll build .xcarchive and let Xcode pick the distribution certificate and provisioning profile for you when exporting .ipa for AppStore submission.");
+                    const buildData = new build_data_1.IOSBuildData(this.$projectData.projectDir, platform, Object.assign(Object.assign({}, this.$options.argv), { buildForAppStore: true, watch: false }));
+                    ipaFilePath = yield this.$buildController.prepareAndBuild(buildData);
+                    this.$logger.info(`Export at: ${ipaFilePath}`);
+                }
+            }
+            yield this.$itmsTransporterService.upload({
+                credentials: { username, password },
+                user,
+                applicationSpecificPassword: this.$options
+                    .appleApplicationSpecificPassword,
+                ipaFilePath,
+                shouldExtractIpa: !!this.$options.ipa,
+                verboseLogging: this.$logger.getLevel() === "TRACE",
+                teamId: this.$options.teamId,
+            });
+        });
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$hostInfo.isDarwin) {
+                this.$errors.fail("iOS publishing is only available on macOS.");
+            }
+            if (!this.$platformValidationService.isPlatformSupportedForOS(this.$devicePlatformsConstants.iOS, this.$projectData)) {
+                this.$errors.fail(`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`);
+            }
+            return true;
+        });
+    }
+}
+exports.PublishIOS = PublishIOS;
+yok_1.injector.registerCommand(["publish|ios", "appstore|upload"], PublishIOS);

package/lib/commands/build.js

@@ -0,0 +1,161 @@
+"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.BuildVisionOsCommand = exports.BuildAndroidCommand = exports.BuildIosCommand = exports.BuildCommandBase = void 0;
+const constants_1 = require("../constants");
+const command_base_1 = require("./command-base");
+const helpers_1 = require("../common/helpers");
+const yok_1 = require("../common/yok");
+class BuildCommandBase extends command_base_1.ValidatePlatformCommandBase {
+    constructor($options, $errors, $projectData, $platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $buildDataService, $logger) {
+        super($options, $platformsDataService, $platformValidationService, $projectData);
+        this.$errors = $errors;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$buildController = $buildController;
+        this.$buildDataService = $buildDataService;
+        this.$logger = $logger;
+        this.dashedOptions = {
+            watch: {
+                type: "boolean",
+                default: false,
+                hasSensitiveValue: false,
+            },
+            hmr: { type: "boolean", default: false, hasSensitiveValue: false },
+        };
+        this.$projectData.initializeProjectData();
+    }
+    executeCore(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = args[0].toLowerCase();
+            const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, platform, Object.assign(Object.assign({}, this.$options.argv), { buildFilterDevicesArch: false }));
+            const outputPath = yield this.$buildController.prepareAndBuild(buildData);
+            return outputPath;
+        });
+    }
+    validatePlatform(platform) {
+        if (!this.$platformValidationService.isPlatformSupportedForOS(platform, this.$projectData)) {
+            this.$errors.fail(`Applications for platform ${platform} can not be built on this OS`);
+        }
+    }
+    validateArgs(args, platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args.length !== 0) {
+                this.$errors.failWithHelp(`The arguments '${args.join(" ")}' are not valid for the current command.`);
+            }
+            const result = yield this.$platformValidationService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, platform);
+            return result;
+        });
+    }
+}
+exports.BuildCommandBase = BuildCommandBase;
+class BuildIosCommand extends BuildCommandBase {
+    constructor($options, $errors, $projectData, $platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $logger, $buildDataService, $migrateController) {
+        super($options, $errors, $projectData, $platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $buildDataService, $logger);
+        this.$options = $options;
+        this.$migrateController = $migrateController;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeCore([this.$devicePlatformsConstants.iOS.toLowerCase()]);
+        });
+    }
+    canExecute(args) {
+        const _super = Object.create(null, {
+            validatePlatform: { get: () => super.validatePlatform },
+            canExecuteCommandBase: { get: () => super.canExecuteCommandBase },
+            validateArgs: { get: () => super.validateArgs }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = this.$devicePlatformsConstants.iOS;
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms: [platform],
+                });
+            }
+            _super.validatePlatform.call(this, platform);
+            let canExecute = yield _super.canExecuteCommandBase.call(this, platform);
+            if (canExecute) {
+                canExecute = yield _super.validateArgs.call(this, args, platform);
+            }
+            return canExecute;
+        });
+    }
+}
+exports.BuildIosCommand = BuildIosCommand;
+yok_1.injector.registerCommand("build|ios", BuildIosCommand);
+class BuildAndroidCommand extends BuildCommandBase {
+    constructor($options, $errors, $projectData, platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $androidBundleValidatorHelper, $buildDataService, $logger, $migrateController) {
+        super($options, $errors, $projectData, platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $buildDataService, $logger);
+        this.$options = $options;
+        this.$errors = $errors;
+        this.$androidBundleValidatorHelper = $androidBundleValidatorHelper;
+        this.$logger = $logger;
+        this.$migrateController = $migrateController;
+        this.allowedParameters = [];
+    }
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeCore([
+                this.$devicePlatformsConstants.Android.toLowerCase(),
+            ]);
+            if (this.$options.aab) {
+                this.$logger.info(constants_1.AndroidAppBundleMessages.ANDROID_APP_BUNDLE_DOCS_MESSAGE);
+                if (this.$options.release) {
+                    this.$logger.info(constants_1.AndroidAppBundleMessages.ANDROID_APP_BUNDLE_PUBLISH_DOCS_MESSAGE);
+                }
+            }
+        });
+    }
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecuteCommandBase: { get: () => super.canExecuteCommandBase },
+            validateArgs: { get: () => super.validateArgs }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const platform = this.$devicePlatformsConstants.Android;
+            if (!this.$options.force) {
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms: [platform],
+                });
+            }
+            this.$androidBundleValidatorHelper.validateRuntimeVersion(this.$projectData);
+            let canExecute = yield _super.canExecuteCommandBase.call(this, platform);
+            if (canExecute) {
+                if (this.$options.release && !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                    this.$errors.failWithHelp(constants_1.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+                }
+                canExecute = yield _super.validateArgs.call(this, args, platform);
+            }
+            return canExecute;
+        });
+    }
+}
+exports.BuildAndroidCommand = BuildAndroidCommand;
+yok_1.injector.registerCommand("build|android", BuildAndroidCommand);
+class BuildVisionOsCommand extends BuildIosCommand {
+    constructor($options, $errors, $projectData, $platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $logger, $buildDataService, $migrateController) {
+        super($options, $errors, $projectData, $platformsDataService, $devicePlatformsConstants, $buildController, $platformValidationService, $logger, $buildDataService, $migrateController);
+        this.$options = $options;
+        this.$migrateController = $migrateController;
+    }
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$errors.fail('Building for "visionOS" platform is not supported via the CLI. Please open the project in Xcode and build it from there.');
+            return false;
+        });
+    }
+}
+exports.BuildVisionOsCommand = BuildVisionOsCommand;
+yok_1.injector.registerCommand("build|vision", BuildVisionOsCommand);
+yok_1.injector.registerCommand("build|visionos", BuildVisionOsCommand);