nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -1,4 +1,13 @@
 "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");
@@ -12,80 +21,103 @@ class IosEmulatorServices {
         this.$iOSSimResolver = $iOSSimResolver;
         this.$mobileHelper = $mobileHelper;
     }
-    async startEmulator(options) {
+    startEmulator(options) {
         var _a;
-        let error = null;
-        try {
-            if (options.platform === this.$devicePlatformsConstants.visionOS &&
-                !options.emulatorIdOrName) {
-                const { devices } = await this.tryGetiOSSimDevices();
-                options.emulatorIdOrName = (_a = devices.find((device) => device.platform === this.$devicePlatformsConstants.visionOS)) === null || _a === void 0 ? void 0 : _a.id;
+        return __awaiter(this, void 0, void 0, function* () {
+            let error = null;
+            try {
+                if (options.platform === this.$devicePlatformsConstants.visionOS &&
+                    !options.emulatorIdOrName) {
+                    // find first available visionOS simulator (for now).
+                    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,
+                });
             }
-            await this.$iOSSimResolver.iOSSim.startSimulator({
-                device: options.imageIdentifier || options.emulatorIdOrName,
-                state: "None",
-                sdkVersion: options.sdk,
-            });
-        }
-        catch (err) {
-            error = err && err.message;
-        }
-        return {
-            errors: error ? [error] : [],
-        };
+            catch (err) {
+                error = err && err.message;
+            }
+            return {
+                errors: error ? [error] : [],
+            };
+        });
     }
-    async getRunningEmulator() {
-        return null;
+    getRunningEmulator() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
     }
-    async getRunningEmulatorIds() {
-        return [];
+    getRunningEmulatorIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
     }
-    async getRunningEmulatorName() {
-        return "";
+    getRunningEmulatorName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "";
+        });
     }
-    async getRunningEmulatorImageIdentifier(emulatorId) {
-        return "";
+    getRunningEmulatorImageIdentifier(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "";
+        });
     }
-    async postDarwinNotification(notification, deviceId) {
-        return this.$iOSSimResolver.iOSSim.sendNotification(notification, deviceId);
+    postDarwinNotification(notification, deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$iOSSimResolver.iOSSim.sendNotification(notification, deviceId);
+        });
     }
-    async connectToPort(data) {
-        try {
-            const socket = net.connect(data.port, "127.0.0.1");
-            return socket;
-        }
-        catch (e) {
-            this.$logger.trace(e);
-        }
+    connectToPort(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // node v17+ resolves localhost to ::1 (ipv6) instead of 127.0.0.1 (ipv4)
+                // so we explicitly pass ipv4
+                const socket = net.connect(data.port, "127.0.0.1");
+                return socket;
+            }
+            catch (e) {
+                this.$logger.trace(e);
+            }
+        });
     }
-    async getEmulatorImages() {
-        let devices = [];
-        const errors = [];
-        const output = await 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 };
+    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 };
+        });
     }
-    async getRunningEmulators() {
-        return [];
+    getRunningEmulators() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
     }
-    async tryGetiOSSimDevices() {
-        let devices = [];
-        let error = null;
-        try {
-            devices = await this.$iOSSimResolver.iOSSim.getDevices();
-        }
-        catch (err) {
-            error = err;
-        }
-        return { devices, error };
+    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;
@@ -108,3 +140,4 @@ class IosEmulatorServices {
     }
 }
 yok_1.injector.register("iOSEmulatorServices", IosEmulatorServices);
+//# sourceMappingURL=ios-emulator-services.js.map

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

@@ -17,7 +17,8 @@ class IOSSimResolver {
         return path.join(require.resolve(IOSSimResolver.iOSSimName), "..", IOSSimResolver.iOSStandaloneExecutableName);
     }
 }
-exports.IOSSimResolver = IOSSimResolver;
 IOSSimResolver.iOSSimName = "ios-sim-portable";
 IOSSimResolver.iOSStandaloneExecutableName = "ios-sim-standalone.js";
+exports.IOSSimResolver = IOSSimResolver;
 yok_1.injector.register("iOSSimResolver", IOSSimResolver);
+//# sourceMappingURL=ios-sim-resolver.js.map

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

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
@@ -26,55 +35,74 @@ class IOSSimulatorApplicationManager extends application_manager_base_1.Applicat
         this.$tempService = $tempService;
         this._lldbProcesses = {};
     }
-    async getInstalledApplications() {
-        return this.iosSim.getInstalledApplications(this.device.deviceInfo.identifier);
+    getInstalledApplications() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.iosSim.getInstalledApplications(this.device.deviceInfo.identifier);
+        });
     }
-    async installApplication(packageFilePath) {
-        if (this.$fs.exists(packageFilePath) &&
-            path.extname(packageFilePath) === ".zip") {
-            const dir = await this.$tempService.mkdirSync("simulatorPackage");
-            await this.$fs.unzip(packageFilePath, dir);
-            const app = _.find(this.$fs.readDirectory(dir), (directory) => path.extname(directory) === ".app");
-            if (app) {
-                packageFilePath = path.join(dir, app);
+    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);
+                }
             }
-        }
-        await this.iosSim.installApplication(this.device.deviceInfo.identifier, packageFilePath);
+            yield this.iosSim.installApplication(this.device.deviceInfo.identifier, packageFilePath);
+        });
     }
-    async uninstallApplication(appIdentifier) {
-        await this.detachNativeDebugger(appIdentifier);
-        return this.iosSim.uninstallApplication(this.device.deviceInfo.identifier, appIdentifier);
+    uninstallApplication(appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.detachNativeDebugger(appIdentifier);
+            return this.iosSim.uninstallApplication(this.device.deviceInfo.identifier, appIdentifier);
+        });
     }
-    async startApplication(appData) {
-        const args = process.env.IOS_SIMULATOR_RUN_ARGS || "";
-        const options = appData.waitForDebugger
-            ? {
-                waitForDebugger: true,
-                args: `--nativescript-debug-brk ${args}`.trim(),
+    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);
             }
-            : args
-                ? { args }
-                : {};
-        await this.setDeviceLogData(appData);
-        const launchResult = await 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);
-        }
+        });
     }
-    async stopApplication(appData) {
-        const { appId } = appData;
-        await this.device.destroyDebugSocket(appId);
-        await this.detachNativeDebugger(appId);
-        await this.iosSim.stopApplication(this.device.deviceInfo.identifier, appData.appId, appData.projectName);
+    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);
+        });
     }
-    async getDebuggableApps() {
-        return [];
+    getDebuggableApps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
     }
-    async getDebuggableAppViews(appIdentifiers) {
-        return Promise.resolve(null);
+    getDebuggableAppViews(appIdentifiers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Implement when we can find debuggable applications for iOS.
+            return Promise.resolve(null);
+        });
     }
+    // iOS will kill the app if we freeze it in the NativeScript Runtime and wait for debug-brk.
+    // In order to avoid that, we are attaching lldb and passing it "process continue".
+    // In this way, iOS will not kill the app because it has a native debugger attached
+    // and the users will be able to attach a debug session using the debug-brk flag.
     attachNativeDebugger(appId, pid) {
         this._lldbProcesses[appId] = this.$childProcess.spawn("lldb", ["-p", pid]);
         if (log4js.levels.TRACE.isGreaterThanOrEqualTo(this.$logger.getLevel())) {
@@ -83,36 +111,43 @@ class IOSSimulatorApplicationManager extends application_manager_base_1.Applicat
         this._lldbProcesses[appId].stderr.pipe(process.stderr);
         this._lldbProcesses[appId].stdin.write("process continue\n");
     }
-    async detachNativeDebugger(appId) {
-        if (this._lldbProcesses[appId]) {
-            this._lldbProcesses[appId].stdin.write("process detach\n");
-            await this.killProcess(this._lldbProcesses[appId]);
-            this._lldbProcesses[appId] = undefined;
-        }
+    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;
+            }
+        });
     }
-    async killProcess(childProcess) {
-        if (childProcess) {
-            return new Promise((resolve, reject) => {
-                childProcess.on("close", resolve);
-                childProcess.kill();
-            });
-        }
+    killProcess(childProcess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (childProcess) {
+                return new Promise((resolve, reject) => {
+                    childProcess.on("close", resolve);
+                    childProcess.kill();
+                });
+            }
+        });
     }
-    async setDeviceLogData(appData) {
-        this.$deviceLogProvider.setProjectNameForDevice(this.device.deviceInfo.identifier, appData.projectName);
-        this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, appData.projectDir);
-        if (!this.$options.justlaunch) {
-            await this.startDeviceLog();
-        }
+    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 });
     }
 }
-exports.IOSSimulatorApplicationManager = IOSSimulatorApplicationManager;
 __decorate([
     (0, helpers_1.hook)("install")
 ], IOSSimulatorApplicationManager.prototype, "installApplication", null);
 __decorate([
     (0, decorators_1.cache)()
 ], IOSSimulatorApplicationManager.prototype, "startDeviceLog", null);
+exports.IOSSimulatorApplicationManager = IOSSimulatorApplicationManager;
+//# sourceMappingURL=ios-simulator-application-manager.js.map

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

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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");
@@ -54,37 +63,49 @@ class IOSSimulator extends ios_device_base_1.IOSDeviceBase {
     get isOnlyWiFiConnected() {
         return false;
     }
-    async openDeviceLogStream(options) {
-        options = options || {};
-        options.predicate = options.hasOwnProperty("predicate")
-            ? options.predicate
-            : constants.IOS_LOG_PREDICATE;
-        return this.$iOSSimulatorLogProvider.startLogProcess(this.simulator.id, options);
+    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);
+        });
     }
-    async getDebugSocketCore(appId) {
-        let socket;
-        const attachRequestMessage = this.$iOSNotification.getAttachRequest(appId, this.deviceInfo.identifier);
-        await 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 = await super.getDebuggerPort(appId).finally(() => {
-            clearInterval(postNotificationRetryInterval);
+    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);
+            // Retry posting the notification every five seconds, in case the AttachRequest
+            // event handler wasn't registered when the first one was sent
+            const postNotificationRetryInterval = setInterval(() => {
+                this.$iOSEmulatorServices
+                    .postDarwinNotification(attachRequestMessage, this.deviceInfo.identifier)
+                    .catch((e) => this.$logger.error(e));
+            }, 5e3);
+            // the internal retry-mechanism of getDebuggerPort will ensure the above
+            // interval has a chance to execute multiple times
+            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;
         });
-        try {
-            socket = await helpers.connectEventuallyUntilTimeout(async () => {
-                return this.$iOSEmulatorServices.connectToPort({ port });
-            }, constants.SOCKET_CONNECTION_TIMEOUT_MS);
-        }
-        catch (e) {
-            this.$logger.warn(e);
-        }
-        return socket;
     }
 }
-exports.IOSSimulator = IOSSimulator;
 __decorate([
     (0, decorators_1.cache)()
 ], IOSSimulator.prototype, "openDeviceLogStream", null);
+exports.IOSSimulator = IOSSimulator;
+//# sourceMappingURL=ios-simulator-device.js.map

package/lib/common/mobile/ios/simulator/ios-simulator-file-system.js

@@ -1,4 +1,13 @@
 "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.IOSSimulatorFileSystem = void 0;
 const path = require("path");
@@ -10,47 +19,64 @@ class IOSSimulatorFileSystem {
         this.$fs = $fs;
         this.$logger = $logger;
     }
-    async listFiles(devicePath) {
-        return this.iosSim.listFiles(devicePath);
-    }
-    async getFile(deviceFilePath, appIdentifier, outputFilePath) {
-        if (outputFilePath) {
-            shelljs.cp("-f", deviceFilePath, outputFilePath);
-        }
-    }
-    async getFileContent(deviceFilePath, appIdentifier) {
-        const result = this.$fs.readText(deviceFilePath);
-        return result;
-    }
-    async putFile(localFilePath, deviceFilePath, appIdentifier) {
-        shelljs.cp("-f", localFilePath, deviceFilePath);
-    }
-    async deleteFile(deviceFilePath, appIdentifier) {
-        shelljs.rm("-rf", deviceFilePath);
-    }
-    async transferFiles(deviceAppData, localToDevicePaths) {
-        await Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath())));
-        return localToDevicePaths;
-    }
-    async transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
-        const destinationPath = await deviceAppData.getDeviceProjectRootPath();
-        this.$logger.trace(`Transferring from ${projectFilesPath} to ${destinationPath}`);
-        const sourcePath = path.join(projectFilesPath, "*");
-        shelljs.cp("-Rf", sourcePath, destinationPath);
-        return localToDevicePaths;
-    }
-    async transferFile(localFilePath, deviceFilePath) {
-        this.$logger.trace(`Transferring from ${localFilePath} to ${deviceFilePath}`);
-        if (this.$fs.getFsStats(localFilePath).isDirectory()) {
-            this.$fs.ensureDirectoryExists(deviceFilePath);
-        }
-        else {
-            this.$fs.ensureDirectoryExists(path.dirname(deviceFilePath));
+    listFiles(devicePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.iosSim.listFiles(devicePath);
+        });
+    }
+    getFile(deviceFilePath, appIdentifier, outputFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (outputFilePath) {
+                shelljs.cp("-f", deviceFilePath, outputFilePath);
+            }
+        });
+    }
+    getFileContent(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = this.$fs.readText(deviceFilePath);
+            return result;
+        });
+    }
+    putFile(localFilePath, deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
             shelljs.cp("-f", localFilePath, deviceFilePath);
-        }
+        });
+    }
+    deleteFile(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            shelljs.rm("-rf", deviceFilePath);
+        });
+    }
+    transferFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath())));
+            return localToDevicePaths;
+        });
+    }
+    transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const destinationPath = yield deviceAppData.getDeviceProjectRootPath();
+            this.$logger.trace(`Transferring from ${projectFilesPath} to ${destinationPath}`);
+            const sourcePath = path.join(projectFilesPath, "*");
+            shelljs.cp("-Rf", sourcePath, destinationPath);
+            return localToDevicePaths;
+        });
+    }
+    transferFile(localFilePath, deviceFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Transferring from ${localFilePath} to ${deviceFilePath}`);
+            if (this.$fs.getFsStats(localFilePath).isDirectory()) {
+                this.$fs.ensureDirectoryExists(deviceFilePath);
+            }
+            else {
+                this.$fs.ensureDirectoryExists(path.dirname(deviceFilePath));
+                shelljs.cp("-f", localFilePath, deviceFilePath);
+            }
+        });
     }
     updateHashesOnDevice(hashes, appIdentifier) {
         return;
     }
 }
 exports.IOSSimulatorFileSystem = IOSSimulatorFileSystem;
+//# sourceMappingURL=ios-simulator-file-system.js.map