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

package/lib/common/di/inject.d.ts

@@ -0,0 +1,8 @@
+import type { Injector, InjectOptions } from "./injector";
+import type { ProviderToken } from "./providers";
+export declare function inject<T = any>(token: ProviderToken<T>): T;
+export declare function inject<T = any>(token: ProviderToken<T>, options: InjectOptions & {
+    optional: true;
+}): T | null;
+export declare function inject<T = any>(token: ProviderToken<T>, options: InjectOptions): T;
+export declare function runInInjectionContext<T>(injector: Injector, fn: () => T): T;

package/lib/common/di/inject.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = inject;
+exports.runInInjectionContext = runInInjectionContext;
+const CONTEXT_SLOT = Symbol.for("nativescript:di:injectionContext");
+const COPY_ID = {};
+let reportedCrossCopyUse = false;
+function currentFrame() {
+    return globalThis[CONTEXT_SLOT] || null;
+}
+function inject(token, options) {
+    const frame = currentFrame();
+    if (!frame) {
+        throw new Error("inject() can only be called from an injection context — a field " +
+            "initializer, a constructor, or a provider factory running under " +
+            "runInInjectionContext(). It is not valid after an await; inject " +
+            "the Injector itself and use injector.get() for late lookups.");
+    }
+    if (frame.owner !== COPY_ID && !reportedCrossCopyUse) {
+        reportedCrossCopyUse = true;
+        const logger = frame.injector.get("logger", { optional: true });
+        if (logger) {
+            logger.warn(`A second copy of the NativeScript CLI (${__dirname}) is serving ` +
+                `inject() in this process. This works, but loads the CLI twice; ` +
+                `extensions and projects should declare nativescript as a ` +
+                `peerDependency so the running copy is shared.`);
+        }
+    }
+    return frame.injector.get(token, options);
+}
+function runInInjectionContext(injector, fn) {
+    const g = globalThis;
+    const previous = g[CONTEXT_SLOT];
+    g[CONTEXT_SLOT] = { injector, owner: COPY_ID };
+    try {
+        return fn();
+    }
+    finally {
+        g[CONTEXT_SLOT] = previous;
+    }
+}

package/lib/common/di/injector.d.ts

@@ -0,0 +1,38 @@
+import type { InternalProvider, Provider, ProviderToken, Type } from "./providers";
+export interface InjectOptions {
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+}
+export declare class Injector {
+    private parent?;
+    private providers;
+    private instantiationOrder;
+    constructor(providers?: Provider[], parent?: Injector);
+    get<T = any>(token: ProviderToken<T>): T;
+    get<T = any>(token: ProviderToken<T>, options: InjectOptions & {
+        optional: true;
+    }): T | null;
+    get<T = any>(token: ProviderToken<T>, options: InjectOptions): T;
+    protected getWithLegacyArguments(token: ProviderToken, ctorArguments?: {
+        [key: string]: any;
+    }): any;
+    createChild(providers?: Provider[]): Injector;
+    createInstance<T = any>(cls: Type<T> | Function, providers?: Provider[], ctorArguments?: {
+        [key: string]: any;
+    }): T;
+    register(providers: InternalProvider | InternalProvider[]): void;
+    getRegisteredNames(prefix?: string): string[];
+    has(token: ProviderToken): boolean;
+    protected hasResolver(token: ProviderToken): boolean;
+    peek(token: ProviderToken): any;
+    remove(token: ProviderToken): void;
+    dispose(exclude?: any[]): void;
+    private keysFor;
+    private applyProvider;
+    private findRecordLocal;
+    private findRecord;
+    private instantiate;
+    private construct;
+    private constructLegacy;
+}

package/lib/common/di/injector.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
+const helpers_1 = require("../helpers");
+const contract_1 = require("./contract");
+const forward_ref_1 = require("./forward-ref");
+const inject_1 = require("./inject");
+const resolutionStack = [];
+class Injector {
+    constructor(providers = [], parent) {
+        this.parent = parent;
+        this.providers = new Map();
+        this.instantiationOrder = [];
+        this.register({ provide: Injector, useValue: this });
+        this.register(providers);
+    }
+    get(token, options) {
+        if (options && options.self && options.skipSelf) {
+            throw new Error("inject options cannot combine self and skipSelf");
+        }
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        const found = this.findRecord(token, options);
+        if (!found) {
+            if (options && options.optional) {
+                return null;
+            }
+            throw new Error("unable to resolve " + displayNameOf(token));
+        }
+        return found.owner.instantiate(found.record);
+    }
+    getWithLegacyArguments(token, ctorArguments) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        const found = this.findRecord(token);
+        if (!found) {
+            throw new Error("unable to resolve " + displayNameOf(token));
+        }
+        return found.owner.instantiate(found.record, ctorArguments);
+    }
+    createChild(providers = []) {
+        return new Injector(providers, this);
+    }
+    createInstance(cls, providers = [], ctorArguments) {
+        const scope = providers.length ? this.createChild(providers) : this;
+        return scope.constructLegacy(cls, ctorArguments);
+    }
+    register(providers) {
+        const list = Array.isArray(providers) ? providers : [providers];
+        for (const provider of list) {
+            const keys = this.keysFor(provider.provide);
+            let record;
+            for (const key of keys) {
+                record = this.providers.get(key);
+                if (record) {
+                    break;
+                }
+            }
+            if (!record) {
+                record = {
+                    displayName: displayNameOf(provider.provide),
+                    shared: true,
+                    instances: [],
+                    constructing: false,
+                };
+            }
+            this.applyProvider(record, provider);
+            for (const key of keys) {
+                this.providers.set(key, record);
+            }
+        }
+    }
+    getRegisteredNames(prefix = "") {
+        const names = [];
+        for (const key of this.providers.keys()) {
+            if (typeof key === "string" && key.startsWith(prefix)) {
+                names.push(key);
+            }
+        }
+        return names;
+    }
+    has(token) {
+        return !!this.findRecord(token);
+    }
+    hasResolver(token) {
+        const found = this.findRecord(token);
+        return !!found && found.record.kind !== undefined;
+    }
+    peek(token) {
+        const found = this.findRecord(token);
+        return found ? found.record.instances[0] : undefined;
+    }
+    remove(token) {
+        const record = this.findRecordLocal(token);
+        if (!record) {
+            return;
+        }
+        const keys = [];
+        for (const [key, value] of this.providers) {
+            if (value === record) {
+                keys.push(key);
+            }
+        }
+        for (const key of keys) {
+            this.providers.delete(key);
+        }
+    }
+    dispose(exclude = []) {
+        const seen = new Set(exclude);
+        const disposeOne = (instance) => {
+            if (!instance || seen.has(instance) || instance === this) {
+                return;
+            }
+            seen.add(instance);
+            if (typeof instance.dispose === "function") {
+                instance.dispose();
+            }
+        };
+        for (let i = this.instantiationOrder.length - 1; i >= 0; i--) {
+            disposeOne(this.instantiationOrder[i]);
+        }
+        for (const record of new Set(this.providers.values())) {
+            for (const instance of record.instances) {
+                disposeOne(instance);
+            }
+        }
+    }
+    keysFor(token) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        if (typeof token === "string") {
+            return [normalizeName(token)];
+        }
+        const name = (0, contract_1.getContractName)(token);
+        return name !== undefined ? [token, name] : [token];
+    }
+    applyProvider(record, provider) {
+        record.shared = provider.shared === undefined ? true : provider.shared;
+        if ("useLazyRequire" in provider) {
+            record.pendingLoader = provider.useLazyRequire;
+            return;
+        }
+        record.useValue = undefined;
+        record.useClass = undefined;
+        record.useFactory = undefined;
+        record.useLazyClass = undefined;
+        record.useLegacyClass = undefined;
+        if ("useValue" in provider) {
+            record.kind = "value";
+            record.useValue = provider.useValue;
+            if (record.shared) {
+                record.instances[0] = provider.useValue;
+            }
+            else {
+                record.instances.push(provider.useValue);
+            }
+        }
+        else if ("useClass" in provider) {
+            record.kind = "class";
+            record.useClass = provider.useClass;
+        }
+        else if ("useFactory" in provider) {
+            record.kind = "factory";
+            record.useFactory = provider.useFactory;
+        }
+        else if ("useLazyClass" in provider) {
+            record.kind = "lazyClass";
+            record.useLazyClass = provider.useLazyClass;
+        }
+        else if ("useLegacyClass" in provider) {
+            record.kind = "legacyClass";
+            record.useLegacyClass = provider.useLegacyClass;
+        }
+    }
+    findRecordLocal(token) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        if (typeof token === "string") {
+            return this.providers.get(normalizeName(token));
+        }
+        const direct = this.providers.get(token);
+        if (direct) {
+            return direct;
+        }
+        const name = (0, contract_1.getContractName)(token);
+        return name !== undefined ? this.providers.get(name) : undefined;
+    }
+    findRecord(token, options) {
+        if (!options || !options.skipSelf) {
+            const local = this.findRecordLocal(token);
+            if (local) {
+                return { record: local, owner: this };
+            }
+            if (options && options.self) {
+                return undefined;
+            }
+        }
+        return this.parent ? this.parent.findRecord(token) : undefined;
+    }
+    instantiate(record, ctorArguments) {
+        if (record.pendingLoader) {
+            const loader = record.pendingLoader;
+            loader();
+            record.pendingLoader = undefined;
+        }
+        if (record.shared && record.instances.length) {
+            return record.instances[0];
+        }
+        if (record.kind === undefined ||
+            (record.kind === "value" && !record.shared)) {
+            throw new Error("no resolver registered for " + record.displayName);
+        }
+        if (record.kind === "value") {
+            return record.instances[0];
+        }
+        if (record.constructing) {
+            const cyclePath = resolutionStack.concat(record.displayName).join(" -> ");
+            throw new Error(`Cyclic dependency detected on dependency '${record.displayName}'. Resolution path: ${cyclePath}`);
+        }
+        record.constructing = true;
+        resolutionStack.push(record.displayName);
+        let instance;
+        try {
+            instance = this.construct(record, ctorArguments);
+        }
+        finally {
+            resolutionStack.pop();
+            record.constructing = false;
+        }
+        record.instances.push(instance);
+        this.instantiationOrder.push(instance);
+        return instance;
+    }
+    construct(record, ctorArguments) {
+        switch (record.kind) {
+            case "class":
+                return (0, inject_1.runInInjectionContext)(this, () => new record.useClass());
+            case "factory":
+                return (0, inject_1.runInInjectionContext)(this, () => record.useFactory());
+            case "lazyClass": {
+                if (!record.useClass) {
+                    record.useClass = record.useLazyClass();
+                }
+                const cls = record.useClass;
+                return (0, inject_1.runInInjectionContext)(this, () => new cls());
+            }
+            case "legacyClass":
+                return this.constructLegacy(record.useLegacyClass, ctorArguments);
+        }
+    }
+    constructLegacy(ctor, ctorArguments) {
+        (0, helpers_1.annotate)(ctor);
+        const resolvedArgs = ctor.$inject.args.map((paramName) => ctorArguments &&
+            Object.prototype.hasOwnProperty.call(ctorArguments, paramName)
+            ? ctorArguments[paramName]
+            : this.get(paramName));
+        const name = ctor.$inject.name;
+        return (0, inject_1.runInInjectionContext)(this, () => name && name[0] === name[0].toUpperCase()
+            ? new ctor(...resolvedArgs)
+            : ctor.apply(null, resolvedArgs));
+    }
+}
+exports.Injector = Injector;
+function normalizeName(name) {
+    return name[0] === "$" ? name.slice(1) : name;
+}
+function displayNameOf(token) {
+    if (typeof token === "string") {
+        return normalizeName(token);
+    }
+    return (0, contract_1.getContractName)(token) || token.name || "<anonymous class>";
+}

package/lib/common/di/providers.d.ts

@@ -0,0 +1,30 @@
+export type Type<T> = new (...args: any[]) => T;
+export type AbstractType<T> = abstract new (...args: any[]) => T;
+export type ProviderToken<T = any> = string | Type<T> | AbstractType<T>;
+interface IBaseProvider<T> {
+    provide: ProviderToken<T>;
+    shared?: boolean;
+}
+export interface IClassProvider<T> extends IBaseProvider<T> {
+    useClass: Type<T>;
+}
+export interface IValueProvider<T> extends IBaseProvider<T> {
+    useValue: T;
+}
+export interface IFactoryProvider<T> extends IBaseProvider<T> {
+    useFactory: () => T;
+}
+export interface ILazyClassProvider<T> extends IBaseProvider<T> {
+    useLazyClass: () => Type<T>;
+}
+export interface ILegacyClassProvider extends IBaseProvider<any> {
+    useLegacyClass: Function;
+}
+export interface ILazyRequireProvider extends IBaseProvider<any> {
+    useLazyRequire: () => void;
+}
+export type Provider<T = any> = IClassProvider<T> | IValueProvider<T> | IFactoryProvider<T> | ILazyClassProvider<T> | ILegacyClassProvider;
+export type InternalProvider<T = any> = Provider<T> | ILazyRequireProvider;
+export declare const provide: <T>(token: AbstractType<T> | string, impl: Type<T>) => Provider<T>;
+export declare const provideLazy: <T>(token: AbstractType<T> | string, load: () => Type<T>) => Provider<T>;
+export {};

