nativescript 9.1.0-alpha.13 → 9.1.0-alpha.15

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

@@ -44,6 +44,12 @@ class BundlerCompilerService extends events_1.EventEmitter {
     getViteDistOutputPath(projectDir) {
         return path.join(projectDir, process.env.NS_VITE_DIST_DIR || constants_1.VITE_DIST_FOLDER_NAME);
     }
+    getViteBuildPaths(platformData, projectData) {
+        return {
+            distOutput: this.getViteDistOutputPath(projectData.projectDir),
+            destDir: path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName),
+        };
+    }
     async compileWithWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
             if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
@@ -88,8 +94,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             console.log("Received Vite IPC message:", message);
                         }
                         // Copy Vite output files directly to platform destination
-                        const distOutput = this.getViteDistOutputPath(projectData.projectDir);
-                        const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+                        const { distOutput, destDir } = this.getViteBuildPaths(platformData, projectData);
                         if (debugLog) {
                             console.log(`Copying from ${distOutput} to ${destDir}.`);
                         }
@@ -256,17 +261,19 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         // 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}`);
+                        // The copy must succeed for the build to succeed — a build
+                        // whose bundle never reached the native app is not a
+                        // successful build, so copy failures reject here.
+                        try {
+                            if (isVite) {
+                                const { distOutput, destDir } = this.getViteBuildPaths(platformData, projectData);
+                                this.copyViteBundleToNative(distOutput, destDir, null, true);
                             }
+                            resolve();
+                        }
+                        catch (error) {
+                            reject(error);
                         }
