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

package/lib/services/livesync/android-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.AndroidLiveSyncService = void 0;
 const android_device_livesync_service_1 = require("./android-device-livesync-service");
@@ -27,24 +36,35 @@ class AndroidLiveSyncService extends platform_livesync_service_base_1.PlatformLi
         }
         return this.$injector.resolve(android_device_livesync_service_1.AndroidDeviceLiveSyncService, { device, data });
     }
-    async liveSyncWatchAction(device, liveSyncInfo) {
-        const liveSyncResult = await super.liveSyncWatchAction(device, liveSyncInfo);
-        const result = await this.finalizeSync(device, liveSyncInfo.projectData, liveSyncResult);
-        return result;
+    liveSyncWatchAction(device, liveSyncInfo) {
+        const _super = Object.create(null, {
+            liveSyncWatchAction: { get: () => super.liveSyncWatchAction }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncResult = yield _super.liveSyncWatchAction.call(this, device, liveSyncInfo);
+            const result = yield this.finalizeSync(device, liveSyncInfo.projectData, liveSyncResult);
+            return result;
+        });
     }
-    async fullSync(syncInfo) {
-        const liveSyncResult = await super.fullSync(syncInfo);
-        const result = await this.finalizeSync(syncInfo.device, syncInfo.projectData, liveSyncResult);
-        return result;
+    fullSync(syncInfo) {
+        const _super = Object.create(null, {
+            fullSync: { get: () => super.fullSync }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncResult = yield _super.fullSync.call(this, syncInfo);
+            const result = yield this.finalizeSync(syncInfo.device, syncInfo.projectData, liveSyncResult);
+            return result;
+        });
     }
-    async finalizeSync(device, projectData, liveSyncResult) {
-        const liveSyncService = (this.getDeviceLiveSyncService(device, projectData));
-        const finalizeResult = await liveSyncService.finalizeSync(liveSyncResult, projectData);
-        const result = _.extend(liveSyncResult, finalizeResult);
-        return result;
+    finalizeSync(device, projectData, liveSyncResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveSyncService = (this.getDeviceLiveSyncService(device, projectData));
+            const finalizeResult = yield liveSyncService.finalizeSync(liveSyncResult, projectData);
+            const result = _.extend(liveSyncResult, finalizeResult);
+            return result;
+        });
     }
 }
