@akylas/nativescript-cli 8.7.2

package/lib/common/verify-node-version.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeWarning = exports.verifyNodeVersion = void 0;
+const color_1 = require("../color");
+var os = require("os");
+var semver = require("semver");
+var util = require("util");
+var versionsCausingFailure = ["0.10.34", "4.0.0", "4.2.0", "5.0.0"];
+var minimumRequiredVersion = "8.0.0";
+function getNodeVersionOpts() {
+    var supportedVersionsRange = require("../../package.json").engines.node;
+    var cliName = "NativeScript";
+    var deprecatedVersions = ["^8.0.0", "^9.0.0"];
+    var nodeVer = process.version.substr(1);
+    return {
+        supportedVersionsRange: supportedVersionsRange,
+        cliName: cliName,
+        nodeVer: nodeVer,
+        deprecatedVersions: deprecatedVersions,
+    };
+}
+function verifyNodeVersion() {
+    var verificationOpts = getNodeVersionOpts();
+    var cliName = verificationOpts.cliName;
+    var supportedVersionsRange = verificationOpts.supportedVersionsRange;
+    var nodeVer = verificationOpts.nodeVer;
+    if (versionsCausingFailure.indexOf(nodeVer) !== -1 ||
+        !semver.valid(nodeVer) ||
+        semver.lt(nodeVer, minimumRequiredVersion)) {
+        console.error(color_1.color.red.bold(util.format("%sNode.js '%s' is not supported. To be able to work with %s CLI, install any Node.js version in the following range: %s.%s", os.EOL, nodeVer, cliName, supportedVersionsRange, os.EOL)));
+        process.exit(1);
+    }
+}
+exports.verifyNodeVersion = verifyNodeVersion;
+var nodeWarn = undefined;
+function getNodeWarning() {
+    if (nodeWarn === undefined) {
+        nodeWarn = null;
+        var verificationOpts = getNodeVersionOpts();
+        var cliName = verificationOpts.cliName;
+        var supportedVersionsRange = verificationOpts.supportedVersionsRange;
+        var deprecatedVersions = verificationOpts.deprecatedVersions;
+        var nodeVer = verificationOpts.nodeVer;
+        var warningMessage = "";
+        if (deprecatedVersions) {
+            deprecatedVersions.forEach(function (version) {
+                if (semver.satisfies(nodeVer, version)) {
+                    warningMessage =
+                        "Support for Node.js " +
+                            version +
+                            " is deprecated and will be removed in one of the next releases of " +
+                            cliName +
+                            ". Please, upgrade to the latest Node.js LTS version. ";
+                    return warningMessage;
+                }
+            });
+        }
+        if (!warningMessage) {
+            var checkSatisfied = semver.satisfies(nodeVer, supportedVersionsRange);
+            if (!checkSatisfied) {
+                warningMessage =
+                    "Support for Node.js " +
+                        nodeVer +
+                        " is not verified. " +
+                        cliName +
+                        " CLI might not install or run properly.";
+            }
+        }
+        if (warningMessage) {
+            nodeWarn = {
+                message: warningMessage,
+                severity: "medium",
+            };
+        }
+    }
+    return nodeWarn;
+}
+exports.getNodeWarning = getNodeWarning;

package/lib/common/yok.js

