nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPMPbxprojService = void 0;
+exports.classifyVersion = classifyVersion;
+const path = require("path");
+const semver = require("semver");
+const yok_1 = require("../../common/yok");
+class SPMPbxprojService {
+    constructor($fs, $logger, $xcode) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$xcode = $xcode;
+    }
+    addPackages(projectRoot, assignments) {
+        if (!assignments.length) {
+            return false;
+        }
+        const pbxProjPath = this.findPbxProjPath(projectRoot);
+        if (!pbxProjPath) {
+            this.$logger.trace(`SPM: no Xcode project found under ${projectRoot}; skipping.`);
+            return false;
+        }
+        const project = new this.$xcode.project(pbxProjPath);
+        project.parseSync();
+        let added = false;
+        for (const { targetName, package: pkg } of assignments) {
+            const targetId = this.findTargetId(project, targetName);
+            if (!targetId) {
+                this.$logger.warn(`SPM: target "${targetName}" not found in ${path.basename(pbxProjPath)} — skipping package "${pkg.name}".`);
+                continue;
+            }
+            if (this.addPackageToTarget(project, targetId, pkg, projectRoot)) {
+                added = true;
+            }
+        }
+        if (!added) {
+            return false;
+        }
+        this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+        return true;
+    }
+    findPbxProjPath(projectRoot) {
+        if (!this.$fs.exists(projectRoot)) {
+            return null;
+        }
+        const xcodeprojName = this.$fs
+            .readDirectory(projectRoot)
+            .find((entry) => entry.endsWith(".xcodeproj"));
+        if (!xcodeprojName) {
+            return null;
+        }
+        const pbxProjPath = path.join(projectRoot, xcodeprojName, "project.pbxproj");
+        return this.$fs.exists(pbxProjPath) ? pbxProjPath : null;
+    }
+    findTargetId(project, targetName) {
+        var _a, _b;
+        const targets = (_a = project.pbxNativeTargetSection()) !== null && _a !== void 0 ? _a : {};
+        for (const key of Object.keys(targets)) {
+            if (key.endsWith("_comment")) {
+                continue;
+            }
+            const name = (_b = targets[key]) === null || _b === void 0 ? void 0 : _b.name;
+            if (name === targetName || name === `"${targetName}"`) {
+                return key;
+            }
+        }
+        return null;
+    }
+    addPackageToTarget(project, targetId, pkg, projectRoot) {
+        var _a, _b, _c, _d;
+        const target = project.pbxNativeTargetSection()[targetId];
+        const frameworkBuildPhaseObj = this.findFrameworksBuildPhase(project, target);
+        if (!frameworkBuildPhaseObj) {
+            this.$logger.warn(`SPM: target for package "${pkg.name}" has no Frameworks build phase — skipping.`);
+            return false;
+        }
+        const firstProject = project.getFirstProject().firstProject;
+        const packageReferences = ((_a = firstProject["packageReferences"]) !== null && _a !== void 0 ? _a : (firstProject["packageReferences"] = []));
+        const packageProductReferences = ((_b = target["packageProductDependencies"]) !== null && _b !== void 0 ? _b : (target["packageProductDependencies"] = []));
+        const frameworkBuildPhaseFiles = ((_c = frameworkBuildPhaseObj["files"]) !== null && _c !== void 0 ? _c : (frameworkBuildPhaseObj["files"] = []));
+        let packageReferenceComment;
+        let packageReferenceSection;
+        let packageReferenceSectionContent;
+        if ("path" in pkg) {
+            const relativePath = path.relative(projectRoot, path.resolve(projectRoot, pkg.path));
+            packageReferenceComment = `XCLocalSwiftPackageReference "${relativePath}"`;
+            packageReferenceSection = "XCLocalSwiftPackageReference";
+            packageReferenceSectionContent = {
+                isa: packageReferenceSection,
+                relativePath: JSON.stringify(relativePath),
+            };
+        }
+        else {
+            packageReferenceComment = `XCRemoteSwiftPackageReference "${pkg.name}"`;
+            packageReferenceSection = "XCRemoteSwiftPackageReference";
+            packageReferenceSectionContent = {
+                isa: packageReferenceSection,
+                repositoryURL: JSON.stringify(pkg.repositoryURL),
+                requirement: quoteValuesForPbxproj(classifyVersion(pkg.version)),
+            };
+        }
+        const { uuid: spmPackageReferenceUUID, comment: spmPackageReferenceComment, } = this.addOrUpdateEntry(project, packageReferenceSection, packageReferenceComment, packageReferenceSectionContent);
+        this.addOrUpdateArrayEntry(packageReferences, spmPackageReferenceUUID, {
+            value: spmPackageReferenceUUID,
+            comment: packageReferenceComment,
+        });
+        for (const lib of (_d = pkg.libs) !== null && _d !== void 0 ? _d : []) {
+            const { uuid: spmProductDependencyUUID } = this.addOrUpdateEntry(project, "XCSwiftPackageProductDependency", lib, {
+                isa: "XCSwiftPackageProductDependency",
+                package: spmPackageReferenceUUID,
+                package_comment: spmPackageReferenceComment,
+                productName: lib,
+            }, (existing) => existing.package === spmPackageReferenceUUID);
+            const libComment = `${lib} in Frameworks`;
+            const { uuid: spmBuildFileUuid } = this.addOrUpdateEntry(project, "PBXBuildFile", libComment, {
+                isa: "PBXBuildFile",
+                productRef: spmProductDependencyUUID,
+                productRef_comment: lib,
+            }, (existing) => existing.productRef === spmProductDependencyUUID);
+            this.addOrUpdateArrayEntry(packageProductReferences, spmProductDependencyUUID, {
+                value: spmProductDependencyUUID,
+                comment: lib,
+            });
+            this.addOrUpdateArrayEntry(frameworkBuildPhaseFiles, spmBuildFileUuid, {
+                value: spmBuildFileUuid,
+                comment: libComment,
+            });
+        }
+        return true;
+    }
+    findFrameworksBuildPhase(project, target) {
+        var _a, _b;
+        const section = (_a = project.hash.project.objects["PBXFrameworksBuildPhase"]) !== null && _a !== void 0 ? _a : {};
+        for (const phase of (_b = target.buildPhases) !== null && _b !== void 0 ? _b : []) {
+            const phaseObj = section[phase.value];
+            if (phaseObj) {
+                return phaseObj;
+            }
+        }
+        return null;
+    }
+    addOrUpdateArrayEntry(array, lookupValue, value) {
+        const existing = array.find((entry) => entry.value === lookupValue);
+        if (existing) {
+            Object.assign(existing, value);
+            return;
+        }
+        array.push(value);
+    }
+    addOrUpdateEntry(project, section, entryComment, entry, matches) {
+        var _a, _b;
+        var _c;
+        const pbxSection = ((_a = (_c = project.hash.project.objects)[section]) !== null && _a !== void 0 ? _a : (_c[section] = {}));
+        const entryUuid = (_b = this.findUuidByComment(project, section, entryComment, matches)) !== null && _b !== void 0 ? _b : project.generateUuid();
+        pbxSection[`${entryUuid}_comment`] = entryComment;
+        pbxSection[entryUuid] = entry;
+        return { uuid: entryUuid, comment: entryComment };
+    }
+    findUuidByComment(project, section, comment, matches) {
+        var _a;
+        const pbxSection = (_a = project.hash.project.objects[section]) !== null && _a !== void 0 ? _a : {};
+        const commentKey = Object.keys(pbxSection).find((key) => {
+            if (!key.endsWith("_comment") || pbxSection[key] !== comment) {
+                return false;
+            }
+            if (!matches) {
+                return true;
+            }
+            const existing = pbxSection[key.replace(/_comment$/, "")];
+            return existing != null && matches(existing);
+        });
+        return commentKey ? commentKey.replace(/_comment$/, "") : null;
+    }
+}
+exports.SPMPbxprojService = SPMPbxprojService;
+function classifyVersion(version) {
+    var _a, _b;
+    if (version.startsWith("#")) {
+        return {
+            kind: "revision",
+            revision: version.replace("#", ""),
+        };
+    }
+    if (semver.valid(version)) {
+        return {
+            kind: "exactVersion",
+            version,
+        };
+    }
+    const range = semver.validRange(version);
+    if (range) {
+        const minimumVersion = (_a = semver.minVersion(range)) === null || _a === void 0 ? void 0 : _a.version;
+        if (version.startsWith("^")) {
+            return {
+                kind: "upToNextMajorVersion",
+                minimumVersion,
+            };
+        }
+        if (version.startsWith("~")) {
+            return {
+                kind: "upToNextMinorVersion",
+                minimumVersion,
+            };
+        }
+        const maximumVersion = (_b = semver.coerce(version.replace(minimumVersion !== null && minimumVersion !== void 0 ? minimumVersion : "", ""))) === null || _b === void 0 ? void 0 : _b.version;
+        if (maximumVersion && maximumVersion !== minimumVersion) {
+            return {
+                kind: "versionRange",
+                minimumVersion,
+                maximumVersion,
+            };
+        }
+        return {
+            kind: "upToNextMajorVersion",
+            minimumVersion,
+        };
+    }
+    return {
+        kind: "branch",
+        branch: version,
+    };
+}
+const UNQUOTED_PBX_VALUE = /^[A-Za-z0-9_$./]+$/;
+function quoteValuesForPbxproj(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] =
+            typeof value === "string" && !UNQUOTED_PBX_VALUE.test(value)
+                ? JSON.stringify(value)
+                : value;
+    }
+    return result;
+}
+yok_1.injector.register("spmPbxprojService", SPMPbxprojService);

