feat: add key commands

Author: ammarahm-ed

lib/bootstrap.ts

@@ -1,7 +1,12 @@
 // using chalk as some of our other dependencies are already using it...
 // exporting from here so we can easily refactor to a different color library if needed
+import * as ansi from "ansi-colors";
 import * as chalk from "chalk";
 
 export type Color = typeof chalk.Color;
 
+export function stripColors(formatStr: string) {
+	return ansi.stripColor(formatStr);
+}
+
 export const color = chalk;

lib/color.ts

@@ -1,22 +1,25 @@
 import { ERROR_NO_VALID_SUBCOMMAND_FORMAT } from "../common/constants";
-import {
-	ANDROID_RELEASE_BUILD_ERROR_MESSAGE,
-	ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE,
-} from "../constants";
+import { IErrors, IHostInfo } from "../common/declarations";
 import { cache } from "../common/decorators";
-import { hasValidAndroidSigning } from "../common/helpers";
-import { IProjectData, IProjectDataService } from "../definitions/project";
-import { IMigrateController } from "../definitions/migrate";
-import { IOptions, IPlatformValidationService } from "../declarations";
 import { ICommand, ICommandParameter } from "../common/definitions/commands";
-import { IErrors, IHostInfo } from "../common/declarations";
+import {
+	IKeyCommandHelper,
+	IKeyCommandPlatform,
+} from "../common/definitions/key-commands";
 import { IInjector } from "../common/definitions/yok";
+import { hasValidAndroidSigning } from "../common/helpers";
 import { injector } from "../common/yok";
