nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -5,6 +5,15 @@ 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");
@@ -34,110 +43,130 @@ class PlatformLiveSyncServiceBase {
         }
         return this._deviceLiveSyncServicesCache[key];
     }
-    async shouldRestart(projectData, liveSyncInfo) {
-        const deviceLiveSyncService = this.getDeviceLiveSyncService(liveSyncInfo.deviceAppData.device, projectData);
-        const shouldRestart = await deviceLiveSyncService.shouldRestart(projectData, liveSyncInfo);
-        return shouldRestart;
-    }
-    async syncAfterInstall(device, liveSyncInfo) {
+    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 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);
+    syncAfterInstall(device, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /* intentionally left blank */
+        });
     }
-    async tryRefreshApplication(projectData, liveSyncInfo) {
-        let didRefresh = true;
-        if (liveSyncInfo.isFullSync || liveSyncInfo.modifiedFilesData.length) {
+    restartApplication(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
             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;
+            this.$logger.info(`Restarting application on device ${liveSyncInfo.deviceAppData.device.deviceInfo.identifier}...`);
+            yield deviceLiveSyncService.restartApplication(projectData, liveSyncInfo);
+        });
     }
-    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,
-        };
+    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 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);
+    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);
             }
-            if (existingFiles.length) {
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+            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,
+            };
+        });
+    }
+    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 mappedFiles = _.map(filesToSync, filePath => this.$projectFilesProvider.mapFilePath(filePath, device.deviceInfo.platform, projectData));
+                // Some plugins modify platforms dir on afterPrepare (check nativescript-dev-sass) - we want to sync only existing file.
+                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, this.$options.hostProjectModuleName);
+                    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 });
+                }
+            }
+            if (liveSyncInfo.filesToRemove.length) {
+                const filePaths = liveSyncInfo.filesToRemove;
                 const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-                const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
-                const localToDevicePaths = await this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, existingFiles, []);
+                const mappedFiles = _(filePaths)
+                    // .map(filePath => this.$projectFilesProvider.mapFilePath(filePath, device.deviceInfo.platform, projectData))
+                    .filter((filePath) => !!filePath)
+                    .value();
+                const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+                const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, mappedFiles, []);
                 modifiedLocalToDevicePaths.push(...localToDevicePaths);
-                modifiedLocalToDevicePaths = await this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncInfo.liveSyncDeviceData, { isFullSync: false, force: liveSyncInfo.force });
+                yield deviceLiveSyncService.removeFiles(deviceAppData, localToDevicePaths, projectFilesPath);
             }
-        }
-        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,
-        };
+            return {
+                modifiedFilesData: modifiedLocalToDevicePaths,
+                isFullSync: false,
+                deviceAppData,
+                useHotModuleReload: liveSyncInfo.useHotModuleReload,
+            };
+        });
     }
-    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;
+    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 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,
-        };
+    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,
+            };
+        });
     }
     logFilesSyncInformation(localToDevicePaths, message, action, deviceIdentifier) {
         if (localToDevicePaths && localToDevicePaths.length < 10) {
@@ -150,7 +179,8 @@ class PlatformLiveSyncServiceBase {
         }
     }
 }
-exports.PlatformLiveSyncServiceBase = PlatformLiveSyncServiceBase;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], PlatformLiveSyncServiceBase.prototype, "liveSyncWatchAction", null);
+exports.PlatformLiveSyncServiceBase = PlatformLiveSyncServiceBase;
+//# sourceMappingURL=platform-livesync-service-base.js.map

package/lib/services/livesync-process-data-service.js

@@ -41,3 +41,4 @@ class LiveSyncProcessDataService {
 }
 exports.LiveSyncProcessDataService = LiveSyncProcessDataService;
 yok_1.injector.register("liveSyncProcessDataService", LiveSyncProcessDataService);
+//# sourceMappingURL=livesync-process-data-service.js.map

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

@@ -45,8 +45,9 @@ 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);
+//# sourceMappingURL=log-parser-service.js.map

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

@@ -1,4 +1,13 @@
 "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");
@@ -26,37 +35,40 @@ 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));
     }
-    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;
-                    });
+    setSourceMapConsumerForFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.$fs.getFsStats(filePath).isDirectory()) {
+                    const mapFile = filePath + ".map";
+                    let sourceMapRaw;
+                    // Skip files bigger than 50MB
+                    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;
                 }