package/lib/services/ios/spm-service.d.ts

@@ -0,0 +1,35 @@
+import { IProjectConfigService, IProjectData } from "../../definitions/project";
+import { IPlatformData } from "../../definitions/platform";
+import { IFileSystem } from "../../common/declarations";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class SPMService implements ISPMService {
+    private $logger;
+    private $fs;
+    private $projectConfigService;
+    private $terminalSpinnerService;
+    private $xcodebuildCommandService;
+    private $xcodebuildArgsService;
+    private $spmPbxprojService;
+    private static readonly SWIFTPM_REPO_CACHE;
+    private static readonly LARGE_CLONE_NOTE_BYTES;
+    private static readonly OUTPUT_TAIL_LINES;
+    constructor($logger: ILogger, $fs: IFileSystem, $projectConfigService: IProjectConfigService, $terminalSpinnerService: ITerminalSpinnerService, $xcodebuildCommandService: IXcodebuildCommandService, $xcodebuildArgsService: IXcodebuildArgsService, $spmPbxprojService: ISPMPbxprojService);
+    getSPMPackages(projectData: IProjectData, platform: string): IosSPMPackage[];
+    private mergePluginSPMPackages;
+    applySPMPackages(platformData: IPlatformData, projectData: IProjectData, pluginSpmPackages?: IosSPMPackage[]): Promise<void>;
+    resolveSPMDependencies(platformData: IPlatformData, projectData: IProjectData, options?: {
+        showProgress?: boolean;
+    }): Promise<void>;
+    ensureSPMDependenciesResolved(platformData: IPlatformData, projectData: IProjectData): Promise<void>;
+    private describeSPMActivity;
+    private describePackageActivity;
+    private shortenPackageRef;
+    private formatElapsed;
+    private formatPackageListing;
+    private describePackageSource;
+    private getPackageCloneSizeBytes;
+    private getDirectorySizeBytes;
+    private formatBytes;
+    private hasSPMReferences;
+    private arePackagesResolved;
+}

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

