@akylas/nativescript-cli 8.7.2

package/lib/node-package-manager.js

@@ -0,0 +1,156 @@
+"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.NodePackageManager = void 0;
+const path_1 = require("path");
+const base_package_manager_1 = require("./base-package-manager");
+const decorators_1 = require("./common/decorators");
+const constants_1 = require("./constants");
+const _ = require("lodash");
+const yok_1 = require("./common/yok");
+class NodePackageManager extends base_package_manager_1.BasePackageManager {
+    constructor($childProcess, $errors, $fs, $hostInfo, $logger, $httpClient, $pacoteService) {
+        super($childProcess, $fs, $hostInfo, $pacoteService, "npm");
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$httpClient = $httpClient;
+    }
+    install(packageName, pathToSave, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (config.disableNpmInstall) {
+                return;
+            }
+            if (config.ignoreScripts) {
+                config["ignore-scripts"] = true;
+            }
+            const packageJsonPath = (0, path_1.join)(pathToSave, "package.json");
+            const jsonContentBefore = this.$fs.readJson(packageJsonPath);
+            const flags = this.getFlagsString(config, true);
+            let params = ["install", "--legacy-peer-deps"];
+            const isInstallingAllDependencies = packageName === pathToSave;
+            if (!isInstallingAllDependencies) {
+                params.push(packageName);
+            }
+            params = params.concat(flags);
+            const cwd = pathToSave;
+            const etcDirectoryLocation = (0, path_1.join)(cwd, "etc");
+            const etcExistsPriorToInstallation = this.$fs.exists(etcDirectoryLocation);
+            if (config.path) {
+                let relativePathFromCwdToSource = "";
+                if (config.frameworkPath) {
+                    relativePathFromCwdToSource = (0, path_1.relative)(config.frameworkPath, pathToSave);
+                    if (this.$fs.exists(relativePathFromCwdToSource)) {
+                        packageName = relativePathFromCwdToSource;
+                    }
+                }
+            }
+            try {
+                const result = yield this.processPackageManagerInstall(packageName, params, { cwd, isInstallingAllDependencies });
+                return result;
+            }
+            catch (err) {
+                if (err.message && err.message.indexOf("EPEERINVALID") !== -1) {
+                    this.$logger.warn(err.message);
+                }
+                else {
+                    this.$fs.writeJson(packageJsonPath, jsonContentBefore);
+                    throw err;
+                }
+            }
+            finally {
+                if (!etcExistsPriorToInstallation) {
+                    this.$fs.deleteDirectory(etcDirectoryLocation);
+                }
+            }
+        });
+    }
+    uninstall(packageName, config, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const flags = this.getFlagsString(config, false);
+            return this.$childProcess.exec(`npm uninstall ${packageName} ${flags}`, {
+                cwd: path,
+            });
+        });
+    }
+    search(filter, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const flags = this.getFlagsString(config, false);
+            return this.$childProcess.exec(`npm search ${filter.join(" ")} ${flags}`);
+        });
+    }
+    view(packageName, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wrappedConfig = _.extend({}, config, { json: true });
+            const flags = this.getFlagsString(wrappedConfig, false);
+            let viewResult;
+            try {
+                viewResult = yield this.$childProcess.exec(`npm view ${packageName} ${flags}`);
+            }
+            catch (e) {
+                this.$errors.fail(e.message);
+            }
+            try {
+                return JSON.parse(viewResult);
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    searchNpms(keyword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const httpRequestResult = yield this.$httpClient.httpRequest(`https://api.npms.io/v2/search?q=keywords:${keyword}`);
+            const result = JSON.parse(httpRequestResult.body);
+            return result;
+        });
+    }
+    getRegistryPackageData(packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = yield this.$childProcess.exec(`npm config get registry`);
+            const url = registry.trim() + packageName;
+            this.$logger.trace(`Trying to get data from npm registry for package ${packageName}, url is: ${url}`);
+            const responseData = (yield this.$httpClient.httpRequest(url)).body;
+            this.$logger.trace(`Successfully received data from npm registry for package ${packageName}. Response data is: ${responseData}`);
+            const jsonData = JSON.parse(responseData);
+            this.$logger.trace(`Successfully parsed data from npm registry for package ${packageName}.`);
+            return jsonData;
+        });
+    }
+    getCachePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachePath = yield this.$childProcess.exec(`npm config get cache`);
+            return (0, path_1.join)(cachePath.trim(), constants_1.CACACHE_DIRECTORY_NAME);
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("npm")
+], NodePackageManager.prototype, "install", null);
+__decorate([
+    (0, decorators_1.exported)("npm")
+], NodePackageManager.prototype, "uninstall", null);
+__decorate([
+    (0, decorators_1.exported)("npm")
+], NodePackageManager.prototype, "search", null);
+__decorate([
+    (0, decorators_1.exported)("npm")
+], NodePackageManager.prototype, "view", null);
+__decorate([
+    (0, decorators_1.cache)()
+], NodePackageManager.prototype, "getCachePath", null);
+exports.NodePackageManager = NodePackageManager;
+yok_1.injector.register("npm", NodePackageManager);