package/lib/common/di/providers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideLazy = exports.provide = void 0;
+const provide = (token, impl) => ({ provide: token, useClass: impl });
+exports.provide = provide;
+const provideLazy = (token, load) => ({ provide: token, useLazyClass: load });
+exports.provideLazy = provideLazy;

package/lib/common/dispatchers.d.ts

@@ -0,0 +1,21 @@
+import { ICommandDispatcher, ICancellationService, ISysInfo } from "./declarations";
+import { IOptions, IPackageManager, IVersionsService } from "../declarations";
+import { IInjector } from "./definitions/yok";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class CommandDispatcher implements ICommandDispatcher {
+    private $logger;
+    protected $injector: IInjector;
+    private $cancellation;
+    private $commandsService;
+    private $staticConfig;
+    private $sysInfo;
+    private $options;
+    private $versionsService;
+    private $packageManager;
+    private $terminalSpinnerService;
+    constructor($logger: ILogger, $injector: IInjector, $cancellation: ICancellationService, $commandsService: ICommandsService, $staticConfig: Config.IStaticConfig, $sysInfo: ISysInfo, $options: IOptions, $versionsService: IVersionsService, $packageManager: IPackageManager, $terminalSpinnerService: ITerminalSpinnerService);
+    dispatchCommand(): Promise<void>;
+    private resolveCommand;
+    private getCommandName;
+    private printVersion;
+}

package/lib/common/dispatchers.js

