nativescript 9.1.0-alpha.10 → 9.1.0-alpha.12

package/lib/definitions/ios.d.ts

@@ -8,18 +8,18 @@ declare global {
 		setupSigningForDevice(
 			projectRoot: string,
 			projectData: IProjectData,
-			buildConfig: IOSBuildData
+			buildConfig: IOSBuildData,
 		): Promise<void>;
 		setupSigningFromTeam(
 			projectRoot: string,
 			projectData: IProjectData,
-			teamId: string
+			teamId: string,
 		): Promise<void>;
 		setupSigningFromProvision(
 			projectRoot: string,
 			projectData: IProjectData,
 			provision?: string,
-			mobileProvisionData?: any
+			mobileProvisionData?: any,
 		): Promise<void>;
 	}
 
@@ -27,17 +27,17 @@ declare global {
 		buildForSimulator(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<void>;
 		buildForDevice(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<string>;
 		buildForAppStore(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<string>;
 	}
 
@@ -47,35 +47,44 @@ declare global {
 		applySPMPackages(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			pluginSpmPackages?: IosSPMPackage[]
+			pluginSpmPackages?: IosSPMPackage[],
 		);
 		getSPMPackages(
 			projectData: IProjectData,
-			platform: string
+			platform: string,
 		): IosSPMPackage[];
+		resolveSPMDependencies(
+			platformData: IPlatformData,
+			projectData: IProjectData,
+			options?: { showProgress?: boolean },
+		): Promise<void>;
+		ensureSPMDependenciesResolved(
+			platformData: IPlatformData,
+			projectData: IProjectData,
+		): Promise<void>;
 	}
 
 	interface IXcodebuildArgsService {
 		getBuildForSimulatorArgs(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<string[]>;
 		getBuildForDeviceArgs(
 			platformData: IPlatformData,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<string[]>;
 		getXcodeProjectArgs(
 			platformData: IPlatformData,
-			projectData: IProjectData
+			projectData: IProjectData,
 		): string[];
 	}
 
 	interface IXcodebuildCommandService {
 		executeCommand(
 			args: string[],
-			options: IXcodebuildCommandOptions
+			options: IXcodebuildCommandOptions,
 		): Promise<ISpawnResult>;
 	}
 
@@ -84,18 +93,24 @@ declare global {
 		cwd: string;
 		stdio?: string;
 		spawnOptions?: any;
+		/**
+		 * When provided, xcodebuild's output is piped (rather than inherited) and
+		 * forwarded here so the caller can render its own progress UI (e.g. a
+		 * spinner for Swift Package resolution/download activity).
+		 */
+		onProgress?: (chunk: { data: string; pipe: string }) => void;
 	}
 
 	interface IExportOptionsPlistService {
 		createDevelopmentExportOptionsPlist(
 			archivePath: string,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<IExportOptionsPlistOutput>;
 		createDistributionExportOptionsPlist(
 			projectRoot: string,
 			projectData: IProjectData,
-			buildConfig: IBuildConfig
+			buildConfig: IBuildConfig,
 		): Promise<IExportOptionsPlistOutput>;
 	}
 

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

@@ -201,7 +201,10 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         };
     }
     async createProject(frameworkDir, frameworkVersion, projectData) {
-        if (semver.lt(frameworkVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
+        var _a;
+        const packageName = ((_a = projectData.nsConfig.android) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants.SCOPED_ANDROID_RUNTIME_NAME;
+        if (packageName === constants.SCOPED_ANDROID_RUNTIME_NAME &&
+            semver.lt(frameworkVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
             this.$errors.fail(`The NativeScript CLI requires Android runtime ${AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE} or later to work properly.`);
         }
         this.$fs.ensureDirectoryExists(this.getPlatformData(projectData).projectRoot);
@@ -288,7 +291,10 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
         return null;
     }
     async updatePlatform(currentVersion, newVersion, canUpdate, projectData, addPlatform, removePlatforms) {
-        if (semver.eq(newVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
+        var _a;
+        const packageName = ((_a = projectData.nsConfig.android) === null || _a === void 0 ? void 0 : _a.runtimePackageName) || constants.SCOPED_ANDROID_RUNTIME_NAME;
+        if (packageName === constants.SCOPED_ANDROID_RUNTIME_NAME &&
+            semver.eq(newVersion, AndroidProjectService.MIN_RUNTIME_VERSION_WITH_GRADLE)) {
             const platformLowercase = this.getPlatformData(projectData).normalizedPlatformName.toLowerCase();
             await removePlatforms([platformLowercase.split("@")[0]]);
             await addPlatform(platformLowercase);

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

@@ -3,11 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SPMService = void 0;
 const yok_1 = require("../../common/yok");
 const trapezedev_project_1 = require("@nstudio/trapezedev-project");
+const color_1 = require("../../color");
 const path = require("path");
 class SPMService {
-    constructor($logger, $projectConfigService, $xcodebuildCommandService, $xcodebuildArgsService) {
+    constructor($logger, $fs, $projectConfigService, $terminalSpinnerService, $xcodebuildCommandService, $xcodebuildArgsService) {
         this.$logger = $logger;
+        this.$fs = $fs;
         this.$projectConfigService = $projectConfigService;
+        this.$terminalSpinnerService = $terminalSpinnerService;
         this.$xcodebuildCommandService = $xcodebuildCommandService;
         this.$xcodebuildArgsService = $xcodebuildArgsService;
     }
@@ -24,7 +27,7 @@ class SPMService {
     mergePluginSPMPackages(appPackages, pluginPackages) {
         // include swift packages from plugin configs
         // but allow app packages to override plugin packages with the same name
-        const appPackageNames = new Set(appPackages.map(pkg => pkg.name));
+        const appPackageNames = new Set(appPackages.map((pkg) => pkg.name));
         for (const pluginPkg of pluginPackages) {
             if (appPackageNames.has(pluginPkg.name)) {
                 this.$logger.trace(`SPM: app package overrides plugin package: ${pluginPkg.name}`);
@@ -39,7 +42,7 @@ class SPMService {
     // 	return this.getSPMPackages(projectData).length > 0;
     // }
     async applySPMPackages(platformData, projectData, pluginSpmPackages) {
-        var _a;
+        var _a, _b;
         try {
             const spmPackages = this.getSPMPackages(projectData, platformData.platformNameLowerCase);
             if (pluginSpmPackages === null || pluginSpmPackages === void 0 ? void 0 : pluginSpmPackages.length) {
@@ -79,23 +82,199 @@ class SPMService {
             }
             await project.commit();
             // finally resolve the dependencies
-            await this.resolveSPMDependencies(platformData, projectData);
+            await this.resolveSPMDependencies(platformData, projectData, {
+                showProgress: true,
+            });
         }
         catch (err) {
+            // best-effort, but don't bury the failure below trace level — a red
+            // resolve spinner with no visible reason is confusing. Warn with the
+            // message, keep the full error at trace.
+            this.$logger.warn(`Failed to apply Swift Package dependencies: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
             this.$logger.trace("SPM: error applying SPM packages: ", err);
         }
     }
-    async resolveSPMDependencies(platformData, projectData) {
-        await this.$xcodebuildCommandService.executeCommand(this.$xcodebuildArgsService
+    /**
+     * Resolves (downloads + pins) the Swift Package dependencies referenced by
+     * the Xcode project. On a first build this is where the NativeScript runtime
+     * (now distributed as a remote Swift package) and any other SPM packages are
+     * actually downloaded — which can take a while. Pass `showProgress` to render
+     * a live spinner so the CLI doesn't look stalled while that happens.
+     *
+     * In verbose mode (`--log trace`) the condensed spinner is bypassed and
+     * xcodebuild's raw resolution log is streamed straight through instead.
+     */
+    async resolveSPMDependencies(platformData, projectData, options) {
+        const args = this.$xcodebuildArgsService
             .getXcodeProjectArgs(platformData, projectData)
             .concat([
             "-destination",
             "generic/platform=iOS",
             "-resolvePackageDependencies",
-        ]), {
-            cwd: projectData.projectDir,
-            message: "Resolving SPM dependencies...",
-        });
+        ]);
+        // Without progress, or when verbose: let xcodebuild's own resolution log
+        // stream straight to the terminal (inherited stdio). Verbose users want
+        // the raw log, not a condensed spinner that hides it.
+        if (!(options === null || options === void 0 ? void 0 : options.showProgress) || this.$logger.isVerbose()) {
+            await this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: projectData.projectDir,
+                message: "Resolving Swift Package dependencies...",
+            });
+            return;
+        }
+        const spinner = this.$terminalSpinnerService.createSpinner();
+        const startedAt = Date.now();
+        let activity = "Resolving Swift Package dependencies";
+        let lineBuffer = "";
+        const render = () => {
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            spinner.text = `${activity}… ${color_1.color.dim(`(${this.formatElapsed(elapsed)})`)}`;
+        };
+        // keep the elapsed timer ticking even when xcodebuild is silent (e.g.
+        // while a binary artifact downloads) so the user can see it's alive.
+        const ticker = setInterval(render, 1000);
+        const onProgress = (chunk) => {
+            lineBuffer += chunk.data;
+            const lines = lineBuffer.split("\n");
+            // keep the last (possibly partial) line in the buffer
+            lineBuffer = lines.pop();
+            for (const line of lines) {
+                const described = this.describeSPMActivity(line);
+                if (described) {
+                    activity = described;
+                    render();
+                }
+            }
+        };
+        render();
+        spinner.start();
+        try {
+            await this.$xcodebuildCommandService.executeCommand(args, {
+                cwd: projectData.projectDir,
+                onProgress,
+            });
+            spinner.succeed(color_1.color.green("Swift Package dependencies resolved"));
+        }
+        catch (err) {
+            spinner.fail(color_1.color.red("Failed to resolve Swift Package dependencies"));
+            throw err;
+        }
+        finally {
+            clearInterval(ticker);
+        }
+    }
+    /**
+     * Best-effort pre-resolve before a build so the (potentially slow) first-time
+     * Swift package download happens under a clear progress indicator instead of
+     * silently inside the subsequent "Xcode build..." step. No-op when the
+     * project has no SPM references or they're already resolved.
+     */
+    async ensureSPMDependenciesResolved(platformData, projectData) {
+        if (!this.hasSPMReferences(platformData, projectData)) {
+            this.$logger.trace("SPM: project has no Swift Package references.");
+            return;
+        }
+        if (this.arePackagesResolved(platformData, projectData)) {
+            this.$logger.trace("SPM: Swift Package dependencies already resolved; skipping pre-resolve.");
+            return;
+        }
+        try {
+            await this.resolveSPMDependencies(platformData, projectData, {
+                showProgress: true,
+            });
+        }
+        catch (err) {
+            // non-fatal: the build itself will resolve packages and surface the
+            // authoritative error if something is genuinely wrong.
+            this.$logger.trace("SPM: pre-resolve failed (continuing): ", err);
+        }
+    }
+    /**
+     * Maps a raw xcodebuild/SwiftPM resolution log line to a concise,
+     * user-facing activity description (or null for lines we don't surface).
+     */
+    describeSPMActivity(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return null;
+        }
+        // the big, otherwise-silent wait on a first build: a binary artifact
+        // (the NativeScript runtime xcframework) downloading.
+        if (/Downloading binary artifact/i.test(trimmed)) {
+            if (/ios-spm|nativescript/i.test(trimmed)) {
+                return "Downloading the NativeScript runtime (first build only)";
+            }
+            return "Downloading Swift Package binaries (first build only)";
+        }
+        if (/^Fetching\b/i.test(trimmed)) {
+            return this.describePackageActivity("Fetching", trimmed);
+        }
+        if (/^Cloning\b/i.test(trimmed)) {
+            return this.describePackageActivity("Cloning", trimmed);
+        }
+        if (/Computing version for/i.test(trimmed)) {
+            return "Computing package versions";
+        }
+        if (/Resolve Package Graph/i.test(trimmed)) {
+            return "Resolving Swift Package graph";
+        }
+        if (/Resolved source packages/i.test(trimmed)) {
+            return "Finalizing Swift Package dependencies";
+        }
+        return null;
+    }
+    /**
+     * Builds a stable, self-explanatory activity label with the package being
+     * worked on in parentheses, e.g. "Fetching Swift Packages (Auth0.swift)".
+     */
+    describePackageActivity(verb, line) {
+        const packageRef = this.shortenPackageRef(line);
+        return packageRef
+            ? `${verb} Swift Packages (${packageRef})`
+            : `${verb} Swift Packages`;
+    }
+    /**
+     * Extracts a short, readable name from a SwiftPM repo URL/log line, or null
+     * when the line contains no URL to name the package by.
+     */
+    shortenPackageRef(line) {
+        const match = line.match(/https?:\/\/\S+/);
+        if (!match) {
+            return null;
+        }
+        return path
+            .basename(match[0])
+            .replace(/\.git$/, "")
+            .replace(/[)\s].*$/, "");
+    }
+    /** Formats an elapsed duration in whole seconds as "5m 15s". */
+    formatElapsed(totalSeconds) {
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        return `${minutes}m ${seconds}s`;
+    }
+    /** True when the Xcode project references any Swift packages. */
+    hasSPMReferences(platformData, projectData) {
+        const pbxprojPath = path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`, "project.pbxproj");
+        if (!this.$fs.exists(pbxprojPath)) {
+            return false;
+        }
+        const contents = this.$fs.readText(pbxprojPath);
+        return (contents.includes("XCRemoteSwiftPackageReference") ||
+            contents.includes("XCLocalSwiftPackageReference") ||
+            contents.includes("packageReferences"));
+    }
+    /**
+     * True when a Package.resolved already exists for the project — i.e. packages
+     * have been resolved at least once, so the build's own resolve step will be a
+     * fast no-op rather than a slow, silent first-time download.
+     */
+    arePackagesResolved(platformData, projectData) {
+        const candidates = [
+            path.join(platformData.projectRoot, `${projectData.projectName}.xcworkspace`, "xcshareddata", "swiftpm", "Package.resolved"),
+            path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`, "project.xcworkspace", "xcshareddata", "swiftpm", "Package.resolved"),
+        ];
+        return candidates.some((p) => this.$fs.exists(p));
     }
 }
 exports.SPMService = SPMService;

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

@@ -10,9 +10,22 @@ class XcodebuildCommandService {
         this.$logger = $logger;
     }
     async executeCommand(args, options) {
-        const { message, cwd, stdio, spawnOptions } = options;
-        this.$logger.info(message || "Xcode build...");
-        const childProcessOptions = { cwd, stdio: stdio || "inherit" };
+        const { message, cwd, stdio, spawnOptions, onProgress } = options;
+        // A caller rendering its own progress UI owns stdout, so skip the
+        // default "Xcode build..." line that would otherwise clobber it.
+        if (!onProgress) {
+            this.$logger.info(message || "Xcode build...");
+        }
+        const childProcessOptions = {
+            cwd,
+            stdio: onProgress ? "pipe" : stdio || "inherit",
+        };
+        let detachProgress;
+        if (onProgress) {
+            const handler = (chunk) => onProgress(chunk);
+            this.$childProcess.on(constants.BUILD_OUTPUT_EVENT_NAME, handler);
+            detachProgress = () => this.$childProcess.removeListener(constants.BUILD_OUTPUT_EVENT_NAME, handler);
+        }
         try {
             const commandResult = await this.$childProcess.spawnFromEvent("xcodebuild", args, "exit", childProcessOptions, spawnOptions || {
                 emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
@@ -23,6 +36,9 @@ class XcodebuildCommandService {
         catch (err) {
             this.$errors.fail(err.message);
         }
+        finally {
+            detachProgress === null || detachProgress === void 0 ? void 0 : detachProgress();
+        }
     }
 }
 exports.XcodebuildCommandService = XcodebuildCommandService;

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

@@ -243,6 +243,10 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
     }
     async buildProject(projectRoot, projectData, buildData) {
         const platformData = this.getPlatformData(projectData);
+        // On a first build, the runtime (and any other Swift packages) download
+        // here. Pre-resolve under a clear spinner so the subsequent
+        // "Xcode build..." step doesn't appear to hang while that happens.
+        await this.$spmService.ensureSPMDependenciesResolved(platformData, projectData);
         const handler = (data) => {
             this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
         };
@@ -356,7 +360,18 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         project.addFramework(relativeStaticLibPath);
         const relativeHeaderSearchPath = path.join(this.getLibSubpathRelativeToProjectPath(headersSubpath, projectData));
         project.addToHeaderSearchPaths({ relativePath: relativeHeaderSearchPath });
-        this.generateModulemap(headersSubpath, libraryName);
+        // Write the generated modulemap into a CLI-managed folder under the
+        // platform root (never into node_modules). The modulemap references the
+        // plugin's headers in-place via relative paths, so nothing is copied.
+        const modulemapDir = path.join(this.getPlatformData(projectData).projectRoot, IOSProjectService.GENERATED_PLUGINS_DIR_NAME, libraryName);
+        const hasModulemap = this.generateModulemap(headersSubpath, libraryName, modulemapDir);
+        if (hasModulemap) {
+            // Put the modulemap dir on the header search path so clang discovers
+            // the module there instead of inside node_modules.
+            project.addToHeaderSearchPaths({
+                relativePath: this.getLibSubpathRelativeToProjectPath(modulemapDir, projectData),
+            });
+        }
         this.savePbxProj(project, projectData);
     }
     async prepareProject(projectData, prepareData) {
@@ -905,23 +920,46 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
             project.removeFromHeaderSearchPaths({
                 relativePath: relativeHeaderSearchPath,
             });
+            // Remove the generated modulemap dir search path (see addStaticLibrary)
+            const modulemapDir = path.join(this.getPlatformData(projectData).projectRoot, IOSProjectService.GENERATED_PLUGINS_DIR_NAME, path.basename(staticLibPath, ".a"));
+            project.removeFromHeaderSearchPaths({
+                relativePath: this.getLibSubpathRelativeToProjectPath(modulemapDir, projectData),
+            });
         });
         this.savePbxProj(project, projectData);
     }
-    generateModulemap(headersFolderPath, libraryName) {
+    generateModulemap(headersFolderPath, libraryName, modulemapDir) {
+        const modulemapPath = path.join(modulemapDir, "module.modulemap");
+        // A plugin may ship a `.a` without an `include/{lib}` headers folder. In
+        // that case there's nothing to expose as a module - clean up any stale
+        // modulemap and bail out instead of letting readDirectory throw.
+        if (!this.$fs.exists(headersFolderPath)) {
+            if (this.$fs.exists(modulemapPath)) {
+                this.$fs.deleteFile(modulemapPath);
+            }
+            return false;
+        }
         const headersFilter = (fileName, containingFolderPath) => path.extname(fileName) === ".h" &&
             this.$fs.getFsStats(path.join(containingFolderPath, fileName)).isFile();
         const headersFolderContents = this.$fs.readDirectory(headersFolderPath);
-        let headers = _(headersFolderContents)
-            .filter((item) => headersFilter(item, headersFolderPath))
-            .value();
-        if (!headers.length) {
-            this.$fs.deleteFile(path.join(headersFolderPath, "module.modulemap"));
-            return;
+        const headerFiles = headersFolderContents.filter((item) => headersFilter(item, headersFolderPath));
+        if (!headerFiles.length) {
+            if (this.$fs.exists(modulemapPath)) {
+                this.$fs.deleteFile(modulemapPath);
+            }
+            return false;
         }
-        headers = _.map(headers, (value) => `header "${value}"`);
+        // Reference the plugin's headers (still in node_modules) relative to the
+        // generated modulemap's location, so we don't copy headers or write into
+        // node_modules.
+        const headers = _.map(headerFiles, (value) => {
+            const relativeHeaderPath = path.relative(modulemapDir, path.join(headersFolderPath, value));
+            return `header "${relativeHeaderPath}"`;
+        });
         const modulemap = `module ${libraryName} { explicit module ${libraryName} { ${headers.join(" ")} } }`;
-        this.$fs.writeFile(path.join(headersFolderPath, "module.modulemap"), modulemap);
+        this.$fs.ensureDirectoryExists(modulemapDir);
+        this.$fs.writeFile(modulemapPath, modulemap);
+        return true;
     }
     async mergeProjectXcconfigFiles(projectData) {
         const platformData = this.getPlatformData(projectData);
@@ -995,6 +1033,9 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
 exports.IOSProjectService = IOSProjectService;
 IOSProjectService.IOS_PROJECT_NAME_PLACEHOLDER = "__PROJECT_NAME__";
 IOSProjectService.IOS_PLATFORM_NAME = "ios";
+// CLI-managed folder under the platform root where we write generated
+// artifacts (e.g. plugin modulemaps) so we never write into node_modules
+IOSProjectService.GENERATED_PLUGINS_DIR_NAME = ".plugins";
 __decorate([
     (0, helpers_2.hook)("buildIOS")
 ], IOSProjectService.prototype, "buildProject", null);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "9.1.0-alpha.10",
+  "version": "9.1.0-alpha.12",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {