@akylas/nativescript-cli 8.7.2

package/lib/device-path-provider.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePathProvider = void 0;
+const helpers_1 = require("./common/helpers");
+const constants_1 = require("./constants");
+const constants_2 = require("./common/constants");
+const path = require("path");
+const yok_1 = require("./common/yok");
+class DevicePathProvider {
+    constructor($mobileHelper, $iOSSimResolver, $errors) {
+        this.$mobileHelper = $mobileHelper;
+        this.$iOSSimResolver = $iOSSimResolver;
+        this.$errors = $errors;
+    }
+    getDeviceProjectRootPath(device, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let projectRoot = "";
+            if (this.$mobileHelper.isApplePlatform(device.deviceInfo.platform)) {
+                projectRoot = device.isEmulator
+                    ? yield this.$iOSSimResolver.iOSSim.getApplicationPath(device.deviceInfo.identifier, options.appIdentifier)
+                    : constants_2.LiveSyncPaths.IOS_DEVICE_PROJECT_ROOT_PATH;
+                if (!projectRoot) {
+                    this.$errors.fail("Unable to get application path on device.");
+                }
+                if (!options.getDirname) {
+                    projectRoot = path.join(projectRoot, constants_1.APP_FOLDER_NAME);
+                }
+            }
+            else if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+                projectRoot = `${constants_2.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
+                if (!options.getDirname) {
+                    const hashService = (device).fileSystem.getDeviceHashService(options.appIdentifier);
+                    const hashFile = yield hashService.doesShasumFileExistsOnDevice();
+                    const syncFolderName = options.watch || hashFile
+                        ? constants_2.LiveSyncPaths.SYNC_DIR_NAME
+                        : constants_2.LiveSyncPaths.FULLSYNC_DIR_NAME;
+                    projectRoot = path.join(projectRoot, syncFolderName);
+                }
+            }
+            return (0, helpers_1.fromWindowsRelativePathToUnix)(projectRoot);
+        });
+    }
+    getDeviceSyncZipPath(device) {
+        return this.$mobileHelper.isApplePlatform(device.deviceInfo.platform) &&
+            !device.isEmulator
+            ? constants_2.LiveSyncPaths.IOS_DEVICE_SYNC_ZIP_PATH
+            : undefined;
+    }
+}
+exports.DevicePathProvider = DevicePathProvider;
+yok_1.injector.register("devicePathProvider", DevicePathProvider);

package/lib/device-sockets/ios/app-debug-socket-proxy-factory.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppDebugSocketProxyFactory = void 0;
+const events_1 = require("events");
+const constants_1 = require("../../constants");
+const net = require("net");
+const ws = require("ws");
+const ios_device_lib_1 = require("ios-device-lib");
+const yok_1 = require("../../common/yok");
+class AppDebugSocketProxyFactory extends events_1.EventEmitter {
+    constructor($logger, $errors, $lockService, $options, $tempService, $net) {
+        super();
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$lockService = $lockService;
+        this.$options = $options;
+        this.$tempService = $tempService;
+        this.$net = $net;
+        this.deviceWebServers = {};
+        this.deviceTcpServers = {};
+    }
+    getTCPSocketProxy(deviceIdentifier, appId) {
+        return this.deviceTcpServers[`${deviceIdentifier}-${appId}`];
+    }
+    addTCPSocketProxy(device, appId, projectName, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+            const existingServer = this.deviceTcpServers[cacheKey];
+            if (existingServer) {
+                this.$errors.fail(`TCP socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+            }
+            this.$logger.info("\nSetting up proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+            const server = net.createServer({
+                allowHalfOpen: true,
+            });
+            this.deviceTcpServers[cacheKey] = server;
+            server.on("connection", (frontendSocket) => __awaiter(this, void 0, void 0, function* () {
+                this.$logger.info("Frontend client connected.");
+                frontendSocket.on("end", () => {
+                    this.$logger.info("Frontend socket closed!");
+                    if (!this.$options.watch) {
+                        process.exit(0);
+                    }
+                });
+                const appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
+                this.$logger.info("Backend socket created.");
+                appDebugSocket.on("end", () => {
+                    this.$logger.info("Backend socket closed!");
+                    if (!this.$options.watch) {
+                        process.exit(0);
+                    }
+                });
+                frontendSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
+                    this.$logger.info("Frontend socket closed");
+                    yield device.destroyDebugSocket(appId);
+                }));
+                appDebugSocket.on("close", () => {
+                    this.$logger.info("Backend socket closed");
+                    frontendSocket.destroy();
+                    server.close();
+                    delete this.deviceTcpServers[cacheKey];
+                });
+                appDebugSocket.pipe(frontendSocket);
+                frontendSocket.pipe(appDebugSocket);
+                frontendSocket.resume();
+            }));
+            const socketFileLocation = yield this.$tempService.path({
+                suffix: ".sock",
+            });
+            server.listen(socketFileLocation);
+            if (!this.$options.client) {
+                this.$logger.info("socket-file-location: " + socketFileLocation);
+            }
+            return server;
+        });
+    }
+    ensureWebSocketProxy(device, appId, projectName, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingWebProxy = this.deviceWebServers[`${device.deviceInfo.identifier}-${appId}`];
+            const result = existingWebProxy ||
+                (yield this.addWebSocketProxy(device, appId, projectName, projectDir));
+            this.$logger.info("Opened localhost " + result.options.port);
+            return result;
+        });
+    }
+    addWebSocketProxy(device, appId, projectName, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let clientConnectionLockRelease;
+            const cacheKey = `${device.deviceInfo.identifier}-${appId}`;
+            const existingServer = this.deviceWebServers[cacheKey];
+            if (existingServer) {
+                this.$errors.fail(`Web socket proxy is already running for device '${device.deviceInfo.identifier}' and app '${appId}'`);
+            }
+            const localPort = yield this.$net.getAvailablePortInRange(41000);
+            this.$logger.info("\nSetting up debugger proxy...\nPress Ctrl + C to terminate, or disconnect.\n");
+            let currentAppSocket = null;
+            let currentWebSocket = null;
+            const server = new ws.Server({
+                port: localPort,
+                verifyClient: (info, callback) => __awaiter(this, void 0, void 0, function* () {
+                    let acceptHandshake = true;
+                    clientConnectionLockRelease = null;
+                    try {
+                        clientConnectionLockRelease = yield this.$lockService.lock(`debug-connection-${device.deviceInfo.identifier}-${appId}.lock`);
+                        this.$logger.info("Frontend client connected.");
+                        let appDebugSocket;
+                        if (currentAppSocket) {
+                            currentAppSocket.removeAllListeners();
+                            currentAppSocket = null;
+                            if (currentWebSocket) {
+                                currentWebSocket.removeAllListeners();
+                                currentWebSocket.close();
+                                currentWebSocket = null;
+                            }
+                            yield device.destroyDebugSocket(appId);
+                        }
+                        appDebugSocket = yield device.getDebugSocket(appId, projectName, projectDir);
+                        currentAppSocket = appDebugSocket;
+                        this.$logger.info("Backend socket created.");
+                        info.req["__deviceSocket"] = appDebugSocket;
+                    }
+                    catch (err) {
+                        if (clientConnectionLockRelease) {
+                            clientConnectionLockRelease();
+                        }
+                        err.deviceIdentifier = device.deviceInfo.identifier;
+                        this.$logger.trace(err);
+                        this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, err);
+                        acceptHandshake = false;
+                        this.$logger.warn(`Cannot connect to device socket. The error message is '${err.message}'.`);
+                    }
+                    callback(acceptHandshake);
+                }),
+            });
+            this.deviceWebServers[cacheKey] = server;
+            server.on("connection", (webSocket, req) => {
+                currentWebSocket = webSocket;
+                const encoding = "utf16le";
+                const appDebugSocket = req["__deviceSocket"];
+                const packets = new ios_device_lib_1.MessageUnpackStream();
+                appDebugSocket.pipe(packets);
+                packets.on("data", (buffer) => {
+                    const message = buffer.toString(encoding);
+                    if (webSocket.readyState === webSocket.OPEN) {
+                        if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
+                            console.log({
+                                msgFromRuntime: JSON.parse(message),
+                            });
+                        }
+                        webSocket.send(message);
+                    }
+                    else {
+                        this.$logger.trace(`Received message ${message}, but unable to send it to webSocket as its state is: ${webSocket.readyState}`);
+                    }
+                });
+                webSocket.on("error", (err) => {
+                    this.$logger.trace("Error on debugger websocket", err);
+                });
+                appDebugSocket.on("error", (err) => {
+                    this.$logger.trace("Error on debugger deviceSocket", err);
+                });
+                webSocket.on("message", (message) => {
+                    const msg = message.toString();
+                    if (process.env.DEBUG_DEVTOOLS_SOCKETS) {
+                        console.log({
+                            msgFromDevtools: JSON.parse(msg),
+                        });
+                    }
+                    const length = Buffer.byteLength(msg, encoding);
+                    const payload = Buffer.allocUnsafe(length + 4);
+                    payload.writeInt32BE(length, 0);
+                    payload.write(msg, 4, length, encoding);
+                    appDebugSocket.write(payload);
+                });
+                appDebugSocket.on("close", () => {
+                    currentAppSocket = null;
+                    this.$logger.trace("Backend socket closed!");
+                    webSocket.close();
+                });
+                webSocket.on("close", () => __awaiter(this, void 0, void 0, function* () {
+                    currentWebSocket = null;
+                    this.$logger.trace("Frontend socket closed!");
+                    appDebugSocket.unpipe(packets);
+                    packets.destroy();
+                    yield device.destroyDebugSocket(appId);
+                    if (!this.$options.watch) {
+                        process.exit(0);
+                    }
+                }));
+                clientConnectionLockRelease();
+            });
+            return server;
+        });
+    }
+    removeAllProxies() {
+        let deviceId;
+        for (deviceId in this.deviceWebServers) {
+            this.deviceWebServers[deviceId].close();
+        }
+        for (deviceId in this.deviceTcpServers) {
+            this.deviceTcpServers[deviceId].close();
+        }
+        this.deviceWebServers = {};
+        this.deviceTcpServers = {};
+    }
+}
+exports.AppDebugSocketProxyFactory = AppDebugSocketProxyFactory;
+yok_1.injector.register("appDebugSocketProxyFactory", AppDebugSocketProxyFactory);

