@akylas/nativescript-cli 8.7.2

package/lib/helpers/livesync-command-helper.js

@@ -0,0 +1,220 @@
+"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.LiveSyncCommandHelper = void 0;
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+const constants_1 = require("../constants");
+class LiveSyncCommandHelper {
+    constructor($androidBundleValidatorHelper, $buildDataService, $projectData, $options, $deployController, $iosDeviceOperations, $mobileHelper, $devicesService, $injector, $buildController, $analyticsService, $errors, $iOSSimulatorLogProvider, $cleanupService, $runController) {
+        this.$androidBundleValidatorHelper = $androidBundleValidatorHelper;
+        this.$buildDataService = $buildDataService;
+        this.$projectData = $projectData;
+        this.$options = $options;
+        this.$deployController = $deployController;
+        this.$iosDeviceOperations = $iosDeviceOperations;
+        this.$mobileHelper = $mobileHelper;
+        this.$devicesService = $devicesService;
+        this.$injector = $injector;
+        this.$buildController = $buildController;
+        this.$analyticsService = $analyticsService;
+        this.$errors = $errors;
+        this.$iOSSimulatorLogProvider = $iOSSimulatorLogProvider;
+        this.$cleanupService = $cleanupService;
+        this.$runController = $runController;
+    }
+    get $platformsDataService() {
+        return this.$injector.resolve("platformsDataService");
+    }
+    getLiveSyncData(projectDir) {
+        const liveSyncInfo = {
+            projectDir,
+            skipWatcher: !this.$options.watch || this.$options.justlaunch,
+            clean: this.$options.clean,
+            release: this.$options.release,
+            env: this.$options.env,
+            timeout: this.$options.timeout,
+            useHotModuleReload: this.$options.hmr,
+            force: this.$options.force,
+            emulator: this.$options.emulator,
+        };
+        return liveSyncInfo;
+    }
+    getDeviceInstances(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                platform,
+                deviceId: this.$options.device,
+                emulator: this.$options.emulator,
+                skipInferPlatform: !platform,
+                sdk: this.$options.sdk,
+            });
+            const devices = this.$devicesService
+                .getDeviceInstances()
+                .filter((d) => !platform ||
+                d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
+            return devices;
+        });
+    }
+    createDeviceDescriptors(devices, platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceDescriptors = devices.map((d) => {
+                const outputPath = additionalOptions &&
+                    additionalOptions.getOutputDirectory &&
+                    additionalOptions.getOutputDirectory({
+                        platform: d.deviceInfo.platform,
+                        emulator: d.isEmulator,
+                        projectDir: this.$projectData.projectDir,
+                    });
+                const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, d.deviceInfo.platform, Object.assign(Object.assign({}, this.$options.argv), { outputPath, buildForDevice: !d.isEmulator, watch: !this.$options.release && this.$options.watch, nativePrepare: {
+                        forceRebuildNativeApp: additionalOptions.forceRebuildNativeApp,
+                    }, _device: d }));
+                this.$androidBundleValidatorHelper.validateDeviceApiLevel(d, buildData);
+                const buildAction = additionalOptions && additionalOptions.buildPlatform
+                    ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildData, this.$projectData)
+                    : this.$buildController.build.bind(this.$buildController, buildData);
+                const info = {
+                    identifier: d.deviceInfo.identifier,
+                    buildAction,
+                    debuggingEnabled: additionalOptions &&
+                        additionalOptions.deviceDebugMap &&
+                        additionalOptions.deviceDebugMap[d.deviceInfo.identifier],
+                    debugOptions: this.$options,
+                    skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
+                    buildData,
+                };
+                return info;
+            });
+            return deviceDescriptors;
+        });
+    }
+    getPlatformsForOperation(platform) {
+        const availablePlatforms = platform
+            ? [platform]
+            : _.values(this.$mobileHelper.platformNames.map((p) => p.toLowerCase()));
+        return availablePlatforms;
+    }
+    executeCommandLiveSync(platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDeviceInstances(platform);
+            yield this.executeLiveSyncOperation(devices, platform, additionalOptions);
+        });
+    }
+    executeLiveSyncOperation(devices, platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { liveSyncInfo, deviceDescriptors } = yield this.executeLiveSyncOperationCore(devices, platform, additionalOptions);
+            if (this.$options.release) {
+                yield this.runInRelease(platform, deviceDescriptors);
+                return;
+            }
+            if (additionalOptions.restartLiveSync) {
+                yield this.$runController.stop({
+                    projectDir: this.$projectData.projectDir,
+                    deviceIdentifiers: deviceDescriptors.map((device) => device.identifier),
+                    stopOptions: {
+                        shouldAwaitAllActions: true,
+                        keepProcessAlive: true,
+                    },
+                });
+                const devices = yield this.getDeviceInstances(platform);
+                yield this.executeLiveSyncOperation(devices, platform, Object.assign(Object.assign({}, additionalOptions), { restartLiveSync: false }));
+                return;
+            }
+            else {
+                yield this.$runController.run({
+                    liveSyncInfo,
+                    deviceDescriptors,
+                });
+            }
+            this.$runController.on(constants_1.RunOnDeviceEvents.runOnDeviceStopped, (data) => __awaiter(this, void 0, void 0, function* () {
+                const devices = yield this.getDeviceInstances(platform);
+                const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
+                _.remove(remainingDevicesToSync, (d) => d === data.deviceIdentifier);
+                if (remainingDevicesToSync.length === 0 && !data.keepProcessAlive) {
+                    process.exit(134);
+                }
+            }));
+        });
+    }
+    validatePlatform(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const availablePlatforms = this.getPlatformsForOperation(platform);
+            for (const availablePlatform of availablePlatforms) {
+                const platformData = this.$platformsDataService.getPlatformData(availablePlatform, this.$projectData);
+                const platformProjectService = platformData.platformProjectService;
+                const validateOutput = yield platformProjectService.validate(this.$projectData, this.$options);
+                result[availablePlatform.toLowerCase()] = validateOutput;
+            }
+            return result;
+        });
+    }
+    executeLiveSyncOperationCore(devices, platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!devices || !devices.length) {
+                if (platform) {
+                    this.$errors.fail("Unable to find applicable devices to execute operation. Ensure connected devices are trusted and try again.");
+                }
+                else {
+                    this.$errors.fail("Unable to find applicable devices to execute operation and unable to start emulator when platform is not specified.");
+                }
+            }
+            const workingWithAppleDevices = !platform || this.$mobileHelper.isApplePlatform(platform);
+            const shouldKeepProcessAlive = this.$options.watch || !this.$options.justlaunch;
+            if (shouldKeepProcessAlive) {
+                this.$analyticsService.setShouldDispose(false);
+                this.$cleanupService.setShouldDispose(false);
+                if (workingWithAppleDevices) {
+                    this.$iosDeviceOperations.setShouldDispose(false);
+                    this.$iOSSimulatorLogProvider.setShouldDispose(false);
+                }
+            }
+            const deviceDescriptors = yield this.createDeviceDescriptors(devices, platform, additionalOptions);
+            const liveSyncInfo = this.getLiveSyncData(this.$projectData.projectDir);
+            return { liveSyncInfo, deviceDescriptors };
+        });
+    }
+    runInRelease(platform, deviceDescriptors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$devicesService.initialize({
+                platform,
+                deviceId: this.$options.device,
+                emulator: this.$options.emulator,
+                skipInferPlatform: !platform,
+                sdk: this.$options.sdk,
+            });
+            yield this.$deployController.deploy({ deviceDescriptors });
+            for (const deviceDescriptor of deviceDescriptors) {
+                const device = this.$devicesService.getDeviceByIdentifier(deviceDescriptor.identifier);
+                yield device.applicationManager.startApplication({
+                    appId: this.$projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
+                    projectName: this.$projectData.projectName,
+                    projectDir: this.$projectData.projectDir,
+                });
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.getDeviceInstances();
+            return this.$runController.stop({
+                projectDir: this.$projectData.projectDir,
+                deviceIdentifiers: devices.map((d) => d.deviceInfo.identifier),
+                stopOptions: {
+                    shouldAwaitAllActions: true,
+                    keepProcessAlive: true,
+                },
+            });
+        });
+    }
+}
+exports.LiveSyncCommandHelper = LiveSyncCommandHelper;
+yok_1.injector.register("liveSyncCommandHelper", LiveSyncCommandHelper);

