nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/common/file-system.d.ts

@@ -0,0 +1,77 @@
+import * as fs from "fs";
+import { IFileSystem, IReadFileOptions, IFsStats } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare class FileSystem implements IFileSystem {
+    private $injector;
+    private static DEFAULT_INDENTATION_CHARACTER;
+    private static JSON_OBJECT_REGEXP;
+    constructor($injector: IInjector);
+    zipFiles(zipFile: string, files: string[], zipPathCallback: (path: string) => string): Promise<void>;
+    utimes(path: string, atime: Date, mtime: Date): void;
+    unzip(zipFile: string, destinationDir: string, options?: {
+        overwriteExisitingFiles?: boolean;
+        caseSensitive?: boolean;
+    }, fileFilters?: string[]): Promise<void>;
+    private findFileCaseInsensitive;
+    exists(path: string): boolean;
+    deleteFile(path: string): void;
+    deleteDirectory(directory: string): void;
+    deleteDirectorySafe(directory: string): void;
+    getFileSize(path: string): number;
+    getSize(path: string): number;
+    futureFromEvent(eventEmitter: any, event: string): Promise<any>;
+    createDirectory(path: string): void;
+    readDirectory(path: string): string[];
+    readFile(filename: string, options?: IReadFileOptions): string | Buffer;
+    readText(filename: string, options?: IReadFileOptions | string): string;
+    readJson(filename: string, encoding?: string): any;
+    writeFile(filename: string, data: string | Buffer, encoding?: string): void;
+    appendFile(filename: string, data: any, encoding?: string): void;
+    writeJson(filename: string, data: any, space?: string, encoding?: string): void;
+    copyFile(sourceFileName: string, destinationFileName: string): void;
+    createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: BufferEncoding;
+        fd?: number;
+        mode?: number;
+        autoClose?: boolean;
+        emitClose?: boolean;
+        start?: number;
+        end?: number;
+        highWaterMark?: number;
+    }): NodeJS.ReadableStream;
+    createWriteStream(path: string, options?: {
+        flags?: string;
+        encoding?: BufferEncoding;
+        fd?: number;
+        mode?: number;
+        autoClose?: boolean;
+        emitClose?: boolean;
+        start?: number;
+        highWaterMark?: number;
+    }): any;
+    chmod(path: string, mode: any): void;
+    getFsStats(path: string): fs.Stats;
+    getLsStats(path: string): fs.Stats;
+    getUniqueFileName(baseName: string): string;
+    isEmptyDir(directoryPath: string): boolean;
+    isRelativePath(p: string): boolean;
+    ensureDirectoryExists(directoryPath: string): void;
+    rename(oldPath: string, newPath: string): void;
+    renameIfExists(oldPath: string, newPath: string): boolean;
+    symlink(sourcePath: string, destinationPath: string, type?: fs.symlink.Type): void;
+    setCurrentUserAsOwner(path: string, owner: string): Promise<void>;
+    enumerateFilesInDirectorySync(directoryPath: string, filterCallback?: (_file: string, _stat: IFsStats) => boolean, opts?: {
+        enumerateDirectories?: boolean;
+        includeEmptyDirectories?: boolean;
+    }, foundFiles?: string[]): string[];
+    getFileShasum(fileName: string, options?: {
+        algorithm?: string;
+        encoding?: "hex" | "base64";
+    }): Promise<string>;
+    readStdin(): Promise<string>;
+    rm(options?: string, ...files: string[]): void;
+    deleteEmptyParents(directory: string): void;
+    realpath(filePath: string): string;
+    private getIndentationCharacter;
+}

package/lib/common/file-system.js

@@ -20,14 +20,12 @@ const constants_1 = require("../constants");
 const os_1 = require("os");
 const detectNewline = require("detect-newline");
 const yazl = require("yazl");