@@ -2,37 +2,26 @@
 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");
 const os = require("os");
 const fs = require("fs");
 class SPMService {
-    constructor($logger, $fs, $projectConfigService, $terminalSpinnerService, $xcodebuildCommandService, $xcodebuildArgsService) {
+    constructor($logger, $fs, $projectConfigService, $terminalSpinnerService, $xcodebuildCommandService, $xcodebuildArgsService, $spmPbxprojService) {
         this.$logger = $logger;
         this.$fs = $fs;
         this.$projectConfigService = $projectConfigService;
         this.$terminalSpinnerService = $terminalSpinnerService;
         this.$xcodebuildCommandService = $xcodebuildCommandService;
         this.$xcodebuildArgsService = $xcodebuildArgsService;
+        this.$spmPbxprojService = $spmPbxprojService;
     }
     getSPMPackages(projectData, platform) {
         const spmPackages = this.$projectConfigService.getValue(`${platform}.SPMPackages`, []);
         return spmPackages;
     }
-    /**
-     * Merges plugin SPM packages with app SPM packages.
-     * App packages take precedence over plugin packages with the same name.
-     * @param appPackages - Array of app SPM packages (modified in place)
-     * @param pluginPackages - Array of plugin SPM packages to merge
-     */
     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));
-        // 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)) {
@@ -47,10 +36,6 @@ class SPMService {
             }
         }
     }
