nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/services/extensibility-service.js

@@ -12,7 +12,55 @@ const _ = require("lodash");
 const decorators_1 = require("../common/decorators");
 const constants = require("../constants");
 const helpers_1 = require("../common/helpers");
+const deprecation_1 = require("../common/deprecation");
 const yok_1 = require("../common/yok");
+const constants_1 = require("../common/constants");
+const inject_1 = require("../common/di/inject");
+const contracts_1 = require("../common/contracts");
+const define_command_1 = require("../common/define-command");
+const command_definition_adapter_1 = require("../common/services/command-definition-adapter");
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isCommandsMap(commands) {
+    return !!commands && typeof commands === "object" && !Array.isArray(commands);
+}
+function getEntryModulePath(value) {
+    if (isNonEmptyString(value)) {
+        return value;
+    }
+    if (value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        isNonEmptyString(value.path)) {
+        return value.path;
+    }
+    return null;
+}
+const isDefaultCommandName = (name) => name.indexOf(constants_1.CommandsDelimiters.DefaultHierarchicalCommand) !== -1;
+function describeRejection(rejection) {
+    switch (rejection.reason) {
+        case "invalid-name":
+            return rejection.detail;
+        case "claimed":
+            return `it is already registered by extension ${rejection.owner}`;
+        case "built-in":
+            return "it is already provided by the CLI";
+        case "subcommand-parent":
+            return "it is already in use as the parent of its subcommands";
+        case "parent-is-command":
+            return `'${rejection.parent}' is already registered as a command of its own, so the subcommand could never be reached`;
+    }
+}
+function getDeclaredCommandNames(commands, opts) {
+    if (Array.isArray(commands)) {
+        return opts && opts.copy ? commands.slice() : commands;
+    }
+    if (isCommandsMap(commands)) {
+        return _.keys(commands);
+    }
+    return null;
+}
 class ExtensibilityService {
     get pathToPackageJson() {
         return path.join(this.pathToExtensions, constants.PACKAGE_JSON_FILE_NAME);
@@ -24,13 +72,15 @@ class ExtensibilityService {
     set pathToExtensions(pathToExtensions) {
         this.customPathToExtensions = pathToExtensions;
     }
-    constructor($fs, $logger, $packageManager, $settingsService, $requireService) {
+    constructor($fs, $logger, $packageManager, $settingsService, $requireService, $injector) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$packageManager = $packageManager;
         this.$settingsService = $settingsService;
         this.$requireService = $requireService;
+        this.$injector = $injector;
         this.customPathToExtensions = null;
+        this.commandRegistry = (0, inject_1.inject)(contracts_1.CommandRegistry);
     }
     async installExtension(extensionName) {
         this.$logger.trace(`Start installation of extension '${extensionName}'.`);
@@ -83,18 +133,36 @@ class ExtensibilityService {
             packageJsonData.nativescript &&
             packageJsonData.nativescript.docs &&
             path.join(pathToExtension, packageJsonData.nativescript.docs);
-        return {
+        const result = {
             extensionName: packageJsonData.name,
             version: packageJsonData.version,
             docs,
             pathToExtension,
         };
+        const commands = getDeclaredCommandNames(packageJsonData &&
+            packageJsonData.nativescript &&
+            packageJsonData.nativescript.commands);
+        if (commands) {
+            result.commands = commands;
+        }
+        return result;
     }
     async loadExtension(extensionName) {
         try {
             await this.assertExtensionIsInstalled(extensionName);
             const pathToExtension = this.getPathToExtension(extensionName);
-            this.$requireService.require(pathToExtension);
+            const commandsMap = this.getDeclaredCommandsMap(extensionName);
+            if (commandsMap) {
+                this.registerDeclaredCommands(extensionName, pathToExtension, commandsMap);
+            }
+            else {
+                (0, deprecation_1.reportDeprecation)({
+                    api: "extensions.require-time-registration",
+                    detail: extensionName,
+                    logger: this.$logger,
+                });
+                this.$requireService.require(pathToExtension);
+            }
             return this.getInstalledExtensionData(extensionName);
         }
         catch (error) {
@@ -121,9 +189,9 @@ class ExtensibilityService {
             try {
                 const registryData = await this.$packageManager.getRegistryPackageData(extensionName);
                 const latestPackageData = registryData.versions[registryData["dist-tags"].latest];
-                const commands = latestPackageData &&
+                const commands = getDeclaredCommandNames(latestPackageData &&
                     latestPackageData.nativescript &&
-                    latestPackageData.nativescript.commands;
+                    latestPackageData.nativescript.commands, { copy: true });
                 if (commands && commands.length) {
                     _.filter(commands, (command) => command.indexOf(inputOpts.defaultCommandDelimiter) !== -1).forEach((defaultCommand) => {
                         commands.push(defaultCommand.replace(defaultCommandRegExp, ""));
@@ -151,6 +219,59 @@ class ExtensibilityService {
         }
         return null;
     }
+    getDeclaredCommandsMap(extensionName) {
+        let commands;
+        try {
+            const packageJsonData = this.getExtensionPackageJsonData(extensionName);
+            commands =
+                packageJsonData &&
+                    packageJsonData.nativescript &&
+                    packageJsonData.nativescript.commands;
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to read the package.json of extension ${extensionName}. Error is: ${err}`);
+            return null;
+        }
+        return isCommandsMap(commands) ? commands : null;
+    }
+    registerDeclaredCommands(extensionName, pathToExtension, commands) {
+        const commandNames = _.sortBy(_.keys(commands), (commandName) => isDefaultCommandName(commandName) ? 0 : 1);
+        for (const commandName of commandNames) {
+            const modulePath = getEntryModulePath(commands[commandName]);
+            if (!isNonEmptyString(commandName) || !modulePath) {
+                this.$logger.warn(`Extension ${extensionName} declares an invalid command in its nativescript.commands: '${commandName}': ${JSON.stringify(commands[commandName])}. The command name must be a non-empty string and its value either the path to its module or an object with a non-empty 'path'. Skipping this command.`);
+                continue;
+            }
+            const absoluteModulePath = path.join(pathToExtension, modulePath);
+            const result = this.commandRegistry.registerDeferredCommand(commandName, {
+                owner: extensionName,
+                source: absoluteModulePath,
+                load: () => this.loadDeclaredCommand(extensionName, commandName, absoluteModulePath),
+            });
+            if (!result.registered) {
+                this.$logger.warn(`Extension ${extensionName} is unable to register command '${commandName}': ${describeRejection(result.rejection)}.`);
+            }
+        }
+    }
+    loadDeclaredCommand(extensionName, commandName, absoluteModulePath) {
+        var _a;
+        const exported = require(absoluteModulePath);
+        const candidate = (_a = (exported && exported.default)) !== null && _a !== void 0 ? _a : exported;
+        if (!(0, define_command_1.isCommandDefinition)(candidate)) {
+            return;
+        }
+        this.warnOnDeclaredNameMismatch(extensionName, commandName, absoluteModulePath, candidate);
+        (0, command_definition_adapter_1.registerDefinitionAs)(commandName, candidate, this.$injector);
+    }
+    warnOnDeclaredNameMismatch(extensionName, commandName, absoluteModulePath, definition) {
+        const declaredNames = Array.isArray(definition.name)
+            ? definition.name
+            : [definition.name];
+        if (_.includes(declaredNames, commandName)) {
+            return;
+        }
+        this.$logger.warn(`Extension ${extensionName} declares command '${commandName}' in its package.json, but the definition in ${absoluteModulePath} names itself '${declaredNames.join("', '")}'. The command runs as '${commandName}' - the manifest decides how it is invoked.`);
+    }
     getPathToExtension(extensionName) {
         return path.join(this.pathToExtensions, constants.NODE_MODULES_FOLDER_NAME, extensionName);
     }

package/lib/services/files-hash-service.d.ts

@@ -0,0 +1,17 @@
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IPlatformData } from "../definitions/platform";
+import { IFileSystem, IStringDictionary } from "../common/declarations";
+import { IOptions } from "../declarations";
+export declare class FilesHashService implements IFilesHashService {
+    private $fs;
+    private $logger;
+    private $options;
+    constructor($fs: IFileSystem, $logger: ILogger, $options: IOptions);
+    generateHashes(files: string[]): Promise<IStringDictionary>;
+    generateHashesForProject(platformData: IPlatformData): Promise<IStringDictionary>;
+    saveHashesForProject(platformData: IPlatformData, hashesFileDirectory: string): Promise<IStringDictionary>;
+    getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary>;
+    hasChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): boolean;
+    saveHashes(hashes: IStringDictionary, hashesFileDirectory: string): void;
+    getChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): IStringDictionary;
+}

package/lib/services/hmr-status-service.d.ts

@@ -0,0 +1,19 @@
+export declare class HmrStatusService implements IHmrStatusService {
+    private $logParserService;
+    private $devicePlatformsConstants;
+    private $logger;
+    static HMR_STATUS_LOG_REGEX: RegExp;
+    static STARTED_MESSAGE: string;
+    static SUCCESS_MESSAGE: string;
+    static FAILED_MESSAGE: string;
+    private hashOperationStatuses;
+    private intervals;
+    constructor($logParserService: ILogParserService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logger: ILogger);
+    getHmrStatus(deviceId: string, operationHash: string): Promise<number>;
+    watchHmrStatus(deviceId: string, operationHash: string): void;
+    attachToHmrStatusEvent(): void;
+    private handleAppCrash;
+    private handleHmrStatusFound;
+    private getStatusByKey;
+    private setData;
+}

package/lib/services/info-service.d.ts

@@ -0,0 +1,6 @@
+import { IInfoService, IVersionsService } from "../declarations";
+export declare class InfoService implements IInfoService {
+    private $versionsService;
+    constructor($versionsService: IVersionsService);
+    printComponentsInfo(): Promise<void>;
+}

package/lib/services/initialize-service.d.ts

@@ -0,0 +1,8 @@
+import { IInitializeOptions, IInitializeService } from "../definitions/initialize-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class InitializeService implements IInitializeService {
+    private $injector;
+    constructor($injector: IInjector);
+    initialize(initOpts?: IInitializeOptions): Promise<void>;
+    private showWarnings;
+}

package/lib/services/ios/export-options-plist-service.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData, IBuildConfig } from "../../definitions/project";
+import { IFileSystem } from "../../common/declarations";
+import { ITempService } from "../../definitions/temp-service";
+export declare class ExportOptionsPlistService implements IExportOptionsPlistService {
+    private $fs;
+    private $tempService;
+    private $projectData;
+    constructor($fs: IFileSystem, $tempService: ITempService, $projectData: IProjectData);
+    private getExtensionProvisions;
+    createDevelopmentExportOptionsPlist(archivePath: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<IExportOptionsPlistOutput>;
+    createDistributionExportOptionsPlist(archivePath: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<IExportOptionsPlistOutput>;
+    private getExportOptionsMethod;
+}

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

@@ -0,0 +1,33 @@
+import * as mobileProvisionFinder from "ios-mobileprovision-finder";
+import { IOSProvisionService } from "../ios-provision-service";
+import { IOSBuildData } from "../../data/build-data";
+import { IOptions, IXcconfigService, IXcprojService } from "../../declarations";
+import { IProjectData } from "../../definitions/project";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare class IOSSigningService implements IiOSSigningService {
+    private $errors;
+    private $fs;
+    private $iOSProvisionService;
+    private $logger;
+    private $options;
+    private $pbxprojDomXcode;
+    private $prompter;
+    private $xcconfigService;
+    private $xcprojService;
+    constructor($errors: IErrors, $fs: IFileSystem, $iOSProvisionService: IOSProvisionService, $logger: ILogger, $options: IOptions, $pbxprojDomXcode: IPbxprojDomXcode, $prompter: IPrompter, $xcconfigService: IXcconfigService, $xcprojService: IXcprojService);
+    setupSigningForDevice(projectRoot: string, projectData: IProjectData, iOSBuildData: IOSBuildData): Promise<void>;
+    setupSigningFromTeam(projectRoot: string, projectData: IProjectData, teamId: string): Promise<void>;
+    setupSigningFromProvision(projectRoot: string, projectData: IProjectData, provision?: string, mobileProvisionData?: mobileProvisionFinder.provision.MobileProvision): Promise<void>;
+    private getExtensionNames;
+    private getExtensionsManualSigningConfiguration;
+    private getManualSigningConfiguration;
+    private getBuildXCConfigFilePath;
+    private getPbxProjPath;
+    private readTeamIdFromFile;
+    private getDevelopmentTeam;
+    private readXCConfigDevelopmentTeam;
+    private readXCConfigProvisioningProfile;
+    private readXCConfigProvisioningProfileForIPhoneOs;
+    private readXCConfigProvisioningProfileSpecifier;
+    private readXCConfigProvisioningProfileSpecifierForIPhoneOs;
+}

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

@@ -0,0 +1,16 @@
+import { IFileSystem } from "../../common/declarations";
+export declare class SPMPbxprojService implements ISPMPbxprojService {
+    private $fs;
+    private $logger;
+    private $xcode;
+    constructor($fs: IFileSystem, $logger: ILogger, $xcode: IXcode);
+    addPackages(projectRoot: string, assignments: IosSPMPackageAssignment[]): boolean;
+    private findPbxProjPath;
+    private findTargetId;
+    private addPackageToTarget;
+    private findFrameworksBuildPhase;
+    private addOrUpdateArrayEntry;
+    private addOrUpdateEntry;
+    private findUuidByComment;
+}
+export declare function classifyVersion(version: string): Record<string, string>;

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,19 +2,19 @@
 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`, []);
@@ -48,17 +48,7 @@ class SPMService {
                 return;
             }
             this.$logger.info(this.formatPackageListing(spmPackages));
-            const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
-                ios: {
-                    path: ".",
-                },
-                enableAndroid: false,
-            });
-            await project.load();
-            if (!project.ios) {
-                this.$logger.trace("SPM: no iOS project found via trapeze.");
-                return;
-            }
+            const assignments = [];
             for (const pkg of spmPackages) {
                 if ("path" in pkg) {
                     this.$logger.trace("SPM: resolving path for package: ", pkg.path);
@@ -68,14 +58,15 @@ class SPMService {
                     }
                 }
                 this.$logger.trace(`SPM: adding package ${pkg.name} to project.`, pkg);
-                await project.ios.addSPMPackage(projectData.projectName, pkg);
-                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();
+            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,
             });

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;
+}