@nativescript/doctor/src/wrappers/child-process.js

Library that helps identifying if the environment can be used for development of {N} apps.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ChildProcess = void 0;
var childProcess = require("child_process");
var ChildProcess = (function () {
    function ChildProcess() {
    }
    ChildProcess.prototype.spawnFromEvent = function (command, args, event, options) {
        return new Promise(function (resolve, reject) {
            options = options || {};
            var commandChildProcess = childProcess.spawn(command, args, options.spawnOptions);
            var capturedOut = "";
            var capturedErr = "";
            if (commandChildProcess.stdout) {
                commandChildProcess.stdout.on("data", function (data) {
                    capturedOut += data;
                });
            }
            if (commandChildProcess.stderr) {
                commandChildProcess.stderr.on("data", function (data) {
                    capturedErr += data;
                });
            }
            commandChildProcess.on(event, function (arg) {
                var exitCode = typeof arg === "number" ? arg : arg && arg.code;
                var result = {
                    stdout: capturedOut,
                    stderr: capturedErr,
                    exitCode: exitCode,
                };
                if (options.ignoreError) {
                    resolve(result);
                }
                else {
                    if (exitCode === 0) {
                        resolve(result);
                    }
                    else {
                        var errorMessage = "Command ".concat(command, " failed with exit code ").concat(exitCode);
                        if (capturedErr) {
                            errorMessage += " Error output: \n ".concat(capturedErr);
                        }
                        reject(errorMessage);
                    }
                }
            });
            commandChildProcess.once("error", function (err) {
                if (options.ignoreError) {
                    var result = {
                        stdout: capturedOut,
                        stderr: err.message,
                        exitCode: err.code,
                    };
                    resolve(result);
                }
                else {
                    reject(err);
                }
            });
        });
    };
    ChildProcess.prototype.exec = function (command, options) {
        return new Promise(function (resolve, reject) {
            childProcess.exec(command, options, function (err, stdout, stderr) {
                if (err) {
                    reject(err);
                }
                var result = {
                    stdout: stdout,
                    stderr: stderr,
                };
                resolve(result);
            });
        });
    };
    ChildProcess.prototype.execSync = function (command, options) {
        return childProcess.execSync(command, options).toString();
    };
    ChildProcess.prototype.execFile = function (command, args) {
        return new Promise(function (resolve, reject) {
            childProcess.execFile(command, args, function (error, stdout) {
                if (error) {
                    reject(error);
                }
                else {
                    resolve(stdout);
                }
            });
        });
    };
    return ChildProcess;
}());
exports.ChildProcess = ChildProcess;