package/lib/device-sockets/ios/notification.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSNotification = void 0;
+const events_1 = require("events");
+const constants_1 = require("../../common/constants");
+const yok_1 = require("../../common/yok");
+class IOSNotification extends events_1.EventEmitter {
+    getAttachRequest(appId, deviceId) {
+        this.emit(constants_1.ATTACH_REQUEST_EVENT_NAME, { deviceId, appId });
+        return this.formatNotification(IOSNotification.ATTACH_REQUEST_NOTIFICATION_NAME, appId);
+    }
+    getReadyForAttach(appId) {
+        return this.formatNotification(IOSNotification.READY_FOR_ATTACH_NOTIFICATION_NAME, appId);
+    }
+    getRefreshRequest(appId) {
+        return this.formatNotification(IOSNotification.REFRESH_REQUEST_NOTIFICATION_NAME, appId);
+    }
+    getAppRefreshStarted(appId) {
+        return this.formatNotification(IOSNotification.APP_REFRESH_STARTED_NOTIFICATION_NAME, appId);
+    }
+    formatNotification(notification, appId) {
+        return `${appId}:NativeScript.Debug.${notification}`;
+    }
+}
+IOSNotification.REFRESH_REQUEST_NOTIFICATION_NAME = "RefreshRequest";
+IOSNotification.APP_REFRESH_STARTED_NOTIFICATION_NAME = "AppRefreshStarted";
+IOSNotification.ATTACH_REQUEST_NOTIFICATION_NAME = "AttachRequest";
+IOSNotification.READY_FOR_ATTACH_NOTIFICATION_NAME = "ReadyForAttach";
+exports.IOSNotification = IOSNotification;
+yok_1.injector.register("iOSNotification", IOSNotification);

