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

package/lib/services/livesync/ios-device-livesync-service.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.IOSDeviceLiveSyncService = void 0;
 const constants = require("../../constants");
@@ -36,103 +45,122 @@ 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;
     }
-    async setupSocketIfNeeded(projectData) {
-        if (this.socket) {
+    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();
             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;
+        });
     }
-    async removeFiles(deviceAppData, localToDevicePaths) {
-        await Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.device.fileSystem.deleteFile(localToDevicePathData.getDevicePath(), deviceAppData.appIdentifier)));
+    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 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(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) {
                 shouldRestart = true;
             }
-        }
-        return shouldRestart;
+            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;
+        });
     }
-    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);
+    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);
+                }
             }
-        }
-        catch (e) {
-            didRefresh = false;
-        }
-        return didRefresh;
+            catch (e) {
+                didRefresh = false;
+            }
+            return didRefresh;
+        });
     }
-    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();
+    refreshApplicationCore(projectData, liveSyncInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let didRefresh = true;
+            if (this.canRefreshWithNotification(projectData, liveSyncInfo)) {
+                didRefresh = yield this.refreshWithNotification(projectData);
             }
             else {
-                didRefresh = false;
+                if (yield this.setupSocketIfNeeded(projectData)) {
+                    yield this.reloadPage();
+                }
+                else {
+                    didRefresh = false;
+                }
             }
-        }
-        return didRefresh;
+            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;
+    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 restartApplication(projectData, liveSyncInfo) {
-        await this.device.applicationManager.restartApplication({
-            appId: liveSyncInfo.deviceAppData.appIdentifier,
-            projectName: projectData.projectName,
-            waitForDebugger: liveSyncInfo.waitForDebugger,
-            projectDir: projectData.projectDir,
+    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);
+            }
         });
-        if (liveSyncInfo.useHotModuleReload) {
-            await this.setupSocketIfNeeded(projectData);
-        }
     }
-    async reloadPage() {
-        const message = JSON.stringify({
-            method: "Page.reload",
-            params: {
-                ignoreCache: false,
-            },
-            id: ++currentPageReloadId,
+    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);
         });
-        await this.sendMessage(message);
     }
     attachEventHandlers() {
         this.socket.on("close", (hadError) => {
@@ -146,44 +174,52 @@ class IOSDeviceLiveSyncService extends device_livesync_service_base_1.DeviceLive
             this.$logger.trace(`Socket sent data: ${data.toString()}`);
         });
     }
-    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();
-                    }
+    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();
+                        }
+                    });
                 });
-            });
-        }
-        catch (error) {
-            this.$logger.trace("Error while sending message:", error);
-            await this.destroySocket();
-        }
+            }
+            catch (error) {
+                this.$logger.trace("Error while sending message:", error);
+                yield this.destroySocket();
+            }
+        });
     }
-    async destroySocket() {
-        if (this.socket) {
-            await this.device.destroyAllSockets();
-            this.socket = null;
-        }
+    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;
+            }
+        });
     }
 }
-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,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.IOSLiveSyncService = void 0;
 const path = require("path");
@@ -22,58 +31,67 @@ class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSy
         this.$injector = $injector;
         this.$tempService = $tempService;
     }
-    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",
+    fullSync(syncInfo) {
+        const _super = Object.create(null, {
+            fullSync: { get: () => super.fullSync }
         });
-        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));
+        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,
+            };
         });
-        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,
-        };
     }
-    async syncAfterInstall(device, liveSyncInfo) {
-        if (!device.isEmulator) {
-            await this.fullSync({
-                projectData: liveSyncInfo.projectData,
-                device,
-                liveSyncDeviceData: liveSyncInfo.liveSyncDeviceData,
-                watch: true,
-                useHotModuleReload: liveSyncInfo.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,
+                });
+            }
+        });
     }
     _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,3 +12,4 @@ class LiveSyncSocket extends net.Socket {
 }
 exports.LiveSyncSocket = LiveSyncSocket;
 yok_1.injector.register("LiveSyncSocket", LiveSyncSocket, false);
+//# sourceMappingURL=livesync-socket.js.map