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

package/lib/helpers/key-command-helper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const color_1 = require("../color");
 const node_util_1 = require("node:util");
+const key_commands_1 = require("../common/definitions/key-commands");
 const yok_1 = require("../common/yok");
 class KeyCommandHelper {
     constructor() {
@@ -9,8 +10,7 @@ class KeyCommandHelper {
         this.overrides = {};
         this.onKeyPressed = async (data) => {
             const key = data.toString();
-            // Allow Ctrl + C always.
-            if (this.keyCommandExecutionBlocked && key !== "\u0003" /* SpecialKeys.CtrlC */)
+            if (this.keyCommandExecutionBlocked && key !== key_commands_1.SpecialKeys.CtrlC)
                 return;
             try {
                 const exists = yok_1.injector.getRegisteredKeyCommandsNames().includes(key);
@@ -33,7 +33,7 @@ class KeyCommandHelper {
                                 return;
                             }
                         }
-                        if (keyCommand.key !== "\u0003" /* SpecialKeys.CtrlC */) {
+                        if (keyCommand.key !== key_commands_1.SpecialKeys.CtrlC) {
                             const line = ` ${color_1.color.dim("→")} ${color_1.color.bold(keyCommand.key)} — ${keyCommand.description}`;
                             const lineLength = (0, node_util_1.stripVTControlCharacters)(line).length - 1;
                             console.log(color_1.color.dim(` ┌${"─".repeat(lineLength)}┐`));
@@ -115,4 +115,3 @@ class KeyCommandHelper {
 }
 exports.default = KeyCommandHelper;
 yok_1.injector.register("keyCommandHelper", KeyCommandHelper);
-//# sourceMappingURL=key-command-helper.js.map

package/lib/helpers/livesync-command-helper.d.ts

@@ -0,0 +1,36 @@
+import { IAnalyticsService, IDictionary, IErrors } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+import { DeployController } from "../controllers/deploy-controller";
+import { IAndroidBundleValidatorHelper, IOptions } from "../declarations";
+import { IBuildController, IBuildDataService } from "../definitions/build";
+import { ICleanupService } from "../definitions/cleanup-service";
+import { IProjectData, IValidatePlatformOutput } from "../definitions/project";
+export declare class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
+    private $androidBundleValidatorHelper;
+    private $buildDataService;
+    private $projectData;
+    private $options;
+    private $deployController;
+    private $iosDeviceOperations;
+    private $mobileHelper;
+    private $devicesService;
+    private $injector;
+    private $buildController;
+    private $analyticsService;
+    private $errors;
+    private $iOSSimulatorLogProvider;
+    private $cleanupService;
+    private $runController;
+    constructor($androidBundleValidatorHelper: IAndroidBundleValidatorHelper, $buildDataService: IBuildDataService, $projectData: IProjectData, $options: IOptions, $deployController: DeployController, $iosDeviceOperations: IIOSDeviceOperations, $mobileHelper: Mobile.IMobileHelper, $devicesService: Mobile.IDevicesService, $injector: IInjector, $buildController: IBuildController, $analyticsService: IAnalyticsService, $errors: IErrors, $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider, $cleanupService: ICleanupService, $runController: IRunController);
+    private get $platformsDataService();
+    getLiveSyncData(projectDir: string): ILiveSyncInfo;
+    getDeviceInstances(platform?: string): Promise<Mobile.IDevice[]>;
+    createDeviceDescriptors(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<ILiveSyncDeviceDescriptor[]>;
+    getPlatformsForOperation(platform: string): string[];
+    executeCommandLiveSync(platform?: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void>;
+    executeLiveSyncOperation(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void>;
+    validatePlatform(platform: string): Promise<IDictionary<IValidatePlatformOutput>>;
+    private executeLiveSyncOperationCore;
+    private runInRelease;
+    stop(): Promise<void>;
+}

package/lib/helpers/livesync-command-helper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveSyncCommandHelper = void 0;
 const _ = require("lodash");
+const enums_1 = require("../common/enums");
 const yok_1 = require("../common/yok");
 const constants_1 = require("../constants");
 class LiveSyncCommandHelper {
@@ -25,7 +26,6 @@ class LiveSyncCommandHelper {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    // TODO: Remove this and replace it with buildData
     getLiveSyncData(projectDir) {
         const liveSyncInfo = {
             projectDir,
@@ -55,7 +55,6 @@ class LiveSyncCommandHelper {
         return devices;
     }
     async createDeviceDescriptors(devices, platform, additionalOptions) {
-        // Now let's take data for each device:
         const deviceDescriptors = devices.map((d) => {
             const outputPath = additionalOptions &&
                 additionalOptions.getOutputDirectory &&
@@ -135,7 +134,7 @@ class LiveSyncCommandHelper {
             const remainingDevicesToSync = devices.map((d) => d.deviceInfo.identifier);
             _.remove(remainingDevicesToSync, (d) => d === data.deviceIdentifier);
             if (remainingDevicesToSync.length === 0 && !data.keepProcessAlive) {
-                process.exit(134 /* ErrorCodes.ALL_DEVICES_DISCONNECTED */);
+                process.exit(enums_1.ErrorCodes.ALL_DEVICES_DISCONNECTED);
             }
         });
     }
@@ -205,4 +204,3 @@ class LiveSyncCommandHelper {
 }
 exports.LiveSyncCommandHelper = LiveSyncCommandHelper;
 yok_1.injector.register("liveSyncCommandHelper", LiveSyncCommandHelper);
-//# sourceMappingURL=livesync-command-helper.js.map

package/lib/helpers/network-connectivity-validator.d.ts

@@ -0,0 +1,12 @@
+import { INetworkConnectivityValidator } from "../declarations";
+import { IErrors } from "../common/declarations";
+export declare class NetworkConnectivityValidator implements INetworkConnectivityValidator {
+    private $errors;
+    private $logger;
+    private static DNS_LOOKUP_URL;
+    private static NO_INTERNET_ERROR_CODE;
+    private static NO_INTERNET_ERROR_MESSAGE;
+    constructor($errors: IErrors, $logger: ILogger);
+    validate(): Promise<void>;
+    private isConnected;
+}

package/lib/helpers/network-connectivity-validator.js

@@ -34,4 +34,3 @@ NetworkConnectivityValidator.DNS_LOOKUP_URL = "play.nativescript.org";
 NetworkConnectivityValidator.NO_INTERNET_ERROR_CODE = "ENOTFOUND";
 NetworkConnectivityValidator.NO_INTERNET_ERROR_MESSAGE = "No internet connection. Check your internet settings and try again.";
 yok_1.injector.register("networkConnectivityValidator", NetworkConnectivityValidator);
-//# sourceMappingURL=network-connectivity-validator.js.map

package/lib/helpers/options-track-helper.d.ts

@@ -0,0 +1,14 @@
+import { IOptions } from "../declarations";
+import { IAnalyticsService } from "../common/declarations";
+export declare class OptionsTracker {
+    private $analyticsService;
+    static PASSWORD_DETECTION_STRING: string;
+    static PRIVATE_REPLACE_VALUE: string;
+    static PATH_REPLACE_VALUE: string;
+    static SIZE_EXEEDED_REPLACE_VALUE: string;
+    constructor($analyticsService: IAnalyticsService);
+    trackOptions(options: IOptions): Promise<void>;
+    private getTrackObject;
+    private sanitizeTrackObject;
+    private shouldSkipProperty;
+}

package/lib/helpers/options-track-helper.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OptionsTracker = void 0;
 const path = require("path");
+const constants_1 = require("../constants");
+const enums_1 = require("../common/enums");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class OptionsTracker {
@@ -11,7 +13,7 @@ class OptionsTracker {
     async trackOptions(options) {
         const trackObject = this.getTrackObject(options);
         await this.$analyticsService.trackEventActionInGoogleAnalytics({
-            action: "Options" /* TrackActionNames.Options */,
+            action: constants_1.TrackActionNames.Options,
             additionalData: JSON.stringify(trackObject),
         });
     }
@@ -58,7 +60,7 @@ class OptionsTracker {
             return true;
         }
         const optionDef = options[key];
-        if (optionDef && optionDef.type === "boolean" /* OptionType.Boolean */) {
+        if (optionDef && optionDef.type === enums_1.OptionType.Boolean) {
             if ((optionDef.default !== true && value === false) ||
                 (optionDef.default === true && value === true)) {
                 return true;
@@ -75,4 +77,3 @@ OptionsTracker.PRIVATE_REPLACE_VALUE = "private";
 OptionsTracker.PATH_REPLACE_VALUE = "_localpath";
 OptionsTracker.SIZE_EXEEDED_REPLACE_VALUE = "sizeExceeded";
 yok_1.injector.register("optionsTracker", OptionsTracker);
-//# sourceMappingURL=options-track-helper.js.map

package/lib/helpers/package-path-helper.d.ts

@@ -0,0 +1,2 @@
+import { resolvePackagePath, resolvePackageJSONPath } from "@rigor789/resolve-package-path";
+export { resolvePackagePath, resolvePackageJSONPath };

package/lib/helpers/package-path-helper.js

@@ -4,4 +4,3 @@ exports.resolvePackageJSONPath = exports.resolvePackagePath = void 0;
 const resolve_package_path_1 = require("@rigor789/resolve-package-path");
 Object.defineProperty(exports, "resolvePackagePath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackagePath; } });
 Object.defineProperty(exports, "resolvePackageJSONPath", { enumerable: true, get: function () { return resolve_package_path_1.resolvePackageJSONPath; } });
-//# sourceMappingURL=package-path-helper.js.map

package/lib/helpers/platform-command-helper.d.ts

@@ -0,0 +1,35 @@
+import { PlatformController } from "../controllers/platform-controller";
+import { PlatformValidationService } from "../services/platform/platform-validation-service";
+import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IPlatformCommandHelper, IPackageInstallationManager, IOptions } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IFileSystem, IErrors } from "../common/declarations";
+import { ITempService } from "../definitions/temp-service";
+export declare class PlatformCommandHelper implements IPlatformCommandHelper {
+    private $platformController;
+    private $fs;
+    private $errors;
+    private $logger;
+    private $options;
+    private $mobileHelper;
+    private $packageInstallationManager;
+    private $pacoteService;
+    private $platformsDataService;
+    private $platformValidationService;
+    private $projectChangesService;
+    private $projectDataService;
+    private $tempService;
+    constructor($platformController: PlatformController, $fs: IFileSystem, $errors: IErrors, $logger: ILogger, $options: IOptions, $mobileHelper: Mobile.IMobileHelper, $packageInstallationManager: IPackageInstallationManager, $pacoteService: IPacoteService, $platformsDataService: IPlatformsDataService, $platformValidationService: PlatformValidationService, $projectChangesService: IProjectChangesService, $projectDataService: IProjectDataService, $tempService: ITempService);
+    addPlatforms(platforms: string[], projectData: IProjectData, frameworkPath: string): Promise<void>;
+    cleanPlatforms(platforms: string[], projectData: IProjectData, framworkPath: string): Promise<void>;
+    removePlatforms(platforms: string[], projectData: IProjectData): Promise<void>;
+    updatePlatforms(platforms: string[], projectData: IProjectData): Promise<void>;
+    getInstalledPlatforms(projectData: IProjectData): string[];
+    getAvailablePlatforms(projectData: IProjectData): string[];
+    getPreparedPlatforms(projectData: IProjectData): string[];
+    getCurrentPlatformVersion(platform: string, projectData: IProjectData): string;
+    private isPlatformAdded;
+    private updatePlatform;
+    private updatePlatformCore;
+    private isPlatformPrepared;
+}

package/lib/helpers/platform-command-helper.js

@@ -70,10 +70,6 @@ class PlatformCommandHelper {
                 const platformDir = path.join(projectData.platformsDir, platform.toLowerCase());
                 this.$fs.deleteDirectory(platformDir);
                 await this.$packageInstallationManager.uninstall(platformData.frameworkPackageName, projectData.projectDir);
-                // this.$projectDataService.removeNSProperty(
-                // 	projectData.projectDir,
-                // 	platformData.frameworkPackageName
-                // );
                 this.$logger.info(`Platform ${platform} successfully removed.`);
             }
             catch (err) {
@@ -112,7 +108,7 @@ class PlatformCommandHelper {
         const installedPlatforms = this.getInstalledPlatforms(projectData);
         return _.filter(this.$mobileHelper.platformNames, (p) => {
             return (installedPlatforms.indexOf(p) < 0 &&
-                this.$platformValidationService.isPlatformSupportedForOS(p, projectData)); // Only those not already installed
+                this.$platformValidationService.isPlatformSupportedForOS(p, projectData));
         });
     }
     getPreparedPlatforms(projectData) {
@@ -136,7 +132,7 @@ class PlatformCommandHelper {
             return true;
         }
         return (prepareInfo.nativePlatformStatus !==
-            "1" /* constants.NativePlatformStatus.requiresPlatformAdd */);
+            constants.NativePlatformStatus.requiresPlatformAdd);
     }
     async updatePlatform(platform, version, projectData) {
         const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
@@ -182,4 +178,3 @@ class PlatformCommandHelper {
 }
 exports.PlatformCommandHelper = PlatformCommandHelper;
 yok_1.injector.register("platformCommandHelper", PlatformCommandHelper);
-//# sourceMappingURL=platform-command-helper.js.map

package/lib/helpers/version-validator-helper.d.ts

@@ -0,0 +1,8 @@
+export declare class VersionValidatorHelper {
+    protected isValidVersion(version: string): string;
+    protected isVersionGreaterThan(v1: string, v2: string): boolean;
+    protected isVersionGreaterOrEqualThan(v1: string, v2: string): boolean;
+    protected isVersionLowerThan(v1: string, v2: string): boolean;
+    protected isVersionLowerOrEqualThan(v1: string, v2: string): boolean;
+    private compareCoerceVersions;
+}

package/lib/helpers/version-validator-helper.js

@@ -23,4 +23,3 @@ class VersionValidatorHelper {
     }
 }
 exports.VersionValidatorHelper = VersionValidatorHelper;
-//# sourceMappingURL=version-validator-helper.js.map

package/lib/key-commands/bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/key-commands/bootstrap.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const key_commands_1 = require("../common/definitions/key-commands");
 const yok_1 = require("../common/yok");
 const path = "./key-commands/index";
 yok_1.injector.requireKeyCommand("a", path);
@@ -13,10 +14,9 @@ yok_1.injector.requireKeyCommand("R", path);
 yok_1.injector.requireKeyCommand("w", path);
 yok_1.injector.requireKeyCommand("c", path);
 yok_1.injector.requireKeyCommand("n", path);
-yok_1.injector.requireKeyCommand("?" /* SpecialKeys.QuestionMark */, path);
-yok_1.injector.requireKeyCommand("\u0003" /* SpecialKeys.CtrlC */, path);
+yok_1.injector.requireKeyCommand(key_commands_1.SpecialKeys.QuestionMark, path);
+yok_1.injector.requireKeyCommand(key_commands_1.SpecialKeys.CtrlC, path);
 yok_1.injector.requireCommand("open|ios", path);
 yok_1.injector.requireCommand("open|android", path);
 yok_1.injector.requireCommand("open|visionos", path);
 yok_1.injector.requireCommand("open|vision", path);
-//# sourceMappingURL=bootstrap.js.map

package/lib/key-commands/index.d.ts

@@ -0,0 +1,166 @@
+import { IChildProcess, IXcodeSelectService } from "../common/declarations";
+import { IKeyCommand, IKeyCommandHelper, IKeyCommandPlatform, IValidKeyName, SupportedProcessType } from "../common/definitions/key-commands";
+import { IProjectData } from "../definitions/project";
+import { IStartService } from "../definitions/start-service";
+import { IOSProjectService } from "../services/ios-project-service";
+import { IOptions } from "../declarations";
+export declare class A implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftA implements IKeyCommand {
+    private $logger;
+    private $liveSyncCommandHelper;
+    private $childProcess;
+    private $projectData;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($logger: ILogger, $liveSyncCommandHelper: ILiveSyncCommandHelper, $childProcess: IChildProcess, $projectData: IProjectData);
+    getAndroidStudioPath(): string | null;
+    execute(): Promise<void>;
+}
+export declare class OpenAndroidCommand extends ShiftA {
+    private $options;
+    constructor($logger: ILogger, $liveSyncCommandHelper: ILiveSyncCommandHelper, $childProcess: IChildProcess, $projectData: IProjectData, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class I implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftI implements IKeyCommand {
+    private $iOSProjectService;
+    private $logger;
+    private $childProcess;
+    private $projectData;
+    private $xcodeSelectService;
+    private $xcodebuildArgsService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService);
+    execute(): Promise<void>;
+}
+export declare class OpenIOSCommand extends ShiftI {
+    private $options;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class V implements IKeyCommand {
+    private $startService;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    constructor($startService: IStartService);
+    execute(): Promise<void>;
+    canExecute(processType: SupportedProcessType): processType is "start";
+}
+export declare class ShiftV implements IKeyCommand {
+    private $iOSProjectService;
+    private $logger;
+    private $childProcess;
+    private $projectData;
+    private $xcodeSelectService;
+    private $xcodebuildArgsService;
+    protected $options: IOptions;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    protected isInteractive: boolean;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class OpenVisionOSCommand extends ShiftV {
+    protected $options: IOptions;
+    constructor($iOSProjectService: IOSProjectService, $logger: ILogger, $childProcess: IChildProcess, $projectData: IProjectData, $xcodeSelectService: IXcodeSelectService, $xcodebuildArgsService: IXcodebuildArgsService, $options: IOptions);
+    execute(): Promise<void>;
+}
+export declare class R implements IKeyCommand {
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(platform: string): Promise<void>;
+}
+export declare class ShiftR implements IKeyCommand {
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(platform: string): Promise<void>;
+}
+export declare class CtrlC implements IKeyCommand {
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    execute(): Promise<void>;
+}
+export declare class W implements IKeyCommand {
+    private $prepareController;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($prepareController: IPrepareController);
+    execute(): Promise<void>;
+}
+export declare class C implements IKeyCommand {
+    private $childProcess;
+    private $liveSyncCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($childProcess: IChildProcess, $liveSyncCommandHelper: ILiveSyncCommandHelper);
+    execute(): Promise<void>;
+}
+export declare class N implements IKeyCommand {
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    execute(platform: string): Promise<void>;
+}
+export declare class QuestionMark implements IKeyCommand {
+    private $keyCommandHelper;
+    key: IValidKeyName;
+    platform: IKeyCommandPlatform;
+    description: string;
+    group: string;
+    willBlockKeyCommandExecution: boolean;
+    constructor($keyCommandHelper: IKeyCommandHelper);
+    execute(platform_: string): Promise<void>;
+}

package/lib/key-commands/index.js

@@ -5,6 +5,7 @@ const fs = require("fs");
 const os_1 = require("os");
 const path = require("path");
 const color_1 = require("../color");
+const key_commands_1 = require("../common/definitions/key-commands");
 const yok_1 = require("../common/yok");
 class A {
     constructor($startService) {
@@ -294,7 +295,7 @@ class ShiftR {
 exports.ShiftR = ShiftR;
 class CtrlC {
     constructor() {
-        this.key = "\u0003" /* SpecialKeys.CtrlC */;
+        this.key = key_commands_1.SpecialKeys.CtrlC;
         this.platform = "all";
         this.group = "Development Workflow";
         this.willBlockKeyCommandExecution = false;
@@ -365,7 +366,7 @@ exports.N = N;
 class QuestionMark {
     constructor($keyCommandHelper) {
         this.$keyCommandHelper = $keyCommandHelper;
-        this.key = "?" /* SpecialKeys.QuestionMark */;
+        this.key = key_commands_1.SpecialKeys.QuestionMark;
         this.platform = "all";
         this.description = "Show this help";
         this.group = "Development Workflow";
@@ -405,10 +406,9 @@ yok_1.injector.registerKeyCommand("w", W);
 yok_1.injector.registerKeyCommand("c", C);
 yok_1.injector.registerKeyCommand("A", ShiftA);
 yok_1.injector.registerKeyCommand("n", N);
-yok_1.injector.registerKeyCommand("?" /* SpecialKeys.QuestionMark */, QuestionMark);
-yok_1.injector.registerKeyCommand("\u0003" /* SpecialKeys.CtrlC */, CtrlC);
+yok_1.injector.registerKeyCommand(key_commands_1.SpecialKeys.QuestionMark, QuestionMark);
+yok_1.injector.registerKeyCommand(key_commands_1.SpecialKeys.CtrlC, CtrlC);
 yok_1.injector.registerCommand("open|ios", OpenIOSCommand);
 yok_1.injector.registerCommand("open|visionos", OpenVisionOSCommand);
 yok_1.injector.registerCommand("open|vision", OpenVisionOSCommand);
 yok_1.injector.registerCommand("open|android", OpenAndroidCommand);
-//# sourceMappingURL=index.js.map

package/lib/nativescript-cli-lib-bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/nativescript-cli-lib-bootstrap.js

@@ -3,10 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const yok_1 = require("./common/yok");
 require("./bootstrap");
 yok_1.injector.overrideAlreadyRequiredModule = true;
-// Temporary!!! Should not require appbuilder's entry point of mobile-cli-lib,
-// but once we separate logics in mobile-cli-lib, we should be able to require only specific bootstrap.
-// Use this hack for now, as this will allow requiring {N} CLI as library directly and executing some device specific operations.
 yok_1.injector.requirePublicClass("deviceEmitter", "./common/mobile/device-emitter");
 yok_1.injector.requirePublicClass("deviceLogProvider", "./common/mobile/device-log-emitter");
 yok_1.injector.resolve("staticConfig").disableAnalytics = true;
-//# sourceMappingURL=nativescript-cli-lib-bootstrap.js.map

package/lib/nativescript-cli-lib.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/nativescript-cli-lib.js

@@ -3,4 +3,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const yok_1 = require("./common/yok");
 require("./nativescript-cli-lib-bootstrap");
 module.exports = yok_1.injector.publicApi;
-//# sourceMappingURL=nativescript-cli-lib.js.map

package/lib/nativescript-cli.d.ts

@@ -0,0 +1 @@
+export declare const originalProcessOn: any;

package/lib/nativescript-cli.js

@@ -6,7 +6,6 @@ const shelljs = require("shelljs");
 shelljs.config.silent = true;
 shelljs.config.fatal = true;
 if (process.platform === "win32") {
-    // Later versions of shelljs do not process globs with \ path delimiters correctly, for windows change to /
     const realcp = shelljs.cp;
     shelljs.cp = (...args) => {
         if (args.length === 3) {
@@ -37,8 +36,9 @@ if (process.platform === "win32") {
 const errors_1 = require("./common/errors");
 const helpers_1 = require("./common/helpers");
 const yok_1 = require("./common/yok");
+const enums_1 = require("./common/enums");
 const color_1 = require("./color");
-(0, errors_1.installUncaughtExceptionListener)(process.exit.bind(process, 120 /* ErrorCodes.UNCAUGHT */));
+(0, errors_1.installUncaughtExceptionListener)(process.exit.bind(process, enums_1.ErrorCodes.UNCAUGHT));
 const logger = yok_1.injector.resolve("logger");
 exports.originalProcessOn = process.on.bind(process);
 process.on = (event, listener) => {
@@ -52,10 +52,8 @@ process.on = (event, listener) => {
         return (0, exports.originalProcessOn)(event, listener);
     }
 };
-/* tslint:disable:no-floating-promises */
 (async () => {
     if (process.argv.includes("--get-yargs-completions")) {
-        // This is a special case when we want to get the yargs completions as fast as possible...
         yok_1.injector.resolve("$options");
         return;
     }
@@ -72,13 +70,6 @@ process.on = (event, listener) => {
         logger.trace("Unable to load extensions. Error is: ", err);
     }
     const commandDispatcher = yok_1.injector.resolve("commandDispatcher");
-    // unused...
-    // const messages: IMessagesService = injector.resolve("$messagesService");
-    // messages.pathsToMessageJsonFiles = [
-    // 	/* Place client-specific json message file paths here */
-    // ];
     await commandDispatcher.dispatchCommand();
     yok_1.injector.dispose();
 })();
-/* tslint:enable:no-floating-promises */
-//# sourceMappingURL=nativescript-cli.js.map

package/lib/node/pbxproj-dom-xcode.d.ts

@@ -0,0 +1,4 @@
+import * as pbxprojDomXcodeModule from "pbxproj-dom/xcode";
+declare global {
+    type IPbxprojDomXcode = typeof pbxprojDomXcodeModule;
+}

package/lib/node/pbxproj-dom-xcode.js

@@ -3,4 +3,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const pbxprojDomXcodeModule = require("pbxproj-dom/xcode");
 const yok_1 = require("../common/yok");
 yok_1.injector.register("pbxprojDomXcode", pbxprojDomXcodeModule);
-//# sourceMappingURL=pbxproj-dom-xcode.js.map

package/lib/node/xcode.d.ts

@@ -0,0 +1,2 @@
+import * as xcode from "nativescript-dev-xcode";
+export { xcode };

package/lib/node/xcode.js

@@ -5,4 +5,3 @@ const xcode = require("nativescript-dev-xcode");
 exports.xcode = xcode;
 const yok_1 = require("../common/yok");
 yok_1.injector.register("xcode", xcode);
-//# sourceMappingURL=xcode.js.map

package/lib/node-package-manager.d.ts

@@ -0,0 +1,16 @@
+import { BasePackageManager } from "./base-package-manager";
+import { INodePackageManagerInstallOptions, INpmInstallResultInfo, INpmsResult } from "./declarations";
+import { IChildProcess, IErrors, IFileSystem, IHostInfo, Server } from "./common/declarations";
+export declare class NodePackageManager extends BasePackageManager {
+    private $errors;
+    private $logger;
+    private $httpClient;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $fs: IFileSystem, $hostInfo: IHostInfo, $logger: ILogger, $httpClient: Server.IHttpClient, $pacoteService: IPacoteService);
+    install(packageName: string, pathToSave: string, config: INodePackageManagerInstallOptions): Promise<INpmInstallResultInfo>;
+    uninstall(packageName: string, config?: any, path?: string): Promise<string>;
+    search(filter: string[], config: any): Promise<string>;
+    view(packageName: string, config: Object): Promise<any>;
+    searchNpms(keyword: string): Promise<INpmsResult>;
+    getRegistryPackageData(packageName: string): Promise<any>;
+    getCachePath(): Promise<string>;
+}