nativescript 9.1.0-alpha.0 → 9.1.0-alpha.10

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

@@ -8,6 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundlerCompilerService = void 0;
 const path = require("path");
+const net = require("net");
 const semver = require("semver");
 const _ = require("lodash");
 const events_1 = require("events");
@@ -34,8 +35,15 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
         this.bundlerProcesses = {};
+        // Vite-only: the long-lived `vite serve` dev server the device fetches
+        // modules and HMR updates from. Keyed by platform, managed by this CLI
+        // so users no longer need a separate `concurrently`/`wait-on` process.
+        this.viteServeProcesses = {};
         this.expectedHashes = {};
     }
+    getViteDistOutputPath(projectDir) {
+        return path.join(projectDir, process.env.NS_VITE_DIST_DIR || constants_1.VITE_DIST_FOLDER_NAME);
+    }
     async compileWithWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
             if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
@@ -44,6 +52,14 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
+            // Bring up the Vite HMR dev server the device fetches modules /
+            // HMR updates from. No-op unless bundler is vite + hmr + watch.
+            // Fired in parallel with the build watcher; both child processes
+            // inherit the adb-reverse env the run-controller set before
+            // prepare, so neither one spawns adb on its own. Intentionally not
+            // awaited — the device only connects to it at app launch, well
+            // after the first build.
+            this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 // Handle Vite differently from webpack
@@ -67,7 +83,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             console.log("Received Vite IPC message:", message);
                         }
                         // Copy Vite output files directly to platform destination
-                        const distOutput = path.join(projectData.projectDir, ".ns-vite-build");
+                        const distOutput = this.getViteDistOutputPath(projectData.projectDir);
                         const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                         if (debugLog) {
                             console.log(`Copying from ${distOutput} to ${destDir}.`);
@@ -96,6 +112,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                                 console.log("Vite first build completed, resolving compileWithWatch");
                             }
                             resolve(childProcess);
+                            return;
                         }
                         // Transform Vite message to match webpack format
                         const files = message.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
@@ -214,11 +231,31 @@ class BundlerCompilerService extends events_1.EventEmitter {
                     delete this.bundlerProcesses[platformData.platformNameLowerCase];
                     reject(err);
                 });
