@akylas/nativescript-cli 8.7.2

package/lib/services/performance-service.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceService = void 0;
+const os_1 = require("os");
+const helpers_1 = require("../common/helpers");
+const semver = require("semver");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class PerformanceService {
+    constructor($options, $fs, $logger, $analyticsService) {
+        this.$options = $options;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$analyticsService = $analyticsService;
+        this.performance = null;
+        if (this.isPerformanceModuleSupported()) {
+            this.performance = require("perf_hooks").performance;
+        }
+    }
+    processExecutionData(methodInfo, startTime, endTime, args) {
+        const executionTime = Math.floor(endTime - startTime);
+        this.trackAnalyticsData(methodInfo, executionTime);
+        if (typeof this.$options.performance === "string") {
+            this.logDataToFile(this.$options.performance, methodInfo, executionTime, args);
+        }
+        else if (this.$options.performance) {
+            this.$logger.info(PerformanceService.LOG_MESSAGE_TEMPLATE, methodInfo, executionTime);
+        }
+    }
+    now() {
+        if (this.isPerformanceModuleSupported()) {
+            return this.performance.now();
+        }
+        else {
+            return new Date().getTime();
+        }
+    }
+    isPerformanceModuleSupported() {
+        return semver.gte(process.version, PerformanceService.MIN_NODE_PERFORMANCE_MODULE_VERSION);
+    }
+    trackAnalyticsData(methodInfo, executionTime) {
+        this.$analyticsService
+            .trackEventActionInGoogleAnalytics({
+            action: "Performance",
+            additionalData: methodInfo,
+            value: executionTime,
+        })
+            .catch((err) => {
+            throw err;
+        });
+    }
+    logDataToFile(filePath, methodInfo, executionTime, args) {
+        let methodArgs;
+        try {
+            methodArgs = JSON.stringify(args, this.getJsonSanitizer());
+        }
+        catch (e) {
+            methodArgs = "cyclic args";
+        }
+        const info = {
+            methodInfo,
+            executionTime,
+            timestamp: (0, helpers_1.getFixedLengthDateString)(),
+            methodArgs: JSON.parse(methodArgs),
+        };
+        try {
+            this.$fs.appendFile(filePath, `${JSON.stringify(info)}${os_1.EOL}`);
+        }
+        catch (e) {
+            this.$logger.trace(PerformanceService.FAIL_LOG_MESSAGE_TEMPLATE, methodInfo);
+            this.$logger.info(PerformanceService.LOG_MESSAGE_TEMPLATE, methodInfo, executionTime);
+        }
+    }
+    getJsonSanitizer() {
+        const seen = new WeakSet();
+        seen.add(this.$options);
+        return (key, value) => {
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value) || _.startsWith(key, "$")) {
+                    return;
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    }
+}
+PerformanceService.LOG_MESSAGE_TEMPLATE = `Execution of method "%s" took %s ms.`;
+PerformanceService.FAIL_LOG_MESSAGE_TEMPLATE = `Failed to log pefromance data in file for method %s.`;
+PerformanceService.MIN_NODE_PERFORMANCE_MODULE_VERSION = "8.5.0";
+exports.PerformanceService = PerformanceService;
+yok_1.injector.register("performanceService", PerformanceService);

package/lib/services/platform/add-platform-service.js

