@akylas/nativescript-cli 8.8.2 → 8.8.3

package/lib/common/services/json-file-settings-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.JsonFileSettingsService = void 0;
 const path = require("path");
@@ -26,49 +17,43 @@ class JsonFileSettingsService {
         this.jsonSettingsData = null;
         this.jsonSettingsFilePath = jsonFileSettingsPath;
     }
-    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) {
-                            return null;
-                        }
-                        const currentTime = Date.now();
-                        if (currentTime - data.time > cacheOpts.cacheTimeout) {
-                            return null;
-                        }
+    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;
                     }
-                    return dataToReturn;
                 }
-                return null;
-            });
-            return this.$lockService.executeActionWithLock(action, this.lockFilePath);
-        });
+                return dataToReturn;
+            }
+            return null;
+        };
+        return this.$lockService.executeActionWithLock(action, this.lockFilePath);
     }
-    saveSetting(key, value, cacheOpts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const settingObject = {};
-            settingObject[key] = value;
-            return this.saveSettings(settingObject, cacheOpts);
-        });
+    async saveSetting(key, value, cacheOpts) {
+        const settingObject = {};
+        settingObject[key] = value;
+        return this.saveSettings(settingObject, cacheOpts);
     }
-    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);
-        });
+    async removeSetting(key) {
+        const action = async () => {
+            await this.loadUserSettingsFile();
+            delete this.jsonSettingsData[key];
+            await this.saveSettings();
+        };
+        return this.$lockService.executeActionWithLock(action, this.lockFilePath);
     }
     saveSettings(data, cacheOpts) {
-        const action = () => __awaiter(this, void 0, void 0, function* () {
-            yield this.loadUserSettingsFile();
+        const action = async () => {
+            await this.loadUserSettingsFile();
             this.jsonSettingsData = this.jsonSettingsData || {};
             _(data)
                 .keys()
@@ -85,36 +70,32 @@ class JsonFileSettingsService {
                         : data[propertyName];
             });
             this.$fs.writeJson(this.jsonSettingsFilePath, this.jsonSettingsData);
-        });
+        };
         return this.$lockService.executeActionWithLock(action, this.lockFilePath);
     }
-    loadUserSettingsFile() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.jsonSettingsData) {
-                yield this.loadUserSettingsData();
-            }
-        });
+    async loadUserSettingsFile() {
+        if (!this.jsonSettingsData) {
+            await this.loadUserSettingsData();
+        }
     }
-    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);
-                if (process.env.SUDO_USER) {
-                    for (const dir of unexistingDirs) {
-                        yield this.$fs.setCurrentUserAsOwner(dir, process.env.SUDO_USER);
-                    }
+    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);
                 }
             }
-            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 = [];

package/lib/common/services/lock-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.LockService = void 0;
 const lockfile = require("proper-lockfile");
@@ -42,51 +33,43 @@ class LockService {
         this.$settingsService = $settingsService;
         this.$cleanupService = $cleanupService;
     }
-    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 executeActionWithLock(action, lockFilePath, lockOpts) {
+        const releaseFunc = await this.lock(lockFilePath, lockOpts);
+        try {
+            const result = await action();
+            return result;
+        }
+        finally {
+            releaseFunc();
+        }
     }
-    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 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}"`);
+        }
     }
-    unlock(lockFilePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { filePath } = this.getLockFileSettings(lockFilePath);
-            lockfile.unlockSync(filePath);
-            yield this.cleanLock(filePath);
-        });
+    async unlock(lockFilePath) {
+        const { filePath } = this.getLockFileSettings(lockFilePath);
+        lockfile.unlockSync(filePath);
+        await this.cleanLock(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);
-            }
-        });
+    async cleanLock(lockPath) {
+        this.$fs.deleteFile(lockPath);
+        for (const filePath of this.getPathsForCleanupAction(lockPath)) {
+            await this.$cleanupService.removeCleanupDeleteAction(filePath);
+        }
     }
     getPathsForCleanupAction(lockPath) {
         return [lockPath, `${lockPath}.lock`];
@@ -121,9 +104,9 @@ 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);
 yok_1.injector.register("lockfile", LockService);