-// TODO: Add .d.ts for mkdirp module (or use it from @types repo).
 const mkdirp = require("mkdirp");
 let FileSystem = FileSystem_1 = class FileSystem {
     constructor($injector) {
         this.$injector = $injector;
     }
     async zipFiles(zipFile, files, zipPathCallback) {
-        //we are resolving it here instead of in the constructor, because config has dependency on file system and config shouldn't require logger
         const $logger = this.$injector.resolve("logger");
         const zip = new yazl.ZipFile();
         const outFile = fs.createWriteStream(zipFile);
@@ -60,10 +58,10 @@ let FileSystem = FileSystem_1 = class FileSystem {
             proc = (0, path_1.join)(__dirname, "resources/platform-tools/unzip/win32/unzip");
         }
         else if ($hostInfo.isDarwin) {
-            proc = "unzip"; // darwin unzip is info-zip
+            proc = "unzip";
         }
         else if ($hostInfo.isLinux) {
-            proc = "unzip"; // linux unzip is info-zip
+            proc = "unzip";
         }
         if (!isCaseSensitive) {
             zipFile = this.findFileCaseInsensitive(zipFile);
@@ -104,7 +102,6 @@ let FileSystem = FileSystem_1 = class FileSystem {
         }
         catch (err) {
             if (err && err.code !== "ENOENT") {
-                // ignore "file doesn't exist" error
                 throw err;
             }
         }
@@ -143,7 +140,6 @@ let FileSystem = FileSystem_1 = class FileSystem {
                 }
             });
             if (root) {
-                // console.log("root", paths);
                 return Array.from(paths.values()).reduce((sum, current) => sum + current, 0);
             }
         };
@@ -216,8 +212,6 @@ let FileSystem = FileSystem_1 = class FileSystem {
     writeFile(filename, data, encoding) {
         this.createDirectory((0, path_1.dirname)(filename));
         if (!data) {
-            // node 14 will no longer coerce unsupported input to strings anymore.
-            // clean any null or undefined data
             data = "";
         }
         fs.writeFileSync(filename, data, { encoding: encoding });
@@ -248,8 +242,6 @@ let FileSystem = FileSystem_1 = class FileSystem {
             return;
         }
         this.createDirectory((0, path_1.dirname)(destinationFileName));
-        // MobileApplication.app is resolved as a directory on Mac,
-        // therefore we need to copy it recursively as it's not a single file.
         shelljs.cp("-rf", sourceFileName, destinationFileName);
         const err = shelljs.error();
         if (err) {
@@ -325,9 +317,7 @@ let FileSystem = FileSystem_1 = class FileSystem {
             });
             await this.futureFromEvent(chown, "close");
         }
-        // nothing to do on Windows, as chown does not work on this platform
     }
