nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/common/services/ios-notification-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.IOSNotificationService = void 0;
 const constants = require("../constants");
@@ -8,29 +17,34 @@ class IOSNotificationService {
     constructor($iosDeviceOperations) {
         this.$iosDeviceOperations = $iosDeviceOperations;
     }
-    async awaitNotification(deviceIdentifier, socket, timeout) {
-        const notificationResponse = await this.$iosDeviceOperations.awaitNotificationResponse([
-            {
-                deviceId: deviceIdentifier,
-                socket: socket,
-                timeout: timeout,
-                responseCommandType: constants.IOS_RELAY_NOTIFICATION_COMMAND_TYPE,
-                responsePropertyName: "Name",
-            },
-        ]);
-        return _.first(notificationResponse[deviceIdentifier]).response;
+    awaitNotification(deviceIdentifier, socket, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notificationResponse = yield this.$iosDeviceOperations.awaitNotificationResponse([
+                {
+                    deviceId: deviceIdentifier,
+                    socket: socket,
+                    timeout: timeout,
+                    responseCommandType: constants.IOS_RELAY_NOTIFICATION_COMMAND_TYPE,
+                    responsePropertyName: "Name",
+                },
+            ]);
+            return _.first(notificationResponse[deviceIdentifier]).response;
+        });
     }
-    async postNotification(deviceIdentifier, notification, commandType) {
-        commandType = commandType || constants.IOS_POST_NOTIFICATION_COMMAND_TYPE;
-        const response = await this.$iosDeviceOperations.postNotification([
-            {
-                deviceId: deviceIdentifier,
-                commandType: commandType,
-                notificationName: notification,
-            },
-        ]);
-        return +_.first(response[deviceIdentifier]).response;
+    postNotification(deviceIdentifier, notification, commandType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            commandType = commandType || constants.IOS_POST_NOTIFICATION_COMMAND_TYPE;
+            const response = yield this.$iosDeviceOperations.postNotification([
+                {
+                    deviceId: deviceIdentifier,
+                    commandType: commandType,
+                    notificationName: notification,
+                },
+            ]);
+            return +_.first(response[deviceIdentifier]).response;
+        });
     }
 }
 exports.IOSNotificationService = IOSNotificationService;
 yok_1.injector.register("iOSNotificationService", IOSNotificationService);
+//# sourceMappingURL=ios-notification-service.js.map

package/lib/common/services/json-file-settings-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.JsonFileSettingsService = void 0;
 const path = require("path");
@@ -17,43 +26,51 @@ class JsonFileSettingsService {
         this.jsonSettingsData = null;
         this.jsonSettingsFilePath = jsonFileSettingsPath;
     }
-    async getSettingValue(settingName, cacheOpts) {
-        const action = async () => {
-            await this.loadUserSettingsFile();
-            if (this.jsonSettingsData && _.has(this.jsonSettingsData, settingName)) {
-                const data = this.jsonSettingsData[settingName];
-                const dataToReturn = data.modifiedByCacheMechanism ? data.value : data;
-                if (cacheOpts && cacheOpts.cacheTimeout) {
-                    if (!data.modifiedByCacheMechanism) {
-                        return null;
-                    }
-                    const currentTime = Date.now();
-                    if (currentTime - data.time > cacheOpts.cacheTimeout) {
-                        return null;
+    getSettingValue(settingName, cacheOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = () => __awaiter(this, void 0, void 0, function* () {
+                yield this.loadUserSettingsFile();
+                if (this.jsonSettingsData && _.has(this.jsonSettingsData, settingName)) {
+                    const data = this.jsonSettingsData[settingName];
+                    const dataToReturn = data.modifiedByCacheMechanism ? data.value : data;
+                    if (cacheOpts && cacheOpts.cacheTimeout) {
+                        if (!data.modifiedByCacheMechanism) {
+                            // If data has no cache, but we want to check the timeout, consider the data as outdated.
+                            // this should be a really rare case
+                            return null;
+                        }
+                        const currentTime = Date.now();
+                        if (currentTime - data.time > cacheOpts.cacheTimeout) {
+                            return null;
+                        }
                     }
+                    return dataToReturn;
                 }
-                return dataToReturn;
-            }
-            return null;
-        };
-        return this.$lockService.executeActionWithLock(action, this.lockFilePath);
+                return null;
+            });
+            return this.$lockService.executeActionWithLock(action, this.lockFilePath);
+        });
     }
-    async saveSetting(key, value, cacheOpts) {
-        const settingObject = {};
-        settingObject[key] = value;
-        return this.saveSettings(settingObject, cacheOpts);
+    saveSetting(key, value, cacheOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const settingObject = {};
+            settingObject[key] = value;
+            return this.saveSettings(settingObject, cacheOpts);
+        });
     }