package/lib/helpers/network-connectivity-validator.js

@@ -0,0 +1,47 @@
+"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.NetworkConnectivityValidator = void 0;
+const dns = require("dns");
+const yok_1 = require("../common/yok");
+class NetworkConnectivityValidator {
+    constructor($errors, $logger) {
+        this.$errors = $errors;
+        this.$logger = $logger;
+    }
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isConnected = yield this.isConnected();
+            if (!isConnected) {
+                this.$errors.fail(NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE);
+            }
+        });
+    }
+    isConnected() {
+        return new Promise((resolve, reject) => {
+            dns.lookup(NetworkConnectivityValidator.DNS_LOOKUP_URL, (err) => {
+                this.$logger.trace(`Error from dns.lookup is ${err}.`);
+                if (err &&
+                    err.code === NetworkConnectivityValidator.NO_INTERNET_ERROR_CODE) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+}
+NetworkConnectivityValidator.DNS_LOOKUP_URL = "play.nativescript.org";
+NetworkConnectivityValidator.NO_INTERNET_ERROR_CODE = "ENOTFOUND";
+NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE = "No internet connection. Check your internet settings and try again.";
+exports.NetworkConnectivityValidator = NetworkConnectivityValidator;
+yok_1.injector.register("networkConnectivityValidator", NetworkConnectivityValidator);

package/lib/helpers/options-track-helper.js

@@ -0,0 +1,88 @@
+"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.OptionsTracker = void 0;
+const path = require("path");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class OptionsTracker {
+    constructor($analyticsService) {
+        this.$analyticsService = $analyticsService;
+    }
+    trackOptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trackObject = this.getTrackObject(options);
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Options",
+                additionalData: JSON.stringify(trackObject),
+            });
+        });
+    }
+    getTrackObject(options) {
+        const optionsArgvCopy = _.cloneDeep(options.argv);
+        return this.sanitizeTrackObject(optionsArgvCopy, options);
+    }
+    sanitizeTrackObject(data, options) {
+        const shorthands = options ? options.shorthands : [];
+        const optionsDefinitions = options ? options.options : {};
+        _.forEach(data, (value, key) => {
+            if (this.shouldSkipProperty(key, value, shorthands, optionsDefinitions)) {
+                delete data[key];
+            }
+            else {
+                if (options &&
+                    optionsDefinitions[key] &&
+                    optionsDefinitions[key].hasSensitiveValue !== false) {
+                    value = OptionsTracker.PRIVATE_REPLACE_VALUE;
+                }
+                else if (key.toLowerCase().indexOf(OptionsTracker.PASSWORD_DETECTION_STRING) >=
+                    0) {
+                    value = OptionsTracker.PRIVATE_REPLACE_VALUE;
+                }
+                else if (_.isString(value) && value !== path.basename(value)) {
+                    value = OptionsTracker.PATH_REPLACE_VALUE;
+                }
+                else if (_.isObject(value) && !_.isArray(value)) {
+                    value = this.sanitizeTrackObject(value);
+                }
+                data[key] = value;
+            }
+        });
+        return data;
+    }
+    shouldSkipProperty(key, value, shorthands = [], options = {}) {
+        if (shorthands.indexOf(key) >= 0) {
+            return true;
+        }
+        if (key.indexOf("-") >= 0) {
+            return true;
+        }
+        if (key === "_") {
+            return true;
+        }
+        const optionDef = options[key];
+        if (optionDef && optionDef.type === "boolean") {
+            if ((optionDef.default !== true && value === false) ||
+                (optionDef.default === true && value === true)) {
+                return true;
+            }
+        }
+        if (_.isUndefined(value)) {
+            return true;
+        }
+    }
+}
+OptionsTracker.PASSWORD_DETECTION_STRING = "password";
+OptionsTracker.PRIVATE_REPLACE_VALUE = "private";
+OptionsTracker.PATH_REPLACE_VALUE = "_localpath";
+OptionsTracker.SIZE_EXEEDED_REPLACE_VALUE = "sizeExceeded";
+exports.OptionsTracker = OptionsTracker;
+yok_1.injector.register("optionsTracker", OptionsTracker);

