@akylas/nativescript-cli 8.7.2

package/lib/services/files-hash-service.js

@@ -0,0 +1,79 @@
+"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.FilesHashService = void 0;
+const helpers_1 = require("../common/helpers");
+const constants_1 = require("../common/constants");
+const constants_2 = require("../constants");
+const path = require("path");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class FilesHashService {
+    constructor($fs, $logger) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+    }
+    generateHashes(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const action = (file) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const isFile = this.$fs.getFsStats(file).isFile();
+                    if (isFile) {
+                        result[file] = yield this.$fs.getFileShasum(file);
+                    }
+                }
+                catch (err) {
+                    this.$logger.trace(`Unable to generate hash for file ${file}. Error is: ${err}`);
+                }
+            });
+            yield (0, helpers_1.executeActionByChunks)(files, constants_1.DEFAULT_CHUNK_SIZE, action);
+            return result;
+        });
+    }
+    generateHashesForProject(platformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_2.APP_FOLDER_NAME);
+            const files = this.$fs.enumerateFilesInDirectorySync(appFilesPath);
+            const hashes = yield this.generateHashes(files);
+            return hashes;
+        });
+    }
+    saveHashesForProject(platformData, hashesFileDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hashes = yield this.generateHashesForProject(platformData);
+            this.saveHashes(hashes, hashesFileDirectory);
+            return hashes;
+        });
+    }
+    getChanges(files, oldHashes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newHashes = yield this.generateHashes(files);
+            return this.getChangesInShasums(oldHashes, newHashes);
+        });
+    }
+    hasChangesInShasums(oldHashes, newHashes) {
+        return !!_.keys(this.getChangesInShasums(oldHashes, newHashes)).length;
+    }
+    saveHashes(hashes, hashesFileDirectory) {
+        const hashesFilePath = path.join(hashesFileDirectory, constants_2.HASHES_FILE_NAME);
+        this.$fs.writeJson(hashesFilePath, hashes);
+    }
+    getChangesInShasums(oldHashes, newHashes) {
+        const addedFileHashes = _.omitBy(newHashes, (hash, pathToFile) => !!oldHashes[pathToFile] && oldHashes[pathToFile] === hash);
+        const removedFileHashes = _.omitBy(oldHashes, (hash, pathToFile) => !!newHashes[pathToFile] && newHashes[pathToFile] === hash);
+        const result = {};
+        _.extend(result, addedFileHashes, removedFileHashes);
+        return result;
+    }
+}
+exports.FilesHashService = FilesHashService;
+yok_1.injector.register("filesHashService", FilesHashService);

package/lib/services/hmr-status-service.js

@@ -0,0 +1,128 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmrStatusService = void 0;
+const decorators_1 = require("../common/decorators");
+const constants_1 = require("../common/constants");
+const yok_1 = require("../common/yok");
+class HmrStatusService {
+    constructor($logParserService, $devicePlatformsConstants, $logger) {
+        this.$logParserService = $logParserService;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$logger = $logger;
+        this.hashOperationStatuses = {};
+        this.intervals = {};
+    }
+    getHmrStatus(deviceId, operationHash) {
+        return new Promise((resolve, reject) => {
+            const key = `${deviceId}${operationHash}`;
+            let retryCount = 40;
+            this.intervals[key] = setInterval(() => {
+                const status = this.getStatusByKey(key);
+                if (status || retryCount === 0) {
+                    clearInterval(this.intervals[key]);
+                    this.intervals[key] = null;
+                    resolve(status);
+                }
+                else {
+                    retryCount--;
+                }
+            }, 250);
+        });
+    }
+    watchHmrStatus(deviceId, operationHash) {
+        this.setData(deviceId, operationHash);
+    }
+    attachToHmrStatusEvent() {
+        this.$logParserService.addParseRule({
+            regex: HmrStatusService.HMR_STATUS_LOG_REGEX,
+            handler: this.handleHmrStatusFound.bind(this),
+            name: "hmrStatus",
+        });
+        this.$logParserService.addParseRule({
+            regex: constants_1.IOS_APP_CRASH_LOG_REG_EXP,
+            handler: this.handleAppCrash.bind(this),
+            name: "appCrashHmr",
+            platform: this.$devicePlatformsConstants.iOS.toLowerCase(),
+        });
+        this.$logParserService.addParseRule({
+            regex: constants_1.FAIL_LIVESYNC_LOG_REGEX,
+            handler: this.handleAppCrash.bind(this),
+            name: "failedLiveSync",
+            platform: this.$devicePlatformsConstants.iOS.toLowerCase(),
+        });
+        const statusStringMap = {
+            success: constants_1.HmrConstants.HMR_SUCCESS_STATUS,
+            failure: constants_1.HmrConstants.HMR_ERROR_STATUS,
+        };
+        this.$logParserService.addParseRule({
+            regex: /\[HMR]\[(.+)]\s*(\w+)\s*\|/,
+            handler: (matches, deviceId) => {
+                const [hash, status] = matches.slice(1);
+                const mappedStatus = statusStringMap[status.trim()];
+                if (mappedStatus) {
+                    this.setData(deviceId, hash, statusStringMap[status]);
+                }
+            },
+            name: "hmr-status",
+        });
+    }
+    handleAppCrash(matches, deviceId) {
+        for (const operationId in this.hashOperationStatuses) {
+            const operation = this.hashOperationStatuses[operationId];
+            if (operationId.startsWith(deviceId) && !operation.status) {
+                operation.status = constants_1.HmrConstants.HMR_ERROR_STATUS;
+            }
+        }
+    }
+    handleHmrStatusFound(matches, deviceId) {
+        const message = matches[1].trim();
+        const hash = matches[2];
+        let status;
+        switch (message) {
+            case HmrStatusService.SUCCESS_MESSAGE: {
+                status = constants_1.HmrConstants.HMR_SUCCESS_STATUS;
+                break;
+            }
+            case HmrStatusService.FAILED_MESSAGE: {
+                status = constants_1.HmrConstants.HMR_ERROR_STATUS;
+                break;
+            }
+            default: {
+                status = null;
+                break;
+            }
+        }
+        this.$logger.trace("Found hmr status.", { status, hash });
+        if (status) {
+            this.setData(deviceId, hash, status);
+        }
+    }
+    getStatusByKey(key) {
+        if (this.hashOperationStatuses[key]) {
+            return this.hashOperationStatuses[key].status;
+        }
+        return null;
+    }
+    setData(deviceId, operationHash, status) {
+        const key = `${deviceId}${operationHash}`;
+        if (!this.hashOperationStatuses[key]) {
+            this.hashOperationStatuses[key] = {};
+        }
+        this.hashOperationStatuses[key].status = status;
+    }
+}
+HmrStatusService.HMR_STATUS_LOG_REGEX = /([a-z A-Z]*) hmr hash ([a-z0-9]*)\./;
+HmrStatusService.STARTED_MESSAGE = "Checking for updates to the bundle with";
+HmrStatusService.SUCCESS_MESSAGE = "Successfully applied update with";
+HmrStatusService.FAILED_MESSAGE = "Cannot apply update with";
+__decorate([
+    (0, decorators_1.cache)()
+], HmrStatusService.prototype, "attachToHmrStatusEvent", null);
+exports.HmrStatusService = HmrStatusService;
+yok_1.injector.register("hmrStatusService", HmrStatusService);

package/lib/services/info-service.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoService = void 0;
+const yok_1 = require("../common/yok");
+class InfoService {
+    constructor($versionsService) {
+        this.$versionsService = $versionsService;
+    }
+    printComponentsInfo() {
+        return this.$versionsService.printVersionsInformation();
+    }
+}
+exports.InfoService = InfoService;
+yok_1.injector.register("infoService", InfoService);

package/lib/services/initialize-service.js

@@ -0,0 +1,70 @@
+"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.InitializeService = void 0;
+const os_1 = require("os");
+const _ = require("lodash");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class InitializeService {
+    constructor($injector) {
+        this.$injector = $injector;
+    }
+    initialize(initOpts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            initOpts = initOpts || {};
+            const $logger = this.$injector.resolve("logger");
+            const $options = this.$injector.resolve("options");
+            if (initOpts.loggerOptions) {
+                $logger.initialize(initOpts.loggerOptions);
+            }
+            else {
+                const loggerLevel = $options.log &&
+                    constants_1.LoggerLevel[$options.log.toUpperCase()];
+                $logger.initializeCliLogger({ level: loggerLevel });
+            }
+            if (initOpts.settingsServiceOptions) {
+                const $settingsService = this.$injector.resolve("settingsService");
+                $settingsService.setSettings(initOpts.settingsServiceOptions);
+            }
+            if (initOpts.extensibilityOptions) {
+                if (initOpts.extensibilityOptions.pathToExtensions) {
+                    const $extensibilityService = this.$injector.resolve("extensibilityService");
+                    $extensibilityService.pathToExtensions =
+                        initOpts.extensibilityOptions.pathToExtensions;
+                }
+            }
+            if ($options.json) {
+                $logger.trace("Skipping system warnings for --json commands");
+            }
+            else {
+                yield this.showWarnings($logger);
+            }
+        });
+    }
+    showWarnings($logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const $sysInfo = yok_1.injector.resolve("sysInfo");
+            const systemWarnings = yield $sysInfo.getSystemWarnings();
+            _.each(systemWarnings, (systemWarning) => {
+                const message = `${os_1.EOL}${systemWarning.message}${os_1.EOL}`;
+                if (systemWarning.severity === "high") {
+                    $logger.error(message);
+                }
+                else {
+                    $logger.warn(message);
+                }
+            });
+        });
+    }
+}
+exports.InitializeService = InitializeService;
+yok_1.injector.register("initializeService", InitializeService);

package/lib/services/ios/export-options-plist-service.js

@@ -0,0 +1,131 @@
+"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.ExportOptionsPlistService = void 0;
+const path = require("path");
+const mobileProvisionFinder = require("ios-mobileprovision-finder");
+const yok_1 = require("../../common/yok");
+const constants = require("../../constants");
+class ExportOptionsPlistService {
+    constructor($fs, $tempService, $projectData) {
+        this.$fs = $fs;
+        this.$tempService = $tempService;
+        this.$projectData = $projectData;
+    }
+    getExtensionProvisions() {
+        const provisioningJSONPath = path.join(this.$projectData.getAppResourcesDirectoryPath(), constants.iOSAppResourcesFolderName, constants.NATIVE_EXTENSION_FOLDER, constants.EXTENSION_PROVISIONING_FILENAME);
+        if (!this.$fs.exists(provisioningJSONPath)) {
+            return "";
+        }
+        const provisioningJSON = this.$fs.readJson(provisioningJSONPath);
+        return Object.entries(provisioningJSON)
+            .map(([id, provision]) => {
+            return `<key>${id}</key>\n	<string>${provision}</string>`;
+        })
+            .join("\n");
+    }
+    createDevelopmentExportOptionsPlist(archivePath, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exportOptionsMethod = this.getExportOptionsMethod(projectData, archivePath);
+            const provision = buildConfig.provision || buildConfig.mobileProvisionIdentifier;
+            const iCloudContainerEnvironment = buildConfig.iCloudContainerEnvironment;
+            let plistTemplate = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>method</key>
+	<string>${exportOptionsMethod}</string>`;
+            if (provision) {
+                plistTemplate += `    <key>provisioningProfiles</key>
+<dict>
+	<key>${projectData.projectIdentifiers.ios}</key>
+	<string>${provision}</string>
+	${this.getExtensionProvisions()}
+</dict>`;
+            }
+            plistTemplate += `
+    <key>uploadBitcode</key>
+    <false/>
+    <key>compileBitcode</key>
+    <false/>`;
+            if (iCloudContainerEnvironment) {
+                plistTemplate += `
+    <key>iCloudContainerEnvironment</key>
+    <string>${iCloudContainerEnvironment}</string>`;
+            }
+            plistTemplate += `
+</dict>
+</plist>`;
+            const exportOptionsPlistFilePath = yield this.$tempService.path({
+                prefix: "export-",
+                suffix: ".plist",
+            });
+            this.$fs.writeFile(exportOptionsPlistFilePath, plistTemplate);
+            const exportFileDir = path.resolve(path.dirname(archivePath));
+            const exportFilePath = path.join(exportFileDir, projectData.projectName + ".ipa");
+            return { exportFileDir, exportFilePath, exportOptionsPlistFilePath };
+        });
+    }
+    createDistributionExportOptionsPlist(archivePath, projectData, buildConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provision = buildConfig.provision || buildConfig.mobileProvisionIdentifier;
+            const teamId = buildConfig.teamId;
+            let plistTemplate = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+`;
+            if (teamId) {
+                plistTemplate += `    <key>teamID</key>
+    <string>${teamId}</string>
+`;
+            }
+            if (provision) {
+                plistTemplate += `    <key>provisioningProfiles</key>
+    <dict>
+        <key>${projectData.projectIdentifiers.ios}</key>
+        <string>${provision}</string>
+        ${this.getExtensionProvisions()}
+    </dict>`;
+            }
+            plistTemplate += `    <key>method</key>
+    <string>app-store</string>
+    <key>uploadBitcode</key>
+    <false/>
+    <key>compileBitcode</key>
+    <false/>
+    <key>uploadSymbols</key>
+    <false/>
+</dict>
+</plist>`;
+            const exportOptionsPlistFilePath = yield this.$tempService.path({
+                prefix: "export-",
+                suffix: ".plist",
+            });
+            this.$fs.writeFile(exportOptionsPlistFilePath, plistTemplate);
+            const exportFileDir = path.resolve(path.dirname(archivePath));
+            const exportFilePath = path.join(exportFileDir, projectData.projectName + ".ipa");
+            return { exportFileDir, exportFilePath, exportOptionsPlistFilePath };
+        });
+    }
+    getExportOptionsMethod(projectData, archivePath) {
+        const embeddedMobileProvisionPath = path.join(archivePath, "Products", "Applications", `${projectData.projectName}.app`, "embedded.mobileprovision");
+        const provision = mobileProvisionFinder.provision.readFromFile(embeddedMobileProvisionPath);
+        return {
+            Development: "development",
+            AdHoc: "ad-hoc",
+            Distribution: "app-store",
+            Enterprise: "enterprise",
+        }[provision.Type];
+    }
+}
+exports.ExportOptionsPlistService = ExportOptionsPlistService;
+yok_1.injector.register("exportOptionsPlistService", ExportOptionsPlistService);