@akylas/nativescript-cli 8.7.2 → 8.8.3

package/lib/controllers/prepare-controller.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.PrepareController = void 0;
 const choki = require("chokidar");
@@ -24,13 +15,15 @@ const decorators_1 = require("../common/decorators");
 const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
 const constants_1 = require("../constants");
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
 class PrepareController extends events_1.EventEmitter {
-    constructor($platformController, $hooksService, $fs, $logger, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $webpackCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
+    constructor($platformController, $hooksService, $fs, $logger, $options, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $webpackCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
         super();
         this.$platformController = $platformController;
         this.$hooksService = $hooksService;
         this.$fs = $fs;
         this.$logger = $logger;
+        this.$options = $options;
         this.$mobileHelper = $mobileHelper;
         this.$nodeModulesDependenciesBuilder = $nodeModulesDependenciesBuilder;
         this.$platformsDataService = $platformsDataService;
@@ -50,242 +43,267 @@ class PrepareController extends events_1.EventEmitter {
         this.webpackCompilerHandler = null;
         this.pausedFileWatch = false;
     }
-    prepare(prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const projectData = this.$projectDataService.getProjectData(prepareData.projectDir);
-            if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
-                yield this.$markingModeService.handleMarkingModeFullDeprecation({
-                    projectDir: projectData.projectDir,
-                });
-            }
-            yield this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
-            return this.prepareCore(prepareData, projectData);
-        });
+    async prepare(prepareData) {
+        const projectData = this.$projectDataService.getProjectData(prepareData.projectDir);
+        if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
+            await this.$markingModeService.handleMarkingModeFullDeprecation({
+                projectDir: projectData.projectDir,
+            });
+        }
+        await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
+        return this.prepareCore(prepareData, projectData);
     }
-    stopWatchers(projectDir, platform) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platformLowerCase = platform.toLowerCase();
-            if (this.watchersData &&
-                this.watchersData[projectDir] &&
-                this.watchersData[projectDir][platformLowerCase] &&
-                this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher) {
-                yield this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher.close();
-                this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher =
-                    null;
-            }
-            if (this.watchersData &&
-                this.watchersData[projectDir] &&
-                this.watchersData[projectDir][platformLowerCase] &&
-                this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess) {
-                yield this.$webpackCompilerService.stopWebpackCompiler(platformLowerCase);
-                this.$webpackCompilerService.removeListener(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
-                this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess = false;
-            }
-        });
+    async stopWatchers(projectDir, platform) {
+        const platformLowerCase = platform.toLowerCase();
+        if (this.watchersData &&
+            this.watchersData[projectDir] &&
+            this.watchersData[projectDir][platformLowerCase] &&
+            this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher) {
+            await this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher.close();
+            this.watchersData[projectDir][platformLowerCase].nativeFilesWatcher =
+                null;
+        }
+        if (this.watchersData &&
+            this.watchersData[projectDir] &&
+            this.watchersData[projectDir][platformLowerCase] &&
+            this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess) {
+            await this.$webpackCompilerService.stopWebpackCompiler(platformLowerCase);
+            this.$webpackCompilerService.removeListener(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
+            this.watchersData[projectDir][platformLowerCase].hasWebpackCompilerProcess = false;
+        }
     }
-    prepareCore(prepareData, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.$projectService.ensureAppResourcesExist(projectData.projectDir);
-            yield this.$platformController.addPlatformIfNeeded(prepareData, projectData);
-            yield this.trackRuntimeVersion(prepareData.platform, projectData);
-            this.$logger.info("Preparing project...");
-            prepareData.env = prepareData.env || {};
-            prepareData.env.externals = prepareData.env.externals || [];
-            prepareData.env.externals.push("~/package.json");
-            prepareData.env.externals.push("package.json");
-            if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
-                yield this.$projectConfigService.writeLegacyNSConfigIfNeeded(projectData.projectDir, this.$projectDataService.getRuntimePackage(projectData.projectDir, prepareData.platform));
-            }
-            let result = null;
-            const platformData = this.$platformsDataService.getPlatformData(prepareData.platform, projectData);
-            if (prepareData.watch) {
-                result = yield this.startWatchersWithPrepare(platformData, projectData, prepareData);
-            }
-            else {
-                yield this.$webpackCompilerService.compileWithoutWatch(platformData, projectData, prepareData);
-                const hasNativeChanges = yield this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
-                result = {
-                    hasNativeChanges,
-                    platform: prepareData.platform.toLowerCase(),
-                };
-            }
-            yield this.writeRuntimePackageJson(projectData, platformData);
-            yield this.$projectChangesService.savePrepareInfo(platformData, projectData, prepareData);
-            this.$logger.info(`Project successfully prepared (${prepareData.platform.toLowerCase()})`);
-            return result;
-        });
+    async prepareCore(prepareData, projectData) {
+        await this.$projectService.ensureAppResourcesExist(projectData.projectDir);
+        await this.$platformController.addPlatformIfNeeded(prepareData, projectData);
+        await this.trackRuntimeVersion(prepareData.platform, projectData);
+        this.$logger.info("Preparing project...");
+        prepareData.env = prepareData.env || {};
+        prepareData.env.externals = prepareData.env.externals || [];
+        prepareData.env.externals.push("~/package.json");
+        prepareData.env.externals.push("package.json");
+        if (this.$mobileHelper.isAndroidPlatform(prepareData.platform)) {
+            await this.$projectConfigService.writeLegacyNSConfigIfNeeded(projectData.projectDir, this.$projectDataService.getRuntimePackage(projectData.projectDir, prepareData.platform));
+        }
+        let result = null;
+        const platformData = this.$platformsDataService.getPlatformData(prepareData.platform, projectData);
+        if (prepareData.watch) {
+            result = await this.startWatchersWithPrepare(platformData, projectData, prepareData);
+        }
+        else {
+            await this.$webpackCompilerService.compileWithoutWatch(platformData, projectData, prepareData);
+            const hasNativeChanges = await this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
+            result = {
+                hasNativeChanges,
+                platform: prepareData.platform.toLowerCase(),
+            };
+        }
+        await this.writeRuntimePackageJson(projectData, platformData);
+        await this.$projectChangesService.savePrepareInfo(platformData, projectData, prepareData);
+        this.$logger.info(`Project successfully prepared (${prepareData.platform.toLowerCase()})`);
+        return result;
     }