@@ -0,0 +1,119 @@
+"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;
+};
+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.AddPlatformService = void 0;
+const path = require("path");
+const constants_1 = require("../../constants");
+const decorators_1 = require("../../common/decorators");
+const yok_1 = require("../../common/yok");
+class AddPlatformService {
+    constructor($fs, $logger, $packageManager, $terminalSpinnerService, $analyticsService) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$packageManager = $packageManager;
+        this.$terminalSpinnerService = $terminalSpinnerService;
+        this.$analyticsService = $analyticsService;
+    }
+    addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinner = this.$terminalSpinnerService.createSpinner();
+            try {
+                spinner.start();
+                const frameworkDirPath = yield this.installPackage(projectData.projectDir, packageToInstall);
+                const frameworkPackageJsonContent = this.$fs.readJson(path.join(frameworkDirPath, "..", "package.json"));
+                const frameworkVersion = frameworkPackageJsonContent.version;
+                yield this.trackPlatformVersion(frameworkVersion, platformData);
+                if (!addPlatformData.nativePrepare ||
+                    !addPlatformData.nativePrepare.skipNativePrepare) {
+                    yield this.addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion);
+                }
+                return frameworkVersion;
+            }
+            catch (err) {
+                const platformPath = path.join(projectData.platformsDir, platformData.platformNameLowerCase);
+                this.$fs.deleteDirectory(platformPath);
+                throw err;
+            }
+            finally {
+                spinner.stop();
+            }
+        });
+    }
+    setPlatformVersion(platformData, projectData, frameworkVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.installPackage(projectData.projectDir, `${platformData.frameworkPackageName}@${frameworkVersion}`);
+        });
+    }
+    installPackage(projectDir, packageName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const frameworkDir = this.resolveFrameworkDir(projectDir, packageName);
+            if (frameworkDir && this.$fs.exists(frameworkDir)) {
+                return frameworkDir;
+            }
+            const installedPackage = yield this.$packageManager.install(packageName, projectDir, {
+                silent: true,
+                dev: true,
+                "save-dev": true,
+                "save-exact": true,
+            });
+            if (!installedPackage.name) {
+                return "";
+            }
+            return this.resolveFrameworkDir(projectDir, installedPackage.name) || "";
+        });
+    }
+    resolveFrameworkDir(projectDir, packageName) {
+        try {
+            packageName = packageName.replace(/(.+)@.+$/g, "$1");
+            const frameworkDir = require
+                .resolve(`${packageName}/package.json`, {
+                paths: [projectDir],
+            })
+                .replace("package.json", constants_1.PROJECT_FRAMEWORK_FOLDER_NAME);
+            if (frameworkDir) {
+                return path.resolve(frameworkDir);
+            }
+        }
+        catch (err) {
+            this.$logger.trace(`Couldn't resolve installed framework. Continuing with install...`, err);
+        }
+        return null;
+    }
+    addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformDir = path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
+            this.$fs.deleteDirectory(platformDir);
+            yield platformData.platformProjectService.createProject(path.resolve(frameworkDirPath), frameworkVersion, projectData);
+            platformData.platformProjectService.ensureConfigurationFileInAppResources(projectData);
+            yield platformData.platformProjectService.interpolateData(projectData);
+            platformData.platformProjectService.afterCreateProject(platformData.projectRoot, projectData);
+        });
+    }
+    trackPlatformVersion(frameworkVersion, platformData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                action: "Add Platform",
+                additionalData: `${platformData.platformNameLowerCase}${constants_1.AnalyticsEventLabelDelimiter}${frameworkVersion}`,
+            });
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], AddPlatformService.prototype, "addNativePlatform", null);
+exports.AddPlatformService = AddPlatformService;
+yok_1.injector.register("addPlatformService", AddPlatformService);

package/lib/services/platform/platform-validation-service.js

@@ -0,0 +1,85 @@
+"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.PlatformValidationService = void 0;
+const helpers = require("../../common/helpers");
+const path = require("path");
+const yok_1 = require("../../common/yok");
+class PlatformValidationService {
+    constructor($errors, $fs, $logger, $mobileHelper, $platformsDataService) {
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$platformsDataService = $platformsDataService;
+    }
+    isValidPlatform(platform, projectData) {
+        if (!platform) {
+            return false;
+        }
+        platform = platform.split("@")[0].toLowerCase();
+        if (!this.$platformsDataService.getPlatformData(platform, projectData)) {
+            return false;
+        }
+        return true;
+    }
+    validatePlatform(platform, projectData) {
+        if (!platform) {
+            this.$errors.failWithHelp("No platform specified.");
+        }
+        if (!this.isValidPlatform(platform, projectData)) {
+            const platformNames = helpers.formatListOfNames(this.$mobileHelper.platformNames);
+            this.$errors.fail(`Invalid platform ${platform}. Valid platforms are ${platformNames}.`);
+        }
+    }
+    validatePlatformInstalled(platform, projectData) {
+        this.validatePlatform(platform, projectData);
+        const hasPlatformDirectory = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
+        if (!hasPlatformDirectory) {
+            this.$errors.fail("The platform %s is not added to this project. Please use 'ns platform add <platform>'", platform);
+        }
+    }
+    validateOptions(provision, teamId, projectData, platform, aab) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (platform && !this.$mobileHelper.isAndroidPlatform(platform) && aab) {
+                this.$errors.fail("The --aab option is supported only for the Android platform.");
+            }
+            if (platform) {
+                platform = this.$mobileHelper.normalizePlatformName(platform);
+                this.$logger.trace("Validate options for platform: " + platform);
+                const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+                const result = yield platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[platform.toLowerCase()], provision, teamId);
+                return result;
+            }
+            else {
+                let valid = true;
+                const platforms = this.$mobileHelper.platformNames.map((p) => p.toLowerCase());
+                for (const availablePlatform of platforms) {
+                    this.$logger.trace("Validate options for platform: " + availablePlatform);
+                    const platformData = this.$platformsDataService.getPlatformData(availablePlatform, projectData);
+                    valid =
+                        valid &&
+                            (yield platformData.platformProjectService.validateOptions(projectData.projectIdentifiers[availablePlatform.toLowerCase()], provision, teamId));
+                }
+                return valid;
+            }
+        });
+    }
+    isPlatformSupportedForOS(platform, projectData) {
+        const targetedOS = this.$platformsDataService.getPlatformData(platform, projectData).targetedOS;
+        const res = !targetedOS ||
+            targetedOS.indexOf("*") >= 0 ||
+            targetedOS.indexOf(process.platform) >= 0;
+        return res;
+    }
+}
+exports.PlatformValidationService = PlatformValidationService;
+yok_1.injector.register("platformValidationService", PlatformValidationService);