package/lib/common/services/message-contract-generator.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.MessageContractGenerator = void 0;
 const code_entity_1 = require("../codeGeneration/code-entity");
@@ -19,45 +10,43 @@ class MessageContractGenerator {
         this.$fs = $fs;
         this.$messagesService = $messagesService;
     }
-    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);
+    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,
             });
-            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),
-            };
+            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),
+        };
     }
     generateFileRecursive(jsonContents, propertyValue, block, depth, options) {
         _.each(jsonContents, (val, key) => {

package/lib/common/services/micro-templating-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.MicroTemplateService = void 0;
 const util = require("util");
@@ -20,12 +11,10 @@ class MicroTemplateService {
         this.$injector = $injector;
         this.dynamicCallRegex = new RegExp(util.format("(%s)", this.$injector.dynamicCallRegex.source), "g");
     }
-    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")'));
-            return yield compiledTemplate.apply(this, [localVariables]);
-        });
+    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]);
     }
     isPlatform(...args) {
         const platform = os.platform().toLowerCase();

package/lib/common/services/net-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.Net = void 0;
 const net = require("net");
@@ -21,117 +12,109 @@ class Net {
         this.$logger = $logger;
         this.$osInfo = $osInfo;
     }
-    getFreePort() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const server = net.createServer((sock) => {
+    async getFreePort() {
+        const server = net.createServer((sock) => {
+        });
+        return new Promise((resolve, reject) => {
+            let isResolved = false;
+            server.listen(0, () => {
+                const portUsed = server.address().port;
+                server.close();
+                if (!isResolved) {
+                    isResolved = true;
+                    resolve(portUsed);
+                }
             });
-            return new Promise((resolve, reject) => {
-                let isResolved = false;
-                server.listen(0, () => {
-                    const portUsed = server.address().port;
-                    server.close();
-                    if (!isResolved) {
-                        isResolved = true;
-                        resolve(portUsed);
-                    }
-                });
-                server.on("error", (err) => {
-                    if (!isResolved) {
-                        isResolved = true;
-                        reject(err);
-                    }
-                });
+            server.on("error", (err) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(err);
+                }
             });
         });
     }
-    isPortAvailable(port) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                let isResolved = false;
-                const server = net.createServer();
-                server.on("error", (err) => {
-                    if (!isResolved) {
-                        isResolved = true;
-                        resolve(false);
-                    }
-                });
-                server.once("close", () => {
-                    if (!isResolved) {
-                        isResolved = true;
-                        resolve(true);
-                    }
-                });
-                server.on("listening", (err) => {
-                    if (err && !isResolved) {
-                        isResolved = true;
-                        resolve(true);
-                    }
-                    server.close();
-                });
-                server.listen(port, "localhost");
+    async isPortAvailable(port) {
+        return new Promise((resolve, reject) => {
+            let isResolved = false;
+            const server = net.createServer();
+            server.on("error", (err) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    resolve(false);
+                }
             });
+            server.once("close", () => {
+                if (!isResolved) {
+                    isResolved = true;
+                    resolve(true);
+                }
+            });
+            server.on("listening", (err) => {
+                if (err && !isResolved) {
+                    isResolved = true;
+                    resolve(true);
+                }
+                server.close();
+            });
+            server.listen(port, "localhost");
         });
     }
-    getAvailablePortInRange(startPort, endPort) {
-        return __awaiter(this, void 0, void 0, function* () {
-            endPort = endPort || 65534;
-            while (!(yield this.isPortAvailable(startPort))) {
-                startPort++;
-                if (startPort > endPort) {
-                    this.$errors.fail("Unable to find free local port.");
-                }
+    async getAvailablePortInRange(startPort, endPort) {
+        endPort = endPort || 65534;
+        while (!(await this.isPortAvailable(startPort))) {
+            startPort++;
+            if (startPort > endPort) {
+                this.$errors.fail("Unable to find free local port.");
             }
-            return startPort;
-        });
+        }
+        return startPort;
     }
-    waitForPortToListen(waitForPortListenData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!waitForPortListenData) {
-                this.$errors.fail("You must pass port and timeout for check.");
+    async waitForPortToListen(waitForPortListenData) {
+        if (!waitForPortListenData) {
+            this.$errors.fail("You must pass port and timeout for check.");
+        }
+        const { timeout, port } = waitForPortListenData;
+        const interval = waitForPortListenData.interval || Net.DEFAULT_INTERVAL;
+        const endTime = new Date().getTime() + timeout;
+        const platformData = {
+            darwin: {
+                command: "netstat -f inet -p tcp -anL",
+                regex: new RegExp(`\\.${port}\\b`, "g"),
+            },
+            linux: {
+                command: "netstat -tnl",
+                regex: new RegExp(`:${port}\\s`, "g"),
+            },
+            win32: {
+                command: "netstat -ant -p tcp",
+                regex: new RegExp(`TCP\\s+(\\d+\\.){3}\\d+:${port}.*?LISTEN`, "g"),
+            },
+        };
+        const platform = this.$osInfo.platform();
+        const currentPlatformData = platformData[platform];
+        if (!currentPlatformData) {
+            this.$errors.fail(`Unable to check for free ports on ${platform}. Supported platforms are: ${_.keys(platformData).join(", ")}`);
+        }
+        while (true) {
+            const { command, regex } = currentPlatformData;
+            try {
+                const result = await this.$childProcess.exec(command);
+                if (result && !!result.match(regex)) {
+                    return true;
+                }
             }
-            const { timeout, port } = waitForPortListenData;
-            const interval = waitForPortListenData.interval || Net.DEFAULT_INTERVAL;
-            const endTime = new Date().getTime() + timeout;
-            const platformData = {
-                darwin: {
-                    command: "netstat -f inet -p tcp -anL",
-                    regex: new RegExp(`\\.${port}\\b`, "g"),
-                },
-                linux: {
-                    command: "netstat -tnl",
-                    regex: new RegExp(`:${port}\\s`, "g"),
-                },
-                win32: {
-                    command: "netstat -ant -p tcp",
-                    regex: new RegExp(`TCP\\s+(\\d+\\.){3}\\d+:${port}.*?LISTEN`, "g"),
-                },
-            };
-            const platform = this.$osInfo.platform();
-            const currentPlatformData = platformData[platform];
-            if (!currentPlatformData) {
-                this.$errors.fail(`Unable to check for free ports on ${platform}. Supported platforms are: ${_.keys(platformData).join(", ")}`);
+            catch (err) {
+                this.$logger.trace(`Error while calling '${command}': ${err}`);
             }
-            while (true) {
-                const { command, regex } = currentPlatformData;
-                try {
-                    const result = yield this.$childProcess.exec(command);
-                    if (result && !!result.match(regex)) {
-                        return true;
-                    }
-                }
-                catch (err) {
-                    this.$logger.trace(`Error while calling '${command}': ${err}`);
-                }
-                const currentTime = new Date().getTime();
-                if (currentTime >= endTime) {
-                    break;
-                }
-                yield (0, helpers_1.sleep)(interval);
+            const currentTime = new Date().getTime();
+            if (currentTime >= endTime) {
+                break;
             }
-            return false;
-        });
+            await (0, helpers_1.sleep)(interval);
+        }
+        return false;
     }
 }
-Net.DEFAULT_INTERVAL = 1000;
 exports.Net = Net;
+Net.DEFAULT_INTERVAL = 1000;
 yok_1.injector.register("net", Net);