-exports.AndroidLiveSyncService = AndroidLiveSyncService;
 AndroidLiveSyncService.MIN_SOCKETS_LIVESYNC_RUNTIME_VERSION = "4.2.0-2018-07-20-02";
 __decorate([
     (0, decorators_1.performanceLog)()
@@ -52,4 +72,6 @@ __decorate([
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidLiveSyncService.prototype, "fullSync", null);
+exports.AndroidLiveSyncService = AndroidLiveSyncService;
 yok_1.injector.register("androidLiveSyncService", AndroidLiveSyncService);
+//# sourceMappingURL=android-livesync-service.js.map

package/lib/services/livesync/android-livesync-tool.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.AndroidLivesyncTool = void 0;
 const path = require("path");
@@ -27,69 +36,79 @@ class AndroidLivesyncTool {
         this.socketError = null;
         this.socketConnection = null;
     }
-    async connect(configuration) {
-        if (!configuration.appIdentifier) {
-            this.$errors.fail(AndroidLivesyncTool.APP_IDENTIFIER_MISSING_ERROR);
-        }
-        if (!configuration.appPlatformsPath) {
-            this.$errors.fail(AndroidLivesyncTool.APP_PLATFORMS_PATH_MISSING_ERROR);
-        }
-        if (this.socketConnection) {
-            this.$errors.fail(AndroidLivesyncTool.SOCKET_CONNECTION_ALREADY_EXISTS_ERROR);
-        }
-        if (!configuration.localHostAddress) {
-            configuration.localHostAddress =
-                process.env.NATIVESCRIPT_LIVESYNC_ADDRESS || DEFAULT_LOCAL_HOST_ADDRESS;
-        }
-        const connectTimeout = configuration.connectTimeout || TRY_CONNECT_TIMEOUT;
-        this.configuration = configuration;
-        this.socketError = null;
-        const port = await this.$androidProcessService.forwardFreeTcpToAbstractPort({
-            deviceIdentifier: configuration.deviceIdentifier,
-            appIdentifier: configuration.appIdentifier,
-            abstractPort: `localabstract:${configuration.appIdentifier}-livesync`,
+    connect(configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!configuration.appIdentifier) {
+                this.$errors.fail(AndroidLivesyncTool.APP_IDENTIFIER_MISSING_ERROR);
+            }
+            if (!configuration.appPlatformsPath) {
+                this.$errors.fail(AndroidLivesyncTool.APP_PLATFORMS_PATH_MISSING_ERROR);
+            }
+            if (this.socketConnection) {
+                this.$errors.fail(AndroidLivesyncTool.SOCKET_CONNECTION_ALREADY_EXISTS_ERROR);
+            }
+            if (!configuration.localHostAddress) {
+                configuration.localHostAddress =
+                    process.env.NATIVESCRIPT_LIVESYNC_ADDRESS || DEFAULT_LOCAL_HOST_ADDRESS;
+            }
+            const connectTimeout = configuration.connectTimeout || TRY_CONNECT_TIMEOUT;
+            this.configuration = configuration;
+            this.socketError = null;
+            const port = yield this.$androidProcessService.forwardFreeTcpToAbstractPort({
+                deviceIdentifier: configuration.deviceIdentifier,
+                appIdentifier: configuration.appIdentifier,
+                abstractPort: `localabstract:${configuration.appIdentifier}-livesync`,
+            });
+            const connectionResult = yield this.connectEventuallyUntilTimeout(this.createSocket.bind(this, port), connectTimeout, configuration);
+            this.handleConnection(connectionResult);
         });
-        const connectionResult = await this.connectEventuallyUntilTimeout(this.createSocket.bind(this, port), connectTimeout, configuration);
-        this.handleConnection(connectionResult);
     }
-    async sendFile(filePath) {
-        await this.sendFileHeader(filePath);
-        await this.sendFileContent(filePath);
+    sendFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendFileHeader(filePath);
+            yield this.sendFileContent(filePath);
+        });
     }
-    async sendFiles(filePaths) {
-        for (const filePath of filePaths) {
-            if (this.$fs.getLsStats(filePath).isFile()) {
-                if (!this.$fs.exists(filePath)) {
-                    this.$errors.fail(`${filePath} doesn't exist.`);
+    sendFiles(filePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const filePath of filePaths) {
+                if (this.$fs.getLsStats(filePath).isFile()) {
+                    if (!this.$fs.exists(filePath)) {
+                        this.$errors.fail(`${filePath} doesn't exist.`);
+                    }
+                    yield this.sendFile(filePath);
                 }
-                await this.sendFile(filePath);
             }
-        }
+        });
     }
     sendDirectory(directoryPath) {
         const list = this.$fs.enumerateFilesInDirectorySync(directoryPath);
         return this.sendFiles(list);
     }
-    async removeFile(filePath) {
-        this.verifyActiveConnection();
-        const filePathData = this.getFilePathData(filePath);
-        const headerBuffer = Buffer.alloc(PROTOCOL_OPERATION_LENGTH_SIZE +
-            SIZE_BYTE_LENGTH +
-            filePathData.filePathLengthSize +
-            filePathData.filePathLengthBytes);
-        let offset = 0;
-        offset += headerBuffer.write(AndroidLivesyncTool.DELETE_FILE_OPERATION.toString(), offset, PROTOCOL_OPERATION_LENGTH_SIZE);
-        offset = headerBuffer.writeInt8(filePathData.filePathLengthSize, offset);
-        offset += headerBuffer.write(filePathData.filePathLengthString, offset, filePathData.filePathLengthSize);
-        headerBuffer.write(filePathData.relativeFilePath, offset, filePathData.filePathLengthBytes);
-        const hash = crypto.createHash("md5").update(headerBuffer).digest();
-        await this.writeToSocket(headerBuffer);
-        await this.writeToSocket(hash);
+    removeFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.verifyActiveConnection();
+            const filePathData = this.getFilePathData(filePath);
+            const headerBuffer = Buffer.alloc(PROTOCOL_OPERATION_LENGTH_SIZE +
+                SIZE_BYTE_LENGTH +
+                filePathData.filePathLengthSize +
+                filePathData.filePathLengthBytes);
+            let offset = 0;
+            offset += headerBuffer.write(AndroidLivesyncTool.DELETE_FILE_OPERATION.toString(), offset, PROTOCOL_OPERATION_LENGTH_SIZE);
+            offset = headerBuffer.writeInt8(filePathData.filePathLengthSize, offset);
+            offset += headerBuffer.write(filePathData.filePathLengthString, offset, filePathData.filePathLengthSize);
+            headerBuffer.write(filePathData.relativeFilePath, offset, filePathData.filePathLengthBytes);
+            const hash = crypto.createHash("md5").update(headerBuffer).digest();
+            yield this.writeToSocket(headerBuffer);
+            yield this.writeToSocket(hash);
+        });
     }