package/lib/services/platform/prepare-native-platform-service.js

@@ -0,0 +1,87 @@
+"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;
+};
+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.PrepareNativePlatformService = void 0;
+const helpers_1 = require("../../common/helpers");
+const decorators_1 = require("../../common/decorators");
+const yok_1 = require("../../common/yok");
+class PrepareNativePlatformService {
+    constructor($hooksService, $nodeModulesBuilder, $projectChangesService, $metadataFilteringService) {
+        this.$hooksService = $hooksService;
+        this.$nodeModulesBuilder = $nodeModulesBuilder;
+        this.$projectChangesService = $projectChangesService;
+        this.$metadataFilteringService = $metadataFilteringService;
+    }
+    prepareNativePlatform(platformData, projectData, prepareData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { nativePrepare, release } = prepareData;
+            const changesInfo = yield this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
+            if (nativePrepare && nativePrepare.skipNativePrepare) {
+                return changesInfo.hasChanges;
+            }
+            const hasNativeModulesChange = !changesInfo || changesInfo.nativeChanged;
+            const hasConfigChange = !changesInfo || changesInfo.configChanged;
+            const hasChangesRequirePrepare = !changesInfo || changesInfo.changesRequirePrepare;
+            const hasChanges = hasNativeModulesChange || hasConfigChange || hasChangesRequirePrepare;
+            if (changesInfo.hasChanges) {
+                yield this.cleanProject(platformData, { release });
+            }
+            platformData.platformProjectService.prepareAppResources(projectData);
+            if (hasChangesRequirePrepare) {
+                yield platformData.platformProjectService.prepareProject(projectData, prepareData);
+            }
+            if (hasNativeModulesChange) {
+                yield this.$nodeModulesBuilder.prepareNodeModules({
+                    platformData,
+                    projectData,
+                });
+            }
+            if (hasNativeModulesChange || hasConfigChange) {
+                yield platformData.platformProjectService.processConfigurationFilesFromAppResources(projectData, { release });
+                yield platformData.platformProjectService.handleNativeDependenciesChange(projectData, { release });
+                this.$metadataFilteringService.generateMetadataFilters(projectData, platformData.platformNameLowerCase);
+            }
+            platformData.platformProjectService.interpolateConfigurationFile(projectData);
+            yield this.$projectChangesService.setNativePlatformStatus(platformData, projectData, { nativePlatformStatus: "3" });
+            return hasChanges;
+        });
+    }
+    cleanProject(platformData, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (platformData.platformNameLowerCase !== "android") {
+                return;
+            }
+            const previousPrepareInfo = this.$projectChangesService.getPrepareInfo(platformData);
+            if (!previousPrepareInfo ||
+                previousPrepareInfo.nativePlatformStatus !==
+                    "3") {
+                return;
+            }
+            const { release: previousWasRelease } = previousPrepareInfo;
+            const { release: currentIsRelease } = options;
+            if (previousWasRelease !== currentIsRelease) {
+                yield platformData.platformProjectService.cleanProject(platformData.projectRoot);
+            }
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)(),
+    (0, helpers_1.hook)("prepareNativeApp")
+], PrepareNativePlatformService.prototype, "prepareNativePlatform", null);
+exports.PrepareNativePlatformService = PrepareNativePlatformService;
+yok_1.injector.register("prepareNativePlatformService", PrepareNativePlatformService);

package/lib/services/platform-environment-requirements.js