-    async removeSetting(key) {
-        const action = async () => {
-            await this.loadUserSettingsFile();
-            delete this.jsonSettingsData[key];
-            await this.saveSettings();
-        };
-        return this.$lockService.executeActionWithLock(action, this.lockFilePath);
+    removeSetting(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = () => __awaiter(this, void 0, void 0, function* () {
+                yield this.loadUserSettingsFile();
+                delete this.jsonSettingsData[key];
+                yield this.saveSettings();
+            });
+            return this.$lockService.executeActionWithLock(action, this.lockFilePath);
+        });
     }
     saveSettings(data, cacheOpts) {
-        const action = async () => {
-            await this.loadUserSettingsFile();
+        const action = () => __awaiter(this, void 0, void 0, function* () {
+            yield this.loadUserSettingsFile();
             this.jsonSettingsData = this.jsonSettingsData || {};
             _(data)
                 .keys()
@@ -70,37 +87,44 @@ class JsonFileSettingsService {
                         : data[propertyName];
             });
             this.$fs.writeJson(this.jsonSettingsFilePath, this.jsonSettingsData);
-        };
+        });
         return this.$lockService.executeActionWithLock(action, this.lockFilePath);
     }
-    async loadUserSettingsFile() {
-        if (!this.jsonSettingsData) {
-            await this.loadUserSettingsData();
-        }
+    loadUserSettingsFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.jsonSettingsData) {
+                yield this.loadUserSettingsData();
+            }
+        });
     }