package/lib/options.js

@@ -0,0 +1,393 @@
+"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.Options = void 0;
+const helpers = require("./common/helpers");
+const yargs = require("yargs");
+const helpers_1 = require("yargs/helpers");
+const _ = require("lodash");
+const yok_1 = require("./common/yok");
+class Options {
+    setupOptions(commandSpecificDashedOptions) {
+        if (commandSpecificDashedOptions) {
+            _.extend(this.options, commandSpecificDashedOptions);
+            this.setArgv();
+        }
+        this.argv.bundle = "webpack";
+        if (this.initialArgv.release && this.initialArgv.hmr) {
+            this.$errors.fail("The options --release and --hmr cannot be used simultaneously.");
+        }
+        if (this.argv.hmr) {
+            this.argv.hmr = !this.argv.release;
+        }
+        if (this.argv.debugBrk) {
+            this.argv.hmr = false;
+        }
+        if (this.argv.justlaunch) {
+            this.argv.hmr = false;
+        }
+    }
+    constructor($errors, $settingsService) {
+        this.$errors = $errors;
+        this.$settingsService = $settingsService;
+        this.optionsWhiteList = [
+            "ui",
+            "recursive",
+            "reporter",
+            "require",
+            "timeout",
+            "_",
+            "$0",
+        ];
+        this.globalOptions = {
+            log: { type: "string", hasSensitiveValue: false },
+            verbose: { type: "boolean", hasSensitiveValue: false },
+            version: { type: "boolean", alias: "v", hasSensitiveValue: false },
+            help: { type: "boolean", alias: "h", hasSensitiveValue: false },
+            profileDir: { type: "string", hasSensitiveValue: true },
+            analyticsClient: { type: "string", hasSensitiveValue: false },
+            path: { type: "string", alias: "p", hasSensitiveValue: true },
+            config: { type: "string", alias: "c", hasSensitiveValue: true },
+            _: { type: "string", hasSensitiveValue: false },
+        };
+        this.options = _.extend({}, this.commonOptions, this.globalOptions);
+        this.setArgv();
+    }
+    get shorthands() {
+        const result = [];
+        _.each(_.keys(this.options), (optionName) => {
+            if (this.options[optionName].alias) {
+                result.push(this.options[optionName].alias);
+            }
+        });
+        return result;
+    }
+    get commonOptions() {
+        return {
+            ipa: { type: "string", hasSensitiveValue: true },
+            frameworkPath: { type: "string", hasSensitiveValue: true },
+            frameworkName: { type: "string", hasSensitiveValue: false },
+            framework: { type: "string", hasSensitiveValue: false },
+            frameworkVersion: { type: "string", hasSensitiveValue: false },
+            forDevice: { type: "boolean", hasSensitiveValue: false },
+            iCloudContainerEnvironment: {
+                type: "string",
+                hasSensitiveValue: false,
+            },
+            provision: { type: "object", hasSensitiveValue: true },
+            client: {
+                type: "boolean",
+                default: true,
+                hasSensitiveValue: false,
+            },
+            env: { type: "object", hasSensitiveValue: false },
+            production: { type: "boolean", hasSensitiveValue: false },
+            debugTransport: { type: "boolean", hasSensitiveValue: false },
+            keyStorePath: { type: "string", hasSensitiveValue: true },
+            keyStorePassword: { type: "string", hasSensitiveValue: true },
+            keyStoreAlias: { type: "string", hasSensitiveValue: true },
+            keyStoreAliasPassword: {
+                type: "string",
+                hasSensitiveValue: true,
+            },
+            ignoreScripts: { type: "boolean", hasSensitiveValue: false },
+            disableNpmInstall: { type: "boolean", hasSensitiveValue: false },
+            compileSdk: { type: "number", hasSensitiveValue: false },
+            port: { type: "number", hasSensitiveValue: false },
+            copyTo: { type: "string", hasSensitiveValue: true },
+            js: { type: "boolean", hasSensitiveValue: false },
+            javascript: { type: "boolean", hasSensitiveValue: false },
+            ng: { type: "boolean", hasSensitiveValue: false },
+            angular: { type: "boolean", hasSensitiveValue: false },
+            react: { type: "boolean", hasSensitiveValue: false },
+            reactjs: { type: "boolean", hasSensitiveValue: false },
+            vue: { type: "boolean", hasSensitiveValue: false },
+            vuejs: { type: "boolean", hasSensitiveValue: false },
+            svelte: { type: "boolean", hasSensitiveValue: false },
+            vision: { type: "boolean", hasSensitiveValue: false },
+            "vision-ng": { type: "boolean", hasSensitiveValue: false },
+            "vision-react": { type: "boolean", hasSensitiveValue: false },
+            "vision-solid": { type: "boolean", hasSensitiveValue: false },
+            "vision-svelte": { type: "boolean", hasSensitiveValue: false },
+            "vision-vue": { type: "boolean", hasSensitiveValue: false },
+            tsc: { type: "boolean", hasSensitiveValue: false },
+            ts: { type: "boolean", hasSensitiveValue: false },
+            typescript: { type: "boolean", hasSensitiveValue: false },
+            yarn: { type: "boolean", hasSensitiveValue: false },
+            yarn2: { type: "boolean", hasSensitiveValue: false },
+            pnpm: { type: "boolean", hasSensitiveValue: false },
+            androidTypings: { type: "boolean", hasSensitiveValue: false },
+            bundle: { type: "string", hasSensitiveValue: false },
+            all: { type: "boolean", hasSensitiveValue: false },
+            teamId: { type: "object", hasSensitiveValue: true },
+            chrome: { type: "boolean", hasSensitiveValue: false },
+            inspector: { type: "boolean", hasSensitiveValue: false },
+            clean: { type: "boolean", hasSensitiveValue: false },
+            watch: {
+                type: "boolean",
+                default: true,
+                hasSensitiveValue: false,
+            },
+            background: { type: "string", hasSensitiveValue: false },
+            username: { type: "string", hasSensitiveValue: true },
+            pluginName: { type: "string", hasSensitiveValue: false },
+            includeTypeScriptDemo: {
+                type: "string",
+                hasSensitiveValue: false,
+            },
+            includeAngularDemo: { type: "string", hasSensitiveValue: false },
+            hmr: {
+                type: "boolean",
+                hasSensitiveValue: false,
+                default: true,
+            },
+            collection: {
+                type: "string",
+                alias: "c",
+                hasSensitiveValue: false,
+            },
+            json: { type: "boolean", hasSensitiveValue: false },
+            avd: { type: "string", hasSensitiveValue: true },
+            config: { type: "array", hasSensitiveValue: false },
+            insecure: {
+                type: "boolean",
+                alias: "k",
+                hasSensitiveValue: false,
+            },
+            debug: { type: "boolean", alias: "d", hasSensitiveValue: false },
+            timeout: { type: "string", hasSensitiveValue: false },
+            device: { type: "string", hasSensitiveValue: true },
+            availableDevices: { type: "boolean", hasSensitiveValue: false },
+            appid: { type: "string", hasSensitiveValue: true },
+            geny: { type: "string", hasSensitiveValue: true },
+            debugBrk: { type: "boolean", hasSensitiveValue: false },
+            debugPort: { type: "number", hasSensitiveValue: false },
+            start: { type: "boolean", hasSensitiveValue: false },
+            stop: { type: "boolean", hasSensitiveValue: false },
+            ddi: { type: "string", hasSensitiveValue: true },
+            justlaunch: { type: "boolean", hasSensitiveValue: false },
+            file: { type: "string", hasSensitiveValue: true },
+            force: { type: "boolean", alias: "f", hasSensitiveValue: false },
+            emulator: { type: "boolean", hasSensitiveValue: false },
+            simulator: { type: "boolean", hasSensitiveValue: false },
+            sdk: { type: "string", hasSensitiveValue: false },
+            template: { type: "string", hasSensitiveValue: true },
+            certificate: { type: "string", hasSensitiveValue: true },
+            certificatePassword: { type: "string", hasSensitiveValue: true },
+            release: {
+                type: "boolean",
+                alias: "r",
+                hasSensitiveValue: false,
+            },
+            markingMode: { type: "boolean", hasSensitiveValue: false },
+            var: { type: "object", hasSensitiveValue: true },
+            default: { type: "boolean", hasSensitiveValue: false },
+            count: { type: "number", hasSensitiveValue: false },
+            analyticsLogFile: { type: "string", hasSensitiveValue: true },
+            disableAnalytics: { type: "boolean", hasSensitiveValue: false, default: true },
+            cleanupLogFile: { type: "string", hasSensitiveValue: true },
+            hooks: {
+                type: "boolean",
+                default: true,
+                hasSensitiveValue: false,
+            },
+            link: {
+                type: "boolean",
+                default: false,
+                hasSensitiveValue: false,
+            },
+            overrideRuntimeGradleFiles: { type: "boolean", hasSensitiveValue: false },
+            gradleArgs: {
+                type: "string",
+                hasSensitiveValue: false,
+                array: true,
+            },
+            gradleFlavor: { type: "string", hasSensitiveValue: false },
+            gradlePath: { type: "string", hasSensitiveValue: false },
+            aab: { type: "boolean", hasSensitiveValue: false },
+            filterDevicesArch: { type: "boolean", hasSensitiveValue: false },
+            performance: { type: "object", hasSensitiveValue: true },
+            appleApplicationSpecificPassword: {
+                type: "string",
+                hasSensitiveValue: true,
+            },
+            appleSessionBase64: { type: "string", hasSensitiveValue: true },
+            jar: { type: "string", hasSensitiveValue: true },
+            aar: { type: "string", hasSensitiveValue: true },
+            filter: { type: "string", hasSensitiveValue: true },
+            git: {
+                type: "boolean",
+                hasSensitiveValue: false,
+                default: true,
+            },
+            dryRun: { type: "boolean", hasSensitiveValue: false },
+        };
+    }
+    get optionNames() {
+        return _.keys(this.options);
+    }
+    getOptionValue(optionName) {
+        optionName = this.getCorrectOptionName(optionName);
+        return this.argv[optionName];
+    }
+    validateOptions(commandSpecificDashedOptions) {
+        this.setupOptions(commandSpecificDashedOptions);
+        const parsed = {};
+        for (const key of Object.keys(this.argv)) {
+            const optionName = `${this.argv[key]}`;
+            parsed[optionName] = this.getOptionValue(optionName);
+        }
+        _.each(parsed, (value, originalOptionName) => {
+            if (value === undefined) {
+                return;
+            }
+            const optionName = this.getCorrectOptionName(originalOptionName);
+            if (!_.includes(this.optionsWhiteList, optionName)) {
+                if (!this.isOptionSupported(optionName)) {
+                    this.$errors.failWithHelp(`The option '${originalOptionName}' is not supported.`);
+                }
+                const optionType = this.getOptionType(optionName), optionValue = parsed[optionName];
+                if (_.isArray(optionValue) && optionType !== "array") {
+                    this.$errors.failWithHelp("The '%s' option requires a single value.", originalOptionName);
+                }
+                else if (optionType === "string" &&
+                    helpers.isNullOrWhitespace(optionValue)) {
+                    this.$errors.failWithHelp("The option '%s' requires non-empty value.", originalOptionName);
+                }
+                else if (optionType === "array" &&
+                    optionValue.length === 0) {
+                    this.$errors.failWithHelp(`The option '${originalOptionName}' requires one or more values, separated by a space.`);
+                }
+            }
+        });
+    }
+    getCorrectOptionName(optionName) {
+        const secondaryOptionName = this.getNonDashedOptionName(optionName);
+        return _.includes(this.optionNames, secondaryOptionName)
+            ? secondaryOptionName
+            : optionName;
+    }
+    getOptionType(optionName) {
+        const option = this.options[optionName] || this.tryGetOptionByAliasName(optionName);
+        return option ? option.type : "";
+    }
+    tryGetOptionByAliasName(aliasName) {
+        const option = _.find(this.options, (opt) => opt.alias === aliasName);
+        return option;
+    }
+    isOptionSupported(option) {
+        if (!this.options[option]) {
+            const opt = this.tryGetOptionByAliasName(option);
+            return !!opt;
+        }
+        return true;
+    }
+    getNonDashedOptionName(optionName) {
+        const matchUpperCaseLetters = optionName.match(Options.NONDASHED_OPTION_REGEX);
+        if (matchUpperCaseLetters) {
+            const secondaryOptionName = matchUpperCaseLetters[1] +
+                matchUpperCaseLetters[2].toUpperCase() +
+                matchUpperCaseLetters[3] || "";
+            return this.getNonDashedOptionName(secondaryOptionName);
+        }
+        return optionName;
+    }
+    getDashedOptionName(optionName) {
+        const matchUpperCaseLetters = optionName.match(Options.DASHED_OPTION_REGEX);
+        if (matchUpperCaseLetters) {
+            const secondaryOptionName = `${matchUpperCaseLetters[1]}-${matchUpperCaseLetters[2].toLowerCase()}${matchUpperCaseLetters[3] || ""}`;
+            return this.getDashedOptionName(secondaryOptionName);
+        }
+        return optionName;
+    }
+    setArgv() {
+        const opts = {};
+        _.each(this.options, (value, key) => {
+            opts[this.getDashedOptionName(key)] = value;
+        });
+        const parsed = yargs((0, helpers_1.hideBin)(process.argv))
+            .version(false)
+            .help(false)
+            .completion("completion_generate_script", (current_, argv) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const args = argv._.slice(1);
+            const commands = yok_1.injector
+                .getRegisteredCommandsNames(false)
+                .filter((c) => c != "/?");
+            const currentDepth = args.length > 0 ? args.length - 1 : 0;
+            const current = (_a = current_ !== null && current_ !== void 0 ? current_ : args[currentDepth]) !== null && _a !== void 0 ? _a : "";
+            const matchGroups = commands.map((c) => c.split("|"));
+            const possibleMatches = matchGroups.filter((group) => {
+                return group.slice(0, currentDepth).every((g, i) => {
+                    return g === args[i] || args[i].at(0) === "-";
+                });
+            });
+            const completions = [
+                ...new Set(possibleMatches
+                    .map((match) => {
+                    return match[currentDepth];
+                })
+                    .filter(Boolean)),
+            ];
+            if (current.startsWith("--")) {
+                return this.optionNames.filter((o) => o !== "_").map((o) => `--${o}`);
+            }
+            if (current.startsWith("-")) {
+                return this.shorthands.map((o) => `-${o}`);
+            }
+            return completions;
+        }));
+        this.initialArgv = parsed.argv;
+        this.argv = parsed.options(opts).argv;
+        this.$settingsService.setSettings({
+            profileDir: this.argv.profileDir,
+        });
+        this.argv.profileDir = this.argv["profile-dir"] =
+            this.$settingsService.getProfileDir();
+        if (this.argv.justlaunch) {
+            this.argv.watch = false;
+        }
+        if (this.argv.ts || this.argv.typescript) {
+            this.argv.tsc = true;
+        }
+        if (this.argv.angular) {
+            this.argv.ng = true;
+        }
+        if (this.argv.vuejs) {
+            this.argv.vue = true;
+        }
+        if (this.argv.javascript) {
+            this.argv.js = true;
+        }
+        if (this.argv.simulator) {
+            this.argv.emulator = this.argv.simulator;
+        }
+        this.argv.bundle = "webpack";
+        this.adjustDashedOptions();
+    }
+    adjustDashedOptions() {
+        _.each(this.optionNames, (optionName) => {
+            Object.defineProperty(Options.prototype, optionName, {
+                configurable: true,
+                get: () => {
+                    return this.getOptionValue(optionName);
+                },
+                set: (value) => {
+                    this.argv[optionName] = value;
+                },
+            });
+        });
+    }
+}
+Options.DASHED_OPTION_REGEX = /(.+?)([A-Z])(.*)/;
+Options.NONDASHED_OPTION_REGEX = /(.+?)[-]([a-zA-Z])(.*)/;
+exports.Options = Options;
+yok_1.injector.register("options", Options);