-    // filterCallback: function(path: String, stat: fs.Stats): Boolean
     enumerateFilesInDirectorySync(directoryPath, filterCallback, opts, foundFiles) {
         foundFiles = foundFiles || [];
         if (!this.exists(directoryPath)) {
@@ -423,4 +413,3 @@ FileSystem.JSON_OBJECT_REGEXP = new RegExp(`{\\r*\\n*(\\W*)"`, "m");
 exports.FileSystem = FileSystem = FileSystem_1 = __decorate([
     injector.register("fs")
 ], FileSystem);
-//# sourceMappingURL=file-system.js.map

package/lib/common/header.d.ts

@@ -0,0 +1 @@
+export declare function printHeader(): void;

package/lib/common/header.js

@@ -13,13 +13,11 @@ function printHeader() {
         color_1.color.styleText(["cyanBright", "bold"], "{N} NativeScript "),
         color_1.color.styleText(["whiteBright", "bold"], "CLI"),
         color_1.color.dim(` [v${version}] `),
-        // color.dim("  │"),
     ].join("");
     const tagLine = [
         color_1.color.dim("│ "),
         color_1.color.dim(" → "),
         color_1.color.styleText(["whiteBright", "bold"], "Empower JavaScript with native APIs "),
-        // color.dim("  │"),
     ].join("");
     const headerLength = (0, color_1.stripColors)(header).length;
     const tagLineLength = (0, color_1.stripColors)(tagLine).length;
@@ -29,4 +27,3 @@ function printHeader() {
     console.info("  " + tagLine + " ".repeat(width - tagLineLength) + color_1.color.dim("│"));
     console.info("  " + color_1.color.dim("└" + "─".repeat(width - 1) + "┘"));
 }
-//# sourceMappingURL=header.js.map

package/lib/common/helpers.d.ts

@@ -0,0 +1,62 @@
+import * as net from "net";
+import { EventEmitter } from "events";
+import * as crypto from "crypto";
+import { IDictionary, IDeferPromise, Server, IProjectFilesConfig } from "./declarations";
+import { IAndroidSigningData } from "../definitions/build";
+export declare function stripComments(content: string): string;
+export declare function doesCurrentNpmCommandMatch(patterns?: RegExp[]): boolean;
+export declare function someWithRegExps(array: string[], patterns: RegExp[]): boolean;
+export declare function getCurrentNpmCommandArgv(): string[];
+export declare function isInstallingNativeScriptGlobally(): boolean;
+export declare function createRegExp(input: string, opts?: string): RegExp;
+export declare function regExpEscape(input: string): string;
+export declare function getShortPluginName(pluginName: string): string;
+export declare function executeActionByChunks<T>(initialData: T[] | IDictionary<T>, chunkSize: number, elementAction: (element: T, key?: string | number) => Promise<any>): Promise<void>;
+export declare function deferPromise<T>(): IDeferPromise<T>;
+export declare function settlePromises<T>(promises: Promise<T>[]): Promise<T[]>;
+export declare function getPropertyName(func: Function): string;
+export declare function quoteString(s: string): string;
+export declare function createGUID(useBraces?: boolean): string;
+export declare function stringReplaceAll(inputString: string, find: any, replace: string): string;
+export declare function isRequestSuccessful(request: Server.IRequestResponseData): boolean;
+export declare function isResponseRedirect(response: Server.IRequestResponseData): boolean;
+export declare function formatListOfNames(names: string[], conjunction?: string): string;
+export declare function getRelativeToRootPath(rootPath: string, filePath: string): string;
+export declare function setIsInteractive(override?: () => boolean): void;
+export declare function isInteractive(): boolean;
+export declare function toBoolean(str: any): boolean;
+export declare function block(operation: () => void): void;
+export declare function isNumberWithoutExponent(n: any): boolean;
+export declare function fromWindowsRelativePathToUnix(windowsRelativePath: string): string;
+export declare function isNullOrWhitespace(input: any): boolean;
+export declare function getCurrentEpochTime(): number;
+export declare function sleep(ms: number): Promise<void>;
+export declare function createTable(headers: string[], data: string[][]): any;
+export declare function getMessageWithBorders(message: string, spanLength?: number): string;
+export declare function remove<T>(array: T[], predicate: (element: T) => boolean, numberOfElements?: number): T[];
+export declare function trimSymbol(str: string, symbol: string): string;
+export declare function parseJson(data: string): any;
+export declare function getFuturesResults<T>(promises: Promise<T | T[] | T[][]>[], predicate: (element: any) => boolean): Promise<T[] | T[][]>;
+export declare function appendZeroesToVersion(version: string, requiredVersionLength: number): string;
+export declare function decorateMethod(before: (method1: any, self1: any, args1: any[]) => Promise<any>, after: (method2: any, self2: any, result2: any, args2: any[]) => Promise<any>): (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<Function>) => void;
+export declare function hook(commandName: string): (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<Function>) => void;
+export declare function isPromise(candidateFuture: any): boolean;
+export declare function attachAwaitDetach(eventName: string, eventEmitter: EventEmitter, eventHandler: (...args: any[]) => void, operation: Promise<any>): Promise<void>;
+export declare function connectEventually(factory: () => Promise<net.Socket>, handler: (_socket: net.Socket) => void): Promise<void>;
+export declare function getHash(str: string, options?: {
+    algorithm?: string;
+    encoding?: crypto.BinaryToTextEncoding;
+}): string;
+export declare function connectEventuallyUntilTimeout(factory: () => Promise<net.Socket>, timeout: number): Promise<net.Socket>;
+export declare function getProjectFilesConfig(opts: {
+    isReleaseBuild: boolean;
+}): IProjectFilesConfig;
+export declare function getPidFromiOSSimulatorLogs(applicationIdentifier: string, logLine: string): string;
+export declare function getValueFromNestedObject(obj: any, key: string): any;
+export declare function getWinRegPropertyValue(key: string, propertyName: string): Promise<string>;
+export declare function stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string;
+export declare function getFixedLengthDateString(): string;
+export declare function getFormattedDateComponent(component: number): string;
+export declare function getFormattedMilliseconds(date: Date): string;
+export declare function annotate(fn: any): any;
+export declare function hasValidAndroidSigning(signingData: Partial<IAndroidSigningData>): boolean;

package/lib/common/helpers.js

@@ -71,13 +71,6 @@ function doesCurrentNpmCommandMatch(patterns) {
     }
     return result;
 }
-/**
- * Equivalent of lodash's some, but instead of lambda, just pass array of Regular Expressions.
- * If any of them matches any of the given elements, true is returned.
- * @param {string[]} array Elements to be checked.
- * @param {RegExp[]} patterns Regular expressions to be tested
- * @returns {boolean} True in case any element of the array matches any of the patterns. False otherwise.
- */
 function someWithRegExps(array, patterns) {
     return _.some(array, (item) => _.some(patterns, (pattern) => !!item.match(pattern)));
 }
@@ -89,7 +82,6 @@ function getCurrentNpmCommandArgv() {
             result = npmConfigArgv.original || [];
         }
         catch (error) {
-            // ignore
         }
     }
     return result;