-    // note: this is not used anywhere at the moment.
-    // public hasSPMPackages(projectData: IProjectData): boolean {
-    // 	return this.getSPMPackages(projectData).length > 0;
-    // }
     async applySPMPackages(platformData, projectData, pluginSpmPackages) {
         var _a, _b;
         try {
@@ -62,67 +47,35 @@ 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: ".",
-                },
-                enableAndroid: false,
-            });
-            await project.load();
-            // note: in trapeze both visionOS and iOS are handled by the ios project.
-            if (!project.ios) {
-                this.$logger.trace("SPM: no iOS project found via trapeze.");
-                return;
-            }
-            // todo: handle removing packages? Or just warn and require a clean?
+            const assignments = [];
             for (const pkg of spmPackages) {
                 if ("path" in pkg) {
-                    // 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);
-                // Add to other Targets if specified (like widgets, etc.)
-                if ((_a = pkg.targets) === null || _a === void 0 ? void 0 : _a.length) {
-                    for (const target of pkg.targets) {
-                        await project.ios.addSPMPackage(target, pkg);
-                    }
+                assignments.push({ targetName: projectData.projectName, package: pkg });
+                for (const target of (_a = pkg.targets) !== null && _a !== void 0 ? _a : []) {
+                    assignments.push({ targetName: target, package: pkg });
                 }
             }
-            await project.commit();
-            // finally resolve the dependencies
+            if (!this.$spmPbxprojService.addPackages(platformData.projectRoot, assignments)) {
+                this.$logger.trace("SPM: no packages were applied to the project.");
+                return;
+            }
             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);
         }
     }
-    /**
-     * 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)
@@ -131,9 +84,6 @@ class SPMService {
             "generic/platform=iOS",
             "-resolvePackageDependencies",
         ]);
-        // 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,
@@ -145,14 +95,9 @@ 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);
@@ -161,9 +106,6 @@ class SPMService {
                 : "";
             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 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++;
@@ -172,8 +114,6 @@ class SPMService {
                 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 — ` +
@@ -187,9 +127,7 @@ class SPMService {
         }, 1000);
         const onProgress = (chunk) => {
             lineBuffer += chunk.data;
-            // 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();
@@ -203,9 +141,6 @@ class SPMService {
                 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);
                     }
@@ -230,8 +165,6 @@ class SPMService {
         }
         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) {
@@ -244,12 +177,6 @@ class SPMService {
             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.");
@@ -265,22 +192,14 @@ class SPMService {
             });
         }
         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)";
@@ -304,20 +223,12 @@ class SPMService {
         }
         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) {
@@ -328,39 +239,23 @@ class SPMService {
             .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`;
     }
-    /**
-     * 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 {
@@ -380,11 +275,6 @@ class SPMService {
         }
         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];
@@ -408,13 +298,11 @@ class SPMService {
                     }
                 }
                 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;
@@ -426,7 +314,6 @@ class SPMService {
         }
         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");
         if (!this.$fs.exists(pbxprojPath)) {
@@ -437,11 +324,6 @@ class SPMService {
             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"),
@@ -451,17 +333,7 @@ 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/xcodebuild-args-service.d.ts

@@ -0,0 +1,20 @@
+import { IIOSWatchAppService, IProjectData, IBuildConfig } from "../../definitions/project";
+import { IXcconfigService } from "../../declarations";
+import { IPlatformData } from "../../definitions/platform";
+import { IFileSystem } from "../../common/declarations";
+export declare class XcodebuildArgsService implements IXcodebuildArgsService {
+    private $devicePlatformsConstants;
+    private $devicesService;
+    private $fs;
+    private $iOSWatchAppService;
+    private $logger;
+    private $xcconfigService;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $devicesService: Mobile.IDevicesService, $fs: IFileSystem, $iOSWatchAppService: IIOSWatchAppService, $logger: ILogger, $xcconfigService: IXcconfigService);
+    getBuildForSimulatorArgs(platformData: IPlatformData, projectData: IProjectData, buildConfig: IBuildConfig): Promise<string[]>;
+    getBuildForDeviceArgs(platformData: IPlatformData, projectData: IProjectData, buildConfig: IBuildConfig): Promise<string[]>;
+    private getArchitecturesArgs;
+    getXcodeProjectArgs(platformData: IPlatformData, projectData: IProjectData): string[];
+    private getBuildLoggingArgs;
+    private getBuildCommonArgs;
+    private getArchitecturesFromConnectedDevices;
+}