-    startWatchersWithPrepare(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.watchersData[projectData.projectDir]) {
-                this.watchersData[projectData.projectDir] = {};
-            }
-            if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase]) {
-                this.watchersData[projectData.projectDir][platformData.platformNameLowerCase] = {
-                    nativeFilesWatcher: null,
-                    hasWebpackCompilerProcess: false,
-                    prepareArguments: {
-                        platformData,
-                        projectData,
-                        prepareData,
-                    },
-                };
-            }
-            yield this.startJSWatcherWithPrepare(platformData, projectData, prepareData);
-            const hasNativeChanges = yield this.startNativeWatcherWithPrepare(platformData, projectData, prepareData);
-            const result = {
+    async startWatchersWithPrepare(platformData, projectData, prepareData) {
+        if (!this.watchersData[projectData.projectDir]) {
+            this.watchersData[projectData.projectDir] = {};
+        }
+        if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase]) {
+            this.watchersData[projectData.projectDir][platformData.platformNameLowerCase] = {
+                nativeFilesWatcher: null,
+                hasWebpackCompilerProcess: false,
+                prepareArguments: {
+                    platformData,
+                    projectData,
+                    prepareData,
+                },
+            };
+        }
+        await this.startJSWatcherWithPrepare(platformData, projectData, prepareData);
+        const hasNativeChanges = await this.startNativeWatcherWithPrepare(platformData, projectData, prepareData);
+        const result = {
+            platform: platformData.platformNameLowerCase,
+            hasNativeChanges,
+        };
+        const hasPersistedDataWithNativeChanges = this.persistedData.find((data) => data.platform === result.platform && data.hasNativeChanges);
+        if (hasPersistedDataWithNativeChanges) {
+            result.hasNativeChanges = true;
+        }
+        this.isInitialPrepareReady = true;
+        if (this.persistedData && this.persistedData.length) {
+            this.emitPrepareEvent({
+                files: [],
+                staleFiles: [],
+                hasOnlyHotUpdateFiles: false,
+                hasNativeChanges: result.hasNativeChanges,
+                hmrData: null,
                 platform: platformData.platformNameLowerCase,
-                hasNativeChanges,
+            });
+        }
+        return result;
+    }
+    async startJSWatcherWithPrepare(platformData, projectData, prepareData) {
+        if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess) {
+            const handler = (data) => {
+                var _a;
+                if (data.platform.toLowerCase() === platformData.platformNameLowerCase) {
+                    if (this.isFileWatcherPaused())
+                        return;
+                    this.emitPrepareEvent({
+                        ...data,
+                        files: (_a = data.files) !== null && _a !== void 0 ? _a : [],
+                        hasNativeChanges: false,
+                    });
+                }
             };
-            const hasPersistedDataWithNativeChanges = this.persistedData.find((data) => data.platform === result.platform && data.hasNativeChanges);
-            if (hasPersistedDataWithNativeChanges) {
-                result.hasNativeChanges = true;
+            this.webpackCompilerHandler = handler.bind(this);
+            this.$webpackCompilerService.on(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
+            this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess = true;
+            await this.$webpackCompilerService.compileWithWatch(platformData, projectData, prepareData);
+        }
+    }
+    async startNativeWatcherWithPrepare(platformData, projectData, prepareData) {
+        let newNativeWatchStarted = false;
+        let hasNativeChanges = false;
+        if (prepareData.watchNative) {
+            newNativeWatchStarted = await this.startNativeWatcher(platformData, projectData);
+        }
+        if (newNativeWatchStarted) {
+            hasNativeChanges =
+                await this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
+        }
+        return hasNativeChanges;
+    }
+    async startNativeWatcher(platformData, projectData) {
+        if (this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher) {
+            return false;
+        }
+        const patterns = await this.getWatcherPatterns(platformData, projectData);
+        const watcherOptions = {
+            ignoreInitial: true,
+            cwd: projectData.projectDir,
+            awaitWriteFinish: {
+                pollInterval: 100,
+                stabilityThreshold: 500,
+            },
+            ignored: ["**/.*", ".*"],
+        };
+        const watcher = choki
+            .watch(patterns, watcherOptions)
+            .on("all", async (event, filePath) => {
+            if (this.isFileWatcherPaused())
+                return;
+            filePath = path.join(projectData.projectDir, filePath);
+            if (this.$watchIgnoreListService.isFileInIgnoreList(filePath)) {
+                this.$watchIgnoreListService.removeFileFromIgnoreList(filePath);
             }
-            this.isInitialPrepareReady = true;
-            if (this.persistedData && this.persistedData.length) {
+            else {
+                this.$logger.info(`Chokidar raised event ${event} for ${filePath}.`);
+                await this.writeRuntimePackageJson(projectData, platformData);
                 this.emitPrepareEvent({
-                    files: [],
+                    files: [filePath],
                     staleFiles: [],
                     hasOnlyHotUpdateFiles: false,
-                    hasNativeChanges: result.hasNativeChanges,
                     hmrData: null,
+                    hasNativeChanges: true,
                     platform: platformData.platformNameLowerCase,
                 });
             }
-            return result;
-        });
-    }
-    startJSWatcherWithPrepare(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess) {
-                const handler = (data) => {
-                    var _a;
-                    if (data.platform.toLowerCase() === platformData.platformNameLowerCase) {
-                        if (this.isFileWatcherPaused())
-                            return;
-                        this.emitPrepareEvent(Object.assign(Object.assign({}, data), { files: (_a = data.files) !== null && _a !== void 0 ? _a : [], hasNativeChanges: false }));
-                    }
-                };
-                this.webpackCompilerHandler = handler.bind(this);
-                this.$webpackCompilerService.on(constants_1.WEBPACK_COMPILATION_COMPLETE, this.webpackCompilerHandler);
-                this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].hasWebpackCompilerProcess = true;
-                yield this.$webpackCompilerService.compileWithWatch(platformData, projectData, prepareData);
-            }
-        });
-    }
-    startNativeWatcherWithPrepare(platformData, projectData, prepareData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let newNativeWatchStarted = false;
-            let hasNativeChanges = false;
-            if (prepareData.watchNative) {
-                newNativeWatchStarted = yield this.startNativeWatcher(platformData, projectData);
-            }
-            if (newNativeWatchStarted) {
-                hasNativeChanges =
-                    yield this.$prepareNativePlatformService.prepareNativePlatform(platformData, projectData, prepareData);
-            }
-            return hasNativeChanges;
         });
