@akylas/nativescript-cli 8.7.2 → 8.8.3

package/lib/services/livesync/platform-livesync-service-base.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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.PlatformLiveSyncServiceBase = void 0;
 const path = require("path");
@@ -24,12 +15,13 @@ const helpers_1 = require("../../common/helpers");
 const decorators_1 = require("../../common/decorators");
 const color_1 = require("../../color");
 class PlatformLiveSyncServiceBase {
-    constructor($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider) {
+    constructor($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider, $options) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$platformsDataService = $platformsDataService;
         this.$projectFilesManager = $projectFilesManager;
         this.$devicePathProvider = $devicePathProvider;
+        this.$options = $options;
         this._deviceLiveSyncServicesCache = {};
     }
     getDeviceLiveSyncService(device, projectData) {
@@ -42,126 +34,110 @@ class PlatformLiveSyncServiceBase {
         }
         return this._deviceLiveSyncServicesCache[key];
     }
-    shouldRestart(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
-            const shouldRestart = yield deviceLiveSyncService.shouldRestart(projectData, liveSyncInfo);
-            return shouldRestart;
-        });
+    async shouldRestart(projectData, liveSyncInfo) {
+        const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+        const shouldRestart = await deviceLiveSyncService.shouldRestart(projectData, liveSyncInfo);
+        return shouldRestart;
     }
-    syncAfterInstall(device, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
+    async syncAfterInstall(device, liveSyncInfo) {
     }
-    restartApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
-            this.$logger.info(`Restarting application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
-            yield deviceLiveSyncService.restartApplication(projectData, liveSyncInfo);
-        });
+    async restartApplication(projectData, liveSyncInfo) {
+        const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+        this.$logger.info(`Restarting application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
+        await deviceLiveSyncService.restartApplication(projectData, liveSyncInfo);
     }
-    tryRefreshApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let didRefresh = true;
-            if (liveSyncInfo.isFullSync || liveSyncInfo.modifiedFilesData.length) {
-                const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
-                this.$logger.info(`Refreshing application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
-                didRefresh = yield deviceLiveSyncService.tryRefreshApplication(projectData, liveSyncInfo);
-            }
-            return didRefresh;
-        });
+    async tryRefreshApplication(projectData, liveSyncInfo) {
+        let didRefresh = true;
+        if (liveSyncInfo.isFullSync || liveSyncInfo.modifiedFilesData.length) {
+            const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
+            this.$logger.info(`Refreshing application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
+            didRefresh = await deviceLiveSyncService.tryRefreshApplication(projectData, liveSyncInfo);
+        }
+        return didRefresh;
     }
-    fullSync(syncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const projectData = syncInfo.projectData;
-            const device = syncInfo.device;
-            const deviceLiveSyncService = this.getDeviceLiveSyncService(device, syncInfo.projectData);
-            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-            const deviceAppData = yield this.getAppData(syncInfo);
-            if (deviceLiveSyncService.beforeLiveSyncAction) {
-                yield deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
-            }
-            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
-            const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, null, []);
-            const modifiedFilesData = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, syncInfo.liveSyncDeviceData, { isFullSync: true, force: syncInfo.force });
-            return {
-                modifiedFilesData,
-                isFullSync: true,
-                deviceAppData,
-                useHotModuleReload: syncInfo.useHotModuleReload,
-            };
-        });
+    async fullSync(syncInfo) {
+        const projectData = syncInfo.projectData;
+        const device = syncInfo.device;
+        const deviceLiveSyncService = this.getDeviceLiveSyncService(device, syncInfo.projectData);
+        const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+        const deviceAppData = await this.getAppData(syncInfo);
+        if (deviceLiveSyncService.beforeLiveSyncAction) {
+            await deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
+        }
+        const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+        const localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, null, []);
+        const modifiedFilesData = await this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, syncInfo.liveSyncDeviceData, { isFullSync: true, force: syncInfo.force });
+        return {
+            modifiedFilesData,
+            isFullSync: true,
+            deviceAppData,
+            useHotModuleReload: syncInfo.useHotModuleReload,
+        };
     }
