@akylas/nativescript-cli 8.7.2

package/lib/common/mobile/ios/ios-device-base.js

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.IOSDeviceBase = void 0;
+const decorators_1 = require("../../decorators");
+class IOSDeviceBase {
+    constructor() {
+        this.cachedSockets = {};
+    }
+    getDebugSocket(appId, projectName, projectDir, ensureAppStarted = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$lockService.executeActionWithLock(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.cachedSockets[appId]) {
+                    return this.cachedSockets[appId];
+                }
+                yield this.attachToDebuggerFoundEvent(appId, projectName, projectDir);
+                try {
+                    if (ensureAppStarted) {
+                        yield this.applicationManager.startApplication({
+                            appId,
+                            projectName,
+                            projectDir,
+                        });
+                    }
+                }
+                catch (err) {
+                    this.$logger.trace(`Unable to start application ${appId} on device ${this.deviceInfo.identifier} in getDebugSocket method. Error is: ${err}`);
+                }
+                this.cachedSockets[appId] = yield this.getDebugSocketCore(appId);
+                if (this.cachedSockets[appId]) {
+                    this.cachedSockets[appId].on("close", () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.destroyDebugSocket(appId);
+                    }));
+                }
+                return this.cachedSockets[appId];
+            }), `ios-debug-socket-${this.deviceInfo.identifier}-${appId}.lock`);
+        });
+    }
+    attachToDebuggerFoundEvent(appId, projectName, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.startDeviceLogProcess(projectName, projectDir);
+            yield this.$iOSDebuggerPortService.attachToDebuggerPortFoundEvent(appId);
+        });
+    }
+    getDebuggerPort(appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = yield this.$iOSDebuggerPortService.getPort({
+                deviceId: this.deviceInfo.identifier,
+                appId,
+            });
+            if (!port) {
+                this.$errors.fail("Device socket port cannot be found.");
+            }
+            return port;
+        });
+    }
+    destroyAllSockets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const appId in this.cachedSockets) {
+                yield this.destroySocketSafe(this.cachedSockets[appId]);
+            }
+            this.cachedSockets = {};
+        });
+    }
+    destroyDebugSocket(appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.destroySocketSafe(this.cachedSockets[appId]);
+            this.cachedSockets[appId] = null;
+        });
+    }
+    destroySocketSafe(socket) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (socket && !socket.destroyed) {
+                return new Promise((resolve, reject) => {
+                    socket.on("close", resolve);
+                    socket.destroy();
+                });
+            }
+        });
+    }
+    startDeviceLogProcess(projectName, projectDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (projectName) {
+                this.$deviceLogProvider.setProjectNameForDevice(this.deviceInfo.identifier, projectName);
+                this.$deviceLogProvider.setProjectDirForDevice(this.deviceInfo.identifier, projectDir);
+            }
+            yield this.openDeviceLogStream();
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSDeviceBase.prototype, "getDebugSocket", null);
+exports.IOSDeviceBase = IOSDeviceBase;

package/lib/common/mobile/ios/ios-device-product-name-mapper.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("../../yok");
+class IosDeviceProductNameMapper {
+    constructor() {
+        this.map = {
+            "iPhone1,1": "iPhone",
+            "iPhone1,2": "iPhone 3G",
+            "iPhone2,1": "iPhone 3GS",
+            "iPhone3,1": "iPhone 4 (GSM)",
+            "iPhone3,3": "iPhone 4 (CDMA)",
+            "iPhone4,1": "iPhone 4S",
+            "iPhone5,1": "iPhone 5 (A1428)",
+            "iPhone5,2": "iPhone 5 (A1429)",
+            "iPhone5,3": "iPhone 5c (A1456/A1532)",
+            "iPhone5,4": "iPhone 5c (A1507/A1516/A1529)",
+            "iPhone6,1": "iPhone 5s (A1433/A1453)",
+            "iPhone6,2": "iPhone 5s (A1457/A1518/A1530)",
+            "iPhone7,1": "iPhone 6 Plus",
+            "iPhone7,2": "iPhone 6",
+            "iPhone8,1": "iPhone 6s",
+            "iPhone8,2": "iPhone 6s Plus",
+            "iPad1,1": "iPad",
+            "iPad2,1": "iPad 2 (Wi-Fi)",
+            "iPad2,2": "iPad 2 (GSM)",
+            "iPad2,3": "iPad 2 (CDMA)",
+            "iPad2,4": "iPad 2 (Wi-Fi, revised)",
+            "iPad2,5": "iPad mini (Wi-Fi)",
+            "iPad2,6": "iPad mini (A1454)",
+            "iPad2,7": "iPad mini (A1455)",
+            "iPad3,1": "iPad (3rd gen, Wi-Fi)",
+            "iPad3,2": "iPad (3rd gen, Wi-Fi+LTE Verizon)",
+            "iPad3,3": "iPad (3rd gen, Wi-Fi+LTE AT&T)",
+            "iPad3,4": "iPad (4th gen, Wi-Fi)",
+            "iPad3,5": "iPad (4th gen, A1459)",
+            "iPad3,6": "iPad (4th gen, A1460)",
+            "iPad4,1": "iPad Air (Wi-Fi)",
+            "iPad4,2": "iPad Air (Wi-Fi+LTE)",
+            "iPad4,3": "iPad Air (Rev)",
+            "iPad4,4": "iPad mini 2 (Wi-Fi)",
+            "iPad4,5": "iPad mini 2 (Wi-Fi+LTE)",
+            "iPad4,6": "iPad mini 2 (Rev)",
+            "iPad4,7": "iPad mini 3 (Wi-Fi)",
+            "iPad4,8": "iPad mini 3 (A1600)",
+            "iPad4,9": "iPad mini 3 (A1601)",
+            "iPad5,1": "iPad mini 4 (Wi-Fi)",
+            "iPad5,2": "iPad mini 4 (Wi-Fi+LTE)",
+            "iPad5,3": "iPad Air 2 (Wi-Fi)",
+            "iPad5,4": "iPad Air 2 (Wi-Fi+LTE)",
+            "iPad6,7": "iPad Pro (Wi-Fi)",
+            "iPad6,8": "iPad Pro (Wi-Fi+LTE)",
+            "iPod1,1": "iPod touch",
+            "iPod2,1": "iPod touch (2nd gen)",
+            "iPod3,1": "iPod touch (3rd gen)",
+            "iPod4,1": "iPod touch (4th gen)",
+            "iPod5,1": "iPod touch (5th gen)",
+            "iPod7,1": "iPod touch (6th gen)",
+            "RealityDevice14,1": "Vision Pro (1st gen)",
+        };
+    }
+    resolveProductName(deviceType) {
+        return this.map[deviceType];
+    }
+}
+yok_1.injector.register("iOSDeviceProductNameMapper", IosDeviceProductNameMapper);

package/lib/common/mobile/ios/ios-log-filter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSLogFilter = void 0;
+const yok_1 = require("../../yok");
+class IOSLogFilter {
+    constructor($loggingLevels) {
+        this.$loggingLevels = $loggingLevels;
+        this.infoFilterRegex = /^.*?(AppBuilder|Cordova|NativeScript).*?(<Notice>:.*?|<Warning>:.*?|<Error>:.*?)$/im;
+    }
+    filterData(data, loggingOptions = {}) {
+        const specifiedLogLevel = (loggingOptions.logLevel || "").toUpperCase();
+        const pid = loggingOptions && loggingOptions.applicationPid;
+        if (specifiedLogLevel === this.$loggingLevels.info && data) {
+            if (pid) {
+                return data.indexOf(`[${pid}]`) !== -1 ? data.trim() : null;
+            }
+            const matchingInfoMessage = data.match(this.infoFilterRegex);
+            return matchingInfoMessage ? matchingInfoMessage[2] : null;
+        }
+        return data;
+    }
+}
+exports.IOSLogFilter = IOSLogFilter;
+yok_1.injector.register("iOSLogFilter", IOSLogFilter);

package/lib/common/mobile/ios/simulator/ios-emulator-services.js