@@ -0,0 +1,87 @@
+"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;
+};
+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.PlatformEnvironmentRequirements = void 0;
+const helpers_1 = require("../common/helpers");
+const os_1 = require("os");
+const yok_1 = require("../common/yok");
+class PlatformEnvironmentRequirements {
+    constructor($doctorService, $errors, $analyticsService, $injector) {
+        this.$doctorService = $doctorService;
+        this.$errors = $errors;
+        this.$analyticsService = $analyticsService;
+        this.$injector = $injector;
+    }
+    checkEnvironmentRequirements(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { platform, projectDir, runtimeVersion } = input;
+            const selectedOption = null;
+            if (process.env.NS_SKIP_ENV_CHECK) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Check Environment Requirements",
+                    additionalData: "Skipped: NS_SKIP_ENV_CHECK is set",
+                });
+                return {
+                    canExecute: true,
+                    selectedOption,
+                };
+            }
+            const canExecute = yield this.$doctorService.canExecuteLocalBuild({
+                platform,
+                projectDir,
+                runtimeVersion,
+                forceCheck: input.forceCheck,
+            });
+            if (!canExecute) {
+                yield this.$analyticsService.trackEventActionInGoogleAnalytics({
+                    action: "Check Environment Requirements",
+                    additionalData: "Non-interactive terminal, unable to execute local builds.",
+                });
+                this.fail(this.getNonInteractiveConsoleMessage(platform));
+            }
+            return {
+                canExecute,
+                selectedOption,
+            };
+        });
+    }
+    fail(message) {
+        this.$errors.fail({ formatStr: message, printOnStdout: true });
+    }
+    getNonInteractiveConsoleMessage(platform) {
+        return [
+            PlatformEnvironmentRequirements.MISSING_LOCAL_SETUP_MESSAGE,
+            this.getEnvVerificationMessage(platform),
+        ].join(os_1.EOL);
+    }
+    getEnvVerificationMessage(platform) {
+        const os = {
+            linux: "linux",
+            win32: "windows",
+            darwin: "macos",
+        }[process.platform];
+        const anchor = platform ? `#setting-up-${os}-for-${platform.toLowerCase()}` : "";
+        return (`Verify that your environment is configured according to the system requirements described at\n` +
+            `https://docs.nativescript.org/setup/${os}${anchor}.`);
+    }
+}
+PlatformEnvironmentRequirements.MISSING_LOCAL_SETUP_MESSAGE = "Your environment is not configured properly and you will not be able to execute local builds.";
+__decorate([
+    (0, helpers_1.hook)("checkEnvironment")
+], PlatformEnvironmentRequirements.prototype, "checkEnvironmentRequirements", null);
+exports.PlatformEnvironmentRequirements = PlatformEnvironmentRequirements;
+yok_1.injector.register("platformEnvironmentRequirements", PlatformEnvironmentRequirements);

package/lib/services/platform-project-service-base.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformProjectServiceBase = void 0;
+const events_1 = require("events");
+const _ = require("lodash");
+class PlatformProjectServiceBase extends events_1.EventEmitter {
+    constructor($fs, $projectDataService) {
+        super();
+        this.$fs = $fs;
+        this.$projectDataService = $projectDataService;
+    }
+    getPluginPlatformsFolderPath(pluginData, platform) {
+        return pluginData.pluginPlatformsFolderPath(platform);
+    }
+    getFrameworkVersion(projectData) {
+        const frameworkData = this.$projectDataService.getRuntimePackage(projectData.projectDir, this.getPlatformData(projectData).platformNameLowerCase);
+        return frameworkData && frameworkData.version;
+    }
+    getAllNativeLibrariesForPlugin(pluginData, platform, filter) {
+        const pluginPlatformsFolderPath = this.getPluginPlatformsFolderPath(pluginData, platform);
+        let nativeLibraries = [];
+        if (pluginPlatformsFolderPath &&
+            this.$fs.exists(pluginPlatformsFolderPath)) {
+            const platformsContents = this.$fs.readDirectory(pluginPlatformsFolderPath);
+            nativeLibraries = _(platformsContents)
+                .filter((platformItemName) => filter(platformItemName, pluginPlatformsFolderPath))
+                .value();
+        }
+        return nativeLibraries;
+    }
+}
+exports.PlatformProjectServiceBase = PlatformProjectServiceBase;

package/lib/services/platforms-data-service.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformsDataService = void 0;
+const yok_1 = require("../common/yok");
+const _ = require("lodash");
+class PlatformsDataService {
+    constructor($options, $androidProjectService, $iOSProjectService) {
+        this.$options = $options;
+        this.platformsDataService = {};
+        this.platformsDataService = {
+            ios: $iOSProjectService,
+            android: $androidProjectService,
+            visionos: $iOSProjectService,
+        };
+    }
+    getPlatformData(platform, projectData) {
+        var _a;
+        var _b;
+        const platformKey = platform && _.first(platform.toLowerCase().split("@"));
+        let platformData;
+        if (platformKey) {
+            (_a = (_b = this.$options).platformOverride) !== null && _a !== void 0 ? _a : (_b.platformOverride = platform);
+            platformData =
+                this.platformsDataService[platformKey] &&
+                    this.platformsDataService[platformKey].getPlatformData(projectData);
+        }
+        return platformData;
+    }
+}
+exports.PlatformsDataService = PlatformsDataService;
+yok_1.injector.register("platformsDataService", PlatformsDataService);