-    liveSyncWatchAction(device, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const projectData = liveSyncInfo.projectData;
-            const deviceLiveSyncService = this.getDeviceLiveSyncService(device, projectData);
-            const syncInfo = _.merge({ device, watch: true }, liveSyncInfo);
-            const deviceAppData = yield this.getAppData(syncInfo);
-            if (deviceLiveSyncService.beforeLiveSyncAction) {
-                yield deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
-            }
-            let modifiedLocalToDevicePaths = [];
-            if (liveSyncInfo.filesToSync.length) {
-                const filesToSync = liveSyncInfo.filesToSync;
-                const existingFiles = filesToSync.filter((m) => m && this.$fs.exists(m));
-                this.$logger.trace("Will execute livesync for files: ", existingFiles);
-                const skippedFiles = _.difference(filesToSync, existingFiles);
-                if (skippedFiles.length) {
-                    this.$logger.trace("The following files will not be synced as they do not exist:", skippedFiles);
-                }
-                if (existingFiles.length) {
-                    const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-                    const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
-                    const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, existingFiles, []);
-                    modifiedLocalToDevicePaths.push(...localToDevicePaths);
-                    modifiedLocalToDevicePaths = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncInfo.liveSyncDeviceData, { isFullSync: false, force: liveSyncInfo.force });
-                }
+    async liveSyncWatchAction(device, liveSyncInfo) {
+        const projectData = liveSyncInfo.projectData;
+        const deviceLiveSyncService = this.getDeviceLiveSyncService(device, projectData);
+        const syncInfo = _.merge({ device, watch: true }, liveSyncInfo);
+        const deviceAppData = await this.getAppData(syncInfo);
+        if (deviceLiveSyncService.beforeLiveSyncAction) {
+            await deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
+        }
+        let modifiedLocalToDevicePaths = [];
+        if (liveSyncInfo.filesToSync.length) {
+            const filesToSync = liveSyncInfo.filesToSync;
+            const existingFiles = filesToSync.filter((m) => m && this.$fs.exists(m));
+            this.$logger.trace("Will execute livesync for files: ", existingFiles);
+            const skippedFiles = _.difference(filesToSync, existingFiles);
+            if (skippedFiles.length) {
+                this.$logger.trace("The following files will not be synced as they do not exist:", skippedFiles);
             }
-            if (liveSyncInfo.filesToRemove.length) {
-                const filePaths = liveSyncInfo.filesToRemove;
+            if (existingFiles.length) {
                 const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-                const mappedFiles = _(filePaths)
-                    .filter((filePath) => !!filePath)
-                    .value();
-                const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
-                const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, mappedFiles, []);
+                const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+                const localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, existingFiles, []);
                 modifiedLocalToDevicePaths.push(...localToDevicePaths);
-                yield deviceLiveSyncService.removeFiles(deviceAppData, localToDevicePaths, projectFilesPath);
+                modifiedLocalToDevicePaths = await this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncInfo.liveSyncDeviceData, { isFullSync: false, force: liveSyncInfo.force });
             }
-            return {
-                modifiedFilesData: modifiedLocalToDevicePaths,
-                isFullSync: false,
-                deviceAppData,
-                useHotModuleReload: liveSyncInfo.useHotModuleReload,
-            };
-        });
+        }
+        if (liveSyncInfo.filesToRemove.length) {
+            const filePaths = liveSyncInfo.filesToRemove;
+            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+            const mappedFiles = _(filePaths)
+                .filter((filePath) => !!filePath)
+                .value();
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+            const localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, mappedFiles, []);
+            modifiedLocalToDevicePaths.push(...localToDevicePaths);
+            await deviceLiveSyncService.removeFiles(deviceAppData, localToDevicePaths, projectFilesPath);
+        }
+        return {
+            modifiedFilesData: modifiedLocalToDevicePaths,
+            isFullSync: false,
+            deviceAppData,
+            useHotModuleReload: liveSyncInfo.useHotModuleReload,
+        };
     }
