@akylas/nativescript-cli 8.7.2 → 8.8.2

package/lib/services/android-plugin-build-service.js

@@ -23,15 +23,17 @@ const xml2js_1 = require("xml2js");
 const yok_1 = require("../common/yok");
 const _ = require("lodash");
 const resolve_package_path_1 = require("@rigor789/resolve-package-path");
+const process_1 = require("process");
 class AndroidPluginBuildService {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    constructor($fs, $childProcess, $hostInfo, $androidToolsInfo, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
+    constructor($fs, $childProcess, $androidToolsInfo, $hostInfo, $options, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
         this.$fs = $fs;
         this.$childProcess = $childProcess;
-        this.$hostInfo = $hostInfo;
         this.$androidToolsInfo = $androidToolsInfo;
+        this.$hostInfo = $hostInfo;
+        this.$options = $options;
         this.$logger = $logger;
         this.$packageManager = $packageManager;
         this.$projectData = $projectData;
@@ -133,7 +135,7 @@ class AndroidPluginBuildService {
             this.validateOptions(options);
             const manifestFilePath = this.getManifest(options.platformsAndroidDirPath);
             const androidSourceDirectories = this.getAndroidSourceDirectories(options.platformsAndroidDirPath);
-            const shortPluginName = (0, helpers_1.getShortPluginName)(options.pluginName);
+            const shortPluginName = (0, helpers_1.getShortPluginName)(options.pluginName + (options.aarSuffix || ''));
             const pluginTempDir = path.join(options.tempPluginDirPath, shortPluginName);
             const pluginSourceFileHashesInfo = yield this.getSourceFilesHashes(options.platformsAndroidDirPath, shortPluginName);
             const shouldBuildAar = yield this.shouldBuildAar({
@@ -150,7 +152,7 @@ class AndroidPluginBuildService {
                 yield this.updateManifest(manifestFilePath, pluginTempMainSrcDir, shortPluginName);
                 this.copySourceSetDirectories(androidSourceDirectories, pluginTempMainSrcDir);
                 yield this.setupGradle(pluginTempDir, options.platformsAndroidDirPath, options.projectDir, options.pluginName);
-                const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || [].concat(options.gradleArgs || []));
+                const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || []).concat(options.gradleArgs || []);
                 yield this.buildPlugin({
                     gradlePath: options.gradlePath,
                     gradleArgs,
@@ -265,6 +267,17 @@ class AndroidPluginBuildService {
             this.replaceFileContent(buildGradlePath, "{{pluginNamespace}}", pluginNamespace);
             this.replaceFileContent(buildGradlePath, "{{pluginName}}", pluginName);
             this.replaceFileContent(settingsGradlePath, "{{pluginName}}", pluginName);
+            const shortPluginName = (0, helpers_1.getShortPluginName)(pluginName);
+            const manifestPath = path.join(pluginTempDir, "src", "main", "AndroidManifest.xml");
+            const manifestContent = this.$fs.readText(manifestPath);
+            let packageName = `org.nativescript.${shortPluginName}`;
+            const xml = yield this.getXml(manifestContent);
+            if (xml["manifest"]) {
+                if (xml["manifest"]["$"]["package"]) {
+                    packageName = xml["manifest"]["$"]["package"];
+                }
+            }
+            this.replaceFileContent(buildGradlePath, "{{pluginNamespace}}", packageName);
         });
     }
     getRuntimeGradleVersions(projectDir) {
@@ -443,25 +456,17 @@ class AndroidPluginBuildService {
     buildPlugin(pluginBuildSettings) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!pluginBuildSettings.androidToolsInfo) {
-                this.$androidToolsInfo.validateInfo({
-                    showWarningsAsErrors: true,
-                    validateTargetSdk: true,
-                    projectDir: pluginBuildSettings.projectDir,
-                });
-                pluginBuildSettings.androidToolsInfo =
-                    this.$androidToolsInfo.getToolsInfo({
-                        projectDir: pluginBuildSettings.projectDir,
-                    });
-            }
             const gradlew = (_a = pluginBuildSettings.gradlePath) !== null && _a !== void 0 ? _a : (this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew");
+            const toolsInfo = this.$androidToolsInfo.getToolsInfo({
+                projectDir: this.$projectData.projectDir,
+            });
             const localArgs = [
                 "-p",
                 pluginBuildSettings.pluginDir,
                 "assembleRelease",
                 `-PtempBuild=true`,
-                `-PcompileSdk=android-${pluginBuildSettings.androidToolsInfo.compileSdkVersion}`,
-                `-PbuildToolsVersion=${pluginBuildSettings.androidToolsInfo.buildToolsVersion}`,
+                `-PcompileSdk=${toolsInfo.compileSdkVersion}`,
+                `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`,
                 `-PprojectRoot=${this.$projectData.projectDir}`,
                 `-DprojectRoot=${this.$projectData.projectDir}`,
                 `-PappPath=${this.$projectData.getAppDirectoryPath()}`,
@@ -479,12 +484,19 @@ class AndroidPluginBuildService {
             if (this.$logger.getLevel() === "INFO") {
                 localArgs.push("--quiet");
             }
+            const opts = {
+                cwd: pluginBuildSettings.pluginDir,
+                stdio: "inherit",
+                shell: this.$hostInfo.isWindows,
+            };
+            if (this.$options.hostProjectPath) {
+                opts.env = Object.assign({ USER_PROJECT_PLATFORMS_ANDROID: path.resolve((0, process_1.cwd)(), this.$options.hostProjectPath) }, process.env);
+            }
             try {
-                yield this.$childProcess.spawnFromEvent(gradlew, localArgs, "close", {
-                    cwd: pluginBuildSettings.pluginDir,
-                    stdio: "inherit",
-                    shell: this.$hostInfo.isWindows,
-                });
+                const sanitizedArgs = this.$hostInfo.isWindows
+                    ? localArgs.map((arg) => (0, helpers_1.quoteString)(arg))
+                    : localArgs;
+                yield this.$childProcess.spawnFromEvent(gradlew, sanitizedArgs, "close", opts);
             }
             catch (err) {
                 this.$errors.fail(`Failed to build plugin ${pluginBuildSettings.pluginName} : \n${err}`);

package/lib/services/android-project-service.js

@@ -71,24 +71,26 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
             throw new Error("First call of getPlatformData without providing projectData.");
         }
         if (projectData && projectData.platformsDir) {
-            const projectRoot = path.join(projectData.platformsDir, AndroidProjectService.ANDROID_PLATFORM_NAME);
+            const projectRoot = this.$options.hostProjectPath
+                ? this.$options.hostProjectPath
+                : path.join(projectData.platformsDir, AndroidProjectService.ANDROID_PLATFORM_NAME);
             const appDestinationDirectoryArr = [
                 projectRoot,
-                constants.APP_FOLDER_NAME,
+                this.$options.hostProjectModuleName,
                 constants.SRC_DIR,
                 constants.MAIN_DIR,
                 constants.ASSETS_DIR,
             ];
             const configurationsDirectoryArr = [
                 projectRoot,
-                constants.APP_FOLDER_NAME,
+                this.$options.hostProjectModuleName,
                 constants.SRC_DIR,
                 constants.MAIN_DIR,
                 constants.MANIFEST_FILE_NAME,
             ];
             const deviceBuildOutputArr = [
                 projectRoot,
-                constants.APP_FOLDER_NAME,
+                this.$options.hostProjectModuleName,
                 constants.BUILD_DIR,
                 constants.OUTPUTS_DIR,
                 constants.APK_DIR,
@@ -104,7 +106,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 projectRoot: projectRoot,
                 getBuildOutputPath: (buildOptions) => {
                     if (buildOptions.androidBundle) {
-                        return path.join(projectRoot, constants.APP_FOLDER_NAME, constants.BUILD_DIR, constants.OUTPUTS_DIR, constants.BUNDLE_DIR);
+                        return path.join(projectRoot, this.$options.hostProjectModuleName, constants.BUILD_DIR, constants.OUTPUTS_DIR, constants.BUNDLE_DIR);
                     }
                     return path.join(...deviceBuildOutputArr);
                 },
@@ -115,8 +117,8 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                     if (buildOptions.androidBundle) {
                         return {
                             packageNames: [
-                                `${constants.APP_FOLDER_NAME}${constants.AAB_EXTENSION_NAME}`,
-                                `${constants.APP_FOLDER_NAME}-${buildMode}${constants.AAB_EXTENSION_NAME}`,
+                                `${this.$options.hostProjectModuleName}${constants.AAB_EXTENSION_NAME}`,
+                                `${this.$options.hostProjectModuleName}-${buildMode}${constants.AAB_EXTENSION_NAME}`,
                             ],
                         };
                     }
@@ -125,10 +127,10 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                             `${packageName}-${buildMode}${constants.APK_EXTENSION_NAME}`,
                             `${projectData.projectName}-${buildMode}${constants.APK_EXTENSION_NAME}`,
                             `${projectData.projectName}${constants.APK_EXTENSION_NAME}`,
-                            `${constants.APP_FOLDER_NAME}-${buildMode}${constants.APK_EXTENSION_NAME}`,
+                            `${this.$options.hostProjectModuleName}-${buildMode}${constants.APK_EXTENSION_NAME}`,
                         ],
                         regexes: [
-                            new RegExp(`(${packageName}|${constants.APP_FOLDER_NAME})-.*-(${constants_1.Configurations.Debug}|${constants_1.Configurations.Release})(-unsigned)?${constants.APK_EXTENSION_NAME}`, "i"),
+                            new RegExp(`(${packageName}|${this.$options.hostProjectModuleName})-.*-(${constants_1.Configurations.Debug}|${constants_1.Configurations.Release})(-unsigned)?${constants.APK_EXTENSION_NAME}`, "i"),
                         ],
                     };
                 },
@@ -308,7 +310,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         });
     }
     isPlatformPrepared(projectRoot, projectData) {
-        return this.$fs.exists(path.join(this.getPlatformData(projectData).appDestinationDirectoryPath, constants.APP_FOLDER_NAME));
+        return this.$fs.exists(path.join(this.getPlatformData(projectData).appDestinationDirectoryPath, this.$options.hostProjectModuleName));
     }
     getFrameworkFilesExtensions() {
         return [".jar", ".dat"];
@@ -371,16 +373,9 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         return __awaiter(this, void 0, void 0, function* () {
             const pluginPlatformsFolderPath = this.getPluginPlatformsFolderPath(pluginData, AndroidProjectService.ANDROID_PLATFORM_NAME);
             if (this.$fs.exists(pluginPlatformsFolderPath)) {
-                const gradleArgs = (projectData.nsConfig.android.gradleArgs || [].concat(this.$options.gradleArgs || []));
-                const options = {
-                    gradlePath: this.$options.gradlePath,
-                    gradleArgs,
-                    projectDir: projectData.projectDir,
-                    pluginName: pluginData.name,
-                    platformsAndroidDirPath: pluginPlatformsFolderPath,
-                    aarOutputDir: pluginPlatformsFolderPath,
-                    tempPluginDirPath: path.join(projectData.platformsDir, "tempPlugin"),
-                };
+                const gradleArgs = (projectData.nsConfig.android.gradleArgs || []).concat(this.$options.gradleArgs || []);
+                const pluginOptions = (projectData.nsConfig.android.plugins || {})[pluginData.name] || {};
+                const options = Object.assign({ gradlePath: this.$options.gradlePath, gradleArgs, projectDir: projectData.projectDir, pluginName: pluginData.name, platformsAndroidDirPath: pluginPlatformsFolderPath, aarOutputDir: pluginPlatformsFolderPath, tempPluginDirPath: path.join(projectData.platformsDir, "tempPlugin") }, pluginOptions);
                 if (yield this.$androidPluginBuildService.buildAar(options)) {
                     this.$logger.info(`Built aar for ${options.pluginName}`);
                 }
@@ -421,7 +416,9 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         return _.values(depsDictionary);
     }
     provideDependenciesJson(projectData, dependencies) {
-        const platformDir = path.join(projectData.platformsDir, AndroidProjectService.ANDROID_PLATFORM_NAME);
+        const platformDir = this.$options.hostProjectPath
+            ? this.$options.hostProjectPath
+            : path.join(projectData.platformsDir, AndroidProjectService.ANDROID_PLATFORM_NAME);
         const dependenciesJsonPath = path.join(platformDir, constants.DEPENDENCIES_JSON_NAME);
         let nativeDependencyData = dependencies.filter(AndroidProjectService.isNativeAndroidDependency);
         let nativeDependencies = nativeDependencyData.map(({ name, directory, dependencies }) => {
@@ -525,7 +522,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
     }
     getLegacyAppResourcesDestinationDirPath(projectData) {
         const resourcePath = [
-            constants.APP_FOLDER_NAME,
+            this.$options.hostProjectModuleName,
             constants.SRC_DIR,
             constants.MAIN_DIR,
             constants.RESOURCES_DIR,
@@ -534,7 +531,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
     }
     getUpdatedAppResourcesDestinationDirPath(projectData) {
         const resourcePath = [
-            constants.APP_FOLDER_NAME,
+            this.$options.hostProjectModuleName,
             constants.SRC_DIR,
         ];
         return path.join(this.getPlatformData(projectData).projectRoot, ...resourcePath);

package/lib/services/assets-generation/assets-generation-service.js

@@ -30,13 +30,17 @@ class AssetsGenerationService {
             splash: ["splashBackgrounds", "splashCenterImages", "splashImages"],
         };
     }
-    constructor($logger, $projectDataService, $fs) {
+    constructor($logger, $projectDataService, $fs, $options) {
         this.$logger = $logger;
         this.$projectDataService = $projectDataService;
         this.$fs = $fs;
+        this.$options = $options;
     }
     generateIcons(resourceGenerationData) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.$options.hostProjectPath) {
+                return;
+            }
             this.$logger.info("Generating icons ...");
             yield this.generateImagesForDefinitions(resourceGenerationData, this.propertiesToEnumerate.icon);
             this.$logger.info("Icons generation completed.");

package/lib/services/cocoapods-service.js

@@ -18,7 +18,7 @@ const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
 const constants = require("../constants");
 class CocoaPodsService {
-    constructor($cocoaPodsPlatformManager, $fs, $childProcess, $errors, $logger, $config, $xcconfigService, $xcodeSelectService) {
+    constructor($cocoaPodsPlatformManager, $fs, $childProcess, $errors, $logger, $config, $xcconfigService, $xcodeSelectService, $projectData) {
         this.$cocoaPodsPlatformManager = $cocoaPodsPlatformManager;
         this.$fs = $fs;
         this.$childProcess = $childProcess;
@@ -27,6 +27,7 @@ class CocoaPodsService {
         this.$config = $config;
         this.$xcconfigService = $xcconfigService;
         this.$xcodeSelectService = $xcodeSelectService;
+        this.$projectData = $projectData;
         this.getCocoaPodsFromPodfile = _.memoize(this._getCocoaPodsFromPodfile, helpers_1.getHash);
     }
     getPodfileHeader(targetName) {
@@ -39,13 +40,18 @@ class CocoaPodsService {
         return path.join(projectRoot, constants_1.PODFILE_NAME);
     }
     executePodInstall(projectRoot, xcodeProjPath) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.info("Installing pods...");
+            const cocoapodUseBundleExec = (_a = this.$projectData.nsConfig.ios) === null || _a === void 0 ? void 0 : _a.cocoapodUseBundleExec;
             let podTool = this.$config.USE_POD_SANDBOX ? "sandbox-pod" : "pod";
+            if (cocoapodUseBundleExec === true) {
+                podTool = `bundle exec ${podTool}`;
+            }
+            this.$logger.info(`Installing pods using "${podTool}"...`);
             const args = ["install"];
             if (process.platform === "darwin" && process.arch === "arm64") {
                 const res = yield this.$childProcess
-                    .exec("arch -x86_64 pod --version", null, {
+                    .exec(`arch -x86_64 ${podTool} --version`, null, {
                     showStderr: true,
                 })
                     .then((res) => res.stdout + " " + res.stderr)

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

@@ -17,9 +17,10 @@ const path = require("path");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class FilesHashService {
-    constructor($fs, $logger) {
+    constructor($fs, $logger, $options) {
         this.$fs = $fs;
         this.$logger = $logger;
+        this.$options = $options;
     }
     generateHashes(files) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -41,7 +42,7 @@ class FilesHashService {
     }
     generateHashesForProject(platformData) {
         return __awaiter(this, void 0, void 0, function* () {
-            const appFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_2.APP_FOLDER_NAME);
+            const appFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
             const files = this.$fs.enumerateFilesInDirectorySync(appFilesPath);
             const hashes = yield this.generateHashes(files);
             return hashes;

package/lib/services/ios-project-service.js

@@ -90,7 +90,9 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
             projectData.platformsDir &&
             this._platformsDirCache !== projectData.platformsDir) {
             const platform = this.$mobileHelper.normalizePlatformName((_a = this.$options.platformOverride) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS);
-            const projectRoot = path.join(projectData.platformsDir, platform.toLowerCase());
+            const projectRoot = this.$options.hostProjectPath
+                ? this.$options.hostProjectPath
+                : path.join(projectData.platformsDir, platform.toLowerCase());
             const runtimePackage = this.$projectDataService.getRuntimePackage(projectData.projectDir, platform.toLowerCase());
             this._platformData = {
                 frameworkPackageName: runtimePackage.name,
@@ -297,20 +299,24 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
     }
     addFramework(frameworkPath, projectData) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$hostInfo.isWindows) {
-                this.validateFramework(frameworkPath);
-                const project = this.createPbxProj(projectData);
-                const frameworkAddOptions = { customFramework: true };
-                const dynamic = yield this.isDynamicFramework(frameworkPath);
-                if (dynamic) {
-                    frameworkAddOptions["embed"] = true;
-                    frameworkAddOptions["sign"] = true;
-                }
-                const frameworkRelativePath = "$(SRCROOT)/" +
-                    this.getLibSubpathRelativeToProjectPath(frameworkPath, projectData);
-                project.addFramework(frameworkRelativePath, frameworkAddOptions);
-                this.savePbxProj(project, projectData);
+            if (this.$hostInfo.isWindows) {
+                return;
             }
+            this.validateFramework(frameworkPath);
+            const project = this.createPbxProj(projectData);
+            const frameworkAddOptions = { customFramework: true };
+            const dynamic = yield this.isDynamicFramework(frameworkPath);
+            if (dynamic) {
+                frameworkAddOptions["embed"] = true;
+                frameworkAddOptions["sign"] = true;
+            }
+            if (this.$options.hostProjectPath) {
+                frameworkAddOptions["embed"] = true;
+                frameworkAddOptions["sign"] = false;
+            }
+            const frameworkRelativePath = this.getLibSubpathRelativeToProjectPath(frameworkPath, projectData);
+            project.addFramework(frameworkRelativePath, frameworkAddOptions);
+            this.savePbxProj(project, projectData);
         });
     }
     addStaticLibrary(staticLibPath, projectData) {
@@ -328,7 +334,9 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
     }
     prepareProject(projectData, prepareData) {
         return __awaiter(this, void 0, void 0, function* () {
-            const projectRoot = path.join(projectData.platformsDir, "ios");
+            const projectRoot = this.$options.hostProjectPath
+                ? this.$options.hostProjectPath
+                : path.join(projectData.platformsDir, this.$devicePlatformsConstants.iOS.toLowerCase());
             const platformData = this.getPlatformData(projectData);
             const pluginsData = this.getAllProductionPlugins(projectData);
             const pbxProjPath = this.getPbxProjPath(projectData);
@@ -344,8 +352,25 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 yield this.$iOSSigningService.setupSigningFromTeam(projectRoot, projectData, teamId);
             }
             const project = this.createPbxProj(projectData);
+            if (this.$options.hostProjectPath) {
+                try {
+                    project.addPbxGroup([], "NativeScript", "NativeScript", null, {
+                        isMain: true,
+                        filesRelativeToProject: true,
+                        uuid: "NATIVESCRIPTNATIVESCRIPT",
+                    });
+                    const buildFolderPath = path.join(this.$options.hostProjectPath, projectData.projectName);
+                    project.addResourceFile(buildFolderPath, {}, "NATIVESCRIPTNATIVESCRIPT");
+                    const metadataPath = path.relative(this.$options.hostProjectPath, buildFolderPath);
+                    project.addToOtherLinkerFlags(JSON.stringify(`-sectcreate __DATA __TNSMetadata "${metadataPath}/metadata-arm64.bin"`));
+                    this.savePbxProj(project, projectData);
+                }
+                catch (err) {
+                    this.$logger.trace("Error adding NativeScript group to host project", err);
+                }
+            }
             const resources = project.pbxGroupByName("Resources");
-            if (resources) {
+            if (resources && !this.$options.hostProjectPath) {
                 const references = project.pbxFileReferenceSection();
                 const xcodeProjectImages = _.map(resources.children, (resource) => this.replace(references[resource.value].name));
                 this.$logger.trace("Images from Xcode project");
@@ -489,10 +514,18 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         return name.replace(/\\\"/g, '"');
     }
     getLibSubpathRelativeToProjectPath(targetPath, projectData) {
-        const frameworkPath = path.relative(this.getPlatformData(projectData).projectRoot, targetPath);
+        const projectRoot = this.getPlatformData(projectData).projectRoot;
+        const frameworkPath = path.relative(projectRoot, targetPath);
         return frameworkPath;
     }
     getPbxProjPath(projectData) {
+        if (this.$options.hostProjectPath) {
+            let xcodeProjectPath = this.$xcprojService.findXcodeProject(this.$options.hostProjectPath);
+            if (!xcodeProjectPath) {
+                this.$errors.fail("Xcode project not found at the specified directory");
+            }
+            return path.join(xcodeProjectPath, "project.pbxproj");
+        }
         return path.join(this.$xcprojService.getXcodeprojPath(projectData, this.getPlatformData(projectData).projectRoot), "project.pbxproj");
     }
     createPbxProj(projectData) {

package/lib/services/livesync/android-device-livesync-sockets-service.js

@@ -11,8 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceSocketsLiveSyncService = void 0;
 const android_device_livesync_service_base_1 = require("./android-device-livesync-service-base");
-const constants_1 = require("../../constants");
-const constants_2 = require("../../common/constants");
+const constants_1 = require("../../common/constants");
 const android_livesync_tool_1 = require("./android-livesync-tool");
 const path = require("path");
 const semver = require("semver");
@@ -57,7 +56,7 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
         });
     }
     getPathToLiveSyncFileOnDevice(appIdentifier) {
-        return `${constants_2.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
+        return `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
     }
     finalizeSync(liveSyncInfo, projectData) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -181,7 +180,7 @@ class AndroidDeviceSocketsLiveSyncService extends android_device_livesync_servic
     connectLivesyncTool(appIdentifier, connectTimeout) {
         return __awaiter(this, void 0, void 0, function* () {
             const platformData = this.platformsDataService.getPlatformData(this.$devicePlatformsConstants.Android, this.data);
-            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
             if (!this.livesyncTool.hasConnection()) {
                 yield this.livesyncTool.connect({
                     appIdentifier,

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

@@ -24,8 +24,8 @@ const semver = require("semver");
 const _ = require("lodash");
 const yok_1 = require("../../common/yok");
 class AndroidLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSyncServiceBase {
-    constructor($platformsDataService, $projectFilesManager, $injector, $devicePathProvider, $fs, $logger) {
-        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider);
+    constructor($platformsDataService, $projectFilesManager, $injector, $devicePathProvider, $fs, $logger, $options) {
+        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider, $options);
         this.$platformsDataService = $platformsDataService;
         this.$projectFilesManager = $projectFilesManager;
         this.$injector = $injector;

package/lib/services/livesync/ios-livesync-service.js

@@ -23,8 +23,8 @@ const constants_1 = require("../../constants");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSyncServiceBase {
-    constructor($fs, $platformsDataService, $projectFilesManager, $injector, $tempService, $devicePathProvider, $logger) {
-        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider);
+    constructor($fs, $platformsDataService, $projectFilesManager, $injector, $tempService, $devicePathProvider, $logger, $options) {
+        super($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider, $options);
         this.$fs = $fs;
         this.$platformsDataService = $platformsDataService;
         this.$projectFilesManager = $projectFilesManager;

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

@@ -24,12 +24,13 @@ const helpers_1 = require("../../common/helpers");
 const decorators_1 = require("../../common/decorators");
 const color_1 = require("../../color");
 class PlatformLiveSyncServiceBase {
-    constructor($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider) {
+    constructor($fs, $logger, $platformsDataService, $projectFilesManager, $devicePathProvider, $options) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$platformsDataService = $platformsDataService;
         this.$projectFilesManager = $projectFilesManager;
         this.$devicePathProvider = $devicePathProvider;
+        this.$options = $options;
         this._deviceLiveSyncServicesCache = {};
     }
     getDeviceLiveSyncService(device, projectData) {
@@ -81,7 +82,7 @@ class PlatformLiveSyncServiceBase {
             if (deviceLiveSyncService.beforeLiveSyncAction) {
                 yield deviceLiveSyncService.beforeLiveSyncAction(deviceAppData);
             }
-            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+            const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
             const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, null, []);
             const modifiedFilesData = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, syncInfo.liveSyncDeviceData, { isFullSync: true, force: syncInfo.force });
             return {
@@ -112,7 +113,7 @@ class PlatformLiveSyncServiceBase {
                 }
                 if (existingFiles.length) {
                     const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
-                    const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME);
+                    const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                     const localToDevicePaths = yield this.$projectFilesManager.createLocalToDevicePaths(deviceAppData, projectFilesPath, existingFiles, []);
                     modifiedLocalToDevicePaths.push(...localToDevicePaths);
                     modifiedLocalToDevicePaths = yield this.transferFiles(deviceAppData, localToDevicePaths, projectFilesPath, projectData, liveSyncInfo.liveSyncDeviceData, { isFullSync: false, force: liveSyncInfo.force });

package/lib/services/log-source-map-service.js

@@ -23,10 +23,11 @@ class LogSourceMapService {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    constructor($fs, $projectDataService, $injector, $devicePlatformsConstants, $logger) {
+    constructor($fs, $projectDataService, $injector, $options, $devicePlatformsConstants, $logger) {
         this.$fs = $fs;
         this.$projectDataService = $projectDataService;
         this.$injector = $injector;
+        this.$options = $options;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.$logger = $logger;
         this.cache = {};
@@ -121,7 +122,7 @@ class LogSourceMapService {
         return runtimeVersion;
     }
     getOriginalFileLocation(platform, parsedLine, projectData) {
-        const fileLocation = path.join(this.getFilesLocation(platform, projectData), constants_1.APP_FOLDER_NAME);
+        const fileLocation = path.join(this.getFilesLocation(platform, projectData), this.$options.hostProjectModuleName);
         if (parsedLine && parsedLine.filePath) {
             const sourceMapFile = path.join(fileLocation, parsedLine.filePath);
             const smc = this.cache[sourceMapFile];

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

@@ -21,13 +21,17 @@ 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) {
+    constructor($fs, $logger, $options, $packageManager, $terminalSpinnerService, $analyticsService) {
         this.$fs = $fs;
         this.$logger = $logger;
+        this.$options = $options;
         this.$packageManager = $packageManager;
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.$analyticsService = $analyticsService;
     }
+    addProjectHost() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
     addPlatformSafe(projectData, platformData, packageToInstall, addPlatformData) {
         return __awaiter(this, void 0, void 0, function* () {
             const spinner = this.$terminalSpinnerService.createSpinner();
@@ -94,8 +98,9 @@ class AddPlatformService {
         return null;
     }
     addNativePlatform(platformData, projectData, frameworkDirPath, frameworkVersion) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const platformDir = path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
+            const platformDir = (_a = this.$options.hostProjectPath) !== null && _a !== void 0 ? _a : path.join(projectData.platformsDir, platformData.normalizedPlatformName.toLowerCase());
             this.$fs.deleteDirectory(platformDir);
             yield platformData.platformProjectService.createProject(path.resolve(frameworkDirPath), frameworkVersion, projectData);
             platformData.platformProjectService.ensureConfigurationFileInAppResources(projectData);

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

@@ -20,11 +20,12 @@ 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) {
+    constructor($hooksService, $nodeModulesBuilder, $projectChangesService, $metadataFilteringService, $options) {
         this.$hooksService = $hooksService;
         this.$nodeModulesBuilder = $nodeModulesBuilder;
         this.$projectChangesService = $projectChangesService;
         this.$metadataFilteringService = $metadataFilteringService;
+        this.$options = $options;
     }
     prepareNativePlatform(platformData, projectData, prepareData) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40,8 +41,10 @@ class PrepareNativePlatformService {
             if (changesInfo.hasChanges) {
                 yield this.cleanProject(platformData, { release });
             }
-            platformData.platformProjectService.prepareAppResources(projectData);
-            if (hasChangesRequirePrepare) {
+            if (!this.$options.hostProjectPath) {
+                platformData.platformProjectService.prepareAppResources(projectData);
+            }
+            if (hasChangesRequirePrepare || this.$options.hostProjectPath) {
                 yield platformData.platformProjectService.prepareProject(projectData, prepareData);
             }
             if (hasNativeModulesChange) {

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

@@ -74,7 +74,9 @@ class PlatformEnvironmentRequirements {
             win32: "windows",
             darwin: "macos",
         }[process.platform];
-        const anchor = platform ? `#setting-up-${os}-for-${platform.toLowerCase()}` : "";
+        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}.`);
     }

package/lib/services/plugins-service.js

@@ -412,7 +412,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
                 const isPlatformInstalled = this.$fs.exists(path.join(projectData.platformsDir, platform.toLowerCase()));
                 if (isPlatformInstalled) {
                     const platformData = this.$platformsDataService.getPlatformData(platform.toLowerCase(), projectData);
-                    const pluginDestinationPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME, "tns_modules");
+                    const pluginDestinationPath = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, "tns_modules");
                     yield action(pluginDestinationPath, platform.toLowerCase(), platformData);
                 }
             }
@@ -450,6 +450,9 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         });
     }
     getAllPluginsNativeHashes(pathToPluginsBuildFile) {
+        if (this.$options.hostProjectPath) {
+            return {};
+        }
         let data = {};
         if (this.$fs.exists(pathToPluginsBuildFile)) {
             data = this.$fs.readJson(pathToPluginsBuildFile);
@@ -457,6 +460,9 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
         return data;
     }
     setPluginNativeHashes(opts) {
+        if (this.$options.hostProjectPath) {
+            return;
+        }
         opts.allPluginsNativeHashes[opts.pluginData.name] =
             opts.currentPluginNativeHashes;
         this.$fs.writeJson(opts.pathToPluginsBuildFile, opts.allPluginsNativeHashes);