@akylas/nativescript-cli 8.7.2

package/lib/common/services/json-file-settings-service.js

@@ -0,0 +1,133 @@
+"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");
+const helpers_1 = require("../helpers");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class JsonFileSettingsService {
+    get lockFilePath() {
+        return `${this.jsonSettingsFilePath}.lock`;
+    }
+    constructor(jsonFileSettingsPath, $fs, $lockService, $logger) {
+        this.$fs = $fs;
+        this.$lockService = $lockService;
+        this.$logger = $logger;
+        this.jsonSettingsFilePath = null;
+        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;
+                        }
+                    }
+                    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);
+        });
+    }
+    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 = () => __awaiter(this, void 0, void 0, function* () {
+            yield this.loadUserSettingsFile();
+            this.jsonSettingsData = this.jsonSettingsData || {};
+            _(data)
+                .keys()
+                .each((propertyName) => {
+                this.jsonSettingsData[propertyName] =
+                    cacheOpts &&
+                        cacheOpts.useCaching &&
+                        !data[propertyName].modifiedByCacheMechanism
+                        ? {
+                            time: Date.now(),
+                            value: data[propertyName],
+                            modifiedByCacheMechanism: true,
+                        }
+                        : 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();
+            }
+        });
+    }
+    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);
+                    }
+                }
+            }
+            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) {
+            if (this.$fs.exists(currentDir)) {
+                break;
+            }
+            unexistingDirs.push(currentDir);
+            currentDir = path.join(currentDir, "..");
+        }
+        return unexistingDirs;
+    }
+}
+exports.JsonFileSettingsService = JsonFileSettingsService;
+yok_1.injector.register("jsonFileSettingsService", JsonFileSettingsService, false);

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

@@ -0,0 +1,129 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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");
+const path = require("path");
+const decorators_1 = require("../decorators");
+const helpers_1 = require("../helpers");
+const yok_1 = require("../yok");
+const _ = require("lodash");
+class LockService {
+    get defaultLockFilePath() {
+        return this.getAbsoluteLockFilePath("lockfile.lock");
+    }
+    getAbsoluteLockFilePath(relativeLockFilePath) {
+        return path.join(this.$settingsService.getProfileDir(), relativeLockFilePath);
+    }
+    get defaultLockParams() {
+        const lockParams = {
+            retriesObj: { retries: 13, minTimeout: 100, maxTimeout: 1000, factor: 2 },
+            stale: 10 * 1000,
+            realpath: false,
+        };
+        return lockParams;
+    }
+    constructor($fs, $settingsService, $cleanupService) {
+        this.$fs = $fs;
+        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();
+            }
+        });
+    }
+    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}"`);
+            }
+        });
+    }
+    unlock(lockFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filePath } = this.getLockFileSettings(lockFilePath);
+            lockfile.unlockSync(filePath);
+            yield 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);
+            }
+        });
+    }
+    getPathsForCleanupAction(lockPath) {
+        return [lockPath, `${lockPath}.lock`];
+    }
+    getLockFileSettings(filePath, fileOpts) {
+        if (filePath && !path.isAbsolute(filePath)) {
+            filePath = this.getAbsoluteLockFilePath(filePath);
+        }
+        filePath = filePath || this.defaultLockFilePath;
+        fileOpts = fileOpts
+            ? _.assign({}, this.defaultLockParams, fileOpts)
+            : this.defaultLockParams;
+        fileOpts.retriesObj = fileOpts.retriesObj || {};
+        if (fileOpts.retries) {
+            fileOpts.retriesObj.retries = fileOpts.retries;
+        }
+        if (fileOpts.retryWait) {
+            fileOpts.retriesObj.minTimeout = fileOpts.retriesObj.maxTimeout =
+                fileOpts.retryWait;
+        }
+        fileOpts.retries = fileOpts.retriesObj;
+        return {
+            filePath: this.getShortFileLock(filePath),
+            fileOpts,
+        };
+    }
+    getShortFileLock(filePath) {
+        const dirPath = path.dirname(filePath);
+        const fileName = path.basename(filePath);
+        const hashedFileName = (0, helpers_1.getHash)(fileName, { algorithm: "MD5" });
+        filePath = path.join(dirPath, hashedFileName);
+        return filePath;
+    }
+}
+__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

