nativescript 9.1.0-alpha.12 → 9.1.0-alpha.14

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

@@ -56,10 +56,15 @@ class BundlerCompilerService extends events_1.EventEmitter {
             // 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);
+            // prepare, so neither one spawns adb on its own. Not awaited HERE
+            // — but the first-build resolution below gates on it, because the
+            // app is (re)started as soon as `compileWithWatch` resolves and its
+            // very first HTTP module fetch dies on connection-refused if the
+            // server hasn't bound yet (a cold `vite serve` config load + vendor
+            // prebuild competes with this build watcher for CPU and can take
+            // 10-30s). Running both in parallel keeps the happy-path wall time
+            // at max(first build, server bind) instead of their sum.
+            const viteDevServerStartup = this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 // Handle Vite differently from webpack
@@ -105,13 +110,18 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             }
                             this.copyViteBundleToNative(distOutput, destDir);
                         }
-                        // Resolve the promise on first build completion
+                        // Resolve the promise on first build completion — gated on
+                        // the HMR dev server being reachable (no-op resolve for
+                        // non-HMR runs). `startViteDevServer` never rejects and its
+                        // readiness probe is bounded, so this cannot hang the run;
+                        // on probe timeout we proceed and the device's own retry
+                        // handles any residual gap.
                         if (isFirstBundlerWatchCompilation) {
                             isFirstBundlerWatchCompilation = false;
                             if (debugLog) {
                                 console.log("Vite first build completed, resolving compileWithWatch");
                             }
-                            resolve(childProcess);
+                            viteDevServerStartup.then(() => resolve(childProcess));
                             return;
                         }
                         // Transform Vite message to match webpack format
@@ -454,7 +464,11 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 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).`);
+                // Warn (not trace): the first-build resolution in
+                // `compileWithWatch` gates on this method, so a probe timeout
+                // means the app will be deployed against a server that may not
+                // be up yet — the user should see why a boot might stall.
+                this.$logger.warn(`Vite dev server port ${port} not observed open within the readiness probe window; continuing (it may bind shortly).`);
             }
         }
         catch (err) {

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,12 @@ class SPMService {
                 this.$logger.trace("SPM: no SPM packages to apply.");
                 return;
             }
+            // one compact line naming 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(`Swift Packages: ${spmPackages
+                .map((pkg) => this.describePackageSource(pkg))
+                .join(", ")}`);
             const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
                 ios: {
                     path: ".",
@@ -70,6 +86,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 +147,73 @@ 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.\n` +
+                            `  cache: ${SPMService.SWIFTPM_REPO_CACHE}`),
+                    });
+                    spinner.start();
+                }
+            }
+            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 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 +225,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 +335,88 @@ class SPMService {
         const seconds = totalSeconds % 60;
         return `${minutes}m ${seconds}s`;
     }
+    /**
+     * 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 +442,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.12",
+  "version": "9.1.0-alpha.14",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {