nativescript 8.9.0-dev.2 → 8.9.0-dev.3

package/lib/services/livesync/ios-device-livesync-service.js

@@ -5,15 +5,6 @@ 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.IOSDeviceLiveSyncService = void 0;
 const constants = require("../../constants");
@@ -45,122 +36,103 @@ class IOSDeviceLiveSyncService extends device_livesync_service_base_1.DeviceLive
         const canRefresh = semver.gte(semver.coerce(currentRuntimeVersion), IOSDeviceLiveSyncService.MIN_RUNTIME_VERSION_WITH_REFRESH_NOTIFICATION);
         return canRefresh;
     }
-    setupSocketIfNeeded(projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: persist the sockets per app in order to support LiveSync on multiple apps on the same device
-            if (this.socket) {
-                return true;
-            }
-            const appId = projectData.projectIdentifiers.ios;
-            try {
-                // TODO: temp workaround till we setup the sockets along with the app start
-                const ensureAppStarted = true;
-                this.socket = yield this.device.getDebugSocket(appId, projectData.projectName, projectData.projectDir, ensureAppStarted);
-            }
-            catch (err) {
-                this.$logger.trace(`Error while connecting to the debug socket. Error is:`, err);
-            }
-            if (!this.socket) {
-                return false;
-            }
-            this.attachEventHandlers();
+    async setupSocketIfNeeded(projectData) {
+        if (this.socket) {
             return true;
-        });
+        }
+        const appId = projectData.projectIdentifiers.ios;
+        try {
+            const ensureAppStarted = true;
+            this.socket = await this.device.getDebugSocket(appId, projectData.projectName, projectData.projectDir, ensureAppStarted);
+        }
+        catch (err) {
+            this.$logger.trace(`Error while connecting to the debug socket. Error is:`, err);
+        }
+        if (!this.socket) {
+            return false;
+        }
+        this.attachEventHandlers();
+        return true;
     }
-    removeFiles(deviceAppData, localToDevicePaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.device.fileSystem.deleteFile(localToDevicePathData.getDevicePath(), deviceAppData.appIdentifier)));
-        });
+    async removeFiles(deviceAppData, localToDevicePaths) {
+        await Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.device.fileSystem.deleteFile(localToDevicePathData.getDevicePath(), deviceAppData.appIdentifier)));
     }
-    shouldRestart(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let shouldRestart = false;
-            const deviceAppData = liveSyncInfo.deviceAppData;
-            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
-            if (liveSyncInfo.isFullSync || liveSyncInfo.waitForDebugger) {
+    async shouldRestart(projectData, liveSyncInfo) {
+        let shouldRestart = false;
+        const deviceAppData = liveSyncInfo.deviceAppData;
+        const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+        if (liveSyncInfo.isFullSync || liveSyncInfo.waitForDebugger) {
+            shouldRestart = true;
+        }
+        else {
+            const canExecuteFastSync = this.canExecuteFastSyncForPaths(liveSyncInfo, localToDevicePaths, projectData, deviceAppData.platform);
+            const isRefreshConnectionSetup = this.canRefreshWithNotification(projectData, liveSyncInfo) ||
+                (!this.device.isOnlyWiFiConnected && this.socket);
+            if (!canExecuteFastSync || !isRefreshConnectionSetup) {
                 shouldRestart = true;
             }
-            else {
-                const canExecuteFastSync = this.canExecuteFastSyncForPaths(liveSyncInfo, localToDevicePaths, projectData, deviceAppData.platform);
-                const isRefreshConnectionSetup = this.canRefreshWithNotification(projectData, liveSyncInfo) ||
-                    (!this.device.isOnlyWiFiConnected && this.socket);
-                if (!canExecuteFastSync || !isRefreshConnectionSetup) {
-                    shouldRestart = true;
-                }
-            }
-            return shouldRestart;
-        });
+        }
+        return shouldRestart;
     }