@@ -0,0 +1,83 @@
+"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");
+const code_printer_1 = require("../codeGeneration/code-printer");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class MessageContractGenerator {
+    constructor($fs, $messagesService) {
+        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);
+            });
+            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) => {
+            let newPropertyValue = propertyValue + key;
+            const separator = options.shouldGenerateInterface || depth ? ":" : "=";
+            const endingSymbol = options.shouldGenerateInterface || !depth ? ";" : ",";
+            if (typeof val === "string") {
+                const actualValue = options.shouldGenerateInterface
+                    ? "string"
+                    : `"${newPropertyValue}"`;
+                block.writeLine(`${key}${separator} ${actualValue}${endingSymbol}`);
+                newPropertyValue = propertyValue;
+                return;
+            }
+            const newBlock = new code_entity_1.Block(`${key} ${separator} `);
+            newBlock.endingCharacter = endingSymbol;
+            this.generateFileRecursive(val, newPropertyValue + ".", newBlock, depth + 1, options);
+            block.addBlock(newBlock);
+        });
+    }
+}
+exports.MessageContractGenerator = MessageContractGenerator;
+yok_1.injector.register("messageContractGenerator", MessageContractGenerator);

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesService = void 0;
+const util = require("util");
+const path_1 = require("path");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class MessagesService {
+    get pathToDefaultMessageJson() {
+        return (0, path_1.join)(__dirname, "..", "resources", "messages", "errorMessages.json");
+    }
+    get messageJsonFilesContents() {
+        if (!this._messageJsonFilesContentsCache ||
+            !this._messageJsonFilesContentsCache.length) {
+            this.refreshMessageJsonContentsCache();
+        }
+        return this._messageJsonFilesContentsCache;
+    }
+    constructor($fs) {
+        this.$fs = $fs;
+        this._pathsToMessageJsonFiles = null;
+        this._messageJsonFilesContentsCache = null;
+        this._pathsToMessageJsonFiles = [this.pathToDefaultMessageJson];
+    }
+    get pathsToMessageJsonFiles() {
+        if (!this._pathsToMessageJsonFiles) {
+            throw new Error("No paths to message json files provided.");
+        }
+        return this._pathsToMessageJsonFiles;
+    }
+    set pathsToMessageJsonFiles(pathsToMessageJsonFiles) {
+        this._pathsToMessageJsonFiles = pathsToMessageJsonFiles.concat(this.pathToDefaultMessageJson);
+        this.refreshMessageJsonContentsCache();
+    }
+    getMessage(id, ...args) {
+        const argsArray = args || [];
+        const keys = id.split(".");
+        let result = this.getFormatedMessage.apply(this, [id].concat(argsArray));
+        _.each(this.messageJsonFilesContents, (jsonFileContents) => {
+            const messageValue = this.getMessageFromJsonRecursive(keys, jsonFileContents, 0);
+            if (messageValue) {
+                result = this.getFormatedMessage.apply(this, [messageValue].concat(argsArray));
+                return false;
+            }
+        });
+        return result;
+    }
+    getMessageFromJsonRecursive(keys, jsonContents, index) {
+        if (index >= keys.length) {
+            return null;
+        }
+        const jsonValue = jsonContents[keys[index]];
+        if (!jsonValue) {
+            return null;
+        }
+        if (typeof jsonValue === "string") {
+            return jsonValue;
+        }
+        return this.getMessageFromJsonRecursive(keys, jsonValue, index + 1);
+    }
+    refreshMessageJsonContentsCache() {
+        this._messageJsonFilesContentsCache = [];
+        _.each(this.pathsToMessageJsonFiles, (path) => {
+            if (!this.$fs.exists(path)) {
+                throw new Error("Message json file " + path + " does not exist.");
+            }
+            this._messageJsonFilesContentsCache.push(this.$fs.readJson(path));
+        });
+    }
+    getFormatedMessage(message, ...args) {
+        return ~message.indexOf("%")
+            ? util.format.apply(null, [message].concat(args || []))
+            : message;
+    }
+}
+exports.MessagesService = MessagesService;
+yok_1.injector.register("messagesService", MessagesService);

package/lib/common/services/micro-templating-service.js

@@ -0,0 +1,49 @@
+"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");
+const os = require("os");
+const constants = require("../../constants");
+const yok_1 = require("../yok");
+const _ = require("lodash");
+class MicroTemplateService {
+    constructor($injector) {
+        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]);
+        });
+    }
+    isPlatform(...args) {
+        const platform = os.platform().toLowerCase();
+        return _.some(args, (arg) => arg.toLowerCase() === platform);
+    }
+    getLocalVariables(options) {
+        const isHtml = options.isHtml;
+        const localVariables = {
+            constants,
+        };
+        localVariables["isLinux"] = isHtml || this.isPlatform("linux");
+        localVariables["isWindows"] = isHtml || this.isPlatform("win32");
+        localVariables["isMacOS"] = isHtml || this.isPlatform("darwin");
+        localVariables["isConsole"] = !isHtml;
+        localVariables["isHtml"] = isHtml;
+        localVariables["isJekyll"] = false;
+        return localVariables;
+    }
+}
+exports.MicroTemplateService = MicroTemplateService;
+yok_1.injector.register("microTemplateService", MicroTemplateService);

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

@@ -0,0 +1,137 @@
+"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");
+const _ = require("lodash");
+const helpers_1 = require("../helpers");
+const yok_1 = require("../yok");
+class Net {
+    constructor($errors, $childProcess, $logger, $osInfo) {
+        this.$errors = $errors;
+        this.$childProcess = $childProcess;
+        this.$logger = $logger;
+        this.$osInfo = $osInfo;
+    }
+    getFreePort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+                    }
+                });
+                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");
+            });
+        });
+    }
+    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.");
+                }
+            }
+            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.");
+            }
+            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 = 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);
+            }
+            return false;
+        });
+    }
+}
+Net.DEFAULT_INTERVAL = 1000;
+exports.Net = Net;
+yok_1.injector.register("net", Net);