-    async loadUserSettingsData() {
-        if (!this.$fs.exists(this.jsonSettingsFilePath)) {
-            const unexistingDirs = this.getUnexistingDirectories(this.jsonSettingsFilePath);
-            this.$fs.writeFile(this.jsonSettingsFilePath, null);
-            if (process.env.SUDO_USER) {
-                for (const dir of unexistingDirs) {
-                    await this.$fs.setCurrentUserAsOwner(dir, process.env.SUDO_USER);
+    loadUserSettingsData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$fs.exists(this.jsonSettingsFilePath)) {
+                const unexistingDirs = this.getUnexistingDirectories(this.jsonSettingsFilePath);
+                this.$fs.writeFile(this.jsonSettingsFilePath, null);
+                // when running under 'sudo' we create the <path to home dir>/.local/share/.nativescript-cli dir with root as owner
+                // and other Applications cannot access this directory anymore. (bower/heroku/etc)
+                if (process.env.SUDO_USER) {
+                    for (const dir of unexistingDirs) {
+                        yield this.$fs.setCurrentUserAsOwner(dir, process.env.SUDO_USER);
+                    }
                 }
             }
-        }
-        const data = this.$fs.readText(this.jsonSettingsFilePath);
-        try {
-            this.jsonSettingsData = (0, helpers_1.parseJson)(data);
-        }
-        catch (err) {
-            this.$logger.trace(`Error while trying to parseJson ${data} data from ${this.jsonSettingsFilePath} file. Err is: ${err}`);
-            this.$fs.deleteFile(this.jsonSettingsFilePath);
-        }
+            const data = this.$fs.readText(this.jsonSettingsFilePath);
+            try {
+                this.jsonSettingsData = (0, helpers_1.parseJson)(data);
+            }
+            catch (err) {
+                this.$logger.trace(`Error while trying to parseJson ${data} data from ${this.jsonSettingsFilePath} file. Err is: ${err}`);
+                this.$fs.deleteFile(this.jsonSettingsFilePath);
+            }
+        });
     }
     getUnexistingDirectories(filePath) {
         const unexistingDirs = [];
         let currentDir = path.join(filePath, "..");
         while (true) {
+            // this directory won't be created.
             if (this.$fs.exists(currentDir)) {
                 break;
             }
@@ -112,3 +136,4 @@ class JsonFileSettingsService {
 }
 exports.JsonFileSettingsService = JsonFileSettingsService;
 yok_1.injector.register("jsonFileSettingsService", JsonFileSettingsService, false);
+//# sourceMappingURL=json-file-settings-service.js.map

package/lib/common/services/lock-service.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.LockService = void 0;
 const lockfile = require("proper-lockfile");
@@ -22,6 +31,7 @@ class LockService {
     }
     get defaultLockParams() {
         const lockParams = {
+            // https://www.npmjs.com/package/retry#retrytimeoutsoptions
             retriesObj: { retries: 13, minTimeout: 100, maxTimeout: 1000, factor: 2 },
             stale: 10 * 1000,
             realpath: false,
@@ -33,45 +43,55 @@ class LockService {
         this.$settingsService = $settingsService;
         this.$cleanupService = $cleanupService;
     }
-    async executeActionWithLock(action, lockFilePath, lockOpts) {
-        const releaseFunc = await this.lock(lockFilePath, lockOpts);
-        try {
-            const result = await action();
-            return result;
-        }
-        finally {
-            releaseFunc();
-        }
+    executeActionWithLock(action, lockFilePath, lockOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const releaseFunc = yield this.lock(lockFilePath, lockOpts);
+            try {
+                const result = yield action();
+                return result;
+            }
+            finally {
+                releaseFunc();
+            }
+        });
     }
-    async lock(lockFilePath, lockOpts) {
-        const { filePath, fileOpts } = this.getLockFileSettings(lockFilePath, lockOpts);
-        for (const pathToClean of this.getPathsForCleanupAction(filePath)) {
-            await this.$cleanupService.addCleanupDeleteAction(pathToClean);
-        }
-        this.$fs.writeFile(filePath, "");
-        try {
-            const releaseFunc = await lockfile.lock(filePath, fileOpts);
-            return async () => {
-                await releaseFunc();
-                await this.cleanLock(filePath);
-            };
-        }
-        catch (err) {
-            throw new Error(`Timeout while waiting for lock "${filePath}"`);
-        }
+    lock(lockFilePath, lockOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filePath, fileOpts } = this.getLockFileSettings(lockFilePath, lockOpts);
+            for (const pathToClean of this.getPathsForCleanupAction(filePath)) {
+                yield this.$cleanupService.addCleanupDeleteAction(pathToClean);
+            }
+            this.$fs.writeFile(filePath, "");
+            try {
+                const releaseFunc = yield lockfile.lock(filePath, fileOpts);
+                return () => __awaiter(this, void 0, void 0, function* () {
+                    yield releaseFunc();
+                    yield this.cleanLock(filePath);
+                });
+            }
+            catch (err) {
+                throw new Error(`Timeout while waiting for lock "${filePath}"`);
+            }
+        });
     }
-    async unlock(lockFilePath) {
-        const { filePath } = this.getLockFileSettings(lockFilePath);
-        lockfile.unlockSync(filePath);
-        await this.cleanLock(filePath);
+    unlock(lockFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filePath } = this.getLockFileSettings(lockFilePath);
+            lockfile.unlockSync(filePath);
+            yield this.cleanLock(filePath);
+        });
     }