-                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) {
@@ -155,6 +167,8 @@ class LogSourceMapService {
         }
     }
     parseAndroidLog(projectData, rawMessage) {
+        // "JS: at module.exports.push../main-view-model.ts.HelloWorldModel.onTap (file:///data/data/org.nativescript.sourceMap/files/app/bundle.js:303:17)"
+        // "System.err: File: "file:///data/data/org.nativescript.sourceMap/files/app/bundle.js, line: 304, column: 8"
         const fileIndex = rawMessage.lastIndexOf(LogSourceMapService.FILE_PREFIX);
         const deviceProjectPath = util.format(constants_1.ANDROID_DEVICE_APP_ROOT_TEMPLATE, projectData.projectIdentifiers.android);
         let separator = ",";
@@ -162,18 +176,25 @@ class LogSourceMapService {
         let parts, filePath, line, column, messagePrefix;
         if (fileIndex >= 0) {
             const fileSubstring = rawMessage.substring(fileIndex + LogSourceMapService.FILE_PREFIX.length);
+            //"data/data/org.nativescript.sourceMap/files/app/bundle.js, line: 304, column: 8"
             parts = fileSubstring.split(separator);
             if (parts.length >= 3) {
+                // "data/data/org.nativescript.sourceMap/files/app/bundle.js"
                 parts[0] = parts[0].replace("'", "");
+                // " line: 304"
                 parts[1] = parts[1].replace(" line: ", "");
+                // " column: 8"
                 parts[2] = parts[2].replace(" column: ", "");
             }
             else {
+                // "data/data/org.nativescript.sourceMap/files/app/bundle.js:303:17)"
                 separator = ":";
                 parts = fileSubstring.split(separator);
             }
             if (parts.length >= 3) {
+                // "/data/data/org.nativescript.sourceMap/files/app/"
                 const devicePath = `${deviceProjectPath}/${constants_1.APP_FOLDER_NAME}/`;
+                // "bundle.js"
                 filePath = path.relative(devicePath, `${"/"}${parts[0]}`);
                 line = parseInt(parts[1]);
                 column = parseInt(parts[2]);
@@ -181,20 +202,24 @@ class LogSourceMapService {
                 for (let i = 3; i < parts.length; i++) {
                     messageSuffix += `${parts[i]}${i === parts.length - 1 ? "" : separator}`;
                 }
+                // "JS: at module.exports.push../main-view-model.ts.HelloWorldModel.onTap ("
                 messagePrefix = _.trimEnd(messagePrefix, "(");
             }
         }
         return { filePath, line, column, messagePrefix, messageSuffix };
     }
     parseIosLog(rawMessage) {
+        // "CONSOLE INFO file:///app/vendor.js:131:36: HMR: Hot Module Replacement Enabled. Waiting for signal."
         const fileIndex = rawMessage.lastIndexOf(LogSourceMapService.FILE_PREFIX);
         let messageSuffix = "";
         let parts, filePath, line, column, messagePrefix;
         if (fileIndex >= 0) {
+            // "app/vendor.js:131:36: HMR: Hot Module Replacement Enabled. Waiting for signal."
             const fileSubstring = rawMessage.substring(fileIndex + LogSourceMapService.FILE_PREFIX.length);
             parts = fileSubstring.split(":");
             if (parts && parts.length >= 3) {
                 filePath = parts[0];
+                // "app/vendor.js"
                 if (_.startsWith(filePath, constants_1.APP_FOLDER_NAME)) {
                     filePath = path.relative(constants_1.APP_FOLDER_NAME, parts[0]);
                 }
@@ -218,8 +243,9 @@ 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);
+//# sourceMappingURL=log-source-map-service.js.map

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

@@ -1,4 +1,13 @@
 "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");
@@ -6,7 +15,7 @@ const constants_1 = require("../constants");
 const yok_1 = require("../common/yok");
 const semver = require("semver/preload");
 const MARKING_MODE_PROP = "markingMode";
-const MARKING_MODE_FULL_DEPRECATION_MSG = `In the current version of NativeScript "${MARKING_MODE_PROP}:${"full"}" is no longer supported.`;
+const MARKING_MODE_FULL_DEPRECATION_MSG = `In the current version of NativeScript "${MARKING_MODE_PROP}:${"full" /* MarkingMode.Full */}" is no longer supported.`;
 class MarkingModeService {
     constructor($logger, $projectConfigService, $projectHelper, $projectDataService) {
         this.$logger = $logger;
@@ -14,26 +23,32 @@ class MarkingModeService {
         this.$projectHelper = $projectHelper;
         this.$projectDataService = $projectDataService;
     }
-    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();
+    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" /* MarkingMode.None */);
+                return;
             }
-        }
+            if (!skipWarnings && (markingModeValue === null || markingModeValue === void 0 ? void 0 : markingModeValue.toLowerCase()) !== "none" /* MarkingMode.None */) {
+                // only warn if runtime is less than 7.0.0-rc.5 - where the default has been changed to None
+                // if version is null - we are about to add the latest runtime, so no need to warn
+                const { version } = this.$projectDataService.getRuntimePackage(this.$projectHelper.projectDir, "android" /* PlatformTypes.android */);
+                const isMarkingModeFullDefault = version && semver.lt(semver.coerce(version), "7.0.0-rc.5");
+                if (isMarkingModeFullDefault) {
+                    this.showMarkingModeFullWarning();
+                }
+            }
+        });
     }
-    async setMarkingMode(newMode) {
-        await this.$projectConfigService.setValue("android.markingMode", newMode);
+    setMarkingMode(newMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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'.`;
+        const markingModeFullWarning = `You are using the deprecated "${MARKING_MODE_PROP}:${"full" /* MarkingMode.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'.`;
         this.$logger.warn(markingModeFullWarning, {
             [constants_1.LoggerConfigData.wrapMessageWithBorders]: true,
         });
@@ -41,3 +56,4 @@ class MarkingModeService {
 }
 exports.MarkingModeService = MarkingModeService;
 yok_1.injector.register("markingModeService", MarkingModeService);
+//# sourceMappingURL=marking-mode-service.js.map

package/lib/services/metadata-filtering-service.js

@@ -103,3 +103,4 @@ class MetadataFilteringService {
 }
 exports.MetadataFilteringService = MetadataFilteringService;
 yok_1.injector.register("metadataFilteringService", MetadataFilteringService);
+//# sourceMappingURL=metadata-filtering-service.js.map

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

@@ -21,8 +21,11 @@ class NpmConfigService {
     readConfig() {
         try {
             const res = (0, child_process_1.execSync)("npm config list --json --global");
+            // const data: any = npmconfig.read();
             const data = JSON.parse(res.toString());
+            // todo: remove if not needed with npm config list --json?
             Object.entries(data).forEach(([key, value]) => {
+                // replace env ${VARS} in strings with the process.env value
                 this.config[key] =
                     typeof value !== "string"
                         ? value
@@ -32,8 +35,9 @@ 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);
+//# sourceMappingURL=npm-config-service.js.map