@@ -0,0 +1,139 @@
+"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 net = require("net");
+const _ = require("lodash");
+const constants_1 = require("../../../constants");
+const constants_2 = require("../../../../constants");
+const yok_1 = require("../../../yok");
+class IosEmulatorServices {
+    constructor($logger, $devicePlatformsConstants, $iOSSimResolver, $mobileHelper) {
+        this.$logger = $logger;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$iOSSimResolver = $iOSSimResolver;
+        this.$mobileHelper = $mobileHelper;
+    }
+    startEmulator(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let error = null;
+            try {
+                if (options.platform === this.$devicePlatformsConstants.visionOS &&
+                    !options.emulatorIdOrName) {
+                    const { devices } = yield this.tryGetiOSSimDevices();
+                    options.emulatorIdOrName = (_a = devices.find((device) => device.platform === this.$devicePlatformsConstants.visionOS)) === null || _a === void 0 ? void 0 : _a.id;
+                }
+                yield this.$iOSSimResolver.iOSSim.startSimulator({
+                    device: options.imageIdentifier || options.emulatorIdOrName,
+                    state: "None",
+                    sdkVersion: options.sdk,
+                });
+            }
+            catch (err) {
+                error = err && err.message;
+            }
+            return {
+                errors: error ? [error] : [],
+            };
+        });
+    }
+    getRunningEmulator() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    getRunningEmulatorIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getRunningEmulatorName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "";
+        });
+    }
+    getRunningEmulatorImageIdentifier(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "";
+        });
+    }
+    postDarwinNotification(notification, deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$iOSSimResolver.iOSSim.sendNotification(notification, deviceId);
+        });
+    }
+    connectToPort(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const socket = net.connect(data.port, "127.0.0.1");
+                return socket;
+            }
+            catch (e) {
+                this.$logger.trace(e);
+            }
+        });
+    }
+    getEmulatorImages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let devices = [];
+            const errors = [];
+            const output = yield this.tryGetiOSSimDevices();
+            if (output.devices && output.devices.length) {
+                devices = _(output.devices)
+                    .map((simDevice) => this.convertSimDeviceToDeviceInfo(simDevice))
+                    .sortBy((deviceInfo) => deviceInfo.version)
+                    .value();
+            }
+            if (output.error) {
+                errors.push(output.error);
+            }
+            return { devices, errors };
+        });
+    }
+    getRunningEmulators() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    tryGetiOSSimDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let devices = [];
+            let error = null;
+            try {
+                devices = yield this.$iOSSimResolver.iOSSim.getDevices();
+            }
+            catch (err) {
+                error = err;
+            }
+            return { devices, error };
+        });
+    }
+    convertSimDeviceToDeviceInfo(simDevice) {
+        var _a;
+        return {
+            imageIdentifier: simDevice.id,
+            identifier: simDevice.id,
+            displayName: simDevice.name,
+            model: simDevice.name,
+            version: simDevice.runtimeVersion,
+            vendor: constants_1.APPLE_VENDOR_NAME,
+            status: simDevice.state && simDevice.state.toLowerCase() === "booted"
+                ? constants_1.RUNNING_EMULATOR_STATUS
+                : constants_1.NOT_RUNNING_EMULATOR_STATUS,
+            errorHelp: null,
+            isTablet: this.$mobileHelper.isiOSTablet(simDevice.name),
+            type: constants_1.DeviceTypes.Emulator,
+            connectionTypes: [constants_2.DeviceConnectionType.Local],
+            platform: (_a = simDevice.platform) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS,
+        };
+    }
+}
+yok_1.injector.register("iOSEmulatorServices", IosEmulatorServices);

package/lib/common/mobile/ios/simulator/ios-sim-resolver.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSSimResolver = void 0;
+const path = require("path");
+const yok_1 = require("../../../yok");
+class IOSSimResolver {
+    constructor() {
+        this._iOSSim = null;
+    }
+    get iOSSim() {
+        if (!this._iOSSim) {
+            this._iOSSim = require(IOSSimResolver.iOSSimName);
+        }
+        return this._iOSSim;
+    }
+    get iOSSimPath() {
+        return path.join(require.resolve(IOSSimResolver.iOSSimName), "..", IOSSimResolver.iOSStandaloneExecutableName);
+    }
+}
+IOSSimResolver.iOSSimName = "ios-sim-portable";
+IOSSimResolver.iOSStandaloneExecutableName = "ios-sim-standalone.js";
+exports.IOSSimResolver = IOSSimResolver;
+yok_1.injector.register("iOSSimResolver", IOSSimResolver);

package/lib/common/mobile/ios/simulator/ios-simulator-application-manager.js