-    transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transferredFiles = [];
-            const deviceLiveSyncService = this.getDeviceLiveSyncService(deviceAppData.device, projectData);
-            transferredFiles = yield deviceLiveSyncService.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options);
-            yield deviceAppData.device.applicationManager.setTransferredAppFiles(localToDevicePaths.map((l) => l.getLocalPath()));
-            this.logFilesSyncInformation(transferredFiles, "Successfully transferred %s on device %s.", this.$logger.info, deviceAppData.device.deviceInfo.identifier);
-            return transferredFiles;
-        });
+    async transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options) {
+        let transferredFiles = [];
+        const deviceLiveSyncService = this.getDeviceLiveSyncService(deviceAppData.device, projectData);
+        transferredFiles = await deviceLiveSyncService.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceData, options);
+        await deviceAppData.device.applicationManager.setTransferredAppFiles(localToDevicePaths.map((l) => l.getLocalPath()));
+        this.logFilesSyncInformation(transferredFiles, "Successfully transferred %s on device %s.", this.$logger.info, deviceAppData.device.deviceInfo.identifier);
+        return transferredFiles;
     }
-    getAppData(syncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platform = syncInfo.device.deviceInfo.platform.toLowerCase();
-            const appIdentifier = syncInfo.projectData.projectIdentifiers[platform];
-            const deviceProjectRootOptions = _.assign({ appIdentifier }, syncInfo);
-            return {
-                appIdentifier,
-                device: syncInfo.device,
-                platform: syncInfo.device.deviceInfo.platform,
-                getDeviceProjectRootPath: () => this.$devicePathProvider.getDeviceProjectRootPath(syncInfo.device, deviceProjectRootOptions),
-                deviceSyncZipPath: this.$devicePathProvider.getDeviceSyncZipPath(syncInfo.device),
-                connectTimeout: syncInfo.connectTimeout,
-                projectDir: syncInfo.projectData.projectDir,
-            };
-        });
+    async getAppData(syncInfo) {
+        const platform = syncInfo.device.deviceInfo.platform.toLowerCase();
+        const appIdentifier = syncInfo.projectData.projectIdentifiers[platform];
+        const deviceProjectRootOptions = _.assign({ appIdentifier }, syncInfo);
+        return {
+            appIdentifier,
+            device: syncInfo.device,
+            platform: syncInfo.device.deviceInfo.platform,
+            getDeviceProjectRootPath: () => this.$devicePathProvider.getDeviceProjectRootPath(syncInfo.device, deviceProjectRootOptions),
+            deviceSyncZipPath: this.$devicePathProvider.getDeviceSyncZipPath(syncInfo.device),
+            connectTimeout: syncInfo.connectTimeout,
+            projectDir: syncInfo.projectData.projectDir,
+        };
     }
     logFilesSyncInformation(localToDevicePaths, message, action, deviceIdentifier) {
         if (localToDevicePaths && localToDevicePaths.length < 10) {
@@ -174,7 +150,7 @@ class PlatformLiveSyncServiceBase {
         }
     }
 }
+exports.PlatformLiveSyncServiceBase = PlatformLiveSyncServiceBase;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], PlatformLiveSyncServiceBase.prototype, "liveSyncWatchAction", null);
-exports.PlatformLiveSyncServiceBase = PlatformLiveSyncServiceBase;

package/lib/services/log-parser-service.js

@@ -45,8 +45,8 @@ class LogParserService extends events_1.EventEmitter {
         });
     }
 }
+exports.LogParserService = LogParserService;
 __decorate([
     (0, decorators_1.cache)()
 ], LogParserService.prototype, "startParsingLogCore", null);
-exports.LogParserService = LogParserService;
 yok_1.injector.register("logParserService", LogParserService);

package/lib/services/log-source-map-service.js

@@ -1,13 +1,4 @@
 "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.LogSourceMapService = void 0;
 const path = require("path");
