@akylas/nativescript-cli 8.8.2 → 8.8.4

package/lib/services/livesync/android-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.AndroidLiveSyncService = void 0;
 const android_device_livesync_service_1 = require("./android-device-livesync-service");
@@ -36,35 +27,24 @@ class AndroidLiveSyncService extends platform_livesync_service_base_1.PlatformLi
         }
         return this.$injector.resolve(android_device_livesync_service_1.AndroidDeviceLiveSyncService, { device, data });
     }
-    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 liveSyncWatchAction(device, liveSyncInfo) {
+        const liveSyncResult = await super.liveSyncWatchAction(device, liveSyncInfo);
+        const result = await this.finalizeSync(device, liveSyncInfo.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 fullSync(syncInfo) {
+        const liveSyncResult = await super.fullSync(syncInfo);
+        const result = await this.finalizeSync(syncInfo.device, syncInfo.projectData, liveSyncResult);
+        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;
-        });
+    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;
     }
 }
+exports.AndroidLiveSyncService = AndroidLiveSyncService;
 AndroidLiveSyncService.MIN_SOCKETS_LIVESYNC_RUNTIME_VERSION = "4.2.0-2018-07-20-02";
 __decorate([
     (0, decorators_1.performanceLog)()
@@ -72,5 +52,4 @@ __decorate([
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidLiveSyncService.prototype, "fullSync", null);
-exports.AndroidLiveSyncService = AndroidLiveSyncService;
 yok_1.injector.register("androidLiveSyncService", AndroidLiveSyncService);

package/lib/services/livesync/android-livesync-tool.js

@@ -1,13 +1,4 @@
 "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");
@@ -36,79 +27,69 @@ class AndroidLivesyncTool {
         this.socketError = null;
         this.socketConnection = null;
     }
-    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);
+    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`,
         });
+        const connectionResult = await this.connectEventuallyUntilTimeout(this.createSocket.bind(this, port), connectTimeout, configuration);
+        this.handleConnection(connectionResult);
     }
-    sendFile(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendFileHeader(filePath);
-            yield this.sendFileContent(filePath);
-        });
+    async sendFile(filePath) {
+        await this.sendFileHeader(filePath);
+        await this.sendFileContent(filePath);
     }
-    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);
+    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.`);
                 }
+                await this.sendFile(filePath);
             }
-        });
+        }
     }
     sendDirectory(directoryPath) {
         const list = this.$fs.enumerateFilesInDirectorySync(directoryPath);
         return this.sendFiles(list);
     }
-    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 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);
     }
-    removeFiles(files) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const file of files) {
-                yield this.removeFile(file);
-            }
-        });
+    async removeFiles(files) {
+        for (const file of files) {
+            await this.removeFile(file);
+        }
     }
     generateOperationIdentifier() {
         return crypto.randomBytes(16).toString("hex");
@@ -168,37 +149,35 @@ class AndroidLivesyncTool {
     hasConnection() {
         return !!this.socketConnection;
     }
-    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);
-        });
+    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);
     }
     sendFileContent(filePath) {
         return new Promise((resolve, reject) => {
@@ -270,14 +249,14 @@ class AndroidLivesyncTool {
     connectEventuallyUntilTimeout(factory, timeout, configuration) {
         return new Promise((resolve, reject) => {
             let lastKnownError, isConnected = false;
-            const connectionTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            const connectionTimer = setTimeout(async () => {
                 if (!isConnected) {
                     isConnected = true;
                     if (this.pendingConnectionData &&
                         this.pendingConnectionData.socketTimer) {
                         clearTimeout(this.pendingConnectionData.socketTimer);
                     }
-                    const applicationPid = yield this.$androidProcessService.getAppProcessId(configuration.deviceIdentifier, configuration.appIdentifier);
+                    const applicationPid = await 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}.`));
@@ -294,7 +273,7 @@ class AndroidLivesyncTool {
                     }
                     this.pendingConnectionData = null;
                 }
-            }), timeout);
+            }, timeout);
             this.pendingConnectionData = {
                 connectionTimer,
                 rejectHandler: reject,
@@ -402,14 +381,13 @@ class AndroidLivesyncTool {
         const relativeFilePath = path.relative(this.configuration.appPlatformsPath, filePath);
         return this.$mobileHelper.buildDevicePath(relativeFilePath);
     }
-    writeToSocket(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.verifyActiveConnection();
-            const result = yield this.socketConnection.writeAsync(data);
-            return result;
-        });
+    async writeToSocket(data) {
+        this.verifyActiveConnection();
+        const result = await this.socketConnection.writeAsync(data);
+        return result;
     }
 }
+exports.AndroidLivesyncTool = AndroidLivesyncTool;
 AndroidLivesyncTool.DELETE_FILE_OPERATION = 7;
 AndroidLivesyncTool.CREATE_FILE_OPERATION = 8;
 AndroidLivesyncTool.DO_SYNC_OPERATION = 9;
@@ -423,5 +401,4 @@ 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);

package/lib/services/livesync/device-livesync-service-base.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.DeviceLiveSyncServiceBase = void 0;
 const decorators_1 = require("../../common/decorators");
@@ -38,27 +29,24 @@ class DeviceLiveSyncServiceBase {
         const fastSyncFileExtensions = DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS.concat(platformData.fastLivesyncFileExtensions);
         return fastSyncFileExtensions;
     }
-    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 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;
     }
-    finalizeSync(liveSyncInfo, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                didRefresh: true,
-                operationId: "",
-            };
-        });
+    async finalizeSync(liveSyncInfo, projectData) {
+        return {
+            didRefresh: true,
+            operationId: "",
+        };
     }
 }
+exports.DeviceLiveSyncServiceBase = DeviceLiveSyncServiceBase;
 DeviceLiveSyncServiceBase.FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml", ".html"];
 __decorate([
     (0, decorators_1.cache)()
@@ -66,4 +54,3 @@ __decorate([
 __decorate([
     (0, decorators_2.performanceLog)()
 ], DeviceLiveSyncServiceBase.prototype, "transferFiles", null);
-exports.DeviceLiveSyncServiceBase = DeviceLiveSyncServiceBase;