chore: cleanup

Author: rigor789

lib/commands/start.ts

@@ -1,10 +1,12 @@
 import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { printHeader } from "../common/header";
 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> {
+		printHeader();
 		this.$startService.start();
 		return;
 	}

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

@@ -27,23 +27,32 @@ export type IKeysLowerCase =
 	| "y"
 	| "z";
 
-export type IValidKeyCommands = IKeysLowerCase | `${Uppercase<IKeysLowerCase>}`;
+export type IKeysUpperCase = Uppercase<IKeysLowerCase>;
+
+export const enum SpecialKeys {
+	CtrlC = "\u0003",
+	QuestionMark = "?",
+}
+
+export type IKeysSpecial = `${SpecialKeys}`;
+
+export type IValidKeyName = IKeysLowerCase | IKeysUpperCase | IKeysSpecial;
 
 export interface IKeyCommandHelper {
 	attachKeyCommands: (
 		platform: IKeyCommandPlatform,
 		processType: SupportedProcessType
 	) => void;
 
-	addOverride(key: IValidKeyCommands, execute: () => Promise<boolean>);
-	removeOverride(key: IValidKeyCommands);
+	addOverride(key: IValidKeyName, execute: () => Promise<boolean>);
+	removeOverride(key: IValidKeyName);
 	printCommands(platform: IKeyCommandPlatform): void;
 }
 
 export type SupportedProcessType = "start" | "run";
 
 export interface IKeyCommand {
-	key: IValidKeyCommands;
+	key: IValidKeyName;
 	platform: IKeyCommandPlatform;
 	description: string;
 	willBlockKeyCommandExecution?: boolean;

lib/common/definitions/yok.d.ts

@@ -1,6 +1,6 @@
 import { IDisposable, IDictionary } from "../declarations";
 import { ICommand } from "./commands";
-import { IKeyCommand, IValidKeyCommands } from "./key-commands";
+import { IKeyCommand, IValidKeyName } from "./key-commands";
 
 interface IInjector extends IDisposable {
 	require(name: string, file: string): void;
@@ -9,7 +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;
+	requireKeyCommand(name: IValidKeyName, file: string): void;
 	/**
 	 * Resolves an implementation by constructor function.
 	 * The injector will create new instances for every call.
@@ -28,7 +28,7 @@ interface IInjector extends IDisposable {
 	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;
+	registerKeyCommand(key: IValidKeyName, resolver: any): void;
 	getRegisteredCommandsNames(includeDev: boolean): string[];
 	getRegisteredKeyCommandsNames(): string[];
 	dynamicCallRegex: RegExp;

lib/common/header.ts

@@ -1,28 +1,37 @@
 import { color, stripColors } from "../color";
+import { IStaticConfig } from "../declarations";
+import { injector } from "./yok";
 
 export function printHeader() {
 	if (process.env.HIDE_HEADER) return;
-	const version = "8.5.3";
-	const middle = [
-		color.dim("│  "),
-		color.cyanBright.bold(" {N} NativeScript "),
+
+	const $staticConfig: IStaticConfig = injector.resolve("$staticConfig");
+	const version = $staticConfig.version;
+
+	const header = [
+		color.dim("│ "),
+		color.cyanBright.bold("{N} NativeScript "),
 		color.whiteBright.bold("CLI"),
 		color.dim(` [v${version}] `),
-		color.dim("  │"),
+		// color.dim("  │"),
 	].join("");
-	const middle2 = [
+	const tagLine = [
 		color.dim("│ "),
-		color.whiteBright.bold(" Empower JavaScript with native APIs "),
-		color.dim("  │"),
+		color.dim(" → "),
+		color.whiteBright.bold("Empower JavaScript with native APIs "),
+		// color.dim("  │"),
 	].join("");
 
-	const end = [color.dim("─┘")].join("");
+	const headerLength = stripColors(header).length;
+	const tagLineLength = stripColors(tagLine).length;
+	const width = Math.max(headerLength, tagLineLength);
 
-	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);
+	console.info("  " + color.dim("┌" + "─".repeat(width - 1) + "┐"));
+	console.info(
+		"  " + header + " ".repeat(width - headerLength) + color.dim("│")
+	);
+	console.info(
+		"  " + tagLine + " ".repeat(width - tagLineLength) + color.dim("│")
+	);
+	console.info("  " + color.dim("└" + "─".repeat(width - 1) + "┘"));
 }

lib/common/services/commands-service.ts

@@ -19,7 +19,6 @@ import {
 	ICommand,
 	ISimilarCommand,
 } from "../definitions/commands";
-import { printHeader } from "../header";
 
 class CommandArgumentsValidationHelper {
 	constructor(public isValid: boolean, _remainingArguments: string[]) {
@@ -183,7 +182,6 @@ export class CommandsService implements ICommandsService {
 				: canExecuteResult;
 
 		if (canExecute) {
-			printHeader();
 			await this.executeCommandAction(
 				commandName,
 				commandArguments,

lib/helpers/key-command-helper.ts

@@ -1,8 +1,9 @@
-import { color } from "../color";
+import { color, stripColors } from "../color";
 import {
 	IKeyCommandHelper,
 	IKeyCommandPlatform,
-	IValidKeyCommands,
+	IValidKeyName,
+	SpecialKeys,
 	SupportedProcessType,
 } from "../common/definitions/key-commands";
 import { injector } from "../common/yok";
@@ -13,25 +14,25 @@ export default class KeyCommandHelper implements IKeyCommandHelper {
 	private processType: SupportedProcessType;
 	private overrides: { [key: string]: () => Promise<boolean> } = {};
 
-	public addOverride(key: IValidKeyCommands, execute: () => Promise<boolean>) {
+	public addOverride(key: IValidKeyName, execute: () => Promise<boolean>) {
 		this.overrides[key] = execute;
 	}
 
-	public removeOverride(key: IValidKeyCommands) {
+	public removeOverride(key: IValidKeyName) {
 		this.overrides[key] = undefined;
 	}
 
 	private onKeyPressed = async (data: Buffer) => {
 		const key = data.toString();
 
 		// Allow Ctrl + C always.
-		if (this.keyCommandExecutionBlocked && key !== "\u0003") return;
+		if (this.keyCommandExecutionBlocked && key !== SpecialKeys.CtrlC) return;
 
 		try {
 			const exists = injector.getRegisteredKeyCommandsNames().includes(key);
 
 			if (exists) {
-				const keyCommand = injector.resolveKeyCommand(key as IValidKeyCommands);
+				const keyCommand = injector.resolveKeyCommand(key as IValidKeyName);
 
 				if (
 					keyCommand.platform === "all" ||
@@ -57,6 +58,16 @@ export default class KeyCommandHelper implements IKeyCommandHelper {
 						}
 					}
 
+					if (keyCommand.key !== SpecialKeys.CtrlC) {
+						const line = ` ${color.dim("→")} ${color.bold(keyCommand.key)} — ${
+							keyCommand.description
+						}`;
+						const lineLength = stripColors(line).length - 1;
+						console.log(color.dim(` ┌${"─".repeat(lineLength)}┐`));
+						console.log(line + color.dim(" │"));
+						console.log(color.dim(` └${"─".repeat(lineLength)}┘`));
+						console.log("");
+					}
 					const result = await keyCommand.execute(this.platform);
 					this.keyCommandExecutionBlocked = false;
 
@@ -78,7 +89,7 @@ export default class KeyCommandHelper implements IKeyCommandHelper {
 	public printCommands(platform: IKeyCommandPlatform) {
 		const commands = injector.getRegisteredKeyCommandsNames();
 		const commandHelp = commands.reduce((arr, key) => {
-			const command = injector.resolveKeyCommand(key as IValidKeyCommands);
+			const command = injector.resolveKeyCommand(key as IValidKeyName);
 
 			if (
 				!command.description ||
@@ -102,6 +113,7 @@ export default class KeyCommandHelper implements IKeyCommandHelper {
 				)}, you can press the following keys any time (make sure the terminal has focus).`,
 				"",
 				...commandHelp,
+				"",
 			].join("\n")
 		);
 	}

lib/key-commands/bootstrap.ts

@@ -1,3 +1,4 @@
+import { SpecialKeys } from "../common/definitions/key-commands";
 import { injector } from "../common/yok";
 
 const path = "./key-commands/index";
@@ -11,4 +12,6 @@ injector.requireKeyCommand("R", path);
 injector.requireKeyCommand("w", path);
 injector.requireKeyCommand("c", path);
 injector.requireKeyCommand("n", path);
-injector.requireKeyCommand("\u0003" as any, path);
+
+injector.requireKeyCommand(SpecialKeys.QuestionMark, path);
+injector.requireKeyCommand(SpecialKeys.CtrlC, path);