@@ -23,10 +14,11 @@ class LogSourceMapService {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    constructor($fs, $projectDataService, $injector, $devicePlatformsConstants, $logger) {
+    constructor($fs, $projectDataService, $injector, $options, $devicePlatformsConstants, $logger) {
         this.$fs = $fs;
         this.$projectDataService = $projectDataService;
         this.$injector = $injector;
+        this.$options = $options;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.$logger = $logger;
         this.cache = {};
@@ -34,39 +26,37 @@ class LogSourceMapService {
         this.getProjectData = _.memoize(this.$projectDataService.getProjectData.bind(this.$projectDataService));
         this.getRuntimeVersion = _.memoize(this.getRuntimeVersionCore, (...args) => args.join(LogSourceMapService.MEMOIZE_FUNCTION_RANDOM_KEY_FOR_JOIN));
     }
-    setSourceMapConsumerForFile(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.$fs.getFsStats(filePath).isDirectory()) {
-                    const mapFile = filePath + ".map";
-                    let sourceMapRaw;
-                    if (this.$fs.getFileSize(filePath) > 50 * 1000 * 1000) {
-                        this.$logger.trace(`Skipping source map for file ${filePath} because it is too big (> 50MB).`);
-                        return;
-                    }
-                    const source = this.$fs.readText(filePath);
-                    if (this.$fs.exists(mapFile)) {
-                        sourceMapRaw = sourceMapConverter.fromMapFileSource(source, (filename) => {
-                            return this.$fs.readText(path.join(path.dirname(filePath), filename));
-                        });
-                    }
-                    else {
-                        sourceMapRaw = sourceMapConverter.fromSource(source);
-                    }
-                    let smc = null;
-                    if (sourceMapRaw && sourceMapRaw.sourcemap) {
-                        const sourceMap = sourceMapRaw.sourcemap;
-                        smc = yield sourcemap.SourceMapConsumer.with(sourceMap, null, (c) => {
-                            return c;
-                        });
-                    }
-                    this.cache[filePath] = smc;
+    async setSourceMapConsumerForFile(filePath) {
+        try {
+            if (!this.$fs.getFsStats(filePath).isDirectory()) {
+                const mapFile = filePath + ".map";
+                let sourceMapRaw;
+                if (this.$fs.getFileSize(filePath) > 50 * 1000 * 1000) {
+                    this.$logger.trace(`Skipping source map for file ${filePath} because it is too big (> 50MB).`);
+                    return;
                 }
+                const source = this.$fs.readText(filePath);
+                if (this.$fs.exists(mapFile)) {
+                    sourceMapRaw = sourceMapConverter.fromMapFileSource(source, (filename) => {
+                        return this.$fs.readText(path.join(path.dirname(filePath), filename));
+                    });
+                }
+                else {
+                    sourceMapRaw = sourceMapConverter.fromSource(source);
+                }
+                let smc = null;
+                if (sourceMapRaw && sourceMapRaw.sourcemap) {
+                    const sourceMap = sourceMapRaw.sourcemap;
+                    smc = await sourcemap.SourceMapConsumer.with(sourceMap, null, (c) => {
+                        return c;
+                    });
+                }
+                this.cache[filePath] = smc;
             }
-            catch (err) {
-                this.$logger.trace(`Unable to set sourceMapConsumer for file ${filePath}. Error is: ${err}`);
-            }
-        });
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to set sourceMapConsumer for file ${filePath}. Error is: ${err}`);
+        }
     }
     replaceWithOriginalFileLocations(platform, messageData, loggingOptions) {
         if (!messageData || !loggingOptions || !loggingOptions.projectDir) {
@@ -121,7 +111,7 @@ class LogSourceMapService {
         return runtimeVersion;
     }
     getOriginalFileLocation(platform, parsedLine, projectData) {
-        const fileLocation = path.join(this.getFilesLocation(platform, projectData), constants_1.APP_FOLDER_NAME);
+        const fileLocation = path.join(this.getFilesLocation(platform, projectData), this.$options.hostProjectModuleName);
         if (parsedLine && parsedLine.filePath) {
             const sourceMapFile = path.join(fileLocation, parsedLine.filePath);
             const smc = this.cache[sourceMapFile];
@@ -228,8 +218,8 @@ class LogSourceMapService {
         }
     }
 }
+exports.LogSourceMapService = LogSourceMapService;
 LogSourceMapService.FILE_PREFIX = "file:///";
 LogSourceMapService.FILE_PREFIX_REPLACEMENT = "file: ";
 LogSourceMapService.MEMOIZE_FUNCTION_RANDOM_KEY_FOR_JOIN = "__some_random_value__";
-exports.LogSourceMapService = LogSourceMapService;
 yok_1.injector.register("logSourceMapService", LogSourceMapService);

package/lib/services/marking-mode-service.js

@@ -1,13 +1,4 @@
 "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.MarkingModeService = void 0;
 const os_1 = require("os");
@@ -23,27 +14,23 @@ class MarkingModeService {
         this.$projectHelper = $projectHelper;
         this.$projectDataService = $projectDataService;
     }
-    handleMarkingModeFullDeprecation(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const markingModeValue = this.$projectConfigService.getValue("android.markingMode");
-            const { skipWarnings, forceSwitch } = options;
-            if (forceSwitch) {
-                yield this.setMarkingMode("none");
-                return;
+    async handleMarkingModeFullDeprecation(options) {
+        const markingModeValue = this.$projectConfigService.getValue("android.markingMode");
+        const { skipWarnings, forceSwitch } = options;
+        if (forceSwitch) {
+            await this.setMarkingMode("none");
+            return;
+        }
+        if (!skipWarnings && (markingModeValue === null || markingModeValue === void 0 ? void 0 : markingModeValue.toLowerCase()) !== "none") {
+            const { version } = this.$projectDataService.getRuntimePackage(this.$projectHelper.projectDir, "android");
+            const isMarkingModeFullDefault = version && semver.lt(semver.coerce(version), "7.0.0-rc.5");
+            if (isMarkingModeFullDefault) {
+                this.showMarkingModeFullWarning();
             }
-            if (!skipWarnings && (markingModeValue === null || markingModeValue === void 0 ? void 0 : markingModeValue.toLowerCase()) !== "none") {
-                const { version } = this.$projectDataService.getRuntimePackage(this.$projectHelper.projectDir, "android");
-                const isMarkingModeFullDefault = version && semver.lt(semver.coerce(version), "7.0.0-rc.5");
-                if (isMarkingModeFullDefault) {
-                    this.showMarkingModeFullWarning();
-                }
-            }
-        });
+        }
     }
-    setMarkingMode(newMode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$projectConfigService.setValue("android.markingMode", newMode);
-        });
+    async setMarkingMode(newMode) {
+        await this.$projectConfigService.setValue("android.markingMode", newMode);
     }
     showMarkingModeFullWarning() {
         const markingModeFullWarning = `You are using the deprecated "${MARKING_MODE_PROP}:${"full"}".${os_1.EOL}${os_1.EOL}${MARKING_MODE_FULL_DEPRECATION_MSG}${os_1.EOL}${os_1.EOL}You should update your marking mode by executing 'ns update --markingMode'.`;

package/lib/services/npm-config-service.js

@@ -32,8 +32,8 @@ class NpmConfigService {
         catch (e) { }
     }
 }
+exports.NpmConfigService = NpmConfigService;
 __decorate([
     (0, decorators_1.cache)()
 ], NpmConfigService.prototype, "readConfig", null);
-exports.NpmConfigService = NpmConfigService;
 yok_1.injector.register("npmConfigService", NpmConfigService);

package/lib/services/pacote-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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.PacoteService = void 0;
 const pacote = require("pacote");
@@ -35,64 +26,58 @@ class PacoteService {
     get $packageManager() {
         return this.$injector.resolve("packageManager");
     }
-    manifest(packageName, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.trace(`Calling pacoteService.manifest for packageName: '${packageName}' and options: `, options);
-            const manifestOptions = yield this.getPacoteBaseOptions();
-            if (options) {
-                _.extend(manifestOptions, options);
-            }
-            packageName = this.getRealPackageName(packageName);
-            this.$logger.trace(`Calling pacote.manifest for packageName: ${packageName} and manifestOptions:`, manifestOptions);
-            const result = yield pacote.manifest(packageName, manifestOptions);
-            this.$logger.trace("pacote.manifest result:", result);
-            return result;
-        });
+    async manifest(packageName, options) {
+        this.$logger.trace(`Calling pacoteService.manifest for packageName: '${packageName}' and options: `, options);
+        const manifestOptions = await this.getPacoteBaseOptions();
+        if (options) {
+            _.extend(manifestOptions, options);
+        }
+        packageName = this.getRealPackageName(packageName);
+        this.$logger.trace(`Calling pacote.manifest for packageName: ${packageName} and manifestOptions:`, manifestOptions);
+        const result = await pacote.manifest(packageName, manifestOptions);
+        this.$logger.trace("pacote.manifest result:", result);
+        return result;
     }
-    extractPackage(packageName, destinationDirectory, options) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async extractPackage(packageName, destinationDirectory, options) {
+        this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
+        const extractOptions = { strip: 1, C: destinationDirectory };
+        if (options) {
+            _.extend(extractOptions, options);
+        }
+        packageName = this.getRealPackageName(packageName);
+        const pacoteOptions = await this.getPacoteBaseOptions();
+        return new Promise(async (resolve, reject) => {
             this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
-            const extractOptions = { strip: 1, C: destinationDirectory };
-            if (options) {
-                _.extend(extractOptions, options);
-            }
-            packageName = this.getRealPackageName(packageName);
-            const pacoteOptions = yield this.getPacoteBaseOptions();
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
-                const source = yield pacote
-                    .tarball(packageName, pacoteOptions)
-                    .catch((err) => {
-                    this.$logger.trace(`Error in source while trying to extract stream from ${packageName}. Error is ${err}`);
-                    reject(err);
-                });
-                this.$logger.trace(`Creating extract tar stream with options: ${JSON.stringify(extractOptions, null, 2)}`);
-                const destination = tar.x(extractOptions);
-                const sourceStream = new stream_1.PassThrough();
-                sourceStream.end(source);
-                sourceStream.pipe(destination);
-                destination.on("error", (err) => {
-                    this.$logger.trace(`Error in destination while trying to extract stream from ${packageName}. Error is ${err}`);
-                    reject(err);
-                });
-                destination.on("finish", () => {
-                    this.$logger.trace(`Successfully extracted '${packageName}' to ${destinationDirectory}`);
-                    resolve();
-                });
-            }));
+            const source = await pacote
+                .tarball(packageName, pacoteOptions)
+                .catch((err) => {
+                this.$logger.trace(`Error in source while trying to extract stream from ${packageName}. Error is ${err}`);
+                reject(err);
+            });
+            this.$logger.trace(`Creating extract tar stream with options: ${JSON.stringify(extractOptions, null, 2)}`);
+            const destination = tar.x(extractOptions);
+            const sourceStream = new stream_1.PassThrough();
+            sourceStream.end(source);
+            sourceStream.pipe(destination);
+            destination.on("error", (err) => {
+                this.$logger.trace(`Error in destination while trying to extract stream from ${packageName}. Error is ${err}`);
+                reject(err);
+            });
+            destination.on("finish", () => {
+                this.$logger.trace(`Successfully extracted '${packageName}' to ${destinationDirectory}`);
+                resolve();
+            });
         });
     }
-    getPacoteBaseOptions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cachePath = yield this.$packageManager.getCachePath();
-            const npmConfig = this.$npmConfigService.getConfig();
-            const pacoteOptions = _.extend(npmConfig, { cache: cachePath, Arborist: arborist_1.Arborist });
-            const proxySettings = yield this.$proxyService.getCache();
-            if (proxySettings) {
-                _.extend(pacoteOptions, proxySettings);
-            }
-            return pacoteOptions;
-        });
+    async getPacoteBaseOptions() {
+        const cachePath = await this.$packageManager.getCachePath();
+        const npmConfig = this.$npmConfigService.getConfig();
+        const pacoteOptions = _.extend(npmConfig, { cache: cachePath, Arborist: arborist_1.Arborist });
+        const proxySettings = await this.$proxyService.getCache();
+        if (proxySettings) {
+            _.extend(pacoteOptions, proxySettings);
+        }
+        return pacoteOptions;
     }
     getRealPackageName(packageName) {
         if (this.$fs.exists(packageName)) {
@@ -102,8 +87,8 @@ class PacoteService {
         return packageName;
     }
 }
+exports.PacoteService = PacoteService;
 __decorate([
     (0, decorators_1.cache)()
 ], PacoteService.prototype, "$packageManager", null);
-exports.PacoteService = PacoteService;
 yok_1.injector.register("pacoteService", PacoteService);

package/lib/services/performance-service.js

@@ -85,8 +85,8 @@ class PerformanceService {
         };
     }
 }
+exports.PerformanceService = PerformanceService;
 PerformanceService.LOG_MESSAGE_TEMPLATE = `Execution of method "%s" took %s ms.`;
 PerformanceService.FAIL_LOG_MESSAGE_TEMPLATE = `Failed to log pefromance data in file for method %s.`;
 PerformanceService.MIN_NODE_PERFORMANCE_MODULE_VERSION = "8.5.0";
-exports.PerformanceService = PerformanceService;
 yok_1.injector.register("performanceService", PerformanceService);