package/lib/device-sockets/ios/socket-request-executor.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSSocketRequestExecutor = void 0;
+const constants = require("../../common/constants");
+const yok_1 = require("../../common/yok");
+class IOSSocketRequestExecutor {
+    constructor($errors, $iOSNotification, $iOSNotificationService) {
+        this.$errors = $errors;
+        this.$iOSNotification = $iOSNotification;
+        this.$iOSNotificationService = $iOSNotificationService;
+    }
+    executeAttachRequest(device, timeout, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceId = device.deviceInfo.identifier;
+            const mainRequestName = this.$iOSNotification.getAttachRequest(appId, deviceId);
+            const readyRequestName = this.$iOSNotification.getReadyForAttach(appId);
+            yield this.executeRequest(mainRequestName, readyRequestName, appId, deviceId, timeout);
+        });
+    }
+    executeRefreshRequest(device, timeout, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceId = device.deviceInfo.identifier;
+            const mainRequestName = this.$iOSNotification.getRefreshRequest(appId);
+            const refreshRequestStartedName = this.$iOSNotification.getAppRefreshStarted(appId);
+            const result = yield this.executeRequest(mainRequestName, refreshRequestStartedName, appId, deviceId, timeout);
+            return result;
+        });
+    }
+    executeRequest(mainRequestName, successfulyExecutedNotificationName, appId, deviceId, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isSuccessful = false;
+            try {
+                const socket = yield this.$iOSNotificationService.postNotification(deviceId, successfulyExecutedNotificationName, constants.IOS_OBSERVE_NOTIFICATION_COMMAND_TYPE);
+                const notificationPromise = this.$iOSNotificationService.awaitNotification(deviceId, +socket, timeout);
+                yield this.$iOSNotificationService.postNotification(deviceId, mainRequestName);
+                yield notificationPromise;
+                isSuccessful = true;
+            }
+            catch (e) {
+                this.$errors.fail(`The application ${appId} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
+            }
+            return isSuccessful;
+        });
+    }
+}
+exports.IOSSocketRequestExecutor = IOSSocketRequestExecutor;
+yok_1.injector.register("iOSSocketRequestExecutor", IOSSocketRequestExecutor);

package/lib/helpers/android-bundle-validator-helper.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidBundleValidatorHelper = void 0;
+const util = require("util");
+const constants_1 = require("../constants");
+const version_validator_helper_1 = require("./version-validator-helper");
+const semver = require("semver");
+const yok_1 = require("../common/yok");
+class AndroidBundleValidatorHelper extends version_validator_helper_1.VersionValidatorHelper {
+    constructor($projectData, $errors, $options, $projectDataService, $mobileHelper) {
+        super();
+        this.$projectData = $projectData;
+        this.$errors = $errors;
+        this.$options = $options;
+        this.$projectDataService = $projectDataService;
+        this.$mobileHelper = $mobileHelper;
+    }
+    validateNoAab() {
+        if (this.$options.aab) {
+            this.$errors.failWithHelp(constants_1.AndroidBundleValidatorMessages.AAB_NOT_SUPPORTED_BY_COMMNAND_MESSAGE);
+        }
+    }
+    validateRuntimeVersion(projectData) {
+        if (this.$options.aab) {
+            const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, "android");
+            const androidRuntimeVersion = runtimePackage
+                ? runtimePackage.version
+                : "";
+            const shouldThrowError = androidRuntimeVersion &&
+                this.isValidVersion(androidRuntimeVersion) &&
+                this.isVersionLowerThan(androidRuntimeVersion, AndroidBundleValidatorHelper.MIN_RUNTIME_VERSION);
+            if (shouldThrowError) {
+                this.$errors.fail(util.format(constants_1.AndroidBundleValidatorMessages.NOT_SUPPORTED_RUNTIME_VERSION, AndroidBundleValidatorHelper.MIN_RUNTIME_VERSION));
+            }
+        }
+    }
+    validateDeviceApiLevel(device, buildData) {
+        if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+            const androidBuildData = buildData;
+            if (androidBuildData.androidBundle) {
+                if (!!device.deviceInfo.version &&
+                    semver.lt(semver.coerce(device.deviceInfo.version), AndroidBundleValidatorHelper.MIN_ANDROID_WITH_AAB_SUPPORT)) {
+                    this.$errors.fail(util.format(constants_1.AndroidBundleValidatorMessages.NOT_SUPPORTED_ANDROID_VERSION, device.deviceInfo.identifier, device.deviceInfo.version, AndroidBundleValidatorHelper.MIN_ANDROID_WITH_AAB_SUPPORT));
+                }
+            }
+        }
+    }
+}
+AndroidBundleValidatorHelper.MIN_RUNTIME_VERSION = "5.0.0";
+AndroidBundleValidatorHelper.MIN_ANDROID_WITH_AAB_SUPPORT = "4.4.0";
+exports.AndroidBundleValidatorHelper = AndroidBundleValidatorHelper;
+yok_1.injector.register("androidBundleValidatorHelper", AndroidBundleValidatorHelper);

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

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployCommandHelper = void 0;
+const yok_1 = require("../common/yok");
+class DeployCommandHelper {
+    constructor($androidBundleValidatorHelper, $buildDataService, $buildController, $devicesService, $deployController, $options, $projectData) {
+        this.$androidBundleValidatorHelper = $androidBundleValidatorHelper;
+        this.$buildDataService = $buildDataService;
+        this.$buildController = $buildController;
+        this.$devicesService = $devicesService;
+        this.$deployController = $deployController;
+        this.$options = $options;
+        this.$projectData = $projectData;
+    }
+    deploy(platform, additionalOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emulator = this.$options.emulator;
+            yield this.$devicesService.initialize({
+                deviceId: this.$options.device,
+                platform,
+                emulator,
+                skipInferPlatform: !platform,
+                sdk: this.$options.sdk,
+            });
+            const devices = this.$devicesService
+                .getDeviceInstances()
+                .filter((d) => !platform ||
+                d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
+            const deviceDescriptors = devices.map((d) => {
+                const outputPath = additionalOptions &&
+                    additionalOptions.getOutputDirectory &&
+                    additionalOptions.getOutputDirectory({
+                        platform: d.deviceInfo.platform,
+                        emulator: d.isEmulator,
+                        projectDir: this.$projectData.projectDir,
+                    });
+                const buildData = this.$buildDataService.getBuildData(this.$projectData.projectDir, d.deviceInfo.platform, Object.assign(Object.assign({}, this.$options.argv), { outputPath, buildFilterDevicesArch: false, buildForDevice: !d.isEmulator, skipWatcher: !this.$options.watch, nativePrepare: {
+                        skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
+                    } }));
+                this.$androidBundleValidatorHelper.validateDeviceApiLevel(d, buildData);
+                const buildAction = additionalOptions && additionalOptions.buildPlatform
+                    ? additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildData, this.$projectData)
+                    : this.$buildController.build.bind(this.$buildController, buildData);
+                const info = {
+                    identifier: d.deviceInfo.identifier,
+                    buildAction,
+                    debuggingEnabled: additionalOptions &&
+                        additionalOptions.deviceDebugMap &&
+                        additionalOptions.deviceDebugMap[d.deviceInfo.identifier],
+                    debugOptions: this.$options,
+                    skipNativePrepare: additionalOptions && additionalOptions.skipNativePrepare,
+                    buildData,
+                };
+                return info;
+            });
+            yield this.$deployController.deploy({ deviceDescriptors });
+        });
+    }
+}
+exports.DeployCommandHelper = DeployCommandHelper;
+yok_1.injector.register("deployCommandHelper", DeployCommandHelper);

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

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("../color");
+const yok_1 = require("../common/yok");
+class KeyCommandHelper {
+    constructor() {
+        this.platform = "all";
+        this.overrides = {};
+        this.onKeyPressed = (data) => __awaiter(this, void 0, void 0, function* () {
+            const key = data.toString();
+            if (this.keyCommandExecutionBlocked && key !== "\u0003")
+                return;
+            try {
+                const exists = yok_1.injector.getRegisteredKeyCommandsNames().includes(key);
+                if (exists) {
+                    const keyCommand = yok_1.injector.resolveKeyCommand(key);
+                    if (keyCommand.platform === "all" ||
+                        keyCommand.platform === this.platform ||
+                        this.platform === "all") {
+                        if (keyCommand.canExecute &&
+                            !keyCommand.canExecute(this.processType)) {
+                            console.log("blocked execution");
+                            return;
+                        }
+                        if (keyCommand.willBlockKeyCommandExecution)
+                            this.keyCommandExecutionBlocked = true;
+                        if (this.overrides[key]) {
+                            if (!(yield this.overrides[key]())) {
+                                this.keyCommandExecutionBlocked = false;
+                                process.stdin.resume();
+                                return;
+                            }
+                        }
+                        if (keyCommand.key !== "\u0003") {
+                            const line = ` ${color_1.color.dim("→")} ${color_1.color.bold(keyCommand.key)} — ${keyCommand.description}`;
+                            const lineLength = (0, color_1.stripColors)(line).length - 1;
+                            console.log(color_1.color.dim(` ┌${"─".repeat(lineLength)}┐`));
+                            console.log(line + color_1.color.dim(" │"));
+                            console.log(color_1.color.dim(` └${"─".repeat(lineLength)}┘`));
+                            console.log("");
+                        }
+                        const result = yield keyCommand.execute(this.platform);
+                        this.keyCommandExecutionBlocked = false;
+                        if (process.stdin.setRawMode) {
+                            process.stdin.resume();
+                        }
+                        return result;
+                    }
+                }
+                process.stdout.write(key);
+            }
+            catch (e) {
+                const $logger = yok_1.injector.resolve("logger");
+                $logger.error(e.message);
+            }
+        });
+    }
+    addOverride(key, execute) {
+        this.overrides[key] = execute;
+    }
+    removeOverride(key) {
+        this.overrides[key] = undefined;
+    }
+    printCommands(platform) {
+        const commands = yok_1.injector.getRegisteredKeyCommandsNames();
+        const groupings = {};
+        const commandHelp = commands.reduce((arr, key) => {
+            const command = yok_1.injector.resolveKeyCommand(key);
+            if (!command.description ||
+                (command.platform !== "all" &&
+                    command.platform !== platform &&
+                    platform !== "all") ||
+                (command.canExecute && !command.canExecute(this.processType))) {
+                return arr;
+            }
+            else {
+                if (!groupings[command.group]) {
+                    groupings[command.group] = true;
+                    arr.push(` \n${color_1.color.underline(color_1.color.bold(command.group))}\n`);
+                }
+                arr.push(`   ${color_1.color.bold(command.key)} — ${command.description}`);
+                return arr;
+            }
+        }, []);
+        console.info([
+            "",
+            `  The CLI is ${color_1.color.underline(`interactive`)}, you can press the following keys any time (make sure the terminal has focus).`,
+            "",
+            ...commandHelp,
+            "",
+        ].join("\n"));
+    }
+    attachKeyCommands(platform, processType) {
+        this.processType = processType;
+        this.platform = platform;
+        const stdin = process.stdin;
+        if (!stdin.setRawMode) {
+            process.on("message", (key) => {
+                this.onKeyPressed(Buffer.from(key));
+            });
+        }
+        else {
+            stdin.setRawMode(false);
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on("data", this.onKeyPressed);
+        }
+    }
+    detachKeyCommands() {
+        process.stdin.off("data", this.onKeyPressed);
+        process.stdin.setRawMode(false);
+    }
+}
+exports.default = KeyCommandHelper;
+yok_1.injector.register("keyCommandHelper", KeyCommandHelper);