@@ -15,9 +15,7 @@ const yok_1 = require("./yok");
 const constants_1 = require("../constants");
 const semver = require("semver");
 class CommandDispatcher {
-    constructor($logger, 
-    // required by the hooksService
-    $injector, $cancellation, $commandsService, $staticConfig, $sysInfo, $options, $versionsService, $packageManager, $terminalSpinnerService) {
+    constructor($logger, $injector, $cancellation, $commandsService, $staticConfig, $sysInfo, $options, $versionsService, $packageManager, $terminalSpinnerService) {
         this.$logger = $logger;
         this.$injector = $injector;
         this.$cancellation = $cancellation;
@@ -34,7 +32,6 @@ class CommandDispatcher {
             return this.printVersion();
         }
         if (this.$logger.getLevel() === "TRACE" && !this.$options.json) {
-            // CommandDispatcher is called from external CLI's only, so pass the path to their package.json
             this.$logger.trace("Collecting system information...");
             const sysInfo = await this.$sysInfo.getSysInfo({
                 pathToNativeScriptCliPackageJson: path.join(__dirname, "..", "..", "package.json"),
@@ -64,7 +61,6 @@ class CommandDispatcher {
         await this.$commandsService.tryExecuteCommand(commandName, commandArguments);
     }
     async resolveCommand(commandName, commandArguments, argv) {
-        // just a hook point
         return { commandName, commandArguments, argv };
     }
     getCommandName() {
@@ -72,15 +68,12 @@ class CommandDispatcher {
         if (remaining.length > 0) {
             return remaining[0].toString().toLowerCase();
         }
-        // if only <CLI_NAME> is specified on console, show console help
         this.$options.help = true;
         return "";
     }
     async printVersion() {
         this.$logger.info(this.$staticConfig.version);
         if (this.$options.json) {
-            // we don't check for updates when --json is passed
-            // useful for tools that rely on the output of the command
             return;
         }
         const spinner = this.$terminalSpinnerService.createSpinner();
@@ -108,7 +101,6 @@ class CommandDispatcher {
         if (semver.gte(nativescriptCliVersion.currentVersion, nativescriptCliVersion.latestVersion, {
             loose: true,
         })) {
-            // up-to-date
             spinner.succeed("Up to date.");
         }
         else {
@@ -140,4 +132,3 @@ class FutureDispatcher {
     }
 }
 yok_1.injector.register("dispatcher", FutureDispatcher, false);
-//# sourceMappingURL=dispatchers.js.map

package/lib/common/enums.d.ts

@@ -0,0 +1,34 @@
+export declare enum GoogleAnalyticsDataType {
+    Page = "pageview",
+    Event = "event"
+}
+export declare enum TrackingTypes {
+    Initialization = "initialization",
+    Exception = "exception",
+    AcceptTrackFeatureUsage = "acceptTrackFeatureUsage",
+    GoogleAnalyticsData = "googleAnalyticsData",
+    FinishTracking = "FinishTracking"
+}
+export declare enum AnalyticsStatus {
+    enabled = "enabled",
+    disabled = "disabled",
+    notConfirmed = "not confirmed"
+}
+export declare enum OptionType {
+    String = "string",
+    Boolean = "boolean",
+    Number = "number",
+    Array = "array",
+    Object = "object"
+}
+export declare enum ErrorCodes {
+    UNCAUGHT = 120,
+    UNKNOWN = 127,
+    INVALID_ARGUMENT = 128,
+    RESOURCE_PROBLEM = 129,
+    KARMA_FAIL = 130,
+    UNHANDLED_REJECTION_FAILURE = 131,
+    DELETED_KILL_FILE = 132,
+    TESTS_INIT_REQUIRED = 133,
+    ALL_DEVICES_DISCONNECTED = 134
+}

package/lib/common/enums.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodes = exports.OptionType = exports.AnalyticsStatus = exports.TrackingTypes = exports.GoogleAnalyticsDataType = void 0;
+var GoogleAnalyticsDataType;
+(function (GoogleAnalyticsDataType) {
+    GoogleAnalyticsDataType["Page"] = "pageview";
+    GoogleAnalyticsDataType["Event"] = "event";
+})(GoogleAnalyticsDataType || (exports.GoogleAnalyticsDataType = GoogleAnalyticsDataType = {}));
+var TrackingTypes;
+(function (TrackingTypes) {
+    TrackingTypes["Initialization"] = "initialization";
+    TrackingTypes["Exception"] = "exception";
+    TrackingTypes["AcceptTrackFeatureUsage"] = "acceptTrackFeatureUsage";
+    TrackingTypes["GoogleAnalyticsData"] = "googleAnalyticsData";
+    TrackingTypes["FinishTracking"] = "FinishTracking";
+})(TrackingTypes || (exports.TrackingTypes = TrackingTypes = {}));
+var AnalyticsStatus;
+(function (AnalyticsStatus) {
+    AnalyticsStatus["enabled"] = "enabled";
+    AnalyticsStatus["disabled"] = "disabled";
+    AnalyticsStatus["notConfirmed"] = "not confirmed";
+})(AnalyticsStatus || (exports.AnalyticsStatus = AnalyticsStatus = {}));
+var OptionType;
+(function (OptionType) {
+    OptionType["String"] = "string";
+    OptionType["Boolean"] = "boolean";
+    OptionType["Number"] = "number";
+    OptionType["Array"] = "array";
+    OptionType["Object"] = "object";
+})(OptionType || (exports.OptionType = OptionType = {}));
+var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes[ErrorCodes["UNCAUGHT"] = 120] = "UNCAUGHT";
+    ErrorCodes[ErrorCodes["UNKNOWN"] = 127] = "UNKNOWN";
+    ErrorCodes[ErrorCodes["INVALID_ARGUMENT"] = 128] = "INVALID_ARGUMENT";
+    ErrorCodes[ErrorCodes["RESOURCE_PROBLEM"] = 129] = "RESOURCE_PROBLEM";
+    ErrorCodes[ErrorCodes["KARMA_FAIL"] = 130] = "KARMA_FAIL";
+    ErrorCodes[ErrorCodes["UNHANDLED_REJECTION_FAILURE"] = 131] = "UNHANDLED_REJECTION_FAILURE";
+    ErrorCodes[ErrorCodes["DELETED_KILL_FILE"] = 132] = "DELETED_KILL_FILE";
+    ErrorCodes[ErrorCodes["TESTS_INIT_REQUIRED"] = 133] = "TESTS_INIT_REQUIRED";
+    ErrorCodes[ErrorCodes["ALL_DEVICES_DISCONNECTED"] = 134] = "ALL_DEVICES_DISCONNECTED";
+})(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));

package/lib/common/errors.d.ts

@@ -0,0 +1,15 @@
+import { IErrors, IFailOptions } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare function installUncaughtExceptionListener(actionOnException?: () => void): void;
+export declare class Errors implements IErrors {
+    private $injector;
+    constructor($injector: IInjector);
+    printCallStack: boolean;
+    fail(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    failWithoutHelp(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    failWithHelp(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    private getFailOptions;
+    private failWithOptions;
+    beginCommand(action: () => Promise<boolean>, printCommandHelpSuggestion: () => Promise<void>): Promise<boolean>;
+    verifyHeap(message: string): void;
+}

package/lib/common/errors.js

@@ -14,10 +14,9 @@ const _ = require("lodash");
 const source_map_1 = require("source-map");
 const helpers_1 = require("./helpers");
 const decorators_1 = require("./decorators");
+const enums_1 = require("./enums");
 const yok_1 = require("./yok");
-// we need this to overwrite .stack property (read-only in Error)
 function Exception() {
-    /* intentionally left blank */
 }
 Exception.prototype = new Error();
 async function resolveCallStack(error) {
@@ -62,7 +61,6 @@ async function resolveCallStack(error) {
     }));
     let outputMessage = remapped.join("\n");
     if (outputMessage.indexOf(error.message) === -1) {
-        // when fibers throw error in node 0.12.x, the stack does NOT contain the message
         outputMessage = outputMessage.replace(/Error/, "Error: " + error.message);
     }
     return outputMessage;
@@ -86,9 +84,7 @@ function installUncaughtExceptionListener(actionOnException) {
             }
         }
         catch (err) {
-            // In case the handler throws error and we do not catch it, we'll go in infinite loop of unhandled rejections.
-            // We cannot do anything here as even `console.error` may fail. So just exit the process.
-            process.exit(131 /* ErrorCodes.UNHANDLED_REJECTION_FAILURE */);
+            process.exit(enums_1.ErrorCodes.UNHANDLED_REJECTION_FAILURE);
         }
     };
     process.on("uncaughtException", handler);
@@ -100,7 +96,6 @@ async function tryTrackException(error, localInjector) {
         disableAnalytics = localInjector.resolve("staticConfig").disableAnalytics;
     }
     catch (err) {
-        // We should get here only in our unit tests.
         disableAnalytics = true;
     }
     if (!disableAnalytics) {
@@ -109,7 +104,6 @@ async function tryTrackException(error, localInjector) {
             await analyticsService.trackException(error, error.message);
         }
         catch (e) {
-            // Do not replace with logger due to cyclic dependency
             console.error("Error while reporting exception: " + e);
         }
     }
@@ -147,10 +141,9 @@ class Errors {
             exception.message = $messagesService.getMessage.apply($messagesService, [opts.formatStr].concat(argsArray));
         }
         catch (err) {
-            // Ignore
         }
         exception.stack = new Error(exception.message).stack;
-        exception.errorCode = opts.errorCode || 127 /* ErrorCodes.UNKNOWN */;
+        exception.errorCode = opts.errorCode || enums_1.ErrorCodes.UNKNOWN;
         exception.suggestCommandHelp = suggestCommandHelp;
         exception.proxyAuthenticationRequired = !!opts.proxyAuthenticationRequired;
         exception.printOnStdout = opts.printOnStdout;
@@ -182,10 +175,9 @@ class Errors {
                 await printCommandHelpSuggestion();
             }
             await tryTrackException(ex, this.$injector);
-            process.exit(_.isNumber(ex.errorCode) ? ex.errorCode : 127 /* ErrorCodes.UNKNOWN */);
+            process.exit(_.isNumber(ex.errorCode) ? ex.errorCode : enums_1.ErrorCodes.UNKNOWN);
         }
     }
-    // If you want to activate this function, start Node with flags --nouse_idle_notification and --expose_gc
     verifyHeap(message) {
         if (global.gc) {
             console.log("verifyHeap: '%s'", message);
@@ -198,4 +190,3 @@ __decorate([
     (0, decorators_1.deprecated)("Use `fail` instead.")
 ], Errors.prototype, "failWithoutHelp", null);
 yok_1.injector.register("errors", Errors);
-//# sourceMappingURL=errors.js.map