+                const isVite = this.getBundler() === "vite";
                 childProcess.on("close", async (arg) => {
                     await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
                     delete this.bundlerProcesses[platformData.platformNameLowerCase];
                     const exitCode = typeof arg === "number" ? arg : arg && arg.code;
                     if (exitCode === 0) {
+                        // Non-watch Vite builds spawn the child with stdio:"inherit"
+                        // (no IPC channel), so the emittedFiles message handler in
+                        // compileWithWatch never fires and the Vite output is never
+                        // copied to the platforms app folder. Mirror that copy step
+                        // here so release/CI prepare and build flows actually deploy
+                        // the freshly built bundle. Without this, the deploy folder
+                        // is left empty (or worse, runs stale dev/HMR artifacts from
+                        // a previous `ns debug` run) and the runtime crashes on
+                        // launch with `Check failed: has_pending_exception()`.
+                        if (isVite) {
+                            try {
+                                const distOutput = this.getViteDistOutputPath(projectData.projectDir);
+                                const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+                                this.copyViteBundleToNative(distOutput, destDir);
+                            }
+                            catch (copyErr) {
+                                this.$logger.warn(`Failed to copy Vite output to platform destination: ${copyErr.message}`);
+                            }
+                        }
                         resolve();
                     }
                     else {
@@ -244,13 +281,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
         }
     }
-    async shouldUsePreserveSymlinksOption(projectData) {
-        // Modern bundlers (webpack v5+ and rspack) are more sensitive to
-        // duplicate module identities when symlink paths are preserved.
-        // In local file-linked setups this can load webpack internals twice.
-        if (this.isModernBundler(projectData)) {
-            return false;
-        }
+    async shouldUsePreserveSymlinksOption() {
         // pnpm does not require symlink (https://github.com/nodejs/node-eps/issues/46#issuecomment-277373566)
         // and it also does not work in some cases.
         // Check https://github.com/NativeScript/nativescript-cli/issues/5259 for more information
@@ -282,7 +313,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
             ]
             : cliArgs;
         const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
-        if (await this.shouldUsePreserveSymlinksOption(projectData)) {
+        if (await this.shouldUsePreserveSymlinksOption()) {
             additionalNodeArgs.push("--preserve-symlinks");
         }
         if (process.arch === "x64") {
@@ -318,7 +349,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 USER_PROJECT_PLATFORMS_ANDROID: this.$options.hostProjectPath,
                 USER_PROJECT_PLATFORMS_ANDROID_MODULE: this.$options.hostProjectModuleName,
                 USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
-                USER_PROJECT_PLATFORMS_MACOS: this.$options.hostProjectPath,
             });
         }
         if (debugLog) {
@@ -329,13 +359,145 @@ class BundlerCompilerService extends events_1.EventEmitter {
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
         return childProcess;
     }
+    getViteHmrPort() {
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    /**
+     * Spawn and manage the Vite dev server (`vite serve`) for HMR.
+     *
+     * Why the CLI owns this. With Vite, HMR needs a long-lived dev server
+     * (HTTP + the `/ns-hmr` websocket on port 5173) that the device fetches
+     * modules and hot updates from — it is SEPARATE from the
+     * `vite build --watch` process that emits the `bundle.mjs` bootstrap
+     * baked into the app. Historically users wired this up themselves with
+     * `concurrently`/`wait-on`, which left two uncoordinated processes both
+     * touching adb during cold start (the source of the Android
+     * "Searching for devices…" freeze). By spawning it here as a child of
+     * the CLI, the dev server inherits the CLI's environment — crucially
+     * `NS_ADB_REVERSE_READY`/`NS_DEVICE_SERIAL`/`NS_ADB_PATH` set by the
+     * run-controller — so the CLI is the single adb owner and the dev
+     * server never spawns adb itself.
+     *
+     * No-op unless bundler is vite, HMR is on, watch mode, and not release.
+     * Best-effort: failures are logged, never thrown — a dev-server hiccup
+     * must not fail the run.
+     */
+    async startViteDevServer(platformData, projectData, prepareData) {
+        try {
+            if (this.getBundler() !== "vite") {
+                return;
+            }
+            if (!prepareData.watch || !prepareData.hmr || prepareData.release) {
+                return;
+            }
+            const key = platformData.platformNameLowerCase;
+            if (this.viteServeProcesses[key]) {
+                return;
+            }
+            const port = this.getViteHmrPort();
+            // One dev server per port. Simultaneous multi-platform HMR in a
+            // single CLI invocation would collide on 5173 — that case still
+            // needs a distinct NS_HMR_PORT per platform, so skip + warn rather
+            // than fail to bind.
+            const collidingPlatform = Object.keys(this.viteServeProcesses)[0];
+            if (collidingPlatform) {
+                this.$logger.warn(`Vite dev server already running for '${collidingPlatform}' on port ${port}; skipping a second server for '${key}'. For simultaneous multi-platform HMR, set a distinct NS_HMR_PORT per platform.`);
+                return;
+            }
+            const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+            const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+            const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+            if (await this.shouldUsePreserveSymlinksOption()) {
+                additionalNodeArgs.push("--preserve-symlinks");
+            }
+            // `vite serve` (not `build`): runs the dev server and watches on
+            // its own — no `--watch`. Env flags (`--env.android --env.hmr …`)
+            // go after `--` so vite's CLI doesn't choke on unknown options.
+            const args = [
+                ...additionalNodeArgs,
+                this.getBundlerExecutablePath(projectData),
+                "serve",
+                `--config=${projectData.bundlerConfigPath}`,
+                `--mode=development`,
+                "--",
+                ...cliArgs,
+            ].filter(Boolean);
+            const options = {
+                cwd: projectData.projectDir,
+                // Inherit so the dev server's URLs/logs stream to the user as
+                // before. No IPC needed here — the build watcher provides the
+                // bundle-complete IPC; the dev server is fetched over HTTP/ws.
+                stdio: "inherit",
+                env: {
+                    ...process.env,
+                    NATIVESCRIPT_BUNDLER_ENV: JSON.stringify(envData),
+                },
+            };
+            if (this.$hostInfo.isWindows) {
+                Object.assign(options.env, { APPDATA: process.env.appData });
+            }
+            this.$logger.info(`Starting Vite dev server (HMR) for ${key} on port ${port}…`);
+            const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+            this.viteServeProcesses[key] = childProcess;
+            await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+            childProcess.once("exit", (code) => {
+                delete this.viteServeProcesses[key];
+                if (code) {
+                    this.$logger.warn(`Vite dev server for ${key} exited with code ${code}.`);
+                }
+            });
+            // Bounded readiness probe so we can surface a clear log once the
+            // device can actually reach modules.
+            const ready = await this.waitForPort(port, 30000);
+            if (ready) {
+                this.$logger.info(`Vite dev server ready on port ${port} (HMR for ${key}).`);
+            }
+            else {
+                this.$logger.trace(`Vite dev server port ${port} not observed open within the readiness probe window; continuing (it may bind shortly).`);
+            }
+        }
+        catch (err) {
+            this.$logger.warn(`Failed to start the Vite dev server: ${err}. HMR may be unavailable.`);
+        }
+    }
+    /**
+     * Resolve true once `127.0.0.1:<port>` accepts a TCP connection, or
+     * false after `timeoutMs`. Used to detect the Vite dev server is up.
+     */
+    waitForPort(port, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        return new Promise((resolve) => {
+            const attempt = () => {
+                const socket = net.connect({ port, host: "127.0.0.1" });
+                let settled = false;
+                const done = (ok) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    socket.destroy();
+                    if (ok) {
+                        resolve(true);
+                    }
+                    else if (Date.now() >= deadline) {
+                        resolve(false);
+                    }
+                    else {
+                        setTimeout(attempt, 250);
+                    }
+                };
+                socket.once("connect", () => done(true));
+                socket.once("error", () => done(false));
+                socket.setTimeout(1000, () => done(false));
+            };
+            attempt();
+        });
+    }
     buildEnvData(platform, projectData, prepareData) {
         var _a, _b, _c;
         const { env } = prepareData;
         const envData = Object.assign({}, env, { [platform.toLowerCase()]: true });
-        if (platform.toLowerCase() === "macos") {
-            envData.platform = "macos";
-        }
         const appId = projectData.projectIdentifiers[platform];
         const appPath = projectData.getAppDirectoryRelativePath();
         const appResourcesPath = projectData.getAppResourcesRelativeDirectoryPath();
@@ -463,6 +625,13 @@ class BundlerCompilerService extends events_1.EventEmitter {
             bundlerProcess.kill("SIGINT");
             delete this.bundlerProcesses[platform];
         }
+        // Tear down the Vite dev server we manage alongside the build watcher.
+        const viteServeProcess = this.viteServeProcesses[platform];
+        if (viteServeProcess) {
+            await this.$cleanupService.removeKillProcess(viteServeProcess.pid.toString());
+            viteServeProcess.kill("SIGINT");
+            delete this.viteServeProcesses[platform];
+        }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
         // handle new bundler hmr packets

package/lib/services/debug-service-base.js

@@ -43,7 +43,7 @@ class DebugServiceBase extends events_1.EventEmitter {
         if (debugOptions.useHttpUrl) {
             chromeDevToolsPrefix = `https://chrome-devtools-frontend.appspot.com/serve_file/@${commitSHA}`;
         }
-        const chromeUrl = `${chromeDevToolsPrefix}/inspector.html?ws=localhost:${port}`;
+        const chromeUrl = `${chromeDevToolsPrefix}/inspector.html?ws=127.0.0.1:${port}`;
         return chromeUrl;
     }
 }

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

@@ -8,11 +8,12 @@ const _ = require("lodash");
 const yok_1 = require("../../common/yok");
 const constants = require("../../constants");
 class IOSSigningService {
-    constructor($errors, $fs, $iOSProvisionService, $logger, $pbxprojDomXcode, $prompter, $xcconfigService, $xcprojService) {
+    constructor($errors, $fs, $iOSProvisionService, $logger, $options, $pbxprojDomXcode, $prompter, $xcconfigService, $xcprojService) {
         this.$errors = $errors;
         this.$fs = $fs;
         this.$iOSProvisionService = $iOSProvisionService;
         this.$logger = $logger;
+        this.$options = $options;
         this.$pbxprojDomXcode = $pbxprojDomXcode;
         this.$prompter = $prompter;
         this.$xcconfigService = $xcconfigService;
@@ -150,6 +151,7 @@ class IOSSigningService {
         return [];
     }
     async getManualSigningConfiguration(projectData, provision, mobileProvisionData) {
+        var _a;
         const pickStart = Date.now();
         const mobileprovision = mobileProvisionData ||
             (await this.$iOSProvisionService.pick(provision, projectData.projectIdentifiers.ios));
@@ -162,6 +164,7 @@ class IOSSigningService {
         if (!mobileprovision) {
             this.$errors.fail("Failed to find mobile provision with UUID or Name: " + provision);
         }
+        const isVisionOS = ((_a = this.$options.platformOverride) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "visionos";
         const configuration = {
             team: mobileprovision.TeamIdentifier &&
                 mobileprovision.TeamIdentifier.length > 0
@@ -170,8 +173,12 @@ class IOSSigningService {
             uuid: mobileprovision.UUID,
             name: mobileprovision.Name,
             identity: mobileprovision.Type === "Development"
-                ? "iPhone Developer"
-                : "iPhone Distribution",
+                ? isVisionOS
+                    ? "Apple Development"
+                    : "iPhone Developer"
+                : isVisionOS
+                    ? "Apple Distribution"
+                    : "iPhone Distribution",
         };
         return configuration;
     }

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

@@ -86,18 +86,11 @@ class SPMService {
         }
     }
     async resolveSPMDependencies(platformData, projectData) {
-        let destination = "generic/platform=iOS";
-        if (platformData.platformNameLowerCase === "visionos") {
-            destination = "generic/platform=visionOS";
-        }
-        else if (platformData.platformNameLowerCase === "macos") {
-            destination = "generic/platform=macOS";
-        }
         await this.$xcodebuildCommandService.executeCommand(this.$xcodebuildArgsService
             .getXcodeProjectArgs(platformData, projectData)
             .concat([
             "-destination",
-            destination,
+            "generic/platform=iOS",
             "-resolvePackageDependencies",
         ]), {
             cwd: projectData.projectDir,

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

@@ -18,11 +18,7 @@ class XcodebuildArgsService {
     }
     async getBuildForSimulatorArgs(platformData, projectData, buildConfig) {
         let args = await this.getArchitecturesArgs(buildConfig);
-        const isMacOS = this.$devicePlatformsConstants.ismacOS(buildConfig.platform);
-        if (isMacOS) {
-            args = args.concat(["CODE_SIGNING_ALLOWED=NO"]);
-        }
-        else if (this.$iOSWatchAppService.hasWatchApp(platformData, projectData)) {
+        if (this.$iOSWatchAppService.hasWatchApp(platformData, projectData)) {
             args = args.concat(["CODE_SIGNING_ALLOWED=NO"]);
         }
         else {
@@ -30,9 +26,6 @@ class XcodebuildArgsService {
         }
         let destination = "generic/platform=iOS Simulator";
         let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
-        if (isMacOS) {
-            destination = "generic/platform=macOS";
-        }
         if (isvisionOS) {
             destination = "generic/platform=visionOS Simulator";
             if (buildConfig._device) {
@@ -47,11 +40,9 @@ class XcodebuildArgsService {
             "-configuration",
             buildConfig.release ? constants_1.Configurations.Release : constants_1.Configurations.Debug,
         ])
-            .concat(this.getBuildCommonArgs(platformData, projectData, isMacOS
-            ? ios_project_service_1.MacOSPlatformSdkName
-            : 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;
@@ -61,10 +52,6 @@ class XcodebuildArgsService {
         const archivePath = path.join(platformData.getBuildOutputPath(buildConfig), projectData.projectName + ".xcarchive");
         let destination = "generic/platform=iOS";
         let isvisionOS = this.$devicePlatformsConstants.isvisionOS(buildConfig.platform);
-        const isMacOS = this.$devicePlatformsConstants.ismacOS(buildConfig.platform);
-        if (isMacOS) {
-            destination = "generic/platform=macOS";
-        }
         if (isvisionOS) {
             destination = "generic/platform=visionOS";
             if (buildConfig._device) {
@@ -83,12 +70,13 @@ class XcodebuildArgsService {
         ]
             .concat(this.getXcodeProjectArgs(platformData, projectData))
             .concat(architectures)
-            .concat(this.getBuildCommonArgs(platformData, projectData, isMacOS
-            ? ios_project_service_1.MacOSPlatformSdkName
-            : isvisionOS
-                ? ios_project_service_1.VisionDevicePlatformSdkName
-                : ios_project_service_1.DevicePlatformSdkName))
+            .concat(this.getBuildCommonArgs(platformData, projectData, isvisionOS ? ios_project_service_1.VisionDevicePlatformSdkName : ios_project_service_1.DevicePlatformSdkName))
             .concat(this.getBuildLoggingArgs());
+        // pbxproj-dom sets CODE_SIGN_IDENTITY[sdk=iphoneos*] which doesn't match
+        // the xros SDK used by visionOS builds — pass it explicitly as an override
+        if (isvisionOS) {
+            args.push(`CODE_SIGN_IDENTITY=${buildConfig.release ? "Apple Distribution" : "Apple Development"}`);
+        }
         return args;
     }
     async getArchitecturesArgs(buildConfig) {
@@ -99,13 +87,6 @@ class XcodebuildArgsService {
             args.push("ONLY_ACTIVE_ARCH=YES", "EXCLUDED_ARCHS=x86_64");
             return args;
         }
-        if (this.$devicePlatformsConstants.ismacOS(buildConfig.platform)) {
-            if (process.arch === "arm64") {
-                // Avoid attempting x86_64 builds against arm64-only frameworks.
-                args.push("ONLY_ACTIVE_ARCH=YES", "EXCLUDED_ARCHS=x86_64");
-            }
-            return args;
-        }
         const devicesArchitectures = buildConfig.buildForDevice
             ? await this.getArchitecturesFromConnectedDevices(buildConfig)
             : [];
@@ -119,10 +100,17 @@ class XcodebuildArgsService {
         // Introduced in Xcode 14+
         // ref: https://forums.swift.org/t/telling-xcode-14-beta-4-to-trust-build-tool-plugins-programatically/59305/5
         const skipPackageValidation = "-skipPackagePluginValidation";
+        // Introduced in Xcode 15+ to trust Swift macros (compiler plugins)
+        // non-interactively. Required for SPM packages that ship macros
+        // (e.g. apple/RealityKitScripting), otherwise the build fails with:
+        // "Macro '...' from package '...' must be enabled before it can be used"
+        // ref: https://developer.apple.com/documentation/xcode/writing-swift-macros
+        const skipMacroValidation = "-skipMacroValidation";
         const extraArgs = [
             "-scheme",
             projectData.projectName,
             skipPackageValidation,
+            skipMacroValidation,
         ];
         const BUILD_SETTINGS_FILE_PATH = path.join(projectData.appResourcesDirectoryPath, platformData.normalizedPlatformName, constants.BUILD_XCCONFIG_FILE_NAME);
         // Only include explicit properties from build.xcconfig
@@ -131,6 +119,17 @@ class XcodebuildArgsService {
         // like cocoapods issues related to ASSETCATALOG_COMPILER_APPICON_NAME
         // references: https://medium.com/@iostechset/why-cocoapods-eats-app-icons-79fe729808d4
         // https://github.com/CocoaPods/CocoaPods/issues/7003
+        // Xcode 26 makes Swift "explicitly built modules" the default. A
+        // regression there prevents macro/compiler-plugin SPM targets from
+        // resolving their swift-syntax module dependencies, failing with:
+        // "Unable to resolve module dependency: 'SwiftSyntax'" (and SwiftParser,
+        // SwiftSyntaxMacros, SwiftCompilerPlugin, SwiftDiagnostics).
+        // Passed as a command-line build setting so it overrides ALL targets,
+        // including the package targets we don't control.
+        // ref: https://forums.swift.org/t/xcode-26-unable-to-find-module-dependency/80516
+        const explicitModulesProperty = "SWIFT_ENABLE_EXPLICIT_MODULES";
+        const explicitModulesValue = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, explicitModulesProperty) || "NO";
+        extraArgs.push(`${explicitModulesProperty}=${explicitModulesValue}`);
         const deployTargetProperty = "IPHONEOS_DEPLOYMENT_TARGET";
         const deployTargetVersion = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, deployTargetProperty);
         if (deployTargetVersion) {
@@ -141,6 +140,14 @@ class XcodebuildArgsService {
         if (swiftUIBootValue) {
             extraArgs.push(`${swiftUIBootProperty}=${swiftUIBootValue}`);
         }
+        // Swift macro/compiler-plugin SPM targets must be code-signed with a
+        // development team when building for a device. Pass DEVELOPMENT_TEAM as a
+        // command-line build setting so it applies to SPM package targets too.
+        const developmentTeamProperty = "DEVELOPMENT_TEAM";
+        const developmentTeamValue = this.$xcconfigService.readPropertyValue(BUILD_SETTINGS_FILE_PATH, developmentTeamProperty);
+        if (developmentTeamValue) {
+            extraArgs.push(`${developmentTeamProperty}=${developmentTeamValue}`);
+        }
         if (this.$fs.exists(xcworkspacePath)) {
             return ["-workspace", xcworkspacePath, ...extraArgs];
         }

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

@@ -21,7 +21,9 @@ class IOSEntitlementsService {
     }
     getPlatformsEntitlementsPath(projectData) {
         var _a;
-        return path.join(projectData.platformsDir, (_a = this.$options.platformOverride) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS.toLowerCase(), projectData.projectName, projectData.projectName + ".entitlements");
+        return path.join(projectData.platformsDir, this.$mobileHelper
+            .normalizePlatformName((_a = this.$options.platformOverride) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS)
+            .toLowerCase(), projectData.projectName, projectData.projectName + ".entitlements");
     }
     getPlatformsEntitlementsRelativePath(projectData) {
         return path.join(projectData.projectName, projectData.projectName + ".entitlements");