-    async removeFiles(files) {
-        for (const file of files) {
-            await this.removeFile(file);
-        }
+    removeFiles(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const file of files) {
+                yield this.removeFile(file);
+            }
+        });
     }
     generateOperationIdentifier() {
         return crypto.randomBytes(16).toString("hex");
@@ -140,44 +159,49 @@ class AndroidLivesyncTool {
             error =
                 error ||
                     this.getErrorWithMessage("Socket connection ended before sync operation is complete.");
+            //remove listeners and delete this.socketConnection
             this.cleanState(socketUid);
+            //call end of the connection (close and error callbacks won't be called - listeners removed)
             socket.end();
             socket.destroy();
+            //reject all pending sync requests and clear timeouts
             this.rejectPendingSyncOperations(socketUid, error);
         }
     }
     hasConnection() {
         return !!this.socketConnection;
     }
-    async sendFileHeader(filePath) {
-        this.verifyActiveConnection();
-        const filePathData = this.getFilePathData(filePath);
-        const stats = this.$fs.getFsStats(filePathData.filePath);
-        const fileContentLengthBytes = stats.size;
-        const fileContentLengthString = fileContentLengthBytes.toString();
-        const fileContentLengthSize = Buffer.byteLength(fileContentLengthString);
-        const headerBuffer = Buffer.alloc(PROTOCOL_OPERATION_LENGTH_SIZE +
-            SIZE_BYTE_LENGTH +
-            filePathData.filePathLengthSize +
-            filePathData.filePathLengthBytes +
-            SIZE_BYTE_LENGTH +
-            fileContentLengthSize);
-        if (filePathData.filePathLengthSize > 255) {
-            this.$errors.fail("File name size is longer that 255 digits.");
-        }
-        else if (fileContentLengthSize > 255) {
-            this.$errors.fail("File name size is longer that 255 digits.");
-        }
-        let offset = 0;
-        offset += headerBuffer.write(AndroidLivesyncTool.CREATE_FILE_OPERATION.toString(), offset, PROTOCOL_OPERATION_LENGTH_SIZE);
-        offset = headerBuffer.writeUInt8(filePathData.filePathLengthSize, offset);
-        offset += headerBuffer.write(filePathData.filePathLengthString, offset, filePathData.filePathLengthSize);
-        offset += headerBuffer.write(filePathData.relativeFilePath, offset, filePathData.filePathLengthBytes);
-        offset = headerBuffer.writeUInt8(fileContentLengthSize, offset);
-        headerBuffer.write(fileContentLengthString, offset, fileContentLengthSize);
-        const hash = crypto.createHash("md5").update(headerBuffer).digest();
-        await this.writeToSocket(headerBuffer);
-        await this.writeToSocket(hash);
+    sendFileHeader(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.verifyActiveConnection();
+            const filePathData = this.getFilePathData(filePath);
+            const stats = this.$fs.getFsStats(filePathData.filePath);
+            const fileContentLengthBytes = stats.size;
+            const fileContentLengthString = fileContentLengthBytes.toString();
+            const fileContentLengthSize = Buffer.byteLength(fileContentLengthString);
+            const headerBuffer = Buffer.alloc(PROTOCOL_OPERATION_LENGTH_SIZE +
+                SIZE_BYTE_LENGTH +
+                filePathData.filePathLengthSize +
+                filePathData.filePathLengthBytes +
+                SIZE_BYTE_LENGTH +
+                fileContentLengthSize);
+            if (filePathData.filePathLengthSize > 255) {
+                this.$errors.fail("File name size is longer that 255 digits.");
+            }
+            else if (fileContentLengthSize > 255) {
+                this.$errors.fail("File name size is longer that 255 digits.");
+            }
+            let offset = 0;
+            offset += headerBuffer.write(AndroidLivesyncTool.CREATE_FILE_OPERATION.toString(), offset, PROTOCOL_OPERATION_LENGTH_SIZE);
+            offset = headerBuffer.writeUInt8(filePathData.filePathLengthSize, offset);
+            offset += headerBuffer.write(filePathData.filePathLengthString, offset, filePathData.filePathLengthSize);
+            offset += headerBuffer.write(filePathData.relativeFilePath, offset, filePathData.filePathLengthBytes);
+            offset = headerBuffer.writeUInt8(fileContentLengthSize, offset);
+            headerBuffer.write(fileContentLengthString, offset, fileContentLengthSize);
+            const hash = crypto.createHash("md5").update(headerBuffer).digest();
+            yield this.writeToSocket(headerBuffer);
+            yield this.writeToSocket(hash);
+        });
     }
     sendFileContent(filePath) {
         return new Promise((resolve, reject) => {
@@ -249,14 +273,14 @@ class AndroidLivesyncTool {
     connectEventuallyUntilTimeout(factory, timeout, configuration) {
         return new Promise((resolve, reject) => {
             let lastKnownError, isConnected = false;
-            const connectionTimer = setTimeout(async () => {
+            const connectionTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                 if (!isConnected) {
                     isConnected = true;
                     if (this.pendingConnectionData &&
-                        typeof this.pendingConnectionData.socketTimer === "number") {
+                        this.pendingConnectionData.socketTimer) {
                         clearTimeout(this.pendingConnectionData.socketTimer);
                     }
-                    const applicationPid = await this.$androidProcessService.getAppProcessId(configuration.deviceIdentifier, configuration.appIdentifier);
+                    const applicationPid = yield this.$androidProcessService.getAppProcessId(configuration.deviceIdentifier, configuration.appIdentifier);
                     if (!applicationPid) {
                         this.$logger.trace("In Android LiveSync tool, lastKnownError is: ", lastKnownError);
                         this.$logger.info(color_1.color.yellow(`Application ${configuration.appIdentifier} is not running on device ${configuration.deviceIdentifier}.`));
@@ -273,7 +297,7 @@ class AndroidLivesyncTool {
                     }
                     this.pendingConnectionData = null;
                 }
-            }, timeout);
+            }), timeout);
             this.pendingConnectionData = {
                 connectionTimer,
                 rejectHandler: reject,
@@ -381,13 +405,14 @@ class AndroidLivesyncTool {
         const relativeFilePath = path.relative(this.configuration.appPlatformsPath, filePath);
         return this.$mobileHelper.buildDevicePath(relativeFilePath);
     }
-    async writeToSocket(data) {
-        this.verifyActiveConnection();
-        const result = await this.socketConnection.writeAsync(data);
-        return result;
+    writeToSocket(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.verifyActiveConnection();
+            const result = yield this.socketConnection.writeAsync(data);
+            return result;
+        });
     }
 }
-exports.AndroidLivesyncTool = AndroidLivesyncTool;
 AndroidLivesyncTool.DELETE_FILE_OPERATION = 7;
 AndroidLivesyncTool.CREATE_FILE_OPERATION = 8;
 AndroidLivesyncTool.DO_SYNC_OPERATION = 9;
@@ -401,4 +426,6 @@ AndroidLivesyncTool.APP_PLATFORMS_PATH_MISSING_ERROR = 'You need to provide "app
 AndroidLivesyncTool.SOCKET_CONNECTION_ALREADY_EXISTS_ERROR = "Socket connection already exists.";
 AndroidLivesyncTool.SOCKET_CONNECTION_TIMED_OUT_ERROR = "Socket connection timed out.";
 AndroidLivesyncTool.NO_SOCKET_CONNECTION_AVAILABLE_ERROR = "No socket connection available.";
+exports.AndroidLivesyncTool = AndroidLivesyncTool;
 yok_1.injector.register("androidLivesyncTool", AndroidLivesyncTool);
+//# sourceMappingURL=android-livesync-tool.js.map

package/lib/services/livesync/device-livesync-service-base.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.DeviceLiveSyncServiceBase = void 0;
 const decorators_1 = require("../../common/decorators");
@@ -29,24 +38,28 @@ class DeviceLiveSyncServiceBase {
         const fastSyncFileExtensions = DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS.concat(platformData.fastLivesyncFileExtensions);
         return fastSyncFileExtensions;
     }
-    async transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceDescriptor, options) {
-        let transferredFiles = [];
-        if (options.isFullSync) {
-            transferredFiles = await this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
-        }
-        else {
-            transferredFiles = await this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
-        }
-        return transferredFiles;
+    transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncDeviceDescriptor, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transferredFiles = [];
+            if (options.isFullSync) {
+                transferredFiles = yield this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
+            }
+            else {
+                transferredFiles = yield this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
+            }
+            return transferredFiles;
+        });
     }
-    async finalizeSync(liveSyncInfo, projectData) {
-        return {
-            didRefresh: true,
-            operationId: "",
-        };
+    finalizeSync(liveSyncInfo, projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //implement in case a sync point for all remove/create operation is needed
+            return {
+                didRefresh: true,
+                operationId: "",
+            };
+        });
     }
 }
-exports.DeviceLiveSyncServiceBase = DeviceLiveSyncServiceBase;
 DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml", ".html"];
 __decorate([
     (0, decorators_1.cache)()
@@ -54,3 +67,5 @@ __decorate([
 __decorate([
     (0, decorators_2.performanceLog)()
 ], DeviceLiveSyncServiceBase.prototype, "transferFiles", null);
+exports.DeviceLiveSyncServiceBase = DeviceLiveSyncServiceBase;
+//# sourceMappingURL=device-livesync-service-base.js.map