+import {
+	ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE,
+	ANDROID_RELEASE_BUILD_ERROR_MESSAGE,
+} from "../constants";
+import { IOptions, IPlatformValidationService } from "../declarations";
+import { IMigrateController } from "../definitions/migrate";
+import { IProjectData, IProjectDataService } from "../definitions/project";
 
 export class RunCommandBase implements ICommand {
-	private liveSyncCommandHelperAdditionalOptions: ILiveSyncCommandHelperAdditionalOptions = <
-		ILiveSyncCommandHelperAdditionalOptions
-	>{};
+	private liveSyncCommandHelperAdditionalOptions: ILiveSyncCommandHelperAdditionalOptions =
+		<ILiveSyncCommandHelperAdditionalOptions>{};
 
 	public platform: string;
 	constructor(
@@ -26,14 +29,20 @@ export class RunCommandBase implements ICommand {
 		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
 		private $migrateController: IMigrateController,
 		private $options: IOptions,
-		private $projectData: IProjectData
+		private $projectData: IProjectData,
+		private $keyCommandHelper: IKeyCommandHelper,
 	) {}
 
 	public allowedParameters: ICommandParameter[] = [];
 	public async execute(args: string[]): Promise<void> {
-		return this.$liveSyncCommandHelper.executeCommandLiveSync(
+		await this.$liveSyncCommandHelper.executeCommandLiveSync(
 			this.platform,
-			this.liveSyncCommandHelperAdditionalOptions
+			this.liveSyncCommandHelperAdditionalOptions,
+		);
+
+		this.$keyCommandHelper.attachKeyCommands(
+			this.platform as IKeyCommandPlatform,
+			"run",
 		);
 	}
 
@@ -89,7 +98,7 @@ export class RunIosCommand implements ICommand {
 		private $injector: IInjector,
 		private $options: IOptions,
 		private $platformValidationService: IPlatformValidationService,
-		private $projectDataService: IProjectDataService
+		private $projectDataService: IProjectDataService,
 	) {}
 
 	public async execute(args: string[]): Promise<void> {
@@ -102,11 +111,11 @@ export class RunIosCommand implements ICommand {
 		if (
 			!this.$platformValidationService.isPlatformSupportedForOS(
 				this.$devicePlatformsConstants.iOS,
-				projectData
+				projectData,
 			)
 		) {
 			this.$errors.fail(
-				`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`
+				`Applications for platform ${this.$devicePlatformsConstants.iOS} can not be built on this OS`,
 			);
 		}
 
@@ -116,7 +125,7 @@ export class RunIosCommand implements ICommand {
 				this.$options.provision,
 				this.$options.teamId,
 				projectData,
-				this.$devicePlatformsConstants.iOS.toLowerCase()
+				this.$devicePlatformsConstants.iOS.toLowerCase(),
 			));
 		return result;
 	}
@@ -143,7 +152,7 @@ export class RunAndroidCommand implements ICommand {
 		private $injector: IInjector,
 		private $options: IOptions,
 		private $platformValidationService: IPlatformValidationService,
-		private $projectData: IProjectData
+		private $projectData: IProjectData,
 	) {}
 
 	public async execute(args: string[]): Promise<void> {
@@ -156,11 +165,11 @@ export class RunAndroidCommand implements ICommand {
 		if (
 			!this.$platformValidationService.isPlatformSupportedForOS(
 				this.$devicePlatformsConstants.Android,
-				this.$projectData
+				this.$projectData,
 			)
 		) {
 			this.$errors.fail(
-				`Applications for platform ${this.$devicePlatformsConstants.Android} can not be built on this OS`
+				`Applications for platform ${this.$devicePlatformsConstants.Android} can not be built on this OS`,
 			);
 		}
 
@@ -179,7 +188,7 @@ export class RunAndroidCommand implements ICommand {
 			this.$options.provision,
 			this.$options.teamId,
 			this.$projectData,
-			this.$devicePlatformsConstants.Android.toLowerCase()
+			this.$devicePlatformsConstants.Android.toLowerCase(),
 		);
 	}
 }

lib/commands/run.ts

@@ -0,0 +1,17 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { injector } from "../common/yok";
+import { IStartService } from "../definitions/start-service";
+
+export class StartCommand implements ICommand {
+	constructor(private $startService: IStartService) {}
+	async execute(args: string[]): Promise<void> {
+		this.$startService.start();
+		return;
+	}
+	allowedParameters: ICommandParameter[];
+	async canExecute?(args: string[]): Promise<boolean> {
+		return true;
+	}
+}
+
+injector.registerCommand("start", StartCommand);

lib/commands/start.ts

@@ -0,0 +1,52 @@
+export type IKeyCommandPlatform = "Android" | "iOS" | "all";
+export type IKeysLowerCase =
+	| "a"
+	| "b"
+	| "c"
+	| "d"
+	| "e"
+	| "f"
+	| "g"
+	| "h"
+	| "i"
+	| "j"
+	| "k"
+	| "l"
+	| "m"
+	| "n"
+	| "o"
+	| "p"
+	| "q"
+	| "r"
+	| "s"
+	| "t"
+	| "u"
+	| "v"
+	| "w"
+	| "x"
+	| "y"
+	| "z";
+
+export type IValidKeyCommands = IKeysLowerCase | `${Uppercase<IKeysLowerCase>}`;
+
+export interface IKeyCommandHelper {
+	attachKeyCommands: (
+		platform: IKeyCommandPlatform,
+		processType: SupportedProcessType,
+	) => void;
+
+	addOverride(key: IValidKeyCommands, execute: () => Promise<boolean>);
+	removeOverride(key: IValidKeyCommands);
+	printCommands(platform: IKeyCommandPlatform): void;
+}
+
+export type SupportedProcessType = "start" | "run";
+
+export interface IKeyCommand {
+	key: IValidKeyCommands;
+	platform: IKeyCommandPlatform;
+	description: string;
+	willBlockKeyCommandExecution?: boolean;
+	execute(platform: string): Promise<void>;
+	canExecute?: (processType: SupportedProcessType) => boolean;
+}

lib/common/definitions/key-commands.d.ts

@@ -1,5 +1,6 @@
 import { IDisposable, IDictionary } from "../declarations";
 import { ICommand } from "./commands";
+import { IKeyCommand, IValidKeyCommands } from "./key-commands";
 
 interface IInjector extends IDisposable {
 	require(name: string, file: string): void;
@@ -8,6 +9,7 @@ interface IInjector extends IDisposable {
 	requirePublicClass(names: string | string[], file: string): void;
 	requireCommand(name: string, file: string): void;
 	requireCommand(names: string[], file: string): void;
+	requireKeyCommand(name: string, file: string): void;
 	/**
 	 * Resolves an implementation by constructor function.
 	 * The injector will create new instances for every call.
@@ -22,21 +24,24 @@ interface IInjector extends IDisposable {
 	resolve<T>(name: string, ctorArguments?: IDictionary<any>): T;
 
 	resolveCommand(name: string): ICommand;
+	resolveKeyCommand(key: string): IKeyCommand;
 	register(name: string, resolver: any, shared?: boolean): void;
 	registerCommand(name: string, resolver: any): void;
 	registerCommand(names: string[], resolver: any): void;
+	registerKeyCommand(key: IValidKeyCommands, resolver: any): void;
 	getRegisteredCommandsNames(includeDev: boolean): string[];
+	getRegisteredKeyCommandsNames(): string[];
 	dynamicCallRegex: RegExp;
 	dynamicCall(call: string, args?: any[]): Promise<any>;
 	isDefaultCommand(commandName: string): boolean;
 	isValidHierarchicalCommand(
 		commandName: string,
-		commandArguments: string[]
+		commandArguments: string[],
 	): Promise<boolean>;
 	getChildrenCommandsNames(commandName: string): string[];
 	buildHierarchicalCommand(
 		parentCommandName: string,
-		commandLineArguments: string[]
+		commandLineArguments: string[],
 	): any;
 	publicApi: any;
 

lib/common/definitions/yok.d.ts

@@ -0,0 +1,28 @@
+import { color, stripColors } from "../color";
+
+export function printHeader() {
+	if (process.env.HIDE_HEADER) return;
+	const version = "8.5.3";
+	const middle = [
+		color.dim("│  "),
+		color.cyanBright.bold(" {N} NativeScript "),
+		color.whiteBright.bold("CLI"),
+		color.dim(` [v${version}] `),
+		color.dim("  │"),
+	].join("");
+	const middle2 = [
+		color.dim("│ "),
+		color.whiteBright.bold(" Empowering JS with Native APIs "),
+		color.dim("  │"),
+	].join("");
+
+	const end = [color.dim("─┘")].join("");
+
+	const width = stripColors(middle).length;
+	const endWidth = stripColors(end).length;
+	console.info(" ");
+	console.info("  " + color.dim("┌" + "─".repeat(width - 2) + "┐"));
+	console.info("  " + middle);
+	console.info("  " + middle2);
+	console.info("  " + color.dim("└" + "─".repeat(width - endWidth - 1)) + end);
+}

lib/common/header.ts

@@ -11,25 +11,26 @@ interface IAdbAndroidDeviceInfo {
 
 export class AndroidDeviceDiscovery
 	extends DeviceDiscovery
-	implements Mobile.IAndroidDeviceDiscovery {
+	implements Mobile.IAndroidDeviceDiscovery
+{
 	private _devices: IAdbAndroidDeviceInfo[] = [];
 	private isStarted: boolean;
 
 	constructor(
 		private $injector: IInjector,
 		private $adb: Mobile.IAndroidDebugBridge,
-		private $mobileHelper: Mobile.IMobileHelper
+		private $mobileHelper: Mobile.IMobileHelper,
 	) {
 		super();
 	}
 
 	private async createAndAddDevice(
-		adbDeviceInfo: IAdbAndroidDeviceInfo
+		adbDeviceInfo: IAdbAndroidDeviceInfo,
 	): Promise<void> {
 		this._devices.push(adbDeviceInfo);
 		const device: Mobile.IAndroidDevice = this.$injector.resolve(
 			AndroidDevice,
-			{ identifier: adbDeviceInfo.identifier, status: adbDeviceInfo.status }
+			{ identifier: adbDeviceInfo.identifier, status: adbDeviceInfo.status },
 		);
 		await device.init();
 		this.addDevice(device);
@@ -41,7 +42,7 @@ export class AndroidDeviceDiscovery
 	}
 
 	public async startLookingForDevices(
-		options?: Mobile.IDeviceLookingOptions
+		options?: Mobile.IDeviceLookingOptions,
 	): Promise<void> {
 		if (
 			options &&
@@ -56,7 +57,6 @@ export class AndroidDeviceDiscovery
 
 	private async checkForDevices(): Promise<void> {
 		const devices = await this.$adb.getDevices();
-
 		await this.checkCurrentData(devices);
 	}
 
@@ -72,7 +72,7 @@ export class AndroidDeviceDiscovery
 					identifier: identifier,
 					status: status,
 				};
-			}
+			},
 		);
 
 		_(this._devices)
@@ -82,12 +82,13 @@ export class AndroidDeviceDiscovery
 						_.find(
 							currentDevices,
 							(device) =>
-								device.identifier === d.identifier && device.status === d.status
+								device.identifier === d.identifier &&
+								device.status === d.status,
 						)
-					)
+					),
 			)
 			.each((d: IAdbAndroidDeviceInfo) =>
-				this.deleteAndRemoveDevice(d.identifier)
+				this.deleteAndRemoveDevice(d.identifier),
 			);
 
 		await Promise.all(
@@ -99,12 +100,12 @@ export class AndroidDeviceDiscovery
 								this._devices,
 								(device) =>
 									device.identifier === d.identifier &&
-									device.status === d.status
+									device.status === d.status,
 							)
-						)
+						),
 				)
 				.map((d: IAdbAndroidDeviceInfo) => this.createAndAddDevice(d))
-				.value()
+				.value(),
 		);
 	}
 

lib/common/mobile/mobile-core/android-device-discovery.ts

@@ -6,7 +6,8 @@ import { injector } from "../../yok";
 
 export class DeviceDiscovery
 	extends EventEmitter
-	implements Mobile.IDeviceDiscovery {
+	implements Mobile.IDeviceDiscovery
+{
 	private devices: IDictionary<Mobile.IDevice> = {};
 
 	public async startLookingForDevices(): Promise<void> {