-    async cleanLock(lockPath) {
-        this.$fs.deleteFile(lockPath);
-        for (const filePath of this.getPathsForCleanupAction(lockPath)) {
-            await this.$cleanupService.removeCleanupDeleteAction(filePath);
-        }
+    cleanLock(lockPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$fs.deleteFile(lockPath);
+            for (const filePath of this.getPathsForCleanupAction(lockPath)) {
+                yield this.$cleanupService.removeCleanupDeleteAction(filePath);
+            }
+        });
     }
     getPathsForCleanupAction(lockPath) {
+        // The proper-lockfile creates directory with the passed name and `.lock` at the end.
+        // Ensure we will take care of it as well.
         return [lockPath, `${lockPath}.lock`];
     }
     getLockFileSettings(filePath, fileOpts) {
@@ -87,6 +107,7 @@ class LockService {
             fileOpts.retriesObj.retries = fileOpts.retries;
         }
         if (fileOpts.retryWait) {
+            // backwards compatibility
             fileOpts.retriesObj.minTimeout = fileOpts.retriesObj.maxTimeout =
                 fileOpts.retryWait;
         }
@@ -104,9 +125,11 @@ class LockService {
         return filePath;
     }
 }
-exports.LockService = LockService;
 __decorate([
     (0, decorators_1.cache)()
 ], LockService.prototype, "defaultLockFilePath", null);
+exports.LockService = LockService;
 yok_1.injector.register("lockService", LockService);
+// backwards compatibility
 yok_1.injector.register("lockfile", LockService);
+//# sourceMappingURL=lock-service.js.map

package/lib/common/services/message-contract-generator.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.MessageContractGenerator = void 0;
 const code_entity_1 = require("../codeGeneration/code-entity");
@@ -10,43 +19,45 @@ class MessageContractGenerator {
         this.$fs = $fs;
         this.$messagesService = $messagesService;
     }