@@ -0,0 +1,147 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.IOSSimulatorApplicationManager = void 0;
+const application_manager_base_1 = require("../../application-manager-base");
+const helpers_1 = require("../../../helpers");
+const decorators_1 = require("../../../decorators");
+const constants_1 = require("../../../constants");
+const path = require("path");
+const log4js = require("log4js");
+const _ = require("lodash");
+class IOSSimulatorApplicationManager extends application_manager_base_1.ApplicationManagerBase {
+    constructor($childProcess, iosSim, device, $options, $fs, $deviceLogProvider, $tempService, $logger, $hooksService) {
+        super($logger, $hooksService, $deviceLogProvider);
+        this.$childProcess = $childProcess;
+        this.iosSim = iosSim;
+        this.device = device;
+        this.$options = $options;
+        this.$fs = $fs;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$tempService = $tempService;
+        this._lldbProcesses = {};
+    }
+    getInstalledApplications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.iosSim.getInstalledApplications(this.device.deviceInfo.identifier);
+        });
+    }
+    installApplication(packageFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$fs.exists(packageFilePath) &&
+                path.extname(packageFilePath) === ".zip") {
+                const dir = yield this.$tempService.mkdirSync("simulatorPackage");
+                yield this.$fs.unzip(packageFilePath, dir);
+                const app = _.find(this.$fs.readDirectory(dir), (directory) => path.extname(directory) === ".app");
+                if (app) {
+                    packageFilePath = path.join(dir, app);
+                }
+            }
+            yield this.iosSim.installApplication(this.device.deviceInfo.identifier, packageFilePath);
+        });
+    }
+    uninstallApplication(appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.detachNativeDebugger(appIdentifier);
+            return this.iosSim.uninstallApplication(this.device.deviceInfo.identifier, appIdentifier);
+        });
+    }
+    startApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = process.env.IOS_SIMULATOR_RUN_ARGS || "";
+            const options = appData.waitForDebugger
+                ? {
+                    waitForDebugger: true,
+                    args: `--nativescript-debug-brk ${args}`.trim(),
+                }
+                : args
+                    ? { args }
+                    : {};
+            yield this.setDeviceLogData(appData);
+            const launchResult = yield this.iosSim.startApplication(this.device.deviceInfo.identifier, appData.appId, options);
+            const pid = (0, helpers_1.getPidFromiOSSimulatorLogs)(appData.appId, launchResult);
+            this.$deviceLogProvider.setApplicationPidForDevice(this.device.deviceInfo.identifier, pid);
+            if (appData.waitForDebugger) {
+                this.attachNativeDebugger(appData.appId, pid);
+            }
+        });
+    }
+    stopApplication(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { appId } = appData;
+            yield this.device.destroyDebugSocket(appId);
+            yield this.detachNativeDebugger(appId);
+            yield this.iosSim.stopApplication(this.device.deviceInfo.identifier, appData.appId, appData.projectName);
+        });
+    }
+    getDebuggableApps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getDebuggableAppViews(appIdentifiers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(null);
+        });
+    }
+    attachNativeDebugger(appId, pid) {
+        this._lldbProcesses[appId] = this.$childProcess.spawn("lldb", ["-p", pid]);
+        if (log4js.levels.TRACE.isGreaterThanOrEqualTo(this.$logger.getLevel())) {
+            this._lldbProcesses[appId].stdout.pipe(process.stdout);
+        }
+        this._lldbProcesses[appId].stderr.pipe(process.stderr);
+        this._lldbProcesses[appId].stdin.write("process continue\n");
+    }
+    detachNativeDebugger(appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._lldbProcesses[appId]) {
+                this._lldbProcesses[appId].stdin.write("process detach\n");
+                yield this.killProcess(this._lldbProcesses[appId]);
+                this._lldbProcesses[appId] = undefined;
+            }
+        });
+    }
+    killProcess(childProcess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (childProcess) {
+                return new Promise((resolve, reject) => {
+                    childProcess.on("close", resolve);
+                    childProcess.kill();
+                });
+            }
+        });
+    }
+    setDeviceLogData(appData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$deviceLogProvider.setProjectNameForDevice(this.device.deviceInfo.identifier, appData.projectName);
+            this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, appData.projectDir);
+            if (!this.$options.justlaunch) {
+                yield this.startDeviceLog();
+            }
+        });
+    }
+    startDeviceLog() {
+        return this.device.openDeviceLogStream({ predicate: constants_1.IOS_LOG_PREDICATE });
+    }
+}
+__decorate([
+    (0, helpers_1.hook)("install")
+], IOSSimulatorApplicationManager.prototype, "installApplication", null);
+__decorate([
+    (0, decorators_1.cache)()
+], IOSSimulatorApplicationManager.prototype, "startDeviceLog", null);
+exports.IOSSimulatorApplicationManager = IOSSimulatorApplicationManager;

package/lib/common/mobile/ios/simulator/ios-simulator-device.js

@@ -0,0 +1,106 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.IOSSimulator = void 0;
+const applicationManagerPath = require("./ios-simulator-application-manager");
+const fileSystemPath = require("./ios-simulator-file-system");
+const constants = require("../../../constants");
+const _ = require("lodash");
+const decorators_1 = require("../../../decorators");
+const helpers = require("../../../../common/helpers");
+const ios_device_base_1 = require("../ios-device-base");
+const constants_1 = require("../../../../constants");
+class IOSSimulator extends ios_device_base_1.IOSDeviceBase {
+    constructor(simulator, $devicePlatformsConstants, $deviceLogProvider, $errors, $lockService, $injector, $iOSDebuggerPortService, $iOSSimResolver, $iOSEmulatorServices, $iOSNotification, $iOSSimulatorLogProvider, $logger) {
+        var _a;
+        super();
+        this.simulator = simulator;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$errors = $errors;
+        this.$lockService = $lockService;
+        this.$injector = $injector;
+        this.$iOSDebuggerPortService = $iOSDebuggerPortService;
+        this.$iOSSimResolver = $iOSSimResolver;
+        this.$iOSEmulatorServices = $iOSEmulatorServices;
+        this.$iOSNotification = $iOSNotification;
+        this.$iOSSimulatorLogProvider = $iOSSimulatorLogProvider;
+        this.$logger = $logger;
+        this.applicationManager = this.$injector.resolve(applicationManagerPath.IOSSimulatorApplicationManager, { iosSim: this.$iOSSimResolver.iOSSim, device: this });
+        this.fileSystem = this.$injector.resolve(fileSystemPath.IOSSimulatorFileSystem, { iosSim: this.$iOSSimResolver.iOSSim });
+        this.deviceInfo = {
+            imageIdentifier: this.simulator.id,
+            identifier: this.simulator.id,
+            displayName: this.simulator.name,
+            model: _.last(this.simulator.fullId.split(".")),
+            version: this.simulator.runtimeVersion,
+            vendor: "Apple",
+            platform: (_a = this.simulator.platform) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS,
+            status: constants.CONNECTED_STATUS,
+            errorHelp: null,
+            isTablet: this.simulator.fullId.toLowerCase().indexOf("ipad") !== -1,
+            type: constants.DeviceTypes.Emulator,
+            connectionTypes: [constants_1.DeviceConnectionType.Local],
+        };
+    }
+    get isEmulator() {
+        return true;
+    }
+    get isOnlyWiFiConnected() {
+        return false;
+    }
+    openDeviceLogStream(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            options = options || {};
+            options.predicate = options.hasOwnProperty("predicate")
+                ? options.predicate
+                : constants.IOS_LOG_PREDICATE;
+            return this.$iOSSimulatorLogProvider.startLogProcess(this.simulator.id, options);
+        });
+    }
+    getDebugSocketCore(appId) {
+        const _super = Object.create(null, {
+            getDebuggerPort: { get: () => super.getDebuggerPort }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            let socket;
+            const attachRequestMessage = this.$iOSNotification.getAttachRequest(appId, this.deviceInfo.identifier);
+            yield this.$iOSEmulatorServices.postDarwinNotification(attachRequestMessage, this.deviceInfo.identifier);
+            const postNotificationRetryInterval = setInterval(() => {
+                this.$iOSEmulatorServices
+                    .postDarwinNotification(attachRequestMessage, this.deviceInfo.identifier)
+                    .catch((e) => this.$logger.error(e));
+            }, 5e3);
+            const port = yield _super.getDebuggerPort.call(this, appId).finally(() => {
+                clearInterval(postNotificationRetryInterval);
+            });
+            try {
+                socket = yield helpers.connectEventuallyUntilTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    return this.$iOSEmulatorServices.connectToPort({ port });
+                }), constants.SOCKET_CONNECTION_TIMEOUT_MS);
+            }
+            catch (e) {
+                this.$logger.warn(e);
+            }
+            return socket;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], IOSSimulator.prototype, "openDeviceLogStream", null);
+exports.IOSSimulator = IOSSimulator;