+        this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher = watcher;
+        return true;
     }
-    startNativeWatcher(platformData, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher) {
-                return false;
-            }
-            const patterns = yield this.getWatcherPatterns(platformData, projectData);
-            const watcherOptions = {
-                ignoreInitial: true,
-                cwd: projectData.projectDir,
-                awaitWriteFinish: {
-                    pollInterval: 100,
-                    stabilityThreshold: 500,
-                },
-                ignored: ["**/.*", ".*"],
-            };
-            const watcher = choki
-                .watch(patterns, watcherOptions)
-                .on("all", (event, filePath) => __awaiter(this, void 0, void 0, function* () {
-                if (this.isFileWatcherPaused())
-                    return;
-                filePath = path.join(projectData.projectDir, filePath);
-                if (this.$watchIgnoreListService.isFileInIgnoreList(filePath)) {
-                    this.$watchIgnoreListService.removeFileFromIgnoreList(filePath);
-                }
-                else {
-                    this.$logger.info(`Chokidar raised event ${event} for ${filePath}.`);
-                    yield this.writeRuntimePackageJson(projectData, platformData);
-                    this.emitPrepareEvent({
-                        files: [filePath],
-                        staleFiles: [],
-                        hasOnlyHotUpdateFiles: false,
-                        hmrData: null,
-                        hasNativeChanges: true,
-                        platform: platformData.platformNameLowerCase,
-                    });
-                }
-            }));
-            this.watchersData[projectData.projectDir][platformData.platformNameLowerCase].nativeFilesWatcher = watcher;
-            return true;
-        });
+    async getWatcherPatterns(platformData, projectData) {
+        const dependencies = this.$nodeModulesDependenciesBuilder
+            .getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies)
+            .filter((dep) => dep.nativescript);
+        const pluginsNativeDirectories = dependencies.map((dep) => path.join(dep.directory, constants_1.PLATFORMS_DIR_NAME, platformData.platformNameLowerCase));
+        const pluginsPackageJsonFiles = dependencies.map((dep) => path.join(dep.directory, constants_1.PACKAGE_JSON_FILE_NAME));
+        const patterns = [
+            path.join(projectData.projectDir, constants_1.PACKAGE_JSON_FILE_NAME),
+            path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_JS),
+            path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_TS),
+            path.join(projectData.getAppDirectoryPath(), constants_1.PACKAGE_JSON_FILE_NAME),
+            path.join(projectData.getAppResourcesRelativeDirectoryPath(), platformData.normalizedPlatformName),
+        ]
+            .concat(pluginsNativeDirectories)
+            .concat(pluginsPackageJsonFiles);
+        return patterns;
     }