package/lib/helpers/package-path-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackageJSONPath = exports.resolvePackagePath = void 0;
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
+Object.defineProperty(exports, "resolvePackagePath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackagePath; } });
+Object.defineProperty(exports, "resolvePackageJSONPath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackageJSONPath; } });

package/lib/helpers/platform-command-helper.js

@@ -0,0 +1,192 @@
+"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.PlatformCommandHelper = void 0;
+const path = require("path");
+const semver = require("semver");
+const _ = require("lodash");
+const constants = require("../constants");
+const yok_1 = require("../common/yok");
+class PlatformCommandHelper {
+    constructor($platformController, $fs, $errors, $logger, $mobileHelper, $packageInstallationManager, $pacoteService, $platformsDataService, $platformValidationService, $projectChangesService, $projectDataService, $tempService) {
+        this.$platformController = $platformController;
+        this.$fs = $fs;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$pacoteService = $pacoteService;
+        this.$platformsDataService = $platformsDataService;
+        this.$platformValidationService = $platformValidationService;
+        this.$projectChangesService = $projectChangesService;
+        this.$projectDataService = $projectDataService;
+        this.$tempService = $tempService;
+    }
+    addPlatforms(platforms, projectData, frameworkPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformsDir = projectData.platformsDir;
+            this.$fs.ensureDirectoryExists(platformsDir);
+            for (const platform of platforms) {
+                this.$platformValidationService.validatePlatform(platform, projectData);
+                const platformPath = path.join(projectData.platformsDir, platform);
+                const isPlatformAdded = this.isPlatformAdded(platform, platformPath, projectData);
+                if (isPlatformAdded) {
+                    this.$errors.fail(`Platform ${platform} already added`);
+                }
+                yield this.$platformController.addPlatform({
+                    projectDir: projectData.projectDir,
+                    platform,
+                    frameworkPath,
+                });
+            }
+        });
+    }
+    cleanPlatforms(platforms, projectData, framworkPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const platform of platforms) {
+                const version = this.getCurrentPlatformVersion(platform, projectData);
+                yield this.removePlatforms([platform], projectData);
+                const platformParam = version ? `${platform}@${version}` : platform;
+                yield this.addPlatforms([platformParam], projectData, framworkPath);
+            }
+        });
+    }
+    removePlatforms(platforms, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const platform of platforms) {
+                this.$platformValidationService.validatePlatformInstalled(platform, projectData);
+                const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+                let errorMessage;
+                try {
+                    yield platformData.platformProjectService.stopServices(platformData.projectRoot);
+                }
+                catch (err) {
+                    errorMessage = err.message;
+                }
+                try {
+                    const platformDir = path.join(projectData.platformsDir, platform.toLowerCase());
+                    this.$fs.deleteDirectory(platformDir);
+                    yield this.$packageInstallationManager.uninstall(platformData.frameworkPackageName, projectData.projectDir);
+                    this.$logger.info(`Platform ${platform} successfully removed.`);
+                }
+                catch (err) {
+                    this.$logger.error(`Failed to remove ${platform} platform with errors:`);
+                    if (errorMessage) {
+                        this.$logger.error(errorMessage);
+                    }
+                    this.$errors.fail(err.message);
+                }
+            }
+        });
+    }
+    updatePlatforms(platforms, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const platformParam of platforms) {
+                const data = platformParam.split("@"), platform = data[0], version = data[1];
+                const hasPlatformDirectory = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
+                if (hasPlatformDirectory) {
+                    yield this.updatePlatform(platform, version, projectData);
+                }
+                else {
+                    yield this.$platformController.addPlatform({
+                        projectDir: projectData.projectDir,
+                        platform: platformParam,
+                    });
+                }
+            }
+        });
+    }
+    getInstalledPlatforms(projectData) {
+        if (!this.$fs.exists(projectData.platformsDir)) {
+            return [];
+        }
+        const subDirs = this.$fs.readDirectory(projectData.platformsDir);
+        const platforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
+        return _.filter(subDirs, (p) => platforms.indexOf(p) > -1);
+    }
+    getAvailablePlatforms(projectData) {
+        const installedPlatforms = this.getInstalledPlatforms(projectData);
+        return _.filter(this.$mobileHelper.platformNames, (p) => {
+            return (installedPlatforms.indexOf(p) < 0 &&
+                this.$platformValidationService.isPlatformSupportedForOS(p, projectData));
+        });
+    }
+    getPreparedPlatforms(projectData) {
+        return _.filter(this.$mobileHelper.platformNames, (p) => {
+            return this.isPlatformPrepared(p, projectData);
+        });
+    }
+    getCurrentPlatformVersion(platform, projectData) {
+        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        const currentPlatformData = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
+        const version = currentPlatformData && currentPlatformData.version;
+        return version;
+    }
+    isPlatformAdded(platform, platformPath, projectData) {
+        if (!this.$fs.exists(platformPath)) {
+            return false;
+        }
+        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        const prepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
+        if (!prepareInfo) {
+            return true;
+        }
+        return (prepareInfo.nativePlatformStatus !==
+            "1");
+    }
+    updatePlatform(platform, version, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            const data = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
+            const currentVersion = data && data.version ? data.version : "0.2.0";
+            const installedModuleDir = yield this.$tempService.mkdirSync("runtime-to-update");
+            let newVersion = version === constants.PackageVersion.NEXT
+                ? yield this.$packageInstallationManager.getNextVersion(platformData.frameworkPackageName)
+                : version ||
+                    (yield this.$packageInstallationManager.getLatestCompatibleVersion(platformData.frameworkPackageName));
+            yield this.$pacoteService.extractPackage(`${platformData.frameworkPackageName}@${newVersion}`, installedModuleDir);
+            const cachedPackageData = this.$fs.readJson(path.join(installedModuleDir, "package.json"));
+            newVersion = (cachedPackageData && cachedPackageData.version) || newVersion;
+            if (!semver.valid(newVersion)) {
+                this.$errors.fail("The version %s is not valid. The version should consists from 3 parts separated by dot.", newVersion);
+            }
+            if (!semver.gt(currentVersion, newVersion)) {
+                yield this.updatePlatformCore(platformData, { currentVersion, newVersion }, projectData);
+            }
+            else if (semver.eq(currentVersion, newVersion)) {
+                this.$errors.fail("Current and new version are the same.");
+            }
+            else {
+                this.$errors.fail(`Your current version: ${currentVersion} is higher than the one you're trying to install ${newVersion}.`);
+            }
+        });
+    }
+    updatePlatformCore(platformData, updateOptions, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let packageName = platformData.normalizedPlatformName.toLowerCase();
+            yield this.removePlatforms([packageName], projectData);
+            packageName = updateOptions.newVersion
+                ? `${packageName}@${updateOptions.newVersion}`
+                : packageName;
+            yield this.$platformController.addPlatform({
+                projectDir: projectData.projectDir,
+                platform: packageName,
+            });
+            this.$logger.info("Successfully updated to version ", updateOptions.newVersion);
+        });
+    }
+    isPlatformPrepared(platform, projectData) {
+        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        return platformData.platformProjectService.isPlatformPrepared(platformData.projectRoot, projectData);
+    }
+}
+exports.PlatformCommandHelper = PlatformCommandHelper;
+yok_1.injector.register("platformCommandHelper", PlatformCommandHelper);

package/lib/helpers/version-validator-helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionValidatorHelper = void 0;
+const semver = require("semver");
+class VersionValidatorHelper {
+    isValidVersion(version) {
+        return semver.valid(version) || semver.validRange(version);
+    }
+    isVersionGreaterThan(v1, v2) {
+        return this.compareCoerceVersions(v1, v2, semver.gt);
+    }
+    isVersionGreaterOrEqualThan(v1, v2) {
+        return this.compareCoerceVersions(v1, v2, semver.gte);
+    }
+    isVersionLowerThan(v1, v2) {
+        return this.compareCoerceVersions(v1, v2, semver.lt);
+    }
+    isVersionLowerOrEqualThan(v1, v2) {
+        return this.compareCoerceVersions(v1, v2, semver.lte);
+    }
+    compareCoerceVersions(version, minVersion, condition) {
+        return condition(semver.coerce(version), semver.coerce(minVersion));
+    }
+}
+exports.VersionValidatorHelper = VersionValidatorHelper;

package/lib/key-commands/bootstrap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("../common/yok");
+const path = "./key-commands/index";
+yok_1.injector.requireKeyCommand("a", path);
+yok_1.injector.requireKeyCommand("A", path);
+yok_1.injector.requireKeyCommand("i", path);
+yok_1.injector.requireKeyCommand("I", path);
+yok_1.injector.requireKeyCommand("v", path);
+yok_1.injector.requireKeyCommand("V", path);
+yok_1.injector.requireKeyCommand("r", path);
+yok_1.injector.requireKeyCommand("R", path);
+yok_1.injector.requireKeyCommand("w", path);
+yok_1.injector.requireKeyCommand("c", path);
+yok_1.injector.requireKeyCommand("n", path);
+yok_1.injector.requireKeyCommand("?", path);
+yok_1.injector.requireKeyCommand("\u0003", path);
+yok_1.injector.requireCommand("open|ios", path);
+yok_1.injector.requireCommand("open|android", path);
+yok_1.injector.requireCommand("open|visionos", path);
+yok_1.injector.requireCommand("open|vision", path);