@@ -108,7 +100,6 @@ function isInstallingNativeScriptGloballyWithNpm() {
     return isInstallCommand && isGlobalCommand && hasNativeScriptPackage;
 }
 function isInstallingNativeScriptGloballyWithYarn() {
-    // yarn populates the same env used by npm - npm_config_argv, so check it for yarn specific command
     const isInstallCommand = doesCurrentNpmCommandMatch([/^add$/]);
     const isGlobalCommand = doesCurrentNpmCommandMatch([/^global$/]);
     const hasNativeScriptPackage = doesCurrentNpmCommandMatch([
@@ -117,13 +108,6 @@ function isInstallingNativeScriptGloballyWithYarn() {
     ]);
     return isInstallCommand && isGlobalCommand && hasNativeScriptPackage;
 }
-/**
- * Creates regular expression from input string.
- * The method replaces all occurences of RegExp special symbols in the input string with \<symbol>.
- * @param {string} input The string from which a regular expression should be created.
- * @param {string} opts RegExp options, for example "gm" - global and multiline.
- * @returns {RegExp} The regular expression created from the input string.
- */
 function createRegExp(input, opts) {
     if (!input || !_.isString(input)) {
         throw new Error("Input must be a string.");
@@ -131,20 +115,13 @@ function createRegExp(input, opts) {
     const escapedSource = regExpEscape(input);
     return new RegExp(escapedSource, opts);
 }
-/**
- * Escapes all special symbols used in regex.
- * @param {string} input The string in which to replace the special regexp symbols.
- * @returns {string} A string in which all regex symbols are escaped.
- */
 function regExpEscape(input) {
-    // https://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
     return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function getShortPluginName(pluginName) {
     return sanitizePluginName(pluginName).replace(/[\-]/g, "_");
 }
 function sanitizePluginName(pluginName) {
-    // avoid long plugin names, exclude the npm module scope (@scope/nativescript-plugin) from the android plugin name
     return pluginName.split("/").pop();
 }
 async function executeActionByChunks(initialData, chunkSize, elementAction) {
@@ -191,13 +168,6 @@ function deferPromise() {
         getResult: () => result,
     };
 }
-/**
- * Executes all promises and does not stop in case any of them throws.
- * Returns the results of all promises in array when all are successfully resolved.
- * In case any of the promises is rejected, rejects the resulted promise with all accumulated errors.
- * @param {Promise<T>[]} promises Promises to be resolved.
- * @returns {Promise<T[]>} New promise which will be resolved with the results of all promises.
- */
 function settlePromises(promises) {
     return new Promise((resolve, reject) => {
         let settledPromisesCount = 0;
@@ -213,7 +183,6 @@ function settlePromises(promises) {
                 results[index] = result;
             })
                 .catch((err) => {
-                // Accumulate all errors.
                 errors.push(err);
             })
                 .then(() => {
@@ -245,14 +214,12 @@ function bashQuote(s) {
     if (s[0] === "'" && s[s.length - 1] === "'") {
         return s;
     }
-    // replace ' with '"'"' and wrap in ''
     return "'" + s.replace(/'/g, "'\"'\"'") + "'";
 }
 function cmdQuote(s) {
     if (s[0] === '"' && s[s.length - 1] === '"') {
         return s;
     }
-    // replace " with \" and wrap in ""
     return '"' + s.replace(/"/g, '\\"') + '"';
 }
 function quoteString(s) {
@@ -309,9 +276,6 @@ function isInteractive() {
     const result = isRunningInTTY() && !isCIEnvironment();
     return result;
 }
-/**
- * Checks if current process is running in Text Terminal (TTY)
- */
 function isRunningInTTY() {
     return (process.stdout &&
         process.stdout.isTTY &&
@@ -319,10 +283,6 @@ function isRunningInTTY() {
         process.stdin.isTTY);
 }
 function isCIEnvironment() {
-    // The following CI environments set their own environment variables that we respect:
-    //  travis: "CI",
-    //  circleCI: "CI",
-    //  jenkins: "JENKINS_HOME"
     return !!(process.env && (process.env.CI || process.env.JENKINS_HOME));
 }
 function toBoolean(str) {
@@ -377,11 +337,11 @@ function getMessageWithBorders(message, spanLength = 3) {
     const longestRowLength = message.split("\n").sort((a, b) => {
         return b.length - a.length;
     })[0].length;
-    let border = "*".repeat(longestRowLength + 2 * spanLength); // * 2 for both sides
+    let border = "*".repeat(longestRowLength + 2 * spanLength);
     if (border.length % 2 === 0) {
-        border += "*"; // the * should always be an odd number in order to get * in each edge (we will remove the even *s below)
+        border += "*";
     }
-    border = border.replace(/\*\*/g, "* "); // ***** => * * * in order to have similar padding to the side borders
+    border = border.replace(/\*\*/g, "* ");
     const formatRow = function (row) {
         return (_.padEnd("*", spanLength) +
             _.padEnd(row, border.length - 2 * spanLength) +
@@ -411,20 +371,12 @@ function trimSymbol(str, symbol) {
     return str;
 }
 function parseJson(data) {
-    // Replace BOM from the header of the file if it exists
     return JSON.parse(data.replace(/^\uFEFF/, ""));
 }
-// TODO: Use generic for predicatе predicate: (element: T|T[]) when TypeScript support this.
 async function getFuturesResults(promises, predicate) {
     const results = await Promise.all(promises);
     return _(results).filter(predicate).flatten().value();
 }
-/**
- * Appends zeroes to a version string until it reaches a specified length.
- * @param {string} version The version on which to append zeroes.
- * @param requiredVersionLength The required length of the version string.
- * @returns {string} Appended version string. In case input is null, undefined or empty string, it is returned immediately without appending anything.
- */
 function appendZeroesToVersion(version, requiredVersionLength) {
     if (version) {
         const zeroesToAppend = requiredVersionLength - version.split(".").length;
@@ -448,7 +400,7 @@ function decorateMethod(before, after) {
                 const replacementMethods = _.filter(newMethods, (f) => _.isFunction(f));
                 if (replacementMethods.length > 0) {
                     hasBeenReplaced = true;
-                    const chainedReplacementMethod = _.reduce(replacementMethods, (prev, next) => next.bind(next, args, prev), sink.bind(this));
+                    const chainedReplacementMethod = _.reduce(replacementMethods, (prev, next) => (...forwardedArgs) => next.call(next, forwardedArgs.length ? forwardedArgs : args, prev), sink.bind(this));
                     result = chainedReplacementMethod();
                 }
             }
@@ -466,7 +418,7 @@ function hook(commandName) {
     function getHooksService(self) {
         let hooksService = self.$hooksService;
         if (!hooksService) {
-            const injector = self.$injector;
+            const injector = self.$injector || require("./yok").getInjector();
             if (!injector) {
                 throw Error("Type with hooks needs to have either $hooksService or $injector injected.");
             }
@@ -487,7 +439,7 @@ function hook(commandName) {
     }
     return decorateMethod(async (method, self, args) => {
         const hooksService = getHooksService(self);
-        return hooksService.executeBeforeHooks(commandName, prepareArguments(method, args, hooksService));
+        return hooksService.executeBeforeHooks(commandName, prepareArguments(method, args, hooksService), { consumesMiddlewares: true });
     }, async (method, self, resultPromise, args) => {
         const result = await resultPromise;
         const hooksService = getHooksService(self);
@@ -569,14 +521,6 @@ function getProjectFilesConfig(opts) {
     };
     return projectFilesConfig;
 }
-/**
- * Tries to find the process id (PID) of the specified application identifier.
- * This is specific implementation for iOS Simulator, where the running applications are real processes.
- * Their PIDs are printed in a specific format in the the logs, once the application is started.
- * @param {string} applicationIdentifier Application Identifier of the app for which we try to get the PID.
- * @param {string} logLine Line that may contain the PID of the process.
- * @returns {string} The PID of the searched application identifier in case it's found in the current line, null otherwise.
- */
 function getPidFromiOSSimulatorLogs(applicationIdentifier, logLine) {
     if (logLine) {
         const pidRegExp = new RegExp(`${applicationIdentifier}:\\s?(\\d+)`);
@@ -624,7 +568,6 @@ function getWinRegPropertyValue(key, propertyName) {
 function stringify(value, replacer, space) {
     return JSON.stringify(value, replacer, space || 2);
 }
-//2019-01-07 18:29:50.745
 function getFixedLengthDateString() {
     const currentDate = new Date();
     const year = currentDate.getFullYear();
@@ -647,28 +590,6 @@ function getFormattedMilliseconds(date) {
     }
     return milliseconds;
 }
-//--- begin part copied from AngularJS
-//The MIT License
-//
-//Copyright (c) 2010-2012 Google, Inc. http://angularjs.org
-//
-//Permission is hereby granted, free of charge, to any person obtaining a copy
-//of this software and associated documentation files (the "Software"), to deal
-//in the Software without restriction, including without limitation the rights
-//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//copies of the Software, and to permit persons to whom the Software is
-//furnished to do so, subject to the following conditions:
-//
-//	The above copyright notice and this permission notice shall be included in
-//all copies or substantial portions of the Software.
-//
-//	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-//THE SOFTWARE.
 const CLASS_NAME = /class\s+([A-Z].+?)(?:\s+.*?)?\{/;
 const CONSTRUCTOR_ARGS = /constructor\s*([^\(]*)\(\s*([^\)]*)\)/m;
 const FN_NAME_AND_ARGS = /^(?:function)?\s*([^\(]*)\(\s*([^\)]*)\)\s*(=>)?\s*[{_]/m;
@@ -698,11 +619,6 @@ function annotate(fn) {
     }
     return $inject;
 }
-/**
- * Returns true if all Android signing options are provided, false otherwise.
- * @param {IAndroidSigningData} signingData The signing data to be validated.
- * @return {void}
- */
 function hasValidAndroidSigning(signingData) {
     const isValid = signingData &&
         signingData.keyStorePath &&
@@ -711,5 +627,3 @@ function hasValidAndroidSigning(signingData) {
         signingData.keyStoreAliasPassword;
     return !!isValid;
 }
-//--- end part copied from AngularJS
-//# sourceMappingURL=helpers.js.map

package/lib/common/host-info.d.ts

@@ -0,0 +1,24 @@
+import { IHostInfo, IErrors } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare class HostInfo implements IHostInfo {
+    private $errors;
+    private $injector;
+    private static WIN32_NAME;
+    private static PROCESSOR_ARCHITEW6432;
+    private static DARWIN_OS_NAME;
+    private static LINUX_OS_NAME;
+    private static DOT_NET_REGISTRY_PATH;
+    private get $childProcess();
+    private get $osInfo();
+    private get $logger();
+    constructor($errors: IErrors, $injector: IInjector);
+    get isWindows(): boolean;
+    get isWindows64(): boolean;
+    get isWindows32(): boolean;
+    get isDarwin(): boolean;
+    get isLinux(): boolean;
+    get isLinux64(): boolean;
+    getMacOSVersion(): Promise<string>;
+    dotNetVersion(): Promise<string>;
+    isDotNet40Installed(message?: string): Promise<boolean>;
+}

package/lib/common/host-info.js

@@ -65,9 +65,6 @@ class HostInfo {
         catch (err) {
             this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand}. Error is: ${err}`);
         }
-        // https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
-        // Each macOS version is labeled 10.<version>, where it looks like <versions> is taken from the major version returned by os.release() (16.x.x for example) and subtracting 4 from it.
-        // So the version becomes "10.12" in this case.
         const osRelease = this.$osInfo.release();
         const majorVersion = osRelease && _.first(osRelease.split("."));
         macOSVersion = majorVersion && `10.${+majorVersion - 4}`;
@@ -121,4 +118,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], HostInfo.prototype, "getMacOSVersion", null);
 yok_1.injector.register("hostInfo", HostInfo);
-//# sourceMappingURL=host-info.js.map

package/lib/common/http-client.d.ts

@@ -0,0 +1,14 @@
+import { Server, IProxySettings, IProxyService } from "./declarations";
+export declare class HttpClient implements Server.IHttpClient {
+    private $logger;
+    private $proxyService;
+    private $staticConfig;
+    private static STUCK_REQUEST_ERROR_MESSAGE;
+    private static STUCK_RESPONSE_ERROR_MESSAGE;
+    private defaultUserAgent;
+    constructor($logger: ILogger, $proxyService: IProxyService, $staticConfig: Config.IStaticConfig);
+    httpRequest(options: any, proxySettings?: IProxySettings): Promise<Server.IResponse>;
+    private httpRequestCore;
+    private getErrorMessage;
+    private useProxySettings;
+}

package/lib/common/http-client.js

@@ -4,6 +4,7 @@ exports.HttpClient = void 0;
 const _ = require("lodash");
 const os_1 = require("os");
 const util = require("util");
+const promises_1 = require("stream/promises");
 const yok_1 = require("./yok");
 const axios_1 = require("axios");
 const constants_1 = require("./constants");
@@ -26,9 +27,6 @@ class HttpClient {
         catch (err) {
             if (err.message === HttpClient.STUCK_REQUEST_ERROR_MESSAGE ||
                 err.message === HttpClient.STUCK_RESPONSE_ERROR_MESSAGE) {
-                // Retry the request immediately because there are at least 10 seconds between the two requests.
-                // We have to retry only once the sporadically stuck requests/responses.
-                // We can add exponential backoff retry here if we decide that we need to workaround bigger network issues on the client side.
                 this.$logger.warn("%s Retrying request to %s...", err.message, options.url || options);
                 const retryResult = await this.httpRequestCore(options, proxySettings);
                 return {
@@ -54,7 +52,6 @@ class HttpClient {
         await this.useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto);
         if (!headers["User-Agent"]) {
             if (!this.defaultUserAgent) {
-                //TODO: the user agent client name is also passed explicitly during login and should be kept in sync
                 this.defaultUserAgent = `${this.$staticConfig.USER_AGENT_NAME}/${this.$staticConfig.version} (Node.js ${process.versions.node}; ${process.platform}; ${process.arch})`;
                 this.$logger.trace("User-Agent: %s", this.defaultUserAgent);
             }
@@ -79,28 +76,33 @@ class HttpClient {
             method: options.method,
             proxy: false,
             httpAgent: agent,
+            httpsAgent: agent,
             data: options.body,
+            responseType: options.pipeTo ? "stream" : undefined,
+            onDownloadProgress: options.onDownloadProgress,
         }).catch((err) => {
             this.$logger.trace("An error occurred while sending the request:", err);
             if (err.response) {
-                // The request was made and the server responded with a status code
-                // that falls out of the range of 2xx
                 const errorMessage = this.getErrorMessage(err.response.status, null);
                 err.proxyAuthenticationRequired =
                     err.response.status === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED;
                 err.message = errorMessage || err.message;
             }
             else if (err.request) {
-                // The request was made but no response was received
-                // `err.request` is an instance of XMLHttpRequest in the browser and an instance of
             }
             else {
-                // Something happened in setting up the request that triggered an Error
             }
             throw err;
         });
         if (result) {
             this.$logger.trace("httpRequest: Done. code = %d", result.status.toString());
+            if (options.pipeTo) {
+                await (0, promises_1.pipeline)(result.data, options.pipeTo);
+                return {
+                    response: result,
+                    headers: result.headers,
+                };
+            }
             return {
                 response: result,
                 body: JSON.stringify(result.data),
@@ -141,17 +143,8 @@ class HttpClient {
             return body;
         }
     }
-    /**
-     * This method respects the proxySettings (or proxyCache) by modifying headers and options passed to http(s) module.
-     * @param {IProxySettings} proxySettings The settings passed for this specific call.
-     * @param {IProxySettings} cliProxySettings The globally set proxy for this CLI.
-     * @param {any}options The object that will be passed to http(s) module.
-     * @param {any} headers Headers of the current request.
-     * @param {string} requestProto The protocol used for the current request - http or https.
-     */
     async useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto) {
         const isLocalRequest = options.host === "localhost" || options.host === "127.0.0.1";
-        // don't use the proxy for requests to localhost
         if (!isLocalRequest && (proxySettings || cliProxySettings)) {
             const proto = (proxySettings && proxySettings.protocol) ||
                 cliProxySettings.protocol ||
@@ -162,7 +155,6 @@ class HttpClient {
             if (cliProxySettings.username && cliProxySettings.password) {
                 credentialsPart = `${cliProxySettings.username}:${cliProxySettings.password}@`;
             }
-            // Note that proto ends with :
             options.proxy = `${proto}//${credentialsPart}${host}:${port}`;
             options.rejectUnauthorized = proxySettings
                 ? proxySettings.rejectUnauthorized
@@ -175,4 +167,3 @@ exports.HttpClient = HttpClient;
 HttpClient.STUCK_REQUEST_ERROR_MESSAGE = "The request can't receive any response.";
 HttpClient.STUCK_RESPONSE_ERROR_MESSAGE = "Can't receive all parts of the response.";
 yok_1.injector.register("httpClient", HttpClient);
-//# sourceMappingURL=http-client.js.map

package/lib/common/logger/appenders/cli-appender.d.ts

@@ -0,0 +1,2 @@
+import { LoggingEvent } from "log4js";
+export declare function configure(config: Log4JSAppenderConfiguration, layouts: any): (loggingEvent: LoggingEvent) => void;

package/lib/common/logger/appenders/cli-appender.js

@@ -15,13 +15,9 @@ function cliAppender(layout) {
     return appender;
 }
 function configure(config, layouts) {
-    // the default layout for the appender
     let layout = layouts.messagePassThroughLayout;
-    // check if there is another layout specified
     if (config.layout) {
         layout = layouts.layout(config.layout.type, config.layout);
     }
-    // create a new appender instance
     return cliAppender(layout);
 }
-//# sourceMappingURL=cli-appender.js.map

package/lib/common/logger/appenders/emit-appender.d.ts

@@ -0,0 +1,5 @@
+import { LoggingEvent } from "log4js";
+export declare function configure(config: Log4JSEmitAppenderConfiguration, layouts: any): {
+    (loggingEvent: LoggingEvent): void;
+    shutdown(): void;
+};