-    async generate() {
-        const interfacesFile = new code_entity_1.Block();
-        const implementationsFile = new code_entity_1.Block();
-        implementationsFile.writeLine("//");
-        implementationsFile.writeLine("// automatically generated code; do not edit manually!");
-        implementationsFile.writeLine("//");
-        implementationsFile.writeLine("/* tslint:disable:all */");
-        implementationsFile.writeLine("");
-        interfacesFile.writeLine("//");
-        interfacesFile.writeLine("// automatically generated code; do not edit manually!");
-        interfacesFile.writeLine("//");
-        interfacesFile.writeLine("/* tslint:disable:all */");
-        const messagesClass = new code_entity_1.Block("export class Messages implements IMessages");
-        const messagesInterface = new code_entity_1.Block("interface IMessages");
-        _.each(this.$messagesService.pathsToMessageJsonFiles, (jsonFilePath) => {
-            const jsonContents = this.$fs.readJson(jsonFilePath), implementationBlock = new code_entity_1.Block(), interfaceBlock = new code_entity_1.Block();
-            this.generateFileRecursive(jsonContents, "", implementationBlock, 0, {
-                shouldGenerateInterface: false,
+    generate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const interfacesFile = new code_entity_1.Block();
+            const implementationsFile = new code_entity_1.Block();
+            implementationsFile.writeLine("//");
+            implementationsFile.writeLine("// automatically generated code; do not edit manually!");
+            implementationsFile.writeLine("//");
+            implementationsFile.writeLine("/* tslint:disable:all */");
+            implementationsFile.writeLine("");
+            interfacesFile.writeLine("//");
+            interfacesFile.writeLine("// automatically generated code; do not edit manually!");
+            interfacesFile.writeLine("//");
+            interfacesFile.writeLine("/* tslint:disable:all */");
+            const messagesClass = new code_entity_1.Block("export class Messages implements IMessages");
+            const messagesInterface = new code_entity_1.Block("interface IMessages");
+            _.each(this.$messagesService.pathsToMessageJsonFiles, (jsonFilePath) => {
+                const jsonContents = this.$fs.readJson(jsonFilePath), implementationBlock = new code_entity_1.Block(), interfaceBlock = new code_entity_1.Block();
+                this.generateFileRecursive(jsonContents, "", implementationBlock, 0, {
+                    shouldGenerateInterface: false,
+                });
+                this.generateFileRecursive(jsonContents, "", interfaceBlock, 0, {
+                    shouldGenerateInterface: true,
+                });
+                messagesClass.addBlock(implementationBlock);
+                messagesInterface.addBlock(interfaceBlock);
             });
-            this.generateFileRecursive(jsonContents, "", interfaceBlock, 0, {
-                shouldGenerateInterface: true,
-            });
-            messagesClass.addBlock(implementationBlock);
-            messagesInterface.addBlock(interfaceBlock);
+            interfacesFile.addBlock(messagesInterface);
+            interfacesFile.writeLine("/* tslint:enable */");
+            interfacesFile.writeLine("");
+            implementationsFile.addBlock(messagesClass);
+            implementationsFile.writeLine("$injector.register('messages', Messages);");
+            implementationsFile.writeLine("/* tslint:enable */");
+            implementationsFile.writeLine("");
+            const codePrinter = new code_printer_1.CodePrinter();
+            return {
+                interfaceFile: codePrinter.composeBlock(interfacesFile),
+                implementationFile: codePrinter.composeBlock(implementationsFile),
+            };
         });
-        interfacesFile.addBlock(messagesInterface);
-        interfacesFile.writeLine("/* tslint:enable */");
-        interfacesFile.writeLine("");
-        implementationsFile.addBlock(messagesClass);
-        implementationsFile.writeLine("$injector.register('messages', Messages);");
-        implementationsFile.writeLine("/* tslint:enable */");
-        implementationsFile.writeLine("");
-        const codePrinter = new code_printer_1.CodePrinter();
-        return {
-            interfaceFile: codePrinter.composeBlock(interfacesFile),
-            implementationFile: codePrinter.composeBlock(implementationsFile),
-        };
     }
     generateFileRecursive(jsonContents, propertyValue, block, depth, options) {
         _.each(jsonContents, (val, key) => {
@@ -70,3 +81,4 @@ class MessageContractGenerator {
 }
 exports.MessageContractGenerator = MessageContractGenerator;
 yok_1.injector.register("messageContractGenerator", MessageContractGenerator);
+//# sourceMappingURL=message-contract-generator.js.map

package/lib/common/services/messages-service.js

@@ -75,3 +75,4 @@ class MessagesService {
 }
 exports.MessagesService = MessagesService;
 yok_1.injector.register("messagesService", MessagesService);
+//# sourceMappingURL=messages-service.js.map

package/lib/common/services/micro-templating-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.MicroTemplateService = void 0;
 const util = require("util");
@@ -9,12 +18,18 @@ const _ = require("lodash");
 class MicroTemplateService {
     constructor($injector) {
         this.$injector = $injector;
+        // Injector's dynamicCallRegex doesn't have 'g' option, which we need here.
+        // Use ( ) in order to use $1 to get whole expression later
         this.dynamicCallRegex = new RegExp(util.format("(%s)", this.$injector.dynamicCallRegex.source), "g");
     }
-    async parseContent(data, options) {
-        const localVariables = this.getLocalVariables(options);
-        const compiledTemplate = _.template(data.replace(this.dynamicCallRegex, 'this.$injector.getDynamicCallData("$1")'));
-        return await compiledTemplate.apply(this, [localVariables]);
+    parseContent(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const localVariables = this.getLocalVariables(options);
+            const compiledTemplate = _.template(data.replace(this.dynamicCallRegex, 'this.$injector.getDynamicCallData("$1")'));
+            // When debugging parsing, uncomment the line below:
+            // console.log(compiledTemplate.source);
+            return yield compiledTemplate.apply(this, [localVariables]);
+        });
     }
     isPlatform(...args) {
         const platform = os.platform().toLowerCase();
@@ -22,6 +37,7 @@ class MicroTemplateService {
     }
     getLocalVariables(options) {
         const isHtml = options.isHtml;
+        // in html help we want to show all help. Only CONSOLE specific help(wrapped in if(isConsole) ) must be omitted
         const localVariables = {
             constants,
         };
@@ -36,3 +52,4 @@ class MicroTemplateService {
 }
 exports.MicroTemplateService = MicroTemplateService;
 yok_1.injector.register("microTemplateService", MicroTemplateService);
+//# sourceMappingURL=micro-templating-service.js.map