@@ -0,0 +1,426 @@
+"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.setGlobalInjector = exports.Yok = exports.register = exports.injector = void 0;
+const path = require("path");
+const _ = require("lodash");
+const helpers_1 = require("./helpers");
+const constants_1 = require("./constants");
+let indent = "";
+function trace(formatStr, ...args) {
+}
+function pushIndent() {
+    indent += "  ";
+}
+function popIndent() {
+    indent = indent.slice(0, -2);
+}
+function forEachName(names, action) {
+    if (_.isString(names)) {
+        action(names);
+    }
+    else {
+        names.forEach(action);
+    }
+}
+function register(...rest) {
+    return function (target) {
+        exports.injector.register(rest[0], target);
+    };
+}
+exports.register = register;
+class Yok {
+    constructor() {
+        this.overrideAlreadyRequiredModule = false;
+        this.COMMANDS_NAMESPACE = "commands";
+        this.KEY_COMMANDS_NAMESPACE = "keyCommands";
+        this.modules = {};
+        this.resolutionProgress = {};
+        this.hierarchicalCommands = {};
+        this.publicApi = {
+            __modules__: {},
+        };
+        this.register("injector", this);
+    }
+    requireCommand(names, file) {
+        forEachName(names, (commandName) => {
+            const commands = commandName.split("|");
+            if (commands.length > 1) {
+                if (_.startsWith(commands[1], "*") &&
+                    this.modules[this.createCommandName(commands[0])]) {
+                    throw new Error("Default commands should be required before child commands");
+                }
+                const parentCommandName = commands[0];
+                if (!this.hierarchicalCommands[parentCommandName]) {
+                    this.hierarchicalCommands[parentCommandName] = [];
+                }
+                this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join("|"));
+            }
+            if (commands.length > 1 &&
+                !this.modules[this.createCommandName(commands[0])]) {
+                this.require(this.createCommandName(commands[0]), file);
+                if (commands[1] && !commandName.match(/\|\*/)) {
+                    this.require(this.createCommandName(commandName), file);
+                }
+            }
+            else {
+                this.require(this.createCommandName(commandName), file);
+            }
+        });
+    }
+    require(names, file) {
+        forEachName(names, (name) => this.requireOne(name, file));
+    }
+    requireKeyCommand(name, file) {
+        this.requireOne(this.createKeyCommandName(name), file);
+    }
+    requirePublic(names, file) {
+        forEachName(names, (name) => {
+            this.requireOne(name, file);
+            this.resolvePublicApi(name, file);
+        });
+    }
+    requirePublicClass(names, file) {
+        forEachName(names, (name) => {
+            this.requireOne(name, file);
+            this.addClassToPublicApi(name, file);
+        });
+    }
+    addClassToPublicApi(name, file) {
+        Object.defineProperty(this.publicApi, name, {
+            get: () => {
+                return this.resolveInstance(name);
+            },
+        });
+    }
+    resolvePublicApi(name, file) {
+        Object.defineProperty(this.publicApi, name, {
+            get: () => {
+                this.resolveInstance(name);
+                return this.publicApi.__modules__[name];
+            },
+        });
+    }
+    resolveInstance(name) {
+        let classInstance = _.first(this.modules[name].instances);
+        if (!classInstance) {
+            classInstance = this.resolve(name);
+        }
+        return classInstance;
+    }
+    requireOne(name, file) {
+        const relativePath = path.join("../", file);
+        const dependency = {
+            require: require("fs").existsSync(path.join(__dirname, relativePath + ".js"))
+                ? relativePath
+                : file,
+            shared: true,
+        };
+        if (!this.modules[name] || this.overrideAlreadyRequiredModule) {
+            this.modules[name] = dependency;
+        }
+        else {
+            throw new Error(`module '${name}' require'd twice.`);
+        }
+    }
+    registerCommand(names, resolver) {
+        forEachName(names, (name) => {
+            const commands = name.split("|");
+            this.register(this.createCommandName(name), resolver);
+            if (commands.length > 1) {
+                this.createHierarchicalCommand(commands[0]);
+            }
+        });
+    }
+    registerKeyCommand(name, resolver) {
+        this.register(this.createKeyCommandName(name), resolver);
+    }
+    getDefaultCommand(name, commandArguments) {
+        const subCommands = this.hierarchicalCommands[name];
+        const defaultCommand = _.find(subCommands, (command) => _.some(command.split("|"), (c) => _.startsWith(c, "*")));
+        return defaultCommand;
+    }
+    buildHierarchicalCommand(parentCommandName, commandLineArguments) {
+        let currentSubCommandName, finalSubCommandName, matchingSubCommandName;
+        const subCommands = this.hierarchicalCommands[parentCommandName];
+        let remainingArguments = commandLineArguments;
+        let finalRemainingArguments = commandLineArguments;
+        _.each(commandLineArguments, (arg) => {
+            arg = arg.toLowerCase();
+            currentSubCommandName = currentSubCommandName
+                ? this.getHierarchicalCommandName(currentSubCommandName, arg)
+                : arg;
+            remainingArguments = _.tail(remainingArguments);
+            if ((matchingSubCommandName = _.find(subCommands, (sc) => sc === currentSubCommandName ||
+                sc ===
+                    `${"*"}${currentSubCommandName}`))) {
+                finalSubCommandName = matchingSubCommandName;
+                finalRemainingArguments = remainingArguments;
+            }
+        });
+        if (!finalSubCommandName) {
+            finalSubCommandName =
+                this.getDefaultCommand(parentCommandName, commandLineArguments) || "";
+            finalRemainingArguments = _.difference(commandLineArguments, finalSubCommandName
+                .split("|")
+                .map((command) => _.startsWith(command, "*")
+                ? command.substr(1)
+                : command));
+        }
+        if (finalSubCommandName) {
+            return {
+                commandName: this.getHierarchicalCommandName(parentCommandName, finalSubCommandName),
+                remainingArguments: finalRemainingArguments,
+            };
+        }
+    }
+    createHierarchicalCommand(name) {
+        const factory = () => {
+            return {
+                disableAnalytics: true,
+                isHierarchicalCommand: true,
+                execute: (args) => __awaiter(this, void 0, void 0, function* () {
+                    const commandsService = exports.injector.resolve("commandsService");
+                    let commandName = null;
+                    const defaultCommand = this.getDefaultCommand(name, args);
+                    let commandArguments = [];
+                    if (args.length > 0) {
+                        const hierarchicalCommand = this.buildHierarchicalCommand(name, args);
+                        if (hierarchicalCommand) {
+                            commandName = hierarchicalCommand.commandName;
+                            commandArguments = hierarchicalCommand.remainingArguments;
+                        }
+                        else {
+                            commandName = defaultCommand
+                                ? this.getHierarchicalCommandName(name, defaultCommand)
+                                : "help";
+                            if (_.includes(this.hierarchicalCommands[name], "*" + args[0])) {
+                                commandArguments = _.tail(args);
+                            }
+                            else {
+                                commandArguments = args;
+                            }
+                        }
+                    }
+                    else {
+                        if (defaultCommand) {
+                            commandName = this.getHierarchicalCommandName(name, defaultCommand);
+                        }
+                        else {
+                            commandName = "help";
+                            const options = this.resolve("options");
+                            options.help = true;
+                        }
+                    }
+                    yield commandsService.tryExecuteCommand(commandName, commandName === "help" ? [name] : commandArguments);
+                }),
+            };
+        };
+        exports.injector.registerCommand(name, factory);
+    }
+    getHierarchicalCommandName(parentCommandName, subCommandName) {
+        return [parentCommandName, subCommandName].join("|");
+    }
+    isValidHierarchicalCommand(commandName, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.includes(Object.keys(this.hierarchicalCommands), commandName)) {
+                const subCommands = this.hierarchicalCommands[commandName];
+                if (subCommands) {
+                    const fullCommandName = this.buildHierarchicalCommand(commandName, commandArguments);
+                    if (!fullCommandName) {
+                        const errors = exports.injector.resolve("errors");
+                        errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, commandName);
+                    }
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    isDefaultCommand(commandName) {
+        return (commandName.indexOf("*") > 0 &&
+            commandName.indexOf("|") > 0);
+    }
+    register(name, resolver, shared) {
+        shared = shared === undefined ? true : shared;
+        trace("registered '%s'", name);
+        const dependency = this.modules[name] || {};
+        dependency.shared = shared;
+        if (_.isFunction(resolver)) {
+            dependency.resolver = resolver;
+        }
+        else {
+            dependency.instances = dependency.instances || [];
+            if (shared) {
+                dependency.instances[0] = resolver;
+            }
+            else {
+                dependency.instances.push(resolver);
+            }
+        }
+        this.modules[name] = dependency;
+    }
+    resolveCommand(name) {
+        let command;
+        const commandModuleName = this.createCommandName(name);
+        if (!this.modules[commandModuleName]) {
+            return null;
+        }
+        command = this.resolve(commandModuleName);
+        return command;
+    }
+    resolveKeyCommand(name) {
+        let command;
+        const commandModuleName = this.createKeyCommandName(name);
+        if (!this.modules[commandModuleName]) {
+            return null;
+        }
+        command = this.resolve(commandModuleName);
+        return command;
+    }
+    resolve(param, ctorArguments) {
+        if (_.isFunction(param)) {
+            return this.resolveConstructor(param, ctorArguments);
+        }
+        else {
+            return this.resolveByName(param, ctorArguments);
+        }
+    }
+    get dynamicCallRegex() {
+        return /#{([^.]+)\.([^}]+?)(\((.+)\))*}/;
+    }
+    getDynamicCallData(call, args) {
+        const parsed = call.match(this.dynamicCallRegex);
+        const module = this.resolve(parsed[1]);
+        if (!args && parsed[3]) {
+            args = _.map(parsed[4].split(","), (arg) => arg.trim());
+        }
+        return module[parsed[2]].apply(module, args);
+    }
+    dynamicCall(call, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = this.getDynamicCallData(call, args);
+            if ((0, helpers_1.isPromise)(data)) {
+                return yield data;
+            }
+            return data;
+        });
+    }
+    resolveConstructor(ctor, ctorArguments) {
+        (0, helpers_1.annotate)(ctor);
+        const resolvedArgs = ctor.$inject.args.map((paramName) => {
+            if (ctorArguments && ctorArguments.hasOwnProperty(paramName)) {
+                return ctorArguments[paramName];
+            }
+            else {
+                return this.resolve(paramName);
+            }
+        });
+        const name = ctor.$inject.name;
+        if (name && name[0] === name[0].toUpperCase()) {
+            return new ctor(...resolvedArgs);
+        }
+        else {
+            return ctor.apply(null, resolvedArgs);
+        }
+    }
+    resolveByName(name, ctorArguments) {
+        if (name[0] === "$") {
+            name = name.substr(1);
+        }
+        if (this.resolutionProgress[name]) {
+            throw new Error(`Cyclic dependency detected on dependency '${name}'`);
+        }
+        this.resolutionProgress[name] = true;
+        trace("resolving '%s'", name);
+        pushIndent();
+        let dependency;
+        let instance;
+        try {
+            dependency = this.resolveDependency(name);
+            if (!dependency) {
+                throw new Error("unable to resolve " + name);
+            }
+            if (!dependency.instances ||
+                !dependency.instances.length ||
+                !dependency.shared) {
+                if (!dependency.resolver) {
+                    throw new Error("no resolver registered for " + name);
+                }
+                dependency.instances = dependency.instances || [];
+                instance = this.resolveConstructor(dependency.resolver, ctorArguments);
+                dependency.instances.push(instance);
+            }
+            else {
+                instance = _.first(dependency.instances);
+            }
+        }
+        finally {
+            popIndent();
+            delete this.resolutionProgress[name];
+        }
+        return instance;
+    }
+    resolveDependency(name) {
+        const module = this.modules[name];
+        if (!module) {
+            throw new Error("unable to resolve " + name);
+        }
+        if (module.require) {
+            require(module.require);
+        }
+        return module;
+    }
+    getRegisteredCommandsNames(includeDev) {
+        const modulesNames = _.keys(this.modules);
+        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.COMMANDS_NAMESPACE}.`));
+        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.COMMANDS_NAMESPACE.length + 1));
+        if (!includeDev) {
+            commands = _.reject(commands, (command) => _.startsWith(command, "dev-"));
+        }
+        return commands;
+    }
+    getRegisteredKeyCommandsNames() {
+        const modulesNames = _.keys(this.modules);
+        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.KEY_COMMANDS_NAMESPACE}.`));
+        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.KEY_COMMANDS_NAMESPACE.length + 1));
+        return commands;
+    }
+    getChildrenCommandsNames(commandName) {
+        return this.hierarchicalCommands[commandName];
+    }
+    createCommandName(name) {
+        return `${this.COMMANDS_NAMESPACE}.${name}`;
+    }
+    createKeyCommandName(name) {
+        return `${this.KEY_COMMANDS_NAMESPACE}.${name}`;
+    }
+    dispose() {
+        Object.keys(this.modules).forEach((moduleName) => {
+            const instances = this.modules[moduleName].instances;
+            _.forEach(instances, (instance) => {
+                if (instance && instance.dispose && instance !== this) {
+                    instance.dispose();
+                }
+            });
+        });
+    }
+}
+exports.Yok = Yok;
+if (!global.$injector) {
+    global.$injector = new Yok();
+    exports.injector = global.$injector;
+}
+function setGlobalInjector(inj) {
+    global.$injector = exports.injector = inj;
+    return inj;
+}
+exports.setGlobalInjector = setGlobalInjector;

