@akylas/nativescript-cli 8.7.2

package/lib/common/mobile/application-manager-base.js

@@ -0,0 +1,136 @@
+"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.ApplicationManagerBase = void 0;
+const events_1 = require("events");
+const constants_1 = require("../constants");
+const _ = require("lodash");
+class ApplicationManagerBase extends events_1.EventEmitter {
+    constructor($logger, $hooksService, $deviceLogProvider) {
+        super();
+        this.$logger = $logger;
+        this.$hooksService = $hooksService;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.lastAvailableDebuggableAppViews = {};
+    }
+    setTransferredAppFiles(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const file of files) {
+                yield this.$deviceLogProvider.setSourceFileLocation(file);
+            }
+        });
+    }
+    reinstallApplication(appIdentifier, packageFilePath, buildData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isApplicationInstalled = yield this.isApplicationInstalled(appIdentifier);
+            if (isApplicationInstalled && (buildData === null || buildData === void 0 ? void 0 : buildData.clean)) {
+                yield this.uninstallApplication(appIdentifier);
+            }
+            yield this.installApplication(packageFilePath, appIdentifier, buildData);
+        });
+    }
+    restartApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.stopApplication(appData);
+            yield this.startApplication(appData);
+        });
+    }
+    isApplicationInstalled(appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.checkForApplicationUpdates();
+            return _.includes(this.lastInstalledAppIdentifiers, appIdentifier);
+        });
+    }
+    checkForApplicationUpdates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.checkForApplicationUpdatesPromise) {
+                this.checkForApplicationUpdatesPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                    let isFulfilled = false;
+                    try {
+                        const currentlyInstalledAppIdentifiers = yield this.getInstalledApplications();
+                        const previouslyInstalledAppIdentifiers = this.lastInstalledAppIdentifiers || [];
+                        const newAppIdentifiers = _.difference(currentlyInstalledAppIdentifiers, previouslyInstalledAppIdentifiers);
+                        const removedAppIdentifiers = _.difference(previouslyInstalledAppIdentifiers, currentlyInstalledAppIdentifiers);
+                        this.lastInstalledAppIdentifiers = currentlyInstalledAppIdentifiers;
+                        _.each(newAppIdentifiers, (appIdentifier) => this.emit("applicationInstalled", appIdentifier));
+                        _.each(removedAppIdentifiers, (appIdentifier) => this.emit("applicationUninstalled", appIdentifier));
+                        yield this.checkForAvailableDebuggableAppsChanges();
+                    }
+                    catch (err) {
+                        isFulfilled = true;
+                        reject(err);
+                    }
+                    finally {
+                        this.checkForApplicationUpdatesPromise = null;
+                        if (!isFulfilled) {
+                            resolve();
+                        }
+                    }
+                }));
+            }
+            return this.checkForApplicationUpdatesPromise;
+        });
+    }
+    tryStartApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.startApplication(appData);
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to start application ${appData.appId} with name ${appData.projectName}. Error is: ${err.message}`);
+            }
+        });
+    }
+    checkForAvailableDebuggableAppsChanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentlyAvailableDebuggableApps = yield this.getDebuggableApps();
+            const previouslyAvailableDebuggableApps = this.lastAvailableDebuggableApps || [];
+            const newAvailableDebuggableApps = _.differenceBy(currentlyAvailableDebuggableApps, previouslyAvailableDebuggableApps, "appIdentifier");
+            const notAvailableAppsForDebugging = _.differenceBy(previouslyAvailableDebuggableApps, currentlyAvailableDebuggableApps, "appIdentifier");
+            this.lastAvailableDebuggableApps = currentlyAvailableDebuggableApps;
+            _.each(newAvailableDebuggableApps, (appInfo) => {
+                this.emit("debuggableAppFound", appInfo);
+            });
+            _.each(notAvailableAppsForDebugging, (appInfo) => {
+                this.emit("debuggableAppLost", appInfo);
+                if (_.has(this.lastAvailableDebuggableAppViews, appInfo.appIdentifier)) {
+                    delete this.lastAvailableDebuggableAppViews[appInfo.appIdentifier];
+                }
+            });
+            const cordovaDebuggableAppIdentifiers = _(currentlyAvailableDebuggableApps)
+                .filter((c) => c.framework === constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova)
+                .map((c) => c.appIdentifier)
+                .value();
+            const currentlyAvailableAppViews = yield this.getDebuggableAppViews(cordovaDebuggableAppIdentifiers);
+            _.each(currentlyAvailableAppViews, (currentlyAvailableViews, appIdentifier) => {
+                const previouslyAvailableViews = this.lastAvailableDebuggableAppViews[appIdentifier];
+                const newAvailableViews = _.differenceBy(currentlyAvailableViews, previouslyAvailableViews, "id");
+                const notAvailableViews = _.differenceBy(previouslyAvailableViews, currentlyAvailableViews, "id");
+                _.each(notAvailableViews, (debugWebViewInfo) => {
+                    this.emit("debuggableViewLost", appIdentifier, debugWebViewInfo);
+                });
+                _.each(newAvailableViews, (debugWebViewInfo) => {
+                    this.emit("debuggableViewFound", appIdentifier, debugWebViewInfo);
+                });
+                const keptViews = _.differenceBy(currentlyAvailableViews, newAvailableViews, "id");
+                _.each(keptViews, (view) => {
+                    const previousTimeViewInfo = _.find(previouslyAvailableViews, (previousView) => previousView.id === view.id);
+                    if (!_.isEqual(view, previousTimeViewInfo)) {
+                        this.emit("debuggableViewChanged", appIdentifier, view);
+                    }
+                });
+                this.lastAvailableDebuggableAppViews[appIdentifier] =
+                    currentlyAvailableViews;
+            });
+        });
+    }
+}
+exports.ApplicationManagerBase = ApplicationManagerBase;

package/lib/common/mobile/device-emitter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceEmitter = void 0;
+const events_1 = require("events");
+const constants_1 = require("../constants");
+const yok_1 = require("../yok");
+class DeviceEmitter extends events_1.EventEmitter {
+    constructor($deviceLogProvider, $devicesService) {
+        super();
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$devicesService = $devicesService;
+        this.initialize();
+    }
+    initialize() {
+        this.$devicesService.on(constants_1.DeviceDiscoveryEventNames.DEVICE_FOUND, (device) => {
+            this.emit(constants_1.DeviceDiscoveryEventNames.DEVICE_FOUND, device.deviceInfo);
+            this.attachApplicationChangedHandlers(device);
+            device.openDeviceLogStream();
+        });
+        this.$devicesService.on(constants_1.DeviceDiscoveryEventNames.DEVICE_LOST, (device) => {
+            this.emit(constants_1.DeviceDiscoveryEventNames.DEVICE_LOST, device.deviceInfo);
+        });
+        this.$devicesService.on(constants_1.DeviceDiscoveryEventNames.DEVICE_UPDATED, (device) => {
+            this.emit(constants_1.DeviceDiscoveryEventNames.DEVICE_UPDATED, device.deviceInfo);
+        });
+        this.$deviceLogProvider.on("data", (identifier, data) => {
+            this.emit(constants_1.DEVICE_LOG_EVENT_NAME, identifier, data.toString());
+        });
+        this.$devicesService.on(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_FOUND, (emulator) => {
+            this.emit(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_FOUND, emulator);
+        });
+        this.$devicesService.on(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_LOST, (emulator) => {
+            this.emit(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_LOST, emulator);
+        });
+    }
+    attachApplicationChangedHandlers(device) {
+        device.applicationManager.on("applicationInstalled", (appIdentifier) => {
+            this.emit("applicationInstalled", device.deviceInfo.identifier, appIdentifier);
+        });
+        device.applicationManager.on("applicationUninstalled", (appIdentifier) => {
+            this.emit("applicationUninstalled", device.deviceInfo.identifier, appIdentifier);
+        });
+        device.applicationManager.on("debuggableAppFound", (debuggableAppInfo) => {
+            this.emit("debuggableAppFound", debuggableAppInfo);
+        });
+        device.applicationManager.on("debuggableAppLost", (debuggableAppInfo) => {
+            this.emit("debuggableAppLost", debuggableAppInfo);
+        });
+        device.applicationManager.on("debuggableViewFound", (appIdentifier, debuggableWebViewInfo) => {
+            this.emit("debuggableViewFound", device.deviceInfo.identifier, appIdentifier, debuggableWebViewInfo);
+        });
+        device.applicationManager.on("debuggableViewLost", (appIdentifier, debuggableWebViewInfo) => {
+            this.emit("debuggableViewLost", device.deviceInfo.identifier, appIdentifier, debuggableWebViewInfo);
+        });
+        device.applicationManager.on("debuggableViewChanged", (appIdentifier, debuggableWebViewInfo) => {
+            this.emit("debuggableViewChanged", device.deviceInfo.identifier, appIdentifier, debuggableWebViewInfo);
+        });
+    }
+}
+exports.DeviceEmitter = DeviceEmitter;
+yok_1.injector.register("deviceEmitter", DeviceEmitter);

package/lib/common/mobile/device-log-emitter.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceLogEmitter = void 0;
+const device_log_provider_base_1 = require("./device-log-provider-base");
+const constants_1 = require("../constants");
+const yok_1 = require("../yok");
+const _ = require("lodash");
+class DeviceLogEmitter extends device_log_provider_base_1.DeviceLogProviderBase {
+    constructor($logFilter, $logger, $loggingLevels, $logSourceMapService) {
+        super($logFilter, $logger, $logSourceMapService);
+        this.$logFilter = $logFilter;
+        this.$loggingLevels = $loggingLevels;
+        this.$logSourceMapService = $logSourceMapService;
+    }
+    logData(line, platform, deviceIdentifier) {
+        this.setDefaultLogLevelForDevice(deviceIdentifier);
+        const loggingOptions = this.getDeviceLogOptionsForDevice(deviceIdentifier) || { logLevel: this.$loggingLevels.info, projectDir: null };
+        let data = this.$logFilter.filterData(platform, line, loggingOptions);
+        data = this.$logSourceMapService.replaceWithOriginalFileLocations(platform, data, loggingOptions);
+        if (data) {
+            this.emit("data", deviceIdentifier, data);
+            this.emit(constants_1.DEVICE_LOG_EVENT_NAME, data, deviceIdentifier, platform);
+        }
+    }
+    setLogLevel(logLevel, deviceIdentifier) {
+        if (deviceIdentifier) {
+            this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.logLevel, logLevel.toUpperCase());
+        }
+        else {
+            this.$logFilter.loggingLevel = logLevel.toUpperCase();
+            _.keys(this.devicesLogOptions).forEach((deviceId) => {
+                this.devicesLogOptions[deviceId] =
+                    this.devicesLogOptions[deviceId] || {};
+                this.devicesLogOptions[deviceId].logLevel = this.$logFilter.loggingLevel;
+            });
+        }
+    }
+}
+exports.DeviceLogEmitter = DeviceLogEmitter;
+yok_1.injector.register("deviceLogProvider", DeviceLogEmitter);

package/lib/common/mobile/device-log-provider-base.js

@@ -0,0 +1,76 @@
+"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.DeviceLogProviderBase = void 0;
+const events_1 = require("events");
+const helpers_1 = require("../helpers");
+class DeviceLogProviderBase extends events_1.EventEmitter {
+    constructor($logFilter, $logger, $logSourceMapService) {
+        super();
+        this.$logFilter = $logFilter;
+        this.$logger = $logger;
+        this.$logSourceMapService = $logSourceMapService;
+        this.devicesLogOptions = {};
+    }
+    setSourceFileLocation(pathToOriginalFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.$logSourceMapService.setSourceMapConsumerForFile(pathToOriginalFile);
+            }
+            catch (err) {
+                this.$logger.trace("Error while trying to set source map file", err);
+            }
+        });
+    }
+    setApplicationPidForDevice(deviceIdentifier, pid) {
+        this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.applicationPid, pid);
+    }
+    setApplicationIdForDevice(deviceIdentifier, appId) {
+        this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.applicationId, appId);
+    }
+    setProjectNameForDevice(deviceIdentifier, projectName) {
+        this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.projectName, projectName);
+    }
+    setProjectDirForDevice(deviceIdentifier, projectDir) {
+        this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions) => deviceLogOptions.projectDir, projectDir);
+    }
+    setDefaultLogLevelForDevice(deviceIdentifier) {
+        const logLevel = (this.devicesLogOptions[deviceIdentifier] &&
+            this.devicesLogOptions[deviceIdentifier].logLevel) ||
+            this.$logFilter.loggingLevel;
+        this.setLogLevel(logLevel, deviceIdentifier);
+    }
+    getApplicationPidForDevice(deviceIdentifier) {
+        return (this.devicesLogOptions[deviceIdentifier] &&
+            this.devicesLogOptions[deviceIdentifier].applicationPid);
+    }
+    getApplicationIdForDevice(deviceIdentifier) {
+        return (this.devicesLogOptions[deviceIdentifier] &&
+            this.devicesLogOptions[deviceIdentifier].applicationId);
+    }
+    getDeviceLogOptionsForDevice(deviceIdentifier) {
+        const loggingOptions = this.devicesLogOptions[deviceIdentifier];
+        if (!loggingOptions) {
+            this.setDefaultLogLevelForDevice(deviceIdentifier);
+        }
+        return this.devicesLogOptions[deviceIdentifier];
+    }
+    setDeviceLogOptionsProperty(deviceIdentifier, propNameFunction, propertyValue) {
+        const propertyName = (0, helpers_1.getPropertyName)(propNameFunction);
+        if (propertyName) {
+            this.devicesLogOptions[deviceIdentifier] =
+                this.devicesLogOptions[deviceIdentifier] ||
+                    {};
+            this.devicesLogOptions[deviceIdentifier][propertyName] = propertyValue;
+        }
+    }
+}
+exports.DeviceLogProviderBase = DeviceLogProviderBase;

package/lib/common/mobile/device-log-provider.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceLogProvider = void 0;
+const device_log_provider_base_1 = require("./device-log-provider-base");
+const constants_1 = require("../constants");
+const yok_1 = require("../yok");
+const constants_2 = require("../../constants");
+const color_1 = require("../../color");
+class DeviceLogProvider extends device_log_provider_base_1.DeviceLogProviderBase {
+    constructor($logFilter, $logger, $logSourceMapService, $timelineProfilerService, $options) {
+        super($logFilter, $logger, $logSourceMapService);
+        this.$logFilter = $logFilter;
+        this.$logger = $logger;
+        this.$logSourceMapService = $logSourceMapService;
+        this.$timelineProfilerService = $timelineProfilerService;
+        this.$options = $options;
+        this.consoleLogLevelRegex = /^CONSOLE (LOG|INFO|WARN|ERROR|TRACE|INFO( .+)|TIME):\s/;
+        this.consoleLevelColor = {
+            log: (line) => line,
+            info: color_1.color.cyanBright,
+            warn: color_1.color.yellowBright,
+            error: color_1.color.redBright,
+            trace: color_1.color.grey,
+            time: color_1.color.greenBright,
+        };
+        this.deviceColorMap = new Map();
+        this.colorPool = [
+            "bgBlackBright",
+            "bgMagentaBright",
+            "bgBlueBright",
+            "bgWhiteBright",
+            "bgCyanBright",
+            "bgYellowBright",
+            "bgGreenBright",
+        ];
+        this.colorPoolIndex = 0;
+    }
+    logData(lineText, platform, deviceIdentifier) {
+        const loggingOptions = this.getDeviceLogOptionsForDevice(deviceIdentifier);
+        let data = this.$logFilter.filterData(platform, lineText, loggingOptions);
+        data = this.$logSourceMapService.replaceWithOriginalFileLocations(platform, data, loggingOptions);
+        if (data) {
+            this.$timelineProfilerService.processLogData(data, deviceIdentifier);
+            this.logDataCore(data, deviceIdentifier);
+            this.emit(constants_1.DEVICE_LOG_EVENT_NAME, lineText, deviceIdentifier, platform);
+        }
+    }
+    setLogLevel(logLevel, deviceIdentifier) {
+        this.$logFilter.loggingLevel = logLevel.toUpperCase();
+    }
+    getDeviceColor(deviceIdentifier) {
+        if (this.deviceColorMap.has(deviceIdentifier)) {
+            return this.deviceColorMap.get(deviceIdentifier);
+        }
+        const color = this.colorPool[this.colorPoolIndex];
+        this.colorPoolIndex =
+            this.colorPoolIndex === this.colorPool.length - 1
+                ? 0
+                : this.colorPoolIndex + 1;
+        this.deviceColorMap.set(deviceIdentifier, color);
+        return color;
+    }
+    logDataCore(data, deviceIdentifier) {
+        var _a, _b, _c;
+        if ("classicLogs" in ((_a = this.$options.env) !== null && _a !== void 0 ? _a : {})) {
+            this.$logger.info(data, { [constants_2.LoggerConfigData.skipNewLine]: true });
+            return;
+        }
+        let shouldPrepend = false;
+        let splitIndexes = [];
+        const lines = data
+            .split(/\n(CONSOLE)/)
+            .map((line, index, lines) => {
+            if (line === "CONSOLE") {
+                shouldPrepend = true;
+                if (lines[index - 1]) {
+                    splitIndexes.push(index - 1);
+                }
+                return null;
+            }
+            if (shouldPrepend) {
+                shouldPrepend = false;
+                return `CONSOLE${line}`;
+            }
+            const suffix = line.endsWith("\n") ? "" : "\n";
+            return line + suffix;
+        })
+            .map((line, index) => {
+            if (splitIndexes.includes(index)) {
+                return line + "\n";
+            }
+            return line;
+        })
+            .filter((line) => {
+            return line !== null;
+        });
+        if (!lines.length && data.length) {
+            lines.push(data);
+        }
+        for (const line of lines) {
+            let [match, level, timeLabel] = (_b = this.consoleLogLevelRegex.exec(line)) !== null && _b !== void 0 ? _b : [];
+            if (timeLabel) {
+                level = "time";
+                timeLabel = timeLabel.replace("INFO ", "").trim() + ": ";
+            }
+            else if (!level && line.startsWith("Trace:")) {
+                level = "trace";
+            }
+            else {
+                level = (_c = level === null || level === void 0 ? void 0 : level.toLowerCase()) !== null && _c !== void 0 ? _c : "log";
+            }
+            const toLog = [timeLabel !== null && timeLabel !== void 0 ? timeLabel : "", match ? line.replace(match, "") : line]
+                .join("")
+                .trimEnd();
+            toLog.split("\n").forEach((actualLine) => {
+                this.printLine(color_1.color[this.getDeviceColor(deviceIdentifier)](" "), this.consoleLevelColor[level](actualLine));
+            });
+        }
+    }
+    printLine(prefix, ...parts) {
+        const fullLine = parts.join(" ");
+        console.log(prefix, fullLine);
+    }
+}
+exports.DeviceLogProvider = DeviceLogProvider;
+yok_1.injector.register("deviceLogProvider", DeviceLogProvider);

package/lib/common/mobile/device-platforms-constants.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePlatformsConstants = void 0;
+const yok_1 = require("../yok");
+class DevicePlatformsConstants {
+    constructor() {
+        this.iOS = "iOS";
+        this.Android = "Android";
+        this.visionOS = "visionOS";
+    }
+    isiOS(value) {
+        return value.toLowerCase() === this.iOS.toLowerCase();
+    }
+    isAndroid(value) {
+        return value.toLowerCase() === this.Android.toLowerCase();
+    }
+    isvisionOS(value) {
+        return value.toLowerCase() === this.visionOS.toLowerCase();
+    }
+}
+exports.DevicePlatformsConstants = DevicePlatformsConstants;
+yok_1.injector.register("devicePlatformsConstants", DevicePlatformsConstants);

package/lib/common/mobile/emulator-helper.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmulatorHelper = void 0;
+const constants_1 = require("../constants");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class EmulatorHelper {
+    constructor() {
+        this.mapAndroidApiLevelToVersion = {
+            "android-34": "14.0.0",
+            "android-33": "13.0.0",
+            "android-32": "12.0.0",
+            "android-31": "12.0.0",
+            "android-30": "11.0.0",
+            "android-29": "10.0.0",
+            "android-28": "9.0.0",
+            "android-27": "8.1.0",
+            "android-26": "8.0.0",
+            "android-25": "7.1.1",
+            "android-24": "7.0.0",
+            "android-23": "6.0.0",
+            "android-22": "5.1.0",
+            "android-21": "5.0.0",
+            "android-20": "4.4.0",
+            "android-19": "4.4.0",
+            "android-18": "4.3.0",
+            "android-17": "4.2.2",
+        };
+    }
+    getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput) {
+        return _(availableEmulatorsOutput)
+            .valuesIn()
+            .map((value) => value.devices)
+            .concat()
+            .flatten()
+            .value();
+    }
+    getErrorsFromAvailableEmulatorsOutput(availableEmulatorsOutput) {
+        return _(availableEmulatorsOutput)
+            .valuesIn()
+            .map((value) => value.errors)
+            .concat()
+            .flatten()
+            .value();
+    }
+    getEmulatorByImageIdentifier(imageIdentifier, emulators) {
+        const imagerIdentifierLowerCase = imageIdentifier && imageIdentifier.toLowerCase();
+        return _.find(emulators, (emulator) => emulator &&
+            emulator.imageIdentifier &&
+            imageIdentifier &&
+            emulator.imageIdentifier.toLowerCase() === imagerIdentifierLowerCase);
+    }
+    getEmulatorByIdOrName(emulatorIdOrName, emulators) {
+        const emulatorIdOrNameLowerCase = emulatorIdOrName && emulatorIdOrName.toLowerCase();
+        return _.find(emulators, (emulator) => emulator &&
+            emulatorIdOrNameLowerCase &&
+            ((emulator.identifier &&
+                emulator.identifier.toLowerCase() === emulatorIdOrNameLowerCase) ||
+                emulator.displayName.toLowerCase() === emulatorIdOrNameLowerCase));
+    }
+    isEmulatorRunning(emulator) {
+        return emulator && emulator.status === constants_1.RUNNING_EMULATOR_STATUS;
+    }
+    getEmulatorByStartEmulatorOptions(options, emulators) {
+        let result = null;
+        if (options.emulator) {
+            result = options.emulator;
+        }
+        if (!result && options.imageIdentifier) {
+            result = this.getEmulatorByImageIdentifier(options.imageIdentifier, emulators);
+        }
+        if (!result && options.emulatorIdOrName) {
+            result = this.getEmulatorByIdOrName(options.emulatorIdOrName, emulators);
+        }
+        return result;
+    }
+    setRunningAndroidEmulatorProperties(emulatorId, emulator) {
+        emulator.identifier = emulatorId;
+        emulator.status = constants_1.RUNNING_EMULATOR_STATUS;
+        emulator.type = constants_1.DeviceTypes.Device;
+    }
+}
+exports.EmulatorHelper = EmulatorHelper;
+yok_1.injector.register("emulatorHelper", EmulatorHelper);