nativescript 9.0.0-alpha.9 → 9.0.0-dev.0

package/lib/services/bundler/bundler-compiler-service.js

@@ -15,6 +15,7 @@ const decorators_1 = require("../../common/decorators");
 const constants_1 = require("../../constants");
 const yok_1 = require("../../common/yok");
 const package_path_helper_1 = require("../../helpers/package-path-helper");
+const debugLog = false;
 class BundlerCompilerService extends events_1.EventEmitter {
     constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager, $projectConfigService) {
         super();
@@ -56,37 +57,34 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         message &&
                         message.emittedFiles) {
                         message = message;
-                        console.log("Received Vite IPC message:", message);
-                        const distOutput = path.join(projectData.projectDir, "dist");
+                        if (debugLog) {
+                            console.log("Received Vite IPC message:", message);
+                        }
+                        const distOutput = path.join(projectData.projectDir, ".ns-vite-build");
                         const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
-                        console.log(`🔥 Copying from ${distOutput} to ${destDir}`);
-                        if (message.isHMR) {
-                            console.log("🔥 HMR update - copying only changed files for:", message.changedFiles);
-                            let filesToCopy = message.emittedFiles;
-                            const hasHTMLChanges = message.changedFiles.some((f) => f.endsWith(".html"));
-                            if (hasHTMLChanges) {
-                                filesToCopy = message.emittedFiles.filter((f) => f.includes(".component") ||
-                                    f === "bundle.mjs" ||
-                                    f === "bundle.mjs.map");
-                                console.log("🔥 HTML change detected - copying component files:", filesToCopy);
-                            }
-                            this.copyViteBundleToNative(distOutput, destDir, filesToCopy);
+                        if (debugLog) {
+                            console.log(`Copying from ${distOutput} to ${destDir}.`);
                         }
-                        else if (message.buildType === "incremental" &&
-                            message.changedFiles &&
-                            message.changedFiles.length > 0) {
-                            console.log("🔥 Incremental build - copying only relevant files for:", message.changedFiles);
-                            const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles, message.changedFiles);
-                            console.log("🔥 Incremental build - files to copy:", filesToCopy);
+                        if (message.buildType === "incremental" &&
+                            message.emittedFiles &&
+                            message.emittedFiles.length > 0) {
+                            const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles);
+                            if (debugLog) {
+                                console.log("Incremental build - files to copy:", filesToCopy);
+                            }
                             this.copyViteBundleToNative(distOutput, destDir, filesToCopy);
                         }
                         else {
-                            console.log("🔥 Full build - copying all files");
+                            if (debugLog) {
+                                console.log("Full build - copying all files.");
+                            }
                             this.copyViteBundleToNative(distOutput, destDir);
                         }
                         if (isFirstBundlerWatchCompilation) {
                             isFirstBundlerWatchCompilation = false;
-                            console.log("Vite first build completed, resolving compileWithWatch");
+                            if (debugLog) {
+                                console.log("Vite first build completed, resolving compileWithWatch");
+                            }
                             resolve(childProcess);
                         }
                         const files = message.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
@@ -100,20 +98,10 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             platform: platformData.platformNameLowerCase,
                         };
                         this.$logger.info(`Vite build completed! Files copied to native platform.`);
-                        this.notifyHMRClients({
-                            type: message.isHMR ? "js-update" : "build-complete",
-                            timestamp: Date.now(),
-                            changedFiles: message.changedFiles || [],
-                            buildType: message.buildType || "incremental",
-                            isHMR: message.isHMR || false,
-                        });
-                        if (message.isHMR) {
-                            console.log("🔥 Skipping BUNDLER_COMPILATION_COMPLETE for HMR update - app will not restart");
-                        }
-                        else {
-                            console.log("🔥 Emitting BUNDLER_COMPILATION_COMPLETE for full build");
-                            this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
+                        if (debugLog) {
+                            console.log("Emitting BUNDLER_COMPILATION_COMPLETE for full build.");
                         }
+                        this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
                         return;
                     }
                     if (typeof message === "object" &&
@@ -255,7 +243,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
         const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
         const envParams = isVite
             ? [
-                `--mode=${platformData.platformNameLowerCase}`,
+                `--mode=${prepareData.release ? "production" : "development"}`,
                 `--watch`,
                 "--",
                 ...cliArgs,
@@ -271,7 +259,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
         const args = [
             ...additionalNodeArgs,
             this.getBundlerExecutablePath(projectData),
-            isVite ? "build" : this.isModernBundler(projectData) ? `build` : null,
+            isVite || this.isModernBundler(projectData) ? "build" : null,
             `--config=${projectData.bundlerConfigPath}`,
             ...envParams,
         ].filter(Boolean);
@@ -300,7 +288,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
             });
         }
-        console.log("args:", args);
+        if (debugLog) {
+            console.log("args:", args);
+        }
         const childProcess = this.$childProcess.spawn(process.execPath, args, options);
         this.bundlerProcesses[platformData.platformNameLowerCase] = childProcess;
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
@@ -313,7 +303,8 @@ class BundlerCompilerService extends events_1.EventEmitter {
         const appId = projectData.projectIdentifiers[platform];
         const appPath = projectData.getAppDirectoryRelativePath();
         const appResourcesPath = projectData.getAppResourcesRelativeDirectoryPath();
-        Object.assign(envData, appId && { appId }, appPath && { appPath }, appResourcesPath && { appResourcesPath }, {
+        const buildPath = projectData.getBuildRelativeDirectoryPath();
+        Object.assign(envData, appId && { appId }, appPath && { appPath }, appResourcesPath && { appResourcesPath }, buildPath && { buildPath }, {
             nativescriptLibPath: path.resolve(__dirname, "..", "..", "nativescript-cli-lib.js"),
         });
         envData.verbose = envData.verbose || this.$logger.isVerbose();
@@ -459,20 +450,15 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
         }
         else if (this.isModernBundler(projectData)) {
-            const packagePath = (0, package_path_helper_1.resolvePackagePath)(`@nativescript/${bundler}`, {
+            const webpackPluginName = this.$projectConfigService.getValue(`webpackPackageName`, constants_1.WEBPACK_PLUGIN_NAME);
+            const packagePath = (0, package_path_helper_1.resolvePackagePath)(webpackPluginName, {
                 paths: [projectData.projectDir],
             });
             if (packagePath) {
                 return path.resolve(packagePath, "dist", "bin", "index.js");
             }
         }
-        const packagePath = (0, package_path_helper_1.resolvePackagePath)("webpack", {
-            paths: [projectData.projectDir],
-        });
-        if (!packagePath) {
-            return "";
-        }
-        return path.resolve(packagePath, "bin", "webpack.js");
+        throw new Error('could not find bundler executable');
     }
     isModernBundler(projectData) {
         const bundler = this.getBundler();
@@ -480,7 +466,8 @@ class BundlerCompilerService extends events_1.EventEmitter {
             case "rspack":
                 return true;
             default:
-                const packageJSONPath = (0, package_path_helper_1.resolvePackageJSONPath)(constants_1.WEBPACK_PLUGIN_NAME, {
+                const webpackPluginName = this.$projectConfigService.getValue(`webpackPackageName`, constants_1.WEBPACK_PLUGIN_NAME);
+                const packageJSONPath = (0, package_path_helper_1.resolvePackageJSONPath)(webpackPluginName, {
                     paths: [projectData.projectDir],
                 });
                 if (packageJSONPath) {
@@ -498,30 +485,37 @@ class BundlerCompilerService extends events_1.EventEmitter {
         return this.$projectConfigService.getValue(`bundler`, "webpack");
     }
     copyViteBundleToNative(distOutput, destDir, specificFiles = null) {
-        console.log(`Copying Vite bundle from "${distOutput}" to "${destDir}"`);
-        const fs = require("fs");
+        if (debugLog) {
+            console.log(`Copying Vite bundle from "${distOutput}" to "${destDir}".`);
+        }
         try {
             if (specificFiles) {
-                console.log("🔥 Selective copy - copying specific files:", specificFiles);
-                fs.mkdirSync(destDir, { recursive: true });
+                if (debugLog) {
+                    console.log("Selective copy - copying specific files:", specificFiles);
+                }
+                this.$fs.createDirectory(destDir);
                 for (const file of specificFiles) {
                     const srcPath = path.join(distOutput, file);
                     const destPath = path.join(destDir, file);
-                    if (!fs.existsSync(srcPath))
+                    if (!this.$fs.exists(srcPath))
                         continue;
-                    fs.mkdirSync(path.dirname(destPath), { recursive: true });
-                    fs.copyFileSync(srcPath, destPath);
-                    console.log(`🔥 Copied ${file}`);
+                    this.$fs.createDirectory(path.dirname(destPath));
+                    this.$fs.copyFile(srcPath, destPath);
+                    if (debugLog) {
+                        console.log(`Copied ${file}`);
+                    }
                 }
             }
             else {
-                console.log("🔥 Full build: Copying all files");
-                if (fs.existsSync(destDir)) {
-                    fs.rmSync(destDir, { recursive: true, force: true });
+                if (debugLog) {
+                    console.log("Full build: Copying all files.");
                 }
-                fs.mkdirSync(destDir, { recursive: true });
-                if (fs.existsSync(distOutput)) {
-                    this.copyRecursiveSync(distOutput, destDir, fs);
+                if (this.$fs.exists(destDir)) {
+                    this.$fs.deleteDirectory(destDir);
+                }
+                this.$fs.createDirectory(destDir);
+                if (this.$fs.exists(distOutput)) {
+                    this.copyRecursiveSync(distOutput, destDir);
                 }
                 else {
                     this.$logger.warn(`Vite output directory does not exist: ${distOutput}`);
@@ -532,56 +526,35 @@ class BundlerCompilerService extends events_1.EventEmitter {
             this.$logger.warn(`Failed to copy Vite bundle: ${error.message}`);
         }
     }
-    getIncrementalFilesToCopy(emittedFiles, changedFiles) {
+    getIncrementalFilesToCopy(emittedFiles) {
         const filesToCopy = [];
         const bundleFiles = emittedFiles.filter((file) => !file.includes("vendor") &&
-            (file.includes("bundle") ||
-                file.includes("main") ||
-                file.includes("app") ||
-                file.endsWith(".mjs") ||
-                file.endsWith(".js")));
+            (file.endsWith(".mjs") ||
+                file.endsWith(".js") ||
+                file.endsWith(".map")));
         filesToCopy.push(...bundleFiles);
-        const sourceMapFiles = emittedFiles.filter((file) => !file.includes("vendor") && file.endsWith(".map"));
-        filesToCopy.push(...sourceMapFiles);
-        const hasAssetChanges = changedFiles.some((file) => file.includes("/assets/") ||
-            file.includes("/static/") ||
-            file.includes("/public/"));
-        if (hasAssetChanges) {
-            const assetFiles = emittedFiles.filter((file) => file.includes("assets/") ||
-                file.includes("static/") ||
-                file.includes("fonts/") ||
-                file.includes("images/"));
+        const assetFiles = emittedFiles.filter((file) => file.includes("assets/") ||
+            file.includes("static/") ||
+            file.includes("fonts/") ||
+            file.includes("images/"));
+        if (assetFiles.length > 0) {
             filesToCopy.push(...assetFiles);
         }
         return [...new Set(filesToCopy)];
     }
-    notifyHMRClients(message) {
-        try {
-            const WebSocket = require("ws");
-            const ws = new WebSocket("ws://localhost:24678");
-            ws.on("open", () => {
-                console.log("🔥 Sending HMR notification to bridge:", message.type);
-                ws.send(JSON.stringify(message));
-                ws.close();
-            });
-            ws.on("error", () => {
-                console.log("🔥 HMR bridge not available (this is normal without HMR)");
-            });
-        }
-        catch (error) {
-            console.log("🔥 WebSocket not available for HMR notifications");
-        }
-    }
-    copyRecursiveSync(src, dest, fs) {
-        for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-            const srcPath = path.join(src, entry.name);
-            const destPath = path.join(dest, entry.name);
-            if (entry.isDirectory()) {
-                fs.mkdirSync(destPath, { recursive: true });
-                this.copyRecursiveSync(srcPath, destPath, fs);
+    copyRecursiveSync(src, dest) {
+        this.$fs.createDirectory(dest);
+        const entries = this.$fs.readDirectory(src);
+        for (const name of entries) {
+            const srcPath = path.join(src, name);
+            const destPath = path.join(dest, name);
+            const lstats = this.$fs.getLsStats(srcPath);
+            if (lstats.isDirectory()) {
+                this.copyRecursiveSync(srcPath, destPath);
             }
-            else if (entry.isFile() || entry.isSymbolicLink()) {
-                fs.copyFileSync(srcPath, destPath);
+            else if (lstats.isFile() || lstats.isSymbolicLink()) {
+                this.$fs.createDirectory(path.dirname(destPath));
+                this.$fs.copyFile(srcPath, destPath);
             }
         }
     }

package/lib/services/cocoapods-service.js

@@ -9,7 +9,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;
@@ -18,6 +18,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) {
@@ -30,12 +31,17 @@ class CocoaPodsService {
         return path.join(projectRoot, constants_1.PODFILE_NAME);
     }
     async executePodInstall(projectRoot, xcodeProjPath) {
-        this.$logger.info("Installing pods...");
+        var _a;
+        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 = await this.$childProcess
-                .exec("arch -x86_64 pod --version", null, {
+                .exec(`arch -x86_64 ${podTool} --version`, null, {
                 showStderr: true,
             })
                 .then((res) => res.stdout + " " + res.stderr)
@@ -163,7 +169,7 @@ end`.trim();
     removePodfileFromProject(moduleName, podfilePath, projectData, projectRoot) {
         if (this.$fs.exists(this.getProjectPodfilePath(projectRoot))) {
             let projectPodFileContent = this.$fs.readText(this.getProjectPodfilePath(projectRoot));
-            const regExpToRemove = new RegExp(`${this.getPluginPodfileHeader(podfilePath)}[\\s\\S]*?${this.getPluginPodfileEnd()}`, "mg");
+            const regExpToRemove = new RegExp(`${this.getPluginPodfileHeader(podfilePath).replace(/\+/g, "\\+")}[\\s\\S]*?${this.getPluginPodfileEnd()}`, "mg");
             projectPodFileContent = projectPodFileContent.replace(regExpToRemove, "");
             projectPodFileContent = this.removePostInstallHook(moduleName, projectPodFileContent);
             projectPodFileContent =

package/lib/services/device/device-install-app-service.js

@@ -15,7 +15,7 @@ class DeviceInstallAppService {
         this.$projectDataService = $projectDataService;
         this.$platformsDataService = $platformsDataService;
     }
-    async installOnDevice(device, buildData, packageFile) {
+    async installOnDevice(device, buildData) {
         this.$logger.info(`Installing on device ${device.deviceInfo.identifier}...`);
         const platform = device.deviceInfo.platform.toLowerCase();
         const projectData = this.$projectDataService.getProjectData(buildData.projectDir);
@@ -25,8 +25,30 @@ class DeviceInstallAppService {
             device,
             projectDir: projectData.projectDir,
         });
+        const buildOutputOptions = platformData.getValidBuildOutputData(buildData);
+        const outputPath = buildData.outputPath || platformData.getBuildOutputPath(buildData);
+        const packages = await this.$buildArtifactsService.getAllAppPackages(outputPath, buildOutputOptions);
+        let packageFile;
+        if (packages.length === 1) {
+            packageFile = packages.at(0).packageName;
+        }
+        else if (device.deviceInfo.abis) {
+            packages.find(({ packageName }) => {
+                if (device.deviceInfo.abis.some((abi) => packageName.includes(abi))) {
+                    packageFile = packageName;
+                    return true;
+                }
+            });
+        }
+        else {
+            const universalPackage = packages.find((p) => p.packageName.includes("universal"));
+            if (universalPackage) {
+                packageFile = universalPackage.packageName;
+            }
+        }
         if (!packageFile) {
-            packageFile = await this.$buildArtifactsService.getLatestAppPackagePath(platformData, buildData);
+            this.$logger.error(`Could not find a package corresponding to the device with identifier '${device.deviceInfo.identifier}'.`);
+            return;
         }
         await platformData.platformProjectService.cleanDeviceTempFolder(device.deviceInfo.identifier, projectData);
         const appIdentifier = projectData.projectIdentifiers[platform];
@@ -41,12 +63,12 @@ class DeviceInstallAppService {
         if (!buildData.release) {
             await this.$buildInfoFileService.saveDeviceBuildInfo(device, projectData, outputFilePath);
         }
-        this.$logger.info(`Successfully installed on device with identifier '${device.deviceInfo.identifier}'.`);
+        this.$logger.info(`Successfully installed on device with identifier '${device.deviceInfo.identifier} using package ${packageFile}'.`);
     }
-    async installOnDeviceIfNeeded(device, buildData, packageFile) {
+    async installOnDeviceIfNeeded(device, buildData) {
         const shouldInstall = await this.shouldInstall(device, buildData);
         if (shouldInstall) {
-            await this.installOnDevice(device, buildData, packageFile);
+            await this.installOnDevice(device, buildData);
         }
     }
     async shouldInstall(device, buildData) {

package/lib/services/extensibility-service.js

@@ -138,7 +138,7 @@ class ExtensibilityService {
                             return {
                                 extensionName,
                                 registeredCommandName: currentCommand,
-                                installationMessage: `The command ${beautifiedCommandName} is registered in extension ${extensionName}. You can install it by executing 'tns extension install ${extensionName}'`,
+                                installationMessage: `The command ${beautifiedCommandName} is registered in extension ${extensionName}. You can install it by executing 'ns extension install ${extensionName}'`,
                             };
                         }
                         copyOfFullArgs.splice(-1, 1);

package/lib/services/ios/xcodebuild-args-service.js

@@ -27,7 +27,7 @@ class XcodebuildArgsService {
         let destination = "generic/platform=iOS Simulator";
         let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
         if (isvisionOS) {
-            destination = "platform=visionOS Simulator";
+            destination = "generic/platform=visionOS Simulator";
             if (buildConfig._device) {
                 destination += `,id=${buildConfig._device.deviceInfo.identifier}`;
             }
@@ -40,7 +40,9 @@ class XcodebuildArgsService {
             "-configuration",
             buildConfig.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug,
         ])
-            .concat(this.getBuildCommonArgs(platformData, projectData, isvisionOS ? ios_project_service_1.VisionSimulatorPlatformSdkName : ios_project_service_1.SimulatorPlatformSdkName))
+            .concat(this.getBuildCommonArgs(platformData, projectData, isvisionOS
+            ? ios_project_service_1.VisionSimulatorPlatformSdkName
+            : ios_project_service_1.SimulatorPlatformSdkName))
             .concat(this.getBuildLoggingArgs())
             .concat(this.getXcodeProjectArgs(platformData, projectData));
         return args;
@@ -51,7 +53,7 @@ class XcodebuildArgsService {
         let destination = "generic/platform=iOS";
         let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
         if (isvisionOS) {
-            destination = "platform=visionOS";
+            destination = "generic/platform=visionOS";
             if (buildConfig._device) {
                 destination += `,id=${buildConfig._device.deviceInfo.identifier}`;
             }
@@ -68,14 +70,14 @@ class XcodebuildArgsService {
         ]
             .concat(this.getXcodeProjectArgs(platformData, projectData))
             .concat(architectures)
-            .concat(this.getBuildCommonArgs(platformData, projectData, ios_project_service_1.DevicePlatformSdkName))
+            .concat(this.getBuildCommonArgs(platformData, projectData, isvisionOS ? ios_project_service_1.VisionDevicePlatformSdkName : ios_project_service_1.DevicePlatformSdkName))
             .concat(this.getBuildLoggingArgs());
         return args;
     }
     async getArchitecturesArgs(buildConfig) {
         const args = [];
         if (this.$devicePlatformsConstants.isvisionOS(buildConfig.platform)) {
-            args.push("ONLY_ACTIVE_ARCH=YES");
+            args.push("ONLY_ACTIVE_ARCH=YES", "EXCLUDED_ARCHS=x86_64");
             return args;
         }
         const devicesArchitectures = buildConfig.buildForDevice

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

@@ -622,9 +622,12 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         return this.getAllNativeLibrariesForPlugin(pluginData, IOSProjectService.IOS_PLATFORM_NAME, filterCallback);
     }
     validateFramework(libraryPath) {
-        const infoPlistPath = path.join(libraryPath, constants.INFO_PLIST_FILE_NAME);
+        let infoPlistPath = path.join(libraryPath, constants.INFO_PLIST_FILE_NAME);
         if (!this.$fs.exists(infoPlistPath)) {
-            this.$errors.fail("The bundle at %s does not contain an Info.plist file.", libraryPath);
+            infoPlistPath = path.join(libraryPath, "Resources", constants.INFO_PLIST_FILE_NAME);
+            if (!this.$fs.exists(infoPlistPath)) {
+                this.$errors.fail("The bundle at %s does not contain an Info.plist file.", libraryPath);
+            }
         }
         const plistJson = this.$plistParser.parseFileSync(infoPlistPath);
         const packageType = plistJson["CFBundlePackageType"];

package/lib/services/plugins-service.js

@@ -213,7 +213,7 @@ class PluginsService {
     ensureValidProductionPluginsForIOS(productionDependencies, projectDir, platform) {
         const dependenciesWithFrameworks = [];
         _.each(productionDependencies, (d) => {
-            const pathToPlatforms = path.join(d.directory, "platforms", platform);
+            const pathToPlatforms = path.join(d.directory, constants.PLATFORMS_DIR_NAME, platform);
             if (this.$fs.exists(pathToPlatforms)) {
                 const contents = this.$fs.readDirectory(pathToPlatforms);
                 _.each(contents, (file) => {
@@ -296,12 +296,13 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
                 if (this.$mobileHelper.isvisionOSPlatform(platform)) {
                     platform = "ios";
                 }
-                return path.join(pluginData.fullPath, "platforms", platform.toLowerCase());
+                return path.join(pluginData.fullPath, constants.PLATFORMS_DIR_NAME, platform.toLowerCase());
             };
             const data = cacheData.nativescript;
             if (pluginData.isPlugin) {
                 pluginData.platformsData = data.platforms;
                 pluginData.pluginVariables = data.variables;
+                pluginData.nativescript = data;
             }
             return pluginData;
         }

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

@@ -18,10 +18,11 @@ const yok_1 = require("../common/yok");
 const semver = require("semver");
 const package_path_helper_1 = require("../helpers/package-path-helper");
 class ProjectDataService {
-    constructor($fs, $staticConfig, $logger, $devicePlatformsConstants, $androidResourcesMigrationService, $injector) {
+    constructor($fs, $staticConfig, $logger, $projectData, $devicePlatformsConstants, $androidResourcesMigrationService, $injector) {
         this.$fs = $fs;
         this.$staticConfig = $staticConfig;
         this.$logger = $logger;
+        this.$projectData = $projectData;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.$androidResourcesMigrationService = $androidResourcesMigrationService;
         this.$injector = $injector;
@@ -350,24 +351,21 @@ class ProjectDataService {
         return this.getInstalledRuntimePackage(projectDir, platform);
     }
     getInstalledRuntimePackage(projectDir, platform) {
+        var _a, _b, _c, _d;
+        let packageName = [];
+        if (platform === "ios") {
+            packageName.push((_a = this.$projectData.nsConfig.ios) === null || _a === void 0 ? void 0 : _a.runtimePackageName, constants.SCOPED_IOS_RUNTIME_NAME, constants.TNS_IOS_RUNTIME_NAME);
+        }
+        else if (platform === "android") {
+            packageName.push((_b = this.$projectData.nsConfig.android) === null || _b === void 0 ? void 0 : _b.runtimePackageName, constants.SCOPED_ANDROID_RUNTIME_NAME, constants.TNS_IOS_RUNTIME_NAME);
+        }
+        else if (platform === "visionos") {
+            packageName.push(constants.SCOPED_VISIONOS_RUNTIME_NAME);
+        }
         const runtimePackage = this.$pluginsService
             .getDependenciesFromPackageJson(projectDir)
             .devDependencies.find((d) => {
-            if (platform === "ios") {
-                return [
-                    constants.SCOPED_IOS_RUNTIME_NAME,
-                    constants.TNS_IOS_RUNTIME_NAME,
-                ].includes(d.name);
-            }
-            else if (platform === "android") {
-                return [
-                    constants.SCOPED_ANDROID_RUNTIME_NAME,
-                    constants.TNS_ANDROID_RUNTIME_NAME,
-                ].includes(d.name);
-            }
-            else if (platform === "visionos") {
-                return d.name === constants.SCOPED_VISIONOS_RUNTIME_NAME;
-            }
+            return packageName.includes(d.name);
         });
         if (runtimePackage) {
             const coerced = semver.coerce(runtimePackage.version);
@@ -398,13 +396,13 @@ class ProjectDataService {
         this.$logger.trace("Could not find an installed runtime, falling back to default runtimes");
         if (platform === "ios") {
             return {
-                name: constants.SCOPED_IOS_RUNTIME_NAME,
+                name: ((_c = this.$projectData.nsConfig.ios) === null || _c === void 0 ? void 0 : _c.runtimePackageName) || constants.SCOPED_IOS_RUNTIME_NAME,
                 version: null,
             };
         }
         else if (platform === "android") {
             return {
-                name: constants.SCOPED_ANDROID_RUNTIME_NAME,
+                name: ((_d = this.$projectData.nsConfig.android) === null || _d === void 0 ? void 0 : _d.runtimePackageName) || constants.SCOPED_ANDROID_RUNTIME_NAME,
                 version: null,
             };
         }

package/lib/services/timeline-profiler-service.js

@@ -51,8 +51,8 @@ class TimelineProfilerService {
             var _a;
             const trace = this.toTrace(line.trim());
             if (trace) {
-                (_a = deviceTimeline.startPoint) !== null && _a !== void 0 ? _a : (deviceTimeline.startPoint = trace.from);
-                deviceTimeline.timeline.push(trace);
+                (_a = deviceTimeline.startPoint) !== null && _a !== void 0 ? _a : (deviceTimeline.startPoint = trace[0].ts);
+                deviceTimeline.timeline.push(...trace);
             }
         });
     }
@@ -60,26 +60,34 @@ class TimelineProfilerService {
         return this.$projectConfigService.getValue("profiling") === "timeline";
     }
     toTrace(text) {
-        var _a, _b;
+        var _a, _b, _c;
         const result = text.match(TIMELINE_LOG_RE);
         if (!result) {
             return;
         }
         const trace = {
-            domain: (_a = result[2]) === null || _a === void 0 ? void 0 : _a.trim().replace(":", ""),
+            domain: (_a = result[2]) === null || _a === void 0 ? void 0 : _a.trim().replace(":", ".").toLowerCase(),
             name: result[3].trim(),
             from: parseFloat(result[4]),
             to: parseFloat(result[5]),
         };
-        return {
-            pid: 1,
-            tid: 1,
-            ts: trace.from * 1000,
-            dur: (trace.to - trace.from) * 1000,
-            name: trace.name,
-            cat: (_b = trace.domain) !== null && _b !== void 0 ? _b : "default",
-            ph: ChromeTraceEventPhase.COMPLETE,
-        };
+        return [{
+                args: {},
+                pid: 1,
+                tid: 1,
+                ts: trace.from * 1000,
+                name: trace.name,
+                cat: (_b = trace.domain) !== null && _b !== void 0 ? _b : "default",
+                ph: ChromeTraceEventPhase.BEGIN,
+            }, {
+                args: {},
+                pid: 1,
+                tid: 1,
+                ts: trace.to * 1000,
+                name: trace.name,
+                cat: (_c = trace.domain) !== null && _c !== void 0 ? _c : "default",
+                ph: ChromeTraceEventPhase.END,
+            }];
     }
     writeTimelines() {
         this.$logger.info("\n\nWriting timeline data to json...");

package/lib/services/versions-service.js

@@ -43,7 +43,8 @@ class VersionsService {
         const versionInformations = [];
         if (this.projectData) {
             const nodeModulesPath = path.join(this.projectData.projectDir, constants.NODE_MODULES_FOLDER_NAME);
-            const scopedPackagePath = path.join(nodeModulesPath, constants.SCOPED_TNS_CORE_MODULES);
+            const packageName = this.projectData.nsConfig.corePackageName || constants.SCOPED_TNS_CORE_MODULES;
+            const scopedPackagePath = path.join(nodeModulesPath, packageName);
             const tnsCoreModulesPath = path.join(nodeModulesPath, constants.TNS_CORE_MODULES_NAME);
             const dependsOnNonScopedPackage = !!this.projectData.dependencies[constants.TNS_CORE_MODULES_NAME];
             const dependsOnScopedPackage = !!this.projectData.dependencies[constants.SCOPED_TNS_CORE_MODULES];