package/lib/config.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.StaticConfig = exports.Configuration = void 0;
+const path = require("path");
+const shelljs = require("shelljs");
+const os = require("os");
+const _ = require("lodash");
+const yok_1 = require("./common/yok");
+class Configuration {
+    constructor($fs) {
+        this.$fs = $fs;
+        this.DEBUG = false;
+        this.ANDROID_DEBUG_UI = null;
+        this.USE_POD_SANDBOX = false;
+        this.GA_TRACKING_ID = null;
+        this.DISABLE_HOOKS = false;
+        _.extend(this, this.loadConfig("config"));
+    }
+    loadConfig(name) {
+        const configFileName = this.getConfigPath(name);
+        return this.$fs.readJson(configFileName);
+    }
+    getConfigPath(filename) {
+        return path.join(__dirname, "../config", filename + ".json");
+    }
+}
+exports.Configuration = Configuration;
+yok_1.injector.register("config", Configuration);
+class StaticConfig {
+    get PROFILE_DIR_NAME() {
+        return ".nativescript-cli";
+    }
+    constructor($injector) {
+        this.$injector = $injector;
+        this.QR_SIZE = 5;
+        this.PROJECT_FILE_NAME = "package.json";
+        this.CLIENT_NAME_KEY_IN_PROJECT_FILE = "nativescript";
+        this.CLIENT_NAME = "tns";
+        this.CLIENT_NAME_ALIAS = "NativeScript";
+        this.TRACK_FEATURE_USAGE_SETTING_NAME = "TrackFeatureUsage";
+        this.ERROR_REPORT_SETTING_NAME = "TrackExceptions";
+        this.ANALYTICS_INSTALLATION_ID_SETTING_NAME = "AnalyticsInstallationID";
+        this.RESOURCE_DIR_PATH = path.join(__dirname, "..", "resources");
+        this.version = require("../package.json").version;
+        this.cliBinPath = path.resolve(__dirname, "..", "bin", "nativescript.js");
+        this._adbFilePath = null;
+        this._userAgent = null;
+    }
+    get disableCommandHooks() {
+        return true;
+    }
+    get HTML_CLI_HELPERS_DIR() {
+        return path.join(__dirname, "../docs/helpers");
+    }
+    get pathToPackageJson() {
+        return path.join(__dirname, "..", "package.json");
+    }
+    get PATH_TO_BOOTSTRAP() {
+        return path.join(__dirname, "bootstrap.js");
+    }
+    getAdbFilePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._adbFilePath) {
+                const androidToolsInfo = this.$injector.resolve("androidToolsInfo");
+                this._adbFilePath =
+                    (yield androidToolsInfo.getPathToAdbFromAndroidHome()) ||
+                        (yield this.getAdbFilePathCore());
+            }
+            return this._adbFilePath;
+        });
+    }
+    get USER_AGENT_NAME() {
+        if (!this._userAgent) {
+            this._userAgent = `${this.CLIENT_NAME}CLI`;
+        }
+        return this._userAgent;
+    }
+    set USER_AGENT_NAME(userAgentName) {
+        this._userAgent = userAgentName;
+    }
+    get MAN_PAGES_DIR() {
+        return path.join(__dirname, "..", "docs", "man_pages");
+    }
+    get HTML_PAGES_DIR() {
+        return path.join(__dirname, "..", "docs", "html");
+    }
+    get HTML_COMMON_HELPERS_DIR() {
+        return path.join(__dirname, "common", "docs", "helpers");
+    }
+    getAdbFilePathCore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const $childProcess = this.$injector.resolve("$childProcess");
+            try {
+                const proc = yield $childProcess.spawnFromEvent("adb", ["version"], "exit", undefined, { throwError: false });
+                if (proc.stderr) {
+                    return yield this.spawnPrivateAdb();
+                }
+            }
+            catch (e) {
+                if (e.code === "ENOENT") {
+                    return yield this.spawnPrivateAdb();
+                }
+            }
+            return "adb";
+        });
+    }
+    spawnPrivateAdb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const $fs = this.$injector.resolve("$fs"), $childProcess = this.$injector.resolve("$childProcess"), $hostInfo = this.$injector.resolve("$hostInfo");
+            const defaultAdbDirPath = path.join(__dirname, "common", "resources", "platform-tools", "android", process.platform);
+            const pathToPackageJson = path.join(__dirname, "..", "package.json");
+            const nsCliVersion = require(pathToPackageJson).version;
+            const tmpDir = path.join(os.tmpdir(), `nativescript-cli-${nsCliVersion}`);
+            $fs.createDirectory(tmpDir);
+            const targetAdb = path.join(tmpDir, "adb");
+            if (!$fs.exists(tmpDir) || !$fs.readDirectory(tmpDir).length) {
+                shelljs.cp(path.join(defaultAdbDirPath, "*"), tmpDir);
+                if (!$hostInfo.isWindows) {
+                    shelljs.chmod("+x", targetAdb);
+                }
+            }
+            yield $childProcess.spawnFromEvent(targetAdb, ["start-server"], "exit");
+            return targetAdb;
+        });
+    }
+}
+exports.StaticConfig = StaticConfig;
+yok_1.injector.register("staticConfig", StaticConfig);

package/lib/constants-provider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constants = void 0;
+const constants = require("./constants");
+const yok_1 = require("./common/yok");
+class Constants {
+    constructor() {
+        Object.assign(this, constants);
+    }
+}
+exports.Constants = Constants;
+yok_1.injector.register("constants", Constants);