-                        resolve();
                     }
                     else {
                         const error = new Error(`Executing ${projectData.bundler} failed with exit code ${exitCode}.`);
@@ -732,7 +739,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
     getBundler() {
         return this.$projectConfigService.getValue(`bundler`, "webpack");
     }
-    copyViteBundleToNative(distOutput, destDir, specificFiles = null) {
+    copyViteBundleToNative(distOutput, destDir, specificFiles = null, failOnError = false) {
         // Clean and copy Vite output to native platform folder
         if (debugLog) {
             console.log(`Copying Vite bundle from "${distOutput}" to "${destDir}".`);
@@ -764,22 +771,27 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 if (debugLog) {
                     console.log("Full build: Copying all files.");
                 }
+                // Validate the source before touching the destination — cleaning
+                // destDir first would wipe a previously good bundle and leave an
+                // empty app folder behind a missing Vite output.
+                if (!this.$fs.exists(distOutput)) {
+                    throw new Error(`Vite output directory does not exist: ${distOutput}`);
+                }
                 // Clean destination directory
                 if (this.$fs.exists(destDir)) {
                     this.$fs.deleteDirectory(destDir);
                 }
                 this.$fs.createDirectory(destDir);
                 // Copy all files from dist to platform destination
-                if (this.$fs.exists(distOutput)) {
-                    this.copyRecursiveSync(distOutput, destDir);
-                }
-                else {
-                    this.$logger.warn(`Vite output directory does not exist: ${distOutput}`);
-                }
+                this.copyRecursiveSync(distOutput, destDir);
             }
         }
         catch (error) {
-            this.$logger.warn(`Failed to copy Vite bundle: ${error.message}`);
+            const copyError = error instanceof Error ? error : new Error(String(error));
+            if (failOnError) {
+                throw copyError;
+            }
+            this.$logger.warn(`Failed to copy Vite bundle: ${copyError.message}`);
         }
     }
     getIncrementalFilesToCopy(emittedFiles) {

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

@@ -5,6 +5,8 @@ const yok_1 = require("../../common/yok");
 const trapezedev_project_1 = require("@nstudio/trapezedev-project");
 const color_1 = require("../../color");
 const path = require("path");
+const os = require("os");
+const fs = require("fs");
 class SPMService {
     constructor($logger, $fs, $projectConfigService, $terminalSpinnerService, $xcodebuildCommandService, $xcodebuildArgsService) {
         this.$logger = $logger;
@@ -28,11 +30,19 @@ class SPMService {
         // 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));
+        // multiple plugins may declare the same package (e.g. a shared shim) —
+        // only the first declaration is added; a second same-name package would
+        // produce duplicate (and possibly conflicting) references in the pbxproj.
+        const addedPluginPackageNames = new Set();
         for (const pluginPkg of pluginPackages) {
             if (appPackageNames.has(pluginPkg.name)) {
                 this.$logger.trace(`SPM: app package overrides plugin package: ${pluginPkg.name}`);
             }
+            else if (addedPluginPackageNames.has(pluginPkg.name)) {
+                this.$logger.trace(`SPM: skipping duplicate plugin package: ${pluginPkg.name}`);
+            }
             else {
+                addedPluginPackageNames.add(pluginPkg.name);
                 appPackages.push(pluginPkg);
             }
         }
@@ -52,6 +62,10 @@ class SPMService {
                 this.$logger.trace("SPM: no SPM packages to apply.");
                 return;
             }
+            // name every package and where it comes from — when resolution is
+            // slow or fails, this is the first thing needed to tell WHICH
+            // dependency is responsible.
+            this.$logger.info(this.formatPackageListing(spmPackages));
             const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
                 ios: {
                     path: ".",
@@ -70,6 +84,11 @@ class SPMService {
                     // resolve the path relative to the project root
                     this.$logger.trace("SPM: resolving path for package: ", pkg.path);
                     pkg.path = path.resolve(projectData.projectDir, pkg.path);
+                    if (!this.$fs.exists(pkg.path)) {
+                        // surface this now — otherwise the only symptom is a cryptic
+                        // xcodebuild resolution failure much later.
+                        this.$logger.warn(`SPM: local package path for "${pkg.name}" does not exist: ${pkg.path} — Xcode will fail to resolve it.`);
+                    }
                 }
                 this.$logger.trace(`SPM: adding package ${pkg.name} to project.`, pkg);
                 await project.ios.addSPMPackage(projectData.projectName, pkg);
@@ -126,22 +145,74 @@ class SPMService {
         const startedAt = Date.now();
         let activity = "Resolving Swift Package dependencies";
         let lineBuffer = "";
+        // package currently being git-fetched (short name), if any — used to
+        // measure its growing clone in the SwiftPM cache so a long silent fetch
+        // shows visible progress ("2.31 GB of git history fetched") instead of
+        // looking hung.
+        let fetchingPackageRef = null;
+        let fetchedBytes = 0;
+        let largeCloneNoted = false;
+        // rolling tail of raw xcodebuild output for the failure report.
+        const outputTail = [];
         const render = () => {
             const elapsed = Math.round((Date.now() - startedAt) / 1000);
-            spinner.text = `${activity}… ${color_1.color.dim(`(${this.formatElapsed(elapsed)})`)}`;
+            const fetched = fetchedBytes > 0
+                ? ` — ${this.formatBytes(fetchedBytes)} of git history fetched`
+                : "";
+            spinner.text = `${activity}…${fetched} ${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);
+        // while a repository clones or a binary artifact downloads) so the user
+        // can see it's alive. Every 5th tick, measure the in-progress clone.
+        let tickCount = 0;
+        const ticker = setInterval(() => {
+            tickCount++;
+            if (fetchingPackageRef && tickCount % 5 === 0) {
+                fetchedBytes = this.getPackageCloneSizeBytes(fetchingPackageRef);
+                if (!largeCloneNoted &&
+                    fetchedBytes >= SPMService.LARGE_CLONE_NOTE_BYTES) {
+                    largeCloneNoted = true;
+                    // persist a one-time explanation above the spinner: this is the
+                    // point where users otherwise assume the CLI is stuck.
+                    spinner.stopAndPersist({
+                        symbol: color_1.color.yellow("ℹ"),
+                        text: color_1.color.yellow(`the "${fetchingPackageRef}" package is hosted in a repository with a large git history — ` +
+                            `SwiftPM clones the entire repository on first fetch, which can take a long time.${os.EOL}` +
+                            `  cache: ${SPMService.SWIFTPM_REPO_CACHE}`),
+                    });
+                    spinner.start();
+                }
+            }
+            render();
+        }, 1000);
         const onProgress = (chunk) => {
             lineBuffer += chunk.data;
-            const lines = lineBuffer.split("\n");
+            // tolerate CRLF as well as LF so parsed lines never carry a stray \r
+            const lines = lineBuffer.split(/\r?\n/);
             // keep the last (possibly partial) line in the buffer
             lineBuffer = lines.pop();
             for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    this.$logger.trace(`SPM: ${trimmed}`);
+                    outputTail.push(trimmed);
+                    if (outputTail.length > SPMService.OUTPUT_TAIL_LINES) {
+                        outputTail.shift();
+                    }
+                }
                 const described = this.describeSPMActivity(line);
                 if (described) {
                     activity = described;
+                    // track which package a "Fetching <url>" line refers to so the
+                    // ticker can measure its clone; any other activity means the
+                    // fetch finished.
+                    if (/^Fetching\b/i.test(trimmed)) {
+                        fetchingPackageRef = this.shortenPackageRef(trimmed);
+                    }
+                    else {
+                        fetchingPackageRef = null;
+                        fetchedBytes = 0;
+                    }
                     render();
                 }
             }
@@ -153,10 +224,20 @@ class SPMService {
                 cwd: projectData.projectDir,
                 onProgress,
             });
-            spinner.succeed(color_1.color.green("Swift Package dependencies resolved"));
+            const elapsed = Math.round((Date.now() - startedAt) / 1000);
+            spinner.succeed(color_1.color.green("Swift Package dependencies resolved") +
+                color_1.color.dim(` (${this.formatElapsed(elapsed)})`));
         }
         catch (err) {
             spinner.fail(color_1.color.red("Failed to resolve Swift Package dependencies"));
+            // the spinner swallowed the raw log — replay the tail so the actual
+            // xcodebuild error is visible without rerunning in verbose mode.
+            if (outputTail.length) {
+                this.$logger.info(color_1.color.dim("xcodebuild output (last lines):"));
+                for (const line of outputTail) {
+                    this.$logger.info(color_1.color.dim(`  ${line}`));
+                }
+            }
             throw err;
         }
         finally {
@@ -253,6 +334,98 @@ class SPMService {
         const seconds = totalSeconds % 60;
         return `${minutes}m ${seconds}s`;
     }
+    /**
+     * Multi-line listing of every package and its source — one package per
+     * line, separated by the platform EOL so entries never clump together in
+     * terminal output on macOS, Windows, or Linux.
+     */
+    formatPackageListing(spmPackages) {
+        return [
+            "Swift Packages:",
+            ...spmPackages.map((pkg) => `  ${this.describePackageSource(pkg)}`),
+        ].join(os.EOL);
+    }
+    /**
+     * One-line description of a package and where it resolves from, e.g.
+     * "FontManager (1.0.12 · https://github.com/NativeScript/font-manager.git)"
+     * or "CanvasNative (local: node_modules/@nativescript/canvas/platforms/ios/NativeScriptV8)".
+     */
+    describePackageSource(pkg) {
+        if ("path" in pkg) {
+            return `${pkg.name} (local: ${pkg.path})`;
+        }
+        return `${pkg.name} (${pkg.version} · ${pkg.repositoryURL})`;
+    }
+    /**
+     * Size on disk of the SwiftPM cache clone(s) for a package ref (the short
+     * name produced by shortenPackageRef). Cache entries are named
+     * "<repo-name>-<hash>". Returns 0 when nothing is there (yet).
+     */
+    getPackageCloneSizeBytes(packageRef) {
+        let entries;
+        try {
+            entries = fs.readdirSync(SPMService.SWIFTPM_REPO_CACHE, {
+                withFileTypes: true,
+            });
+        }
+        catch (err) {
+            return 0;
+        }
+        let total = 0;
+        for (const entry of entries) {
+            if (entry.isDirectory() &&
+                (entry.name === packageRef || entry.name.startsWith(`${packageRef}-`))) {
+                total += this.getDirectorySizeBytes(path.join(SPMService.SWIFTPM_REPO_CACHE, entry.name));
+            }
+        }
+        return total;
+    }
+    /**
+     * Recursive directory size via the raw fs API. Tolerates files vanishing
+     * mid-walk (git renames its temp packfiles while cloning) and does not
+     * follow symlinks.
+     */
+    getDirectorySizeBytes(dirPath) {
+        let total = 0;
+        const pending = [dirPath];
+        while (pending.length) {
+            const current = pending.pop();
+            let entries;
+            try {
+                entries = fs.readdirSync(current, { withFileTypes: true });
+            }
+            catch (err) {
+                continue;
+            }
+            for (const entry of entries) {
+                const fullPath = path.join(current, entry.name);
+                try {
+                    if (entry.isDirectory()) {
+                        pending.push(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        total += fs.statSync(fullPath).size;
+                    }
+                }
+                catch (err) {
+                    // entry disappeared between readdir and stat — ignore
+                }
+            }
+        }
+        return total;
+    }
+    /** Formats a byte count as a short human-readable size ("2.31 GB"). */
+    formatBytes(bytes) {
+        const GB = 1024 ** 3;
+        const MB = 1024 ** 2;
+        if (bytes >= GB) {
+            return `${(bytes / GB).toFixed(2)} GB`;
+        }
+        if (bytes >= MB) {
+            return `${Math.round(bytes / MB)} MB`;
+        }
+        return `${Math.round(bytes / 1024)} KB`;
+    }
     /** True when the Xcode project references any Swift packages. */
     hasSPMReferences(platformData, projectData) {
         const pbxprojPath = path.join(platformData.projectRoot, `${projectData.projectName}.xcodeproj`, "project.pbxproj");
@@ -278,5 +451,17 @@ class SPMService {
     }
 }
 exports.SPMService = SPMService;
+// SwiftPM keeps one bare clone per source package here (shared by Xcode and
+// xcodebuild). Watching a package's clone grow is the only visibility into
+// an otherwise silent long fetch — SwiftPM clones a repository's ENTIRE git
+// history to read Package.swift, so a package hosted in a multi-GB repo can
+// legitimately "fetch" for tens of minutes with no output.
+SPMService.SWIFTPM_REPO_CACHE = path.join(os.homedir(), "Library", "Caches", "org.swift.swiftpm", "repositories");
+// Once a single package's clone passes this size, surface a one-time note
+// explaining why the fetch is slow (250 MB is already far beyond any
+// reasonably-hosted Swift package).
+SPMService.LARGE_CLONE_NOTE_BYTES = 250 * 1024 * 1024;
+// Lines of raw xcodebuild output kept for the failure report.
+SPMService.OUTPUT_TAIL_LINES = 25;
 yok_1.injector.register("spmService", SPMService);
 //# sourceMappingURL=spm-service.js.map

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

@@ -697,6 +697,23 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                     const config = this.$projectConfigService.readConfig(plugin.fullPath);
                     const packages = _.get(config, `${platformData.platformNameLowerCase}.SPMPackages`, []);
                     if (packages.length) {
+                        for (const pkg of packages) {
+                            // a plugin's local package path is naturally authored relative
+                            // to the plugin itself, but the SPM service resolves relative
+                            // paths against the app project dir. When the app-relative
+                            // path doesn't exist (e.g. non-hoisted node_modules layouts),
+                            // fall back to resolving against the plugin's own directory.
+                            if ("path" in pkg &&
+                                pkg.path &&
+                                !path.isAbsolute(pkg.path) &&
+                                !this.$fs.exists(path.resolve(projectData.projectDir, pkg.path))) {
+                                const pluginRelativePath = path.resolve(plugin.fullPath, pkg.path);
+                                if (this.$fs.exists(pluginRelativePath)) {
+                                    this.$logger.trace(`SPM: resolved plugin-relative package path for ${pkg.name}: ${pluginRelativePath}`);
+                                    pkg.path = pluginRelativePath;
+                                }
+                            }
+                        }
                         pluginSpmPackages.push(...packages);
                     }
                 }
@@ -798,11 +815,18 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         this.$fs.rename(path.join(fileRootLocation, oldFileName), path.join(fileRootLocation, newFileName));
     }
     async prepareNativeSourceCode(groupName, sourceFolderPath, projectData) {
+        var _a;
         const project = this.createPbxProj(projectData);
         const group = await this.getRootGroup(groupName, sourceFolderPath);
+        // pin the sources to the main app target: without an explicit target the
+        // underlying xcode lib picks whichever "Sources" build phase it finds
+        // first, which can be an extension target (e.g. a widget) once one
+        // exists — compiling plugin native code into extensions breaks their
+        // builds (and bloats them) since they lack the app's search paths.
         project.addPbxGroup(group.files, group.name, group.path, null, {
             isMain: true,
             filesRelativeToProject: true,
+            target: (_a = project.getFirstTarget()) === null || _a === void 0 ? void 0 : _a.uuid,
         });
         project.addToHeaderSearchPaths(group.path);
         const headerFiles = this.$fs.exists(sourceFolderPath)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "9.1.0-alpha.13",
+  "version": "9.1.0-alpha.15",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {
@@ -60,7 +60,7 @@
     "@npmcli/arborist": "9.1.8",
     "@nstudio/trapezedev-project": "7.2.4",
     "@rigor789/resolve-package-path": "1.0.7",
-    "axios": "1.13.5",
+    "axios": "1.18.1",
     "byline": "5.0.0",
     "chokidar": "^3.6.0",
     "cli-table3": "0.6.5",
@@ -96,7 +96,7 @@
     "qrcode-terminal": "0.12.0",
     "semver": "7.7.3",
     "shelljs": "0.10.0",
-    "simple-git": "3.30.0",
+    "simple-git": "3.36.0",
     "simple-plist": "1.4.0",
     "source-map": "0.7.6",
     "tar": "7.5.9",