-    tryRefreshApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let didRefresh = true;
-            const localToDevicePaths = liveSyncInfo.modifiedFilesData;
-            let scriptRelatedFiles = [];
-            constants.LIVESYNC_EXCLUDED_FILE_PATTERNS.forEach((pattern) => (scriptRelatedFiles = _.concat(scriptRelatedFiles, localToDevicePaths.filter((file) => (0, minimatch_1.minimatch)(file.getDevicePath(), pattern, { nocase: true })))));
-            const scriptFiles = _.filter(localToDevicePaths, (localToDevicePath) => _.endsWith(localToDevicePath.getDevicePath(), ".js"));
-            const otherFiles = _.difference(localToDevicePaths, _.concat(scriptFiles, scriptRelatedFiles));
-            try {
-                if (otherFiles.length) {
-                    didRefresh = yield this.refreshApplicationCore(projectData, liveSyncInfo);
-                }
+    async tryRefreshApplication(projectData, liveSyncInfo) {
+        let didRefresh = true;
+        const localToDevicePaths = liveSyncInfo.modifiedFilesData;
+        let scriptRelatedFiles = [];
+        constants.LIVESYNC_EXCLUDED_FILE_PATTERNS.forEach((pattern) => (scriptRelatedFiles = _.concat(scriptRelatedFiles, localToDevicePaths.filter((file) => (0, minimatch_1.minimatch)(file.getDevicePath(), pattern, { nocase: true })))));
+        const scriptFiles = _.filter(localToDevicePaths, (localToDevicePath) => _.endsWith(localToDevicePath.getDevicePath(), ".js"));
+        const otherFiles = _.difference(localToDevicePaths, _.concat(scriptFiles, scriptRelatedFiles));
+        try {
+            if (otherFiles.length) {
+                didRefresh = await this.refreshApplicationCore(projectData, liveSyncInfo);
             }
-            catch (e) {
-                didRefresh = false;
-            }
-            return didRefresh;
-        });
+        }
+        catch (e) {
+            didRefresh = false;
+        }
+        return didRefresh;
     }
-    refreshApplicationCore(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let didRefresh = true;
-            if (this.canRefreshWithNotification(projectData, liveSyncInfo)) {
-                didRefresh = yield this.refreshWithNotification(projectData);
+    async refreshApplicationCore(projectData, liveSyncInfo) {
+        let didRefresh = true;
+        if (this.canRefreshWithNotification(projectData, liveSyncInfo)) {
+            didRefresh = await this.refreshWithNotification(projectData);
+        }
+        else {
+            if (await this.setupSocketIfNeeded(projectData)) {
+                await this.reloadPage();
             }
             else {
-                if (yield this.setupSocketIfNeeded(projectData)) {
-                    yield this.reloadPage();
-                }
-                else {
-                    didRefresh = false;
-                }
+                didRefresh = false;
             }
-            return didRefresh;
-        });
+        }
+        return didRefresh;
     }
-    refreshWithNotification(projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let didRefresh = false;
-            yield this.$lockService.executeActionWithLock(() => __awaiter(this, void 0, void 0, function* () {
-                didRefresh = yield this.$iOSSocketRequestExecutor.executeRefreshRequest(this.device, 5, projectData.projectIdentifiers.ios);
-            }), `ios-device-livesync-${this.device.deviceInfo.identifier}-${projectData.projectIdentifiers.ios}.lock`);
-            return didRefresh;
-        });
+    async refreshWithNotification(projectData) {
+        let didRefresh = false;
+        await this.$lockService.executeActionWithLock(async () => {
+            didRefresh = await this.$iOSSocketRequestExecutor.executeRefreshRequest(this.device, 5, projectData.projectIdentifiers.ios);
+        }, `ios-device-livesync-${this.device.deviceInfo.identifier}-${projectData.projectIdentifiers.ios}.lock`);
+        return didRefresh;
     }
-    restartApplication(projectData, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.device.applicationManager.restartApplication({
-                appId: liveSyncInfo.deviceAppData.appIdentifier,
-                projectName: projectData.projectName,
-                waitForDebugger: liveSyncInfo.waitForDebugger,
-                projectDir: projectData.projectDir,
-            });
-            if (liveSyncInfo.useHotModuleReload) {
-                // enable HOT updates
-                yield this.setupSocketIfNeeded(projectData);
-            }
+    async restartApplication(projectData, liveSyncInfo) {
+        await this.device.applicationManager.restartApplication({
+            appId: liveSyncInfo.deviceAppData.appIdentifier,
+            projectName: projectData.projectName,
+            waitForDebugger: liveSyncInfo.waitForDebugger,
+            projectDir: projectData.projectDir,
         });
+        if (liveSyncInfo.useHotModuleReload) {
+            await this.setupSocketIfNeeded(projectData);
+        }
     }
-    reloadPage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const message = JSON.stringify({
-                method: "Page.reload",
-                params: {
-                    ignoreCache: false,
-                },
-                id: ++currentPageReloadId,
-            });
-            yield this.sendMessage(message);
+    async reloadPage() {
+        const message = JSON.stringify({
+            method: "Page.reload",
+            params: {
+                ignoreCache: false,
+            },
+            id: ++currentPageReloadId,
         });
+        await this.sendMessage(message);
     }
     attachEventHandlers() {
         this.socket.on("close", (hadError) => {
@@ -174,52 +146,44 @@ class IOSDeviceLiveSyncService extends device_livesync_service_base_1.DeviceLive
             this.$logger.trace(`Socket sent data: ${data.toString()}`);
         });
     }
-    sendMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield new Promise((resolve, reject) => {
-                    let isResolved = false;
-                    const length = Buffer.byteLength(message, "utf16le");
-                    const payload = Buffer.allocUnsafe(length + 4);
-                    payload.writeInt32BE(length, 0);
-                    payload.write(message, 4, length, "utf16le");
-                    const errorCallback = (error) => {
-                        if (!isResolved) {
-                            isResolved = true;
-                            reject(error);
-                        }
-                    };
-                    this.socket.once("error", errorCallback);
-                    this.socket.write(payload, "utf16le", () => {
-                        this.socket.removeListener("error", errorCallback);
-                        if (!isResolved) {
-                            isResolved = true;
-                            resolve();
-                        }
-                    });
+    async sendMessage(message) {
+        try {
+            await new Promise((resolve, reject) => {
+                let isResolved = false;
+                const length = Buffer.byteLength(message, "utf16le");
+                const payload = Buffer.allocUnsafe(length + 4);
+                payload.writeInt32BE(length, 0);
+                payload.write(message, 4, length, "utf16le");
+                const errorCallback = (error) => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        reject(error);
+                    }
+                };
+                this.socket.once("error", errorCallback);
+                this.socket.write(payload, "utf16le", () => {
+                    this.socket.removeListener("error", errorCallback);
+                    if (!isResolved) {
+                        isResolved = true;
+                        resolve();
+                    }
                 });
-            }
-            catch (error) {
-                this.$logger.trace("Error while sending message:", error);
-                yield this.destroySocket();
-            }
-        });
+            });
+        }
+        catch (error) {
+            this.$logger.trace("Error while sending message:", error);
+            await this.destroySocket();
+        }
     }
-    destroySocket() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.socket) {
-                // we do not support LiveSync on multiple apps on the same device
-                // in order to do that, we should cache the socket per app
-                // and destroy just the current app socket when possible
-                yield this.device.destroyAllSockets();
-                this.socket = null;
-            }
-        });
+    async destroySocket() {
+        if (this.socket) {
+            await this.device.destroyAllSockets();
+            this.socket = null;
+        }
     }
 }
+exports.IOSDeviceLiveSyncService = IOSDeviceLiveSyncService;
 IOSDeviceLiveSyncService.MIN_RUNTIME_VERSION_WITH_REFRESH_NOTIFICATION = "6.1.0";
 __decorate([
     (0, decorators_1.performanceLog)()
 ], IOSDeviceLiveSyncService.prototype, "removeFiles", null);
-exports.IOSDeviceLiveSyncService = IOSDeviceLiveSyncService;
-//# sourceMappingURL=ios-device-livesync-service.js.map

package/lib/services/livesync/ios-livesync-service.js

@@ -5,15 +5,6 @@ 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.IOSLiveSyncService = void 0;
 const path = require("path");
@@ -31,67 +22,58 @@ class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSy
         this.$injector = $injector;
         this.$tempService = $tempService;
     }
-    fullSync(syncInfo) {
-        const _super = Object.create(null, {
-            fullSync: { get: () => super.fullSync }
+    async fullSync(syncInfo) {
+        const device = syncInfo.device;
+        if (device.isEmulator) {
+            return super.fullSync(syncInfo);
+        }
+        const projectData = syncInfo.projectData;
+        const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
+        const deviceAppData = await this.getAppData(syncInfo);
+        const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+        const tempZip = await this.$tempService.path({
+            prefix: "sync",
+            suffix: ".zip",
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const device = syncInfo.device;
-            if (device.isEmulator) {
-                return _super.fullSync.call(this, syncInfo);
-            }
-            const projectData = syncInfo.projectData;
-            const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-            const deviceAppData = yield this.getAppData(syncInfo);
-            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
-            const tempZip = yield this.$tempService.path({
-                prefix: "sync",
-                suffix: ".zip",
-            });
-            this.$logger.trace("Creating zip file: " + tempZip);
-            const filesToTransfer = this.$fs.enumerateFilesInDirectorySync(projectFilesPath);
-            yield this.$fs.zipFiles(tempZip, filesToTransfer, (res) => {
-                return path.join(constants_1.APP_FOLDER_NAME, path.relative(projectFilesPath, res));
-            });
-            yield device.fileSystem.transferFiles(deviceAppData, [
-                {
-                    getLocalPath: () => tempZip,
-                    getDevicePath: () => deviceAppData.deviceSyncZipPath,
-                    getRelativeToProjectBasePath: () => "../sync.zip",
-                    deviceProjectRootPath: yield deviceAppData.getDeviceProjectRootPath(),
-                },
-            ]);
-            yield deviceAppData.device.applicationManager.setTransferredAppFiles(filesToTransfer);
-            return {
-                deviceAppData,
-                isFullSync: true,
-                modifiedFilesData: [],
-                useHotModuleReload: syncInfo.useHotModuleReload,
-            };
+        this.$logger.trace("Creating zip file: " + tempZip);
+        const filesToTransfer = this.$fs.enumerateFilesInDirectorySync(projectFilesPath);
+        await this.$fs.zipFiles(tempZip, filesToTransfer, (res) => {
+            return path.join(constants_1.APP_FOLDER_NAME, path.relative(projectFilesPath, res));
         });
+        await device.fileSystem.transferFiles(deviceAppData, [
+            {
+                getLocalPath: () => tempZip,
+                getDevicePath: () => deviceAppData.deviceSyncZipPath,
+                getRelativeToProjectBasePath: () => "../sync.zip",
+                deviceProjectRootPath: await deviceAppData.getDeviceProjectRootPath(),
+            },
+        ]);
+        await deviceAppData.device.applicationManager.setTransferredAppFiles(filesToTransfer);
+        return {
+            deviceAppData,
+            isFullSync: true,
+            modifiedFilesData: [],
+            useHotModuleReload: syncInfo.useHotModuleReload,
+        };
     }
-    syncAfterInstall(device, liveSyncInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!device.isEmulator) {
-                // In this case we should execute fullsync because iOS Runtime requires the full content of app dir to be extracted in the root of sync dir.
-                yield this.fullSync({
-                    projectData: liveSyncInfo.projectData,
-                    device,
-                    liveSyncDeviceData: liveSyncInfo.liveSyncDeviceData,
-                    watch: true,
-                    useHotModuleReload: liveSyncInfo.useHotModuleReload,
-                });
-            }
-        });
+    async syncAfterInstall(device, liveSyncInfo) {
+        if (!device.isEmulator) {
+            await this.fullSync({
+                projectData: liveSyncInfo.projectData,
+                device,
+                liveSyncDeviceData: liveSyncInfo.liveSyncDeviceData,
+                watch: true,
+                useHotModuleReload: liveSyncInfo.useHotModuleReload,
+            });
+        }
     }
     _getDeviceLiveSyncService(device, data) {
         const service = this.$injector.resolve(ios_device_livesync_service_1.IOSDeviceLiveSyncService, { device, data });
         return service;
     }
 }
+exports.IOSLiveSyncService = IOSLiveSyncService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], IOSLiveSyncService.prototype, "fullSync", null);
-exports.IOSLiveSyncService = IOSLiveSyncService;
 yok_1.injector.register("iOSLiveSyncService", IOSLiveSyncService);
-//# sourceMappingURL=ios-livesync-service.js.map

package/lib/services/livesync/livesync-socket.js

@@ -12,4 +12,3 @@ class LiveSyncSocket extends net.Socket {
 }
 exports.LiveSyncSocket = LiveSyncSocket;
 yok_1.injector.register("LiveSyncSocket", LiveSyncSocket, false);
-//# sourceMappingURL=livesync-socket.js.map