-    getWatcherPatterns(platformData, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dependencies = this.$nodeModulesDependenciesBuilder
-                .getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies)
-                .filter((dep) => dep.nativescript);
-            const pluginsNativeDirectories = dependencies.map((dep) => path.join(dep.directory, constants_1.PLATFORMS_DIR_NAME, platformData.platformNameLowerCase));
-            const pluginsPackageJsonFiles = dependencies.map((dep) => path.join(dep.directory, constants_1.PACKAGE_JSON_FILE_NAME));
-            const patterns = [
-                path.join(projectData.projectDir, constants_1.PACKAGE_JSON_FILE_NAME),
-                path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_JS),
-                path.join(projectData.projectDir, constants_1.CONFIG_FILE_NAME_TS),
-                path.join(projectData.getAppDirectoryPath(), constants_1.PACKAGE_JSON_FILE_NAME),
-                path.join(projectData.getAppResourcesRelativeDirectoryPath(), platformData.normalizedPlatformName),
-            ]
-                .concat(pluginsNativeDirectories)
-                .concat(pluginsPackageJsonFiles);
-            return patterns;
+    async writeRuntimePackageJson(projectData, platformData) {
+        var _a, _b;
+        const configInfo = this.$projectConfigService.detectProjectConfigs(projectData.projectDir);
+        if (configInfo.usingNSConfig) {
+            return;
+        }
+        this.$logger.info("Updating runtime package.json with configuration values...");
+        const { hooks, ignoredNativeDependencies, webpackPackageName, webpackConfigPath, appResourcesPath, buildPath, appPath, ...nsConfig } = this.$projectConfigService.readConfig(projectData.projectDir);
+        const platform = platformData.platformNameLowerCase;
+        let installedRuntimePackageJSON;
+        let runtimePackageName;
+        if (platform === "ios") {
+            runtimePackageName = ((_a = projectData.nsConfig.ios) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants_1.SCOPED_IOS_RUNTIME_NAME;
+        }
+        else if (platform === "android") {
+            runtimePackageName = ((_b = projectData.nsConfig.android) === null || _b === void 0 ? void 0 : _b.runtimePackageName) || constants_1.SCOPED_ANDROID_RUNTIME_NAME;
+        }
+        const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(runtimePackageName, {
+            paths: [projectData.projectDir],
         });
-    }
-    writeRuntimePackageJson(projectData, platformData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const configInfo = this.$projectConfigService.detectProjectConfigs(projectData.projectDir);
-            if (configInfo.usingNSConfig) {
-                return;
+        if (installedRuntimePackageJSONPath) {
+            installedRuntimePackageJSON = this.$fs.readJson(installedRuntimePackageJSONPath);
+        }
+        const packageData = {
+            ..._.pick(projectData.packageJsonData, ["name"]),
+            ...nsConfig,
+            main: "bundle",
+            ...(installedRuntimePackageJSON ? {} : {})
+        };
+        if (platform === "ios") {
+            if (installedRuntimePackageJSON) {
+                packageData.ios = packageData.ios || {};
+                packageData.ios.runtime = {
+                    version: installedRuntimePackageJSON.version
+                };
             }
-            this.$logger.info("Updating runtime package.json with configuration values...");
-            const nsConfig = this.$projectConfigService.readConfig(projectData.projectDir);
-            const packageData = Object.assign(Object.assign(Object.assign({}, _.pick(projectData.packageJsonData, ["name"])), nsConfig), { main: "bundle" });
-            if (platformData.platformNameLowerCase === "ios" &&
-                packageData.ios &&
+            if (packageData.ios &&
                 packageData.ios.discardUncaughtJsExceptions) {
                 packageData.discardUncaughtJsExceptions =
                     packageData.ios.discardUncaughtJsExceptions;
             }
-            if (platformData.platformNameLowerCase === "android" &&
-                packageData.android &&
+            delete packageData.android;
+        }
+        if (platform === "android") {
+            if (installedRuntimePackageJSON) {
+                packageData.android = packageData.android || {};
+                packageData.android.runtime = {
+                    version: installedRuntimePackageJSON.version,
+                    version_info: installedRuntimePackageJSON.version_info,
+                    gradle: installedRuntimePackageJSON.gradle
+                };
+            }
+            if (packageData.android &&
                 packageData.android.discardUncaughtJsExceptions) {
                 packageData.discardUncaughtJsExceptions =
                     packageData.android.discardUncaughtJsExceptions;
             }
-            let packagePath;
-            if (this.$mobileHelper.isApplePlatform(platformData.platformNameLowerCase)) {
-                packagePath = path.join(platformData.projectRoot, projectData.projectName, "app", "package.json");
-            }
-            else {
-                packagePath = path.join(platformData.projectRoot, "app", "src", "main", "assets", "app", "package.json");
-            }
-            try {
-                const emittedPackageData = this.$fs.readJson(packagePath);
-                if (emittedPackageData === null || emittedPackageData === void 0 ? void 0 : emittedPackageData.main) {
-                    packageData.main = emittedPackageData.main;
-                }
-            }
-            catch (error) {
-                this.$logger.trace("Failed to read emitted package.json. Error is: ", error);
+            delete packageData.ios;
+        }
+        let packagePath;
+        if (this.$mobileHelper.isApplePlatform(platformData.platformNameLowerCase)) {
+            packagePath = path.join(platformData.projectRoot, projectData.projectName, "app", "package.json");
+        }
+        else {
+            packagePath = path.join(platformData.projectRoot, this.$options.hostProjectModuleName, "src", this.$options.hostProjectPath ? "nativescript" : "main", "assets", "app", "package.json");
+        }
+        try {
+            const emittedPackageData = this.$fs.readJson(packagePath);
+            if (emittedPackageData === null || emittedPackageData === void 0 ? void 0 : emittedPackageData.main) {
+                packageData.main = emittedPackageData.main;
             }
-            this.$fs.writeJson(packagePath, packageData);
-        });
+        }
+        catch (error) {
+            this.$logger.trace("Failed to read emitted package.json. Error is: ", error);
+        }
+        this.$fs.writeJson(packagePath, packageData);
     }
     emitPrepareEvent(filesChangeEventData) {
         if (this.isInitialPrepareReady) {
@@ -295,47 +313,44 @@ class PrepareController extends events_1.EventEmitter {
             this.persistedData.push(filesChangeEventData);
         }
     }
-    trackRuntimeVersion(platform, projectData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { version } = this.$projectDataService.getRuntimePackage(projectData.projectDir, platform);
-            if (!version) {
-                this.$logger.trace(`Unable to get runtime version for project directory: ${projectData.projectDir} and platform ${platform}.`);
-                return;
-            }
-            yield this.$analyticsService.trackEventActionInGoogleAnalytics({
-                action: "Using Runtime Version",
-                additionalData: `${platform.toLowerCase()}${constants_1.AnalyticsEventLabelDelimiter}${version}`,
-            });
+    async trackRuntimeVersion(platform, projectData) {
+        const { version } = this.$projectDataService.getRuntimePackage(projectData.projectDir, platform);
+        if (!version) {
+            this.$logger.trace(`Unable to get runtime version for project directory: ${projectData.projectDir} and platform ${platform}.`);
+            return;
+        }
+        await this.$analyticsService.trackEventActionInGoogleAnalytics({
+            action: "Using Runtime Version",
+            additionalData: `${platform.toLowerCase()}${constants_1.AnalyticsEventLabelDelimiter}${version}`,
         });
     }
     isFileWatcherPaused() {
         return this.pausedFileWatch;
     }
-    toggleFileWatcher() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.pausedFileWatch = !this.pausedFileWatch;
-            const watchers = Object.values(this.watchersData);
-            if (this.pausedFileWatch) {
-                for (const watcher of watchers) {
-                    for (const platform in watcher) {
-                        yield this.$webpackCompilerService.stopWebpackCompiler(platform);
-                        watcher[platform].hasWebpackCompilerProcess = false;
-                    }
+    async toggleFileWatcher() {
+        this.pausedFileWatch = !this.pausedFileWatch;
+        const watchers = Object.values(this.watchersData);
+        if (this.pausedFileWatch) {
+            for (const watcher of watchers) {
+                for (const platform in watcher) {
+                    await this.$webpackCompilerService.stopWebpackCompiler(platform);
+                    watcher[platform].hasWebpackCompilerProcess = false;
                 }
             }
-            else {
-                for (const watcher of watchers) {
-                    for (const platform in watcher) {
-                        const args = watcher[platform].prepareArguments;
-                        watcher[platform].hasWebpackCompilerProcess = true;
-                        yield this.$webpackCompilerService.compileWithWatch(args.platformData, args.projectData, args.prepareData);
-                    }
+        }
+        else {
+            for (const watcher of watchers) {
+                for (const platform in watcher) {
+                    const args = watcher[platform].prepareArguments;
+                    watcher[platform].hasWebpackCompilerProcess = true;
+                    await this.$webpackCompilerService.compileWithWatch(args.platformData, args.projectData, args.prepareData);
                 }
             }
-            return this.pausedFileWatch;
-        });
+        }
+        return this.pausedFileWatch;
     }
 }
+exports.PrepareController = PrepareController;
 __decorate([
     (0, decorators_1.performanceLog)(),
     (0, helpers_1.hook)("prepare")
@@ -349,5 +364,4 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], PrepareController.prototype, "trackRuntimeVersion", null);
-exports.PrepareController = PrepareController;
 yok_1.injector.register("prepareController", PrepareController);