nativescript 9.0.6-rc.2 → 9.0.7-dev.0

package/lib/.d.ts

@@ -256,7 +256,6 @@
 /// <reference path="definitions/data.d.ts" />
 /// <reference path="definitions/debug.d.ts" />
 /// <reference path="definitions/deploy.d.ts" />
-/// <reference path="definitions/devtools-host-service.d.ts" />
 /// <reference path="definitions/file-log-service.d.ts" />
 /// <reference path="definitions/files-hash-service.d.ts" />
 /// <reference path="definitions/gradle.d.ts" />
@@ -357,7 +356,6 @@
 /// <reference path="services/debug-data-service.ts" />
 /// <reference path="services/debug-service-base.ts" />
 /// <reference path="services/device/device-install-app-service.ts" />
-/// <reference path="services/devtools-host-service.ts" />
 /// <reference path="services/doctor-service.ts" />
 /// <reference path="services/extensibility-service.ts" />
 /// <reference path="services/files-hash-service.ts" />

package/lib/bootstrap.js

@@ -191,7 +191,6 @@ yok_1.injector.require("testInitializationService", "./services/test-initializat
 yok_1.injector.require("networkConnectivityValidator", "./helpers/network-connectivity-validator");
 yok_1.injector.requirePublic("cleanupService", "./services/cleanup-service");
 yok_1.injector.require("bundlerCompilerService", "./services/bundler/bundler-compiler-service");
-yok_1.injector.require("devtoolsHostService", "./services/devtools-host-service");
 yok_1.injector.require("applePortalSessionService", "./services/apple-portal/apple-portal-session-service");
 yok_1.injector.require("applePortalCookieService", "./services/apple-portal/apple-portal-cookie-service");
 yok_1.injector.require("applePortalApplicationService", "./services/apple-portal/apple-portal-application-service");

package/lib/constants.js

@@ -324,6 +324,7 @@ var IOSNativeTargetTypes;
     IOSNativeTargetTypes["watchApp"] = "watch_app";
     IOSNativeTargetTypes["watchExtension"] = "watch_extension";
     IOSNativeTargetTypes["appExtension"] = "app_extension";
+    IOSNativeTargetTypes["application"] = "application";
 })(IOSNativeTargetTypes || (exports.IOSNativeTargetTypes = IOSNativeTargetTypes = {}));
 const pathToLoggerAppendersDir = (0, path_1.join)(__dirname, "common", "logger", "appenders");
 exports.LoggerAppenders = {

package/lib/controllers/run-controller.js

@@ -15,7 +15,7 @@ const util = require("util");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class RunController extends events_1.EventEmitter {
-    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $devtoolsHostService) {
+    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService) {
         super();
         this.$analyticsService = $analyticsService;
         this.$buildController = $buildController;
@@ -37,7 +37,6 @@ class RunController extends events_1.EventEmitter {
         this.$prepareNativePlatformService = $prepareNativePlatformService;
         this.$projectChangesService = $projectChangesService;
         this.$projectDataService = $projectDataService;
-        this.$devtoolsHostService = $devtoolsHostService;
         this.prepareReadyEventHandler = null;
     }
     async run(runData) {
@@ -110,7 +109,6 @@ class RunController extends events_1.EventEmitter {
                     await liveSyncProcessInfo.actionsChain;
                 }
                 liveSyncProcessInfo.deviceDescriptors = [];
-                await this.$devtoolsHostService.stopAll();
                 if (this.prepareReadyEventHandler) {
                     this.$prepareController.removeListener(constants_2.PREPARE_READY_EVENT_NAME, this.prepareReadyEventHandler);
                     this.prepareReadyEventHandler = null;

package/lib/definitions/nativescript-dev-xcode.d.ts

@@ -8,16 +8,27 @@ declare module "nativescript-dev-xcode" {
 	}
 
 	class project {
+		hash: any;
+		filepath: string;
 		constructor(filename: string);
 
 		parse(callback: () => void): void;
 		parseSync(): void;
 
+		generateUuid(): string;
+
 		writeSync(options: any): string;
 
 		addFramework(filepath: string, options?: Options): void;
 		removeFramework(filePath: string, options?: Options): void;
 
+
+		getProductFile(watchApptarget: target): any;
+		addToPbxFrameworksBuildPhase(file);
+		addToPbxCopyfilesBuildPhase(file, comment: string, targetid: string);
+		pbxFrameworksBuildPhaseObj(targetid: string): any;
+		pbxBuildFileSection(): {[k: string] : any};
+
 		addPbxGroup(
 			filePathsArray: any[],
 			name: string,
@@ -27,17 +38,30 @@ declare module "nativescript-dev-xcode" {
 
 		removePbxGroup(groupName: string, path: string): void;
 
+		addTargetDependency(target: string, dependencyTargets: string[]);
+
+		findTargetKey(name: string);
+		pbxTargetByName(name: string): target;
+		pbxNativeTargetSection(): {[key: string]: any};
+
 		addToHeaderSearchPaths(options?: Options): void;
 		removeFromHeaderSearchPaths(options?: Options): void;
 		updateBuildProperty(key: string, value: any): void;
 
 		pbxXCBuildConfigurationSection(): any;
 
+		buildPhaseObject(
+			buildPhaseType: string,
+			comment: string,
+			target: tstring
+		)
+
 		addTarget(
 			targetName: string,
 			targetType: string,
 			targetPath?: string,
-			parentTarget?: string
+			parentTarget?: string,
+			productTargetType?: string
 		): target;
 		addBuildPhase(
 			filePathsArray: string[],

package/lib/definitions/project.d.ts

@@ -601,9 +601,7 @@ interface INativePrepare {
 }
 
 interface IBuildConfig
-	extends IAndroidBuildOptionsSettings,
-		IiOSBuildConfig,
-		IProjectDir {
+	extends IAndroidBuildOptionsSettings, IiOSBuildConfig, IProjectDir {
 	clean?: boolean;
 	architectures?: string[];
 	buildOutputStdio?: string;
@@ -615,7 +613,8 @@ interface IBuildConfig
  * Describes iOS-specific build configuration properties
  */
 interface IiOSBuildConfig
-	extends IBuildForDevice,
+	extends
+		IBuildForDevice,
 		IiCloudContainerEnvironment,
 		IDeviceIdentifier,
 		IProvision,
@@ -865,6 +864,7 @@ interface IAddExtensionsFromPathOptions extends IAddTargetFromPathOptions {
 
 interface IAddWatchAppFromPathOptions extends IAddTargetFromPathOptions {
 	watchAppFolderPath: string;
+	disableStubBinary?: boolean;
 }
 
 interface IRemoveExtensionsOptions {
@@ -873,6 +873,37 @@ interface IRemoveExtensionsOptions {
 
 interface IRemoveWatchAppOptions extends IRemoveExtensionsOptions {}
 
+interface IWatchAppJSONConfigModule {
+	name?: string;
+	path: string;
+	targetType?: string;
+	embed?: boolean;
+	frameworks?: Array<string | Record<string, string>>;
+	dependencies?: string[];
+	headerSearchPaths?: string[];
+	resources?: string[];
+	src?: string[];
+	linkerFlags?: string[];
+	buildConfigurationProperties?: Record<string, string>;
+	SPMPackages?: Array<IOSSPMPackage | string>;
+}
+interface IWatchAppJSONConfig {
+	targetType?: string;
+	forceAddEmbedWatchContent?: boolean;
+	sharedModulesBuildConfigurationProperties?: Record<string, string>;
+	basedir?: string;
+	infoPlistPath?: string;
+	xcprivacyPath?: string;
+	importSourcesFromMainFolder?: boolean;
+	importResourcesFromMainFolder?: boolean;
+	resources?: string[];
+	src?: string[];
+	resourcesExclude?: string[];
+	srcExclude?: string[];
+	modules: IWatchAppConfigModule[];
+	SPMPackages?: Array<IOSSPMPackage>;
+}
+
 interface IRubyFunction {
 	functionName: string;
 	functionParameters?: string;

package/lib/helpers/livesync-command-helper.js

@@ -5,7 +5,7 @@ const _ = require("lodash");
 const yok_1 = require("../common/yok");
 const constants_1 = require("../constants");
 class LiveSyncCommandHelper {
-    constructor($androidBundleValidatorHelper, $buildDataService, $projectData, $options, $deployController, $iosDeviceOperations, $mobileHelper, $devicesService, $injector, $buildController, $analyticsService, $errors, $iOSSimulatorLogProvider, $cleanupService, $runController, $devtoolsHostService) {
+    constructor($androidBundleValidatorHelper, $buildDataService, $projectData, $options, $deployController, $iosDeviceOperations, $mobileHelper, $devicesService, $injector, $buildController, $analyticsService, $errors, $iOSSimulatorLogProvider, $cleanupService, $runController) {
         this.$androidBundleValidatorHelper = $androidBundleValidatorHelper;
         this.$buildDataService = $buildDataService;
         this.$projectData = $projectData;
@@ -21,7 +21,6 @@ class LiveSyncCommandHelper {
         this.$iOSSimulatorLogProvider = $iOSSimulatorLogProvider;
         this.$cleanupService = $cleanupService;
         this.$runController = $runController;
-        this.$devtoolsHostService = $devtoolsHostService;
     }
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
@@ -126,7 +125,6 @@ class LiveSyncCommandHelper {
             return;
         }
         else {
-            await this.startDevtoolsHostIfDebugging(deviceDescriptors);
             await this.$runController.run({
                 liveSyncInfo,
                 deviceDescriptors,
@@ -152,16 +150,6 @@ class LiveSyncCommandHelper {
         }
         return result;
     }
-    async startDevtoolsHostIfDebugging(deviceDescriptors) {
-        const platforms = _.uniq(deviceDescriptors
-            .filter((d) => { var _a; return d.debuggingEnabled && ((_a = d.buildData) === null || _a === void 0 ? void 0 : _a.platform); })
-            .map((d) => d.buildData.platform.toLowerCase()));
-        for (const platform of platforms) {
-            // DevtoolsHostService swallows port/bind failures and returns null;
-            // a missing source-map origin degrades DevTools gracefully.
-            await this.$devtoolsHostService.start(this.$projectData, platform);
-        }
-    }
     async executeLiveSyncOperationCore(devices, platform, additionalOptions) {
         if (!devices || !devices.length) {
             if (platform) {

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

@@ -19,7 +19,7 @@ const package_path_helper_1 = require("../../helpers/package-path-helper");
 const debugLog = false;
 class BundlerCompilerService extends events_1.EventEmitter {
     constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager, // private $sharedEventBus: ISharedEventBus
-    $projectConfigService, $devtoolsHostService) {
+    $projectConfigService) {
         super();
         this.$options = $options;
         this.$errors = $errors;
@@ -33,7 +33,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageManager = $packageManager;
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
-        this.$devtoolsHostService = $devtoolsHostService;
         this.bundlerProcesses = {};
         this.expectedHashes = {};
     }
@@ -97,6 +96,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                                 console.log("Vite first build completed, resolving compileWithWatch");
                             }
                             resolve(childProcess);
+                            return;
                         }
                         // Transform Vite message to match webpack format
                         const files = message.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
@@ -363,10 +363,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         if (prepareData.uniqueBundle > 0) {
             envData.uniqueBundle = prepareData.uniqueBundle;
         }
-        const devtoolsOrigin = this.$devtoolsHostService.getOrigin(platform);
-        if (devtoolsOrigin) {
-            envData.devtoolsHost = devtoolsOrigin;
-        }
         return envData;
     }
     async buildEnvCommandLineParams(envData, platformData, projectData, prepareData) {

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

@@ -468,7 +468,6 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 }
             }
         }
-        this.$iOSWatchAppService.removeWatchApp({ pbxProjPath });
         const addedWatchApp = await this.$iOSWatchAppService.addWatchAppFromPath({
             watchAppFolderPath: path.join(resourcesDirectoryPath, platformData.normalizedPlatformName),
             projectData,

package/lib/services/ios-watch-app-service.js

@@ -4,34 +4,208 @@ exports.IOSWatchAppService = void 0;
 const path = require("path");
 const constants_1 = require("../constants");
 const yok_1 = require("../common/yok");
+const trapezedev_project_1 = require("@nstudio/trapezedev-project");
+const minimatch_1 = require("minimatch");
+const sourceExtensions = [
+    ".swift",
+    ".m",
+    ".mm",
+    ".c",
+    ".cpp",
+    ".cc",
+    ".cxx",
+    ".h",
+    ".hpp",
+];
+const resourceExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".pdf", // Images
+    ".ttf",
+    ".otf",
+    ".woff",
+    ".woff2", // Fonts
+    ".xcassets", // Asset catalogs
+    ".storyboard",
+    ".xib", // Interface files
+    ".strings",
+    ".stringsdict", // Localization
+    ".json",
+    ".xml",
+    ".plist", // Data files
+    ".m4a",
+    ".mp3",
+    ".wav",
+    ".caf", // Audio
+    ".mp4",
+    ".mov", // Video
+    ".bundle", // Resource bundles
+];
+const WATCH_APP_IDENTIFIER = "watchkitapp";
+const WACTCH_EXTENSION_IDENTIFIER = "watchkitextension";
+const CONFIG_FILE_WATCHAPP = "watchapp.json";
+const CONFIG_FILE_EXTENSION = "extension.json";
+const RESOURCES_TO_IGNORE = [
+    CONFIG_FILE_WATCHAPP,
+    CONFIG_FILE_EXTENSION,
+    "node_modules",
+];
 class IOSWatchAppService {
-    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService) {
+    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService, $logger) {
         this.$fs = $fs;
         this.$pbxprojDomXcode = $pbxprojDomXcode;
         this.$xcode = $xcode;
         this.$iOSNativeTargetService = $iOSNativeTargetService;
+        this.$logger = $logger;
     }
-    async addWatchAppFromPath({ watchAppFolderPath, projectData, platformData, pbxProjPath, }) {
+    addResourceFile(project, path, opt, group = "WatchResources") {
+        const file = project.addResourceFile(path, opt, group);
+        project.addToResourcesPbxGroup(file, group);
+    }
+    addSourceFile(project, path, opt, group = "WatchSrc") {
+        const file = project.addSourceFile(path, opt, group);
+        project.addToResourcesPbxGroup(file, group);
+    }
+    async addWatchAppFromPath({ watchAppFolderPath, projectData, platformData, pbxProjPath, disableStubBinary = false, }) {
+        var _a, _b;
         const targetUuids = [];
+        const targetNames = [];
         const appPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_FOLDER);
         const extensionPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_EXTENSION_FOLDER);
-        if (!this.$fs.exists(appPath) || !this.$fs.exists(extensionPath)) {
+        const hasWatchExtension = this.$fs.exists(extensionPath);
+        // Check if watchapp exists - it's required
+        if (!this.$fs.exists(appPath)) {
             return false;
         }
         const appFolder = this.$iOSNativeTargetService.getTargetDirectories(appPath)[0];
-        const extensionFolder = this.$iOSNativeTargetService.getTargetDirectories(extensionPath)[0];
         const project = new this.$xcode.project(pbxProjPath);
         project.parseSync();
-        const watchApptarget = this.$iOSNativeTargetService.addTargetToProject(appPath, appFolder, constants_1.IOSNativeTargetTypes.watchApp, project, platformData, project.getFirstTarget().uuid);
-        this.configureTarget(appFolder, path.join(appPath, appFolder), `${projectData.projectIdentifiers.ios}.${IOSWatchAppService.WATCH_APP_IDENTIFIER}`, "watchapp.json", watchApptarget, project);
+        const configPath = path.join(path.join(appPath, appFolder), "watchapp.json");
+        const config = this.$fs.exists(configPath)
+            ? this.$fs.readJson(configPath)
+            : null;
+        const targetType = (_a = config === null || config === void 0 ? void 0 : config.targetType) !== null && _a !== void 0 ? _a : constants_1.IOSNativeTargetTypes.watchApp;
+        project.removeTargetsByProductType(constants_1.IOSNativeTargetProductTypes.watchApp);
+        project.removeTargetsByProductType(targetType);
+        const parentTargetUuid = project.getFirstTarget().uuid;
+        const watchApptarget = this.addTarget(appPath, appFolder, targetType, project, platformData, parentTargetUuid, constants_1.IOSNativeTargetTypes.watchApp);
+        await this.configureTarget(appFolder, path.join(appPath, appFolder), `${projectData.projectIdentifiers.ios}.${WATCH_APP_IDENTIFIER}`, configPath, config, watchApptarget, project, projectData, platformData, pbxProjPath, !hasWatchExtension);
         targetUuids.push(watchApptarget.uuid);
-        const watchExtensionTarget = this.$iOSNativeTargetService.addTargetToProject(extensionPath, extensionFolder, constants_1.IOSNativeTargetTypes.watchExtension, project, platformData, watchApptarget.uuid);
-        this.configureTarget(extensionFolder, path.join(extensionPath, extensionFolder), `${projectData.projectIdentifiers.ios}.${IOSWatchAppService.WATCH_APP_IDENTIFIER}.${IOSWatchAppService.WACTCH_EXTENSION_IDENTIFIER}`, "extension.json", watchExtensionTarget, project);
-        targetUuids.push(watchExtensionTarget.uuid);
+        targetNames.push(appFolder);
+        // Extension is optional (Xcode 14+ supports single target)
+        if (hasWatchExtension) {
+            const extensionFolder = this.$iOSNativeTargetService.getTargetDirectories(extensionPath)[0];
+            const configPath = path.join(path.join(extensionPath, extensionFolder), "extension.json");
+            const config = this.$fs.exists(configPath)
+                ? this.$fs.readJson(configPath)
+                : null;
+            const targetType = (_b = config === null || config === void 0 ? void 0 : config.targetType) !== null && _b !== void 0 ? _b : constants_1.IOSNativeTargetTypes.watchExtension;
+            project.removeTargetsByProductType(constants_1.IOSNativeTargetProductTypes.watchExtension);
+            project.removeTargetsByProductType(targetType);
+            const watchExtensionTarget = this.addTarget(extensionPath, extensionFolder, targetType, project, platformData, watchApptarget.uuid);
+            await this.configureTarget(extensionFolder, path.join(extensionPath, extensionFolder), `${projectData.projectIdentifiers.ios}.${WATCH_APP_IDENTIFIER}.${WACTCH_EXTENSION_IDENTIFIER}`, configPath, config, watchExtensionTarget, project, projectData, platformData, pbxProjPath);
+            targetUuids.push(watchExtensionTarget.uuid);
+            targetNames.push(extensionFolder);
+        }
+        else {
+            this.$logger.debug("No watch extension found - using single target mode (Xcode 14+)");
+        }
         this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+        // Add SPM packages (file needs to be saved first)
+        const watchSPMPackages = this.getWatchSPMPackages(platformData);
+        await this.applySPMPackagesToTargets(targetNames, platformData, projectData.projectDir, watchSPMPackages);
+        // nothing done after we dont need to reload project
         this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, pbxProjPath);
+        if (disableStubBinary) {
+            this.applyWatchAppStubBinaryOverrides(appFolder, pbxProjPath);
+        }
         return true;
     }
+    addTarget(targetRootPath, targetFolder, targetType, project, platformData, parentTarget, productTargetType) {
+        const targetPath = path.join(targetRootPath, targetFolder);
+        const targetRelativePath = path.relative(platformData.projectRoot, targetPath);
+        const target = project.addTarget(targetFolder, targetType, targetRelativePath, parentTarget, productTargetType);
+        // Add build phases
+        project.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", target.uuid);
+        project.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", target.uuid);
+        project.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", target.uuid);
+        project.addBuildPhase([], "PBXCopyFilesBuildPhase", "Embed Frameworks", target.uuid, "frameworks");
+        project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
+        return target;
+    }
+    /**
+     * Recursively add source files from a directory to a target
+     */
+    addSourceFilesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
+        const items = this.getFolderFiles(dirPath, platformData.projectRoot, excludePatterns);
+        for (const item of items) {
+            const relativePath = path.relative(platformData.projectRoot, item);
+            // Check if file is a source file by extension
+            const ext = path.extname(item).toLowerCase();
+            if (sourceExtensions.includes(ext)) {
+                this.$logger.debug(`Adding source file: ${relativePath}`);
+                this.addSourceFile(project, relativePath, { target: targetUuid }, groupName);
+            }
+        }
+    }
+    async addTargetResources(watchAppFolderPath, targetUuids, project, platformData, groupName, excludePatterns) {
+        try {
+            if (!this.$fs.exists(watchAppFolderPath)) {
+                return;
+            }
+            for (let i = 0; i < targetUuids.length; i++) {
+                const targetUuid = targetUuids[i];
+                this.addResourcesFromDirectory(watchAppFolderPath, targetUuid, project, platformData, groupName, excludePatterns);
+            }
+            this.$logger.debug("Watch app resources added successfully");
+        }
+        catch (err) {
+            this.$logger.warn(`Error adding watch app resources: ${err.message}`);
+        }
+    }
+    /**
+     * Recursively add resources from a directory to a target
+     */
+    addResourcesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
+        const items = this.$fs.readDirectory(dirPath);
+        for (const item of items) {
+            // Skip hidden files and excluded files/directories
+            if (item.startsWith(".") || RESOURCES_TO_IGNORE.indexOf(item) !== -1) {
+                continue;
+            }
+            const itemPath = path.join(dirPath, item);
+            const stats = this.$fs.getFsStats(itemPath);
+            const relativePath = path.relative(platformData.projectRoot, itemPath);
+            // Check if file/directory should be excluded based on patterns
+            if (excludePatterns &&
+                this.shouldExclude(relativePath, excludePatterns)) {
+                this.$logger.debug(`Excluding from resources: ${relativePath}`);
+                continue;
+            }
+            if (stats.isDirectory()) {
+                // Special handling for .xcassets, .bundle, and other resource bundles
+                if (item.endsWith(".xcassets") || item.endsWith(".bundle")) {
+                    this.$logger.debug(`Adding resource bundle: ${relativePath}`);
+                    this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+                }
+                else {
+                    // Recursively scan subdirectories
+                    this.addResourcesFromDirectory(itemPath, targetUuid, project, platformData, groupName, excludePatterns);
+                }
+            }
+            else {
+                // Check if file is a resource by extension
+                const ext = path.extname(item).toLowerCase();
+                if (resourceExtensions.includes(ext)) {
+                    this.$logger.debug(`Adding resource file: ${relativePath}`);
+                    this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+                }
+            }
+        }
+    }
     removeWatchApp({ pbxProjPath }) {
         const project = new this.$xcode.project(pbxProjPath);
         project.parseSync();
@@ -43,24 +217,497 @@ class IOSWatchAppService {
         const watchAppPath = path.join(projectData.getAppResourcesDirectoryPath(), platformData.normalizedPlatformName, constants_1.IOS_WATCHAPP_FOLDER);
         return this.$fs.exists(watchAppPath);
     }
-    configureTarget(targetName, targetPath, identifier, configurationFileName, target, project) {
-        const targetConfigurationJsonPath = path.join(targetPath, configurationFileName);
+    async configureTarget(targetName, targetPath, identifier, configPath, config, target, project, projectData, platformData, pbxProjPath, disableStubBinary = false) {
         const identifierParts = identifier.split(".");
         identifierParts.pop();
         const wkAppBundleIdentifier = identifierParts.join(".");
-        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+        // Build configuration properties
+        const buildConfigProperties = [
             { name: "PRODUCT_BUNDLE_IDENTIFIER", value: identifier },
             { name: "SDKROOT", value: "watchos" },
             { name: "TARGETED_DEVICE_FAMILY", value: constants_1.IOSDeviceTargets.watchos },
             { name: "WATCHOS_DEPLOYMENT_TARGET", value: 5.2 },
             { name: "WK_APP_BUNDLE_IDENTIFIER", value: wkAppBundleIdentifier },
-        ], targetName, project);
-        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(targetConfigurationJsonPath, target.uuid, targetName, project);
+        ];
+        if (disableStubBinary) {
+            buildConfigProperties.push({ name: "PRODUCT_BINARY_SOURCE_PATH", value: '""' }, { name: "PRODUCT_TYPE_HAS_STUB_BINARY", value: "NO" });
+        }
+        const resourcesGroup = targetName + "Resources";
+        project.addPbxGroup([], resourcesGroup, project.filepath, null, {
+            isMain: true,
+            target: target.uuid,
+            filesRelativeToProject: true,
+        });
+        const srcGroup = targetName + "Src";
+        project.addPbxGroup([], srcGroup, project.filepath, null, {
+            isMain: true,
+            target: target.uuid,
+            filesRelativeToProject: true,
+        });
+        let basedir;
+        if (config === null || config === void 0 ? void 0 : config.basedir) {
+            basedir = path.resolve(path.dirname(configPath), config.basedir);
+            if (!this.$fs.exists(basedir)) {
+                this.$logger.warn(`Basedir not found, using config directory: ${basedir}`);
+                basedir = path.dirname(configPath);
+            }
+        }
+        else {
+            basedir = path.dirname(configPath);
+        }
+        const resourcesExclude = (config === null || config === void 0 ? void 0 : config.resourcesExclude) || [];
+        const srcExclude = (config === null || config === void 0 ? void 0 : config.srcExclude) || [];
+        // Handle custom Info.plist path
+        if (config === null || config === void 0 ? void 0 : config.infoPlistPath) {
+            const infoPlistPath = path.resolve(basedir, config.infoPlistPath);
+            if (this.$fs.exists(infoPlistPath)) {
+                const relativeInfoPlistPath = path.relative(platformData.projectRoot, infoPlistPath);
+                buildConfigProperties.push({
+                    name: "INFOPLIST_FILE",
+                    value: `"${infoPlistPath}"`,
+                });
+                resourcesExclude.push(relativeInfoPlistPath);
+            }
+            else {
+                this.$logger.warn(`Custom Info.plist not found at: ${infoPlistPath}`);
+            }
+        }
+        // Handle custom xcprivacy file path
+        if (config === null || config === void 0 ? void 0 : config.xcprivacyPath) {
+            const xcprivacyPath = path.resolve(basedir, config.xcprivacyPath);
+            if (this.$fs.exists(xcprivacyPath)) {
+                const relativeXcprivacyPath = path.relative(platformData.projectRoot, xcprivacyPath);
+                this.addResourceFile(project, xcprivacyPath, { target: target.uuid }, targetName + "Resources");
+                resourcesExclude.push(relativeXcprivacyPath);
+            }
+            else {
+                this.$logger.warn(`Custom xcprivacy file not found at: ${xcprivacyPath}`);
+            }
+        }
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties(buildConfigProperties, targetName, project);
+        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(configPath, target.uuid, targetName, project);
         project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
+        if ((config === null || config === void 0 ? void 0 : config.importSourcesFromMainFolder) !== false) {
+            await this.addSourceFilesFromDirectory(path.dirname(configPath), target.uuid, project, platformData, targetName + "Src", srcExclude);
+        }
+        if ((config === null || config === void 0 ? void 0 : config.importResourcesFromMainFolder) !== false) {
+            await this.addTargetResources(path.dirname(configPath), [target.uuid], project, platformData, resourcesGroup, resourcesExclude);
+        }
+        if (config) {
+            // Process additional configurations
+            await this.processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude);
+        }
+    }
+    applyWatchAppStubBinaryOverrides(targetName, pbxProjPath) {
+        const project = new this.$xcode.project(pbxProjPath);
+        project.parseSync();
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+            { name: "PRODUCT_BINARY_SOURCE_PATH", value: '""' },
+            { name: "PRODUCT_TYPE_HAS_STUB_BINARY", value: "NO" },
+        ], targetName, project);
+        this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+    }
+    async processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude) {
+        this.$logger.debug(`processWatchAppConfiguration ${JSON.stringify(config)}`);
+        // Handle custom resources
+        if (config.resources && Array.isArray(config.resources)) {
+            this.$logger.debug(`Processing ${config.resources.length} custom resource(s) for watch target: ${targetName}`);
+            for (const resourcePath of config.resources) {
+                this.addCustomResource(resourcePath, target.uuid, project, projectData, platformData, targetName + "Resources", resourcesExclude, basedir);
+            }
+        }
+        if (config.src && Array.isArray(config.src)) {
+            this.$logger.debug(`Processing ${config.src.length} custom source file(s) for watch target: ${targetName}`);
+            for (const srcPath of config.src) {
+                this.addCustomSourceFile(srcPath, target.uuid, project, projectData, platformData, srcExclude, targetName + "Src", basedir);
+            }
+        }
+        if (config.SPMPackages && Array.isArray(config.SPMPackages)) {
+            // to be able to add SPM the file needs to be saved
+            // but it means we need to reload it again after spm packages addition
+            this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+            await this.applySPMPackagesToTargets([targetName], platformData, basedir, config.SPMPackages);
+            project.parseSync();
+        }
+        if (config.modules && Array.isArray(config.modules)) {
+            this.$logger.debug(`Processing ${config.modules.length} module(s) for watch target: ${targetName}`);
+            for (const moduleDef of config.modules) {
+                await this.addModuleDependency(moduleDef, config, targetName, target, project, projectData, platformData, srcExclude, resourcesExclude, basedir);
+            }
+        }
+    }
+    addCustomResource(resourcePath, targetUuid, project, projectData, platformData, groupName, excludePatterns, basedir) {
+        const resolvedPath = this.resolvePathWithBasedir(resourcePath, basedir, projectData.projectDir);
+        if (!this.$fs.exists(resolvedPath)) {
+            this.$logger.warn(`Custom resource not found, skipping: ${resourcePath}`);
+            return;
+        }
+        const relativePath = path.relative(platformData.projectRoot, resolvedPath);
+        if (excludePatterns && this.shouldExclude(relativePath, excludePatterns)) {
+            this.$logger.debug(`Excluding from resources: ${relativePath}`);
+            return;
+        }
+        const stats = this.$fs.getFsStats(resolvedPath);
+        if (stats.isDirectory()) {
+            this.$logger.debug(`Recursively adding files from resource directory: ${resourcePath}`);
+            if (relativePath.endsWith(".xcassets") ||
+                relativePath.endsWith(".bundle")) {
+                this.$logger.debug(`Adding resource bundle: ${relativePath} for target:${targetUuid}`);
+                this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+            }
+            else {
+                this.addAllResourcesRecursively(resolvedPath, targetUuid, project, platformData, groupName, excludePatterns);
+            }
+        }
+        else {
+            this.$logger.debug(`Adding custom resource file: ${relativePath}`);
+            this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+        }
+    }
+    addCustomSourceFile(srcPath, targetUuid, project, projectData, platformData, excludePatterns, groupName, basedir) {
+        const resolvedPath = this.resolvePathWithBasedir(srcPath, basedir, projectData.projectDir);
+        if (!this.$fs.exists(resolvedPath)) {
+            this.$logger.warn(`Custom source file/folder not found, skipping: ${srcPath}`);
+            return;
+        }
+        const relativePath = path.relative(platformData.projectRoot, resolvedPath);
+        if (excludePatterns && this.shouldExclude(relativePath, excludePatterns)) {
+            this.$logger.debug(`Excluding from src: ${relativePath}`);
+            return;
+        }
+        const stats = this.$fs.getFsStats(resolvedPath);
+        if (stats.isDirectory()) {
+            this.$logger.debug(`Adding custom source directory: ${relativePath}`);
+            this.addAllSourceFilesFromDirectory(resolvedPath, targetUuid, project, platformData, groupName, excludePatterns);
+        }
+        else {
+            this.$logger.debug(`Adding custom source file: ${relativePath}`);
+            this.addSourceFile(project, relativePath, { target: targetUuid }, groupName);
+        }
+    }
+    resolvePathWithBasedir(relativePath, basedir, fallbackDir) {
+        return basedir
+            ? path.resolve(basedir, relativePath)
+            : path.resolve(fallbackDir, relativePath);
+    }
+    addAllSourceFilesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
+        const items = this.getFolderFiles(dirPath, platformData.projectRoot, excludePatterns);
+        for (const item of items) {
+            const relativePath = path.relative(platformData.projectRoot, item);
+            // Check if file is a source file by extension
+            const ext = path.extname(item).toLowerCase();
+            if (sourceExtensions.includes(ext)) {
+                this.$logger.debug(`Adding source file: ${relativePath}`);
+                this.addSourceFile(project, relativePath, { target: targetUuid }, groupName);
+            }
+        }
+    }
+    addAllResourcesRecursively(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
+        const items = this.$fs.readDirectory(dirPath);
+        for (const item of items) {
+            if (item.startsWith(".")) {
+                continue;
+            }
+            const itemPath = path.join(dirPath, item);
+            const stats = this.$fs.getFsStats(itemPath);
+            const relativePath = path.relative(platformData.projectRoot, itemPath);
+            if (excludePatterns &&
+                this.shouldExclude(relativePath, excludePatterns)) {
+                this.$logger.debug(`Excluding from resources: ${relativePath}`);
+                return;
+            }
+            if (stats.isDirectory()) {
+                // Special handling for .xcassets, .bundle - add as bundles, not recursively
+                if (item.endsWith(".xcassets") || item.endsWith(".bundle")) {
+                    this.$logger.debug(`Adding resource bundle: ${relativePath} for target:${targetUuid}`);
+                    this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+                }
+                else {
+                    this.addAllResourcesRecursively(itemPath, targetUuid, project, platformData, groupName, excludePatterns);
+                }
+            }
+            else {
+                this.$logger.debug(`Adding resource file: ${relativePath}`);
+                this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+            }
+        }
+    }
+    async addModuleDependency(moduleDef, config, targetName, target, project, projectData, platformData, srcExclude, resourcesExclude, basedir) {
+        const modulePath = moduleDef.path
+            ? this.resolvePathWithBasedir(moduleDef.path, basedir, projectData.projectDir)
+            : null;
+        if (!modulePath || !this.$fs.exists(modulePath)) {
+            this.$logger.warn(`Module path not found, skipping module: ${modulePath}`);
+            return;
+        }
+        const relativePath = path.relative(platformData.projectRoot, modulePath);
+        const stats = this.$fs.getFsStats(modulePath);
+        const isFramework = modulePath.endsWith(".framework") || modulePath.endsWith(".xcframework");
+        const isFolder = stats.isDirectory() && !isFramework;
+        this.$logger.debug(`Adding module dependency: ${JSON.stringify(moduleDef)} to ${targetName}, basedir:${basedir}, isFramework:${isFramework} isFolder:${isFolder}`);
+        if (isFramework) {
+            // Handle compiled frameworks (xcframework, framework)
+            this.addCompiledFramework(moduleDef, relativePath, targetName, target, project);
+        }
+        else if (isFolder) {
+            // Handle folder-based modules
+            await this.addFolderModule(moduleDef, modulePath, relativePath, targetName, target, config, project, basedir, srcExclude, resourcesExclude, projectData, platformData);
+        }
+        else {
+            this.$logger.warn(`Unknown module type for: ${modulePath}`);
+        }
+        if (moduleDef.headerSearchPaths &&
+            Array.isArray(moduleDef.headerSearchPaths)) {
+            for (const headerPath of moduleDef.headerSearchPaths) {
+                const resolvedPath = this.resolvePathWithBasedir(headerPath, basedir, projectData.projectDir);
+                const relPath = path.relative(platformData.projectRoot, resolvedPath);
+                project.addToHeaderSearchPaths(relPath, targetName);
+                this.$logger.debug(`Added header search path: ${relPath}`);
+            }
+        }
+        if (moduleDef.linkerFlags && Array.isArray(moduleDef.linkerFlags)) {
+            this.addLinkerFlags(moduleDef.linkerFlags, targetName, project);
+        }
+    }
+    addCompiledFramework(moduleDef, relativePath, targetName, target, project) {
+        const moduleName = moduleDef.name;
+        project.addFramework(relativePath, {
+            target: target.uuid,
+            customFramework: true,
+            embed: moduleDef.embed !== false, // Default to true
+        });
+        const frameworkDir = path.dirname(relativePath);
+        project.addBuildProperty("FRAMEWORK_SEARCH_PATHS", `"$(inherited)" "${frameworkDir}"`, null, targetName);
+        this.$logger.debug(`Added compiled framework ${moduleName} at ${relativePath}`);
+    }
+    getFolderFiles(dirPath, rootPath, excludePatterns) {
+        const result = [];
+        const files = this.$fs
+            .readDirectory(dirPath)
+            .filter((fileName) => !fileName.startsWith("."));
+        for (const item of files) {
+            const itemPath = path.join(dirPath, item);
+            const stats = this.$fs.getFsStats(itemPath);
+            const relativePath = path.relative(rootPath, itemPath);
+            if (excludePatterns &&
+                this.shouldExclude(relativePath, excludePatterns)) {
+                this.$logger.debug(`Excluding from src: ${relativePath}`);
+                continue;
+            }
+            if (stats.isDirectory()) {
+                result.push(...this.getFolderFiles(itemPath, rootPath, excludePatterns));
+            }
+            else {
+                result.push(itemPath);
+            }
+        }
+        return result;
+    }
+    addBuildPhaseIfNotExisting(project, buildPhaseType, comment, target) {
+        let buildPhase = project.buildPhaseObject(buildPhaseType, comment, target);
+        if (!buildPhase) {
+            project.addBuildPhase([], buildPhaseType, comment, target);
+        }
+    }
+    async addFolderModule(moduleDef, modulePath, relativePath, targetName, target, config, project, basedir, srcExclude, resourcesExclude, projectData, platformData) {
+        var _a;
+        const moduleName = moduleDef.name || path.basename(modulePath);
+        const targetRelativePath = path.relative(platformData.projectRoot, modulePath);
+        const moduleTarget = project.addTarget(moduleName, (_a = moduleDef.targetType) !== null && _a !== void 0 ? _a : "framework", targetRelativePath, target.uuid);
+        this.$logger.debug(`Adding folder module ${moduleName} with path ${modulePath} with target uuid:${moduleTarget.uuid}`);
+        const { path: filePath, name, dependencies, frameworks, buildConfigurationProperties, src, resources, SPMPackages, ...otherProps } = moduleDef;
+        project.addFramework(moduleName + ".framework", {
+            target: target.uuid,
+            basename: moduleName,
+            path: moduleName + ".framework",
+            customFramework: true,
+            explicitFileType: "wrapper.framework",
+            ...otherProps,
+        });
+        // Add build phases
+        project.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", moduleTarget.uuid);
+        project.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", moduleTarget.uuid);
+        project.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", moduleTarget.uuid);
+        project.addBuildPhase([], "PBXCopyFilesBuildPhase", "Embed Frameworks", moduleTarget.uuid, "frameworks");
+        const files = this.getFolderFiles(modulePath, platformData.projectRoot, srcExclude);
+        this.$logger.debug(`module ${moduleName} has  ${files.length} files`);
+        if (files.length > 0) {
+            project.addPbxGroup(files, moduleName, modulePath, null, {
+                isMain: true,
+                target: moduleTarget.uuid,
+                filesRelativeToProject: true,
+            });
+        }
+        if (moduleDef.frameworks && Array.isArray(moduleDef.frameworks)) {
+            this.$logger.debug(`Adding ${moduleDef.frameworks.length} framework(s) for module ${JSON.stringify(moduleDef)}`);
+            for (const framework of moduleDef.frameworks) {
+                this.$logger.debug(`Adding framework ${JSON.stringify(framework)} for module ${JSON.stringify(moduleDef)}`);
+                if (typeof framework === "string") {
+                    project.addFramework(framework, { target: moduleTarget.uuid });
+                }
+                else {
+                    project.addFramework(framework.path, {
+                        target: moduleTarget.uuid,
+                        ...framework,
+                    });
+                }
+                this.$logger.debug(`Added framework dependency: ${framework}`);
+            }
+        }
+        if (moduleDef.src && Array.isArray(moduleDef.src)) {
+            this.$logger.debug(`Processing ${config.src.length} custom source file(s) for target: ${moduleName}`);
+            for (const srcPath of moduleDef.src) {
+                this.addCustomSourceFile(srcPath, moduleTarget.uuid, project, projectData, platformData, srcExclude, moduleName + "Src", basedir);
+            }
+        }
+        if (moduleDef.resources && Array.isArray(moduleDef.resources)) {
+            this.$logger.debug(`Processing ${moduleDef.resources.length} custom resource(s) for target: ${moduleName}/${moduleTarget.uuid}`);
+            for (const resourcePath of moduleDef.resources) {
+                this.addCustomResource(resourcePath, moduleTarget.uuid, project, projectData, platformData, targetName + "Resources", resourcesExclude, basedir);
+            }
+        }
+        if (moduleDef.dependencies && Array.isArray(moduleDef.dependencies)) {
+            const currentTargets = project.pbxNativeTargetSection();
+            const currentTargetsArray = Object.keys(currentTargets)
+                .map((k) => currentTargets[k]["name"]
+                ? { uuid: k, name: currentTargets[k]["name"] }
+                : null)
+                .filter((t) => !!t);
+            const targets = moduleDef.dependencies
+                .map((dependency) => currentTargetsArray.find((t) => t.name === `\"${dependency}\"`))
+                .filter((s) => !!s);
+            if (targets.length) {
+                this.$logger.debug(`Adding target dependencies ${moduleDef.dependencies} with uuids:${targets.map((t) => t.uuid)} for module ${moduleDef.name}`);
+                project.addTargetDependency(moduleTarget.uuid, targets.map((t) => t.uuid));
+            }
+        }
+        if (moduleDef.SPMPackages && Array.isArray(moduleDef.SPMPackages)) {
+            // to be able to add SPM the file needs to be saved
+            // but it means we need to reload it again after spm packages addition
+            this.$fs.writeFile(project.filepath, project.writeSync({ omitEmptyValues: true }));
+            await this.applySPMPackagesToTargets([moduleName], platformData, basedir, moduleDef.SPMPackages.map((t) => {
+                if (typeof t === "string") {
+                    return config.SPMPackages.find((s) => s.name === t);
+                }
+                return t;
+            }));
+            project.parseSync();
+        }
+        if (moduleDef.buildConfigurationProperties ||
+            config.sharedModulesBuildConfigurationProperties) {
+            const configurationProperties = {
+                ...(config.sharedModulesBuildConfigurationProperties || {}),
+                ...(moduleDef.buildConfigurationProperties || {}),
+            };
+            this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties(Object.keys(configurationProperties).map((k) => ({
+                name: k,
+                value: configurationProperties[k],
+            })), moduleName, project);
+        }
+        this.$logger.debug(`Added folder-based module ${moduleName} at ${relativePath}`);
+    }
+    /**
+     * Add linker flags to a target's build settings
+     */
+    addLinkerFlags(flags, targetName, project) {
+        for (const flag of flags) {
+            const currentFlags = this.getBuildProperty("OTHER_LDFLAGS", targetName, project);
+            const flagsArray = currentFlags
+                ? Array.isArray(currentFlags)
+                    ? currentFlags
+                    : [currentFlags]
+                : ['"$(inherited)"'];
+            if (!flagsArray.includes(flag)) {
+                flagsArray.push(flag);
+            }
+            project.addBuildProperty("OTHER_LDFLAGS", flagsArray, null, targetName);
+            this.$logger.debug(`Added linker flag: ${flag}`);
+        }
+    }
+    /**
+     * Get build property value for a specific target
+     */
+    getBuildProperty(propertyName, targetName, project) {
+        // Access the project hash to read build settings
+        const projectHash = project.hash;
+        if (!projectHash) {
+            return null;
+        }
+        const configurations = projectHash.project.objects.XCBuildConfiguration;
+        if (!configurations) {
+            return null;
+        }
+        for (const key in configurations) {
+            const config = configurations[key];
+            if (config &&
+                config.buildSettings &&
+                (config.buildSettings.PRODUCT_NAME === targetName ||
+                    config.buildSettings.PRODUCT_NAME === `"${targetName}"`)) {
+                return config.buildSettings[propertyName];
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a path should be excluded based on glob patterns
+     */
+    shouldExclude(filePath, excludePatterns) {
+        for (const pattern of excludePatterns) {
+            const matcher = new minimatch_1.Minimatch(pattern, { dot: true });
+            if (matcher.match(filePath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Apply SPM packages to watch app targets
+     */
+    async applySPMPackagesToTargets(targetNames, platformData, basedir, watchSPMPackages) {
+        try {
+            this.$logger.debug(`applySPMPackagesToTargets ${JSON.stringify(watchSPMPackages)}`);
+            if (watchSPMPackages.length === 0) {
+                return;
+            }
+            this.$logger.debug(`Applying ${watchSPMPackages.length} SPM package(s) to targets:${targetNames}`);
+            const project = new trapezedev_project_1.MobileProject(platformData.projectRoot, {
+                ios: {
+                    path: ".",
+                },
+                enableAndroid: false,
+            });
+            await project.load();
+            if (!project.ios) {
+                this.$logger.debug("No iOS project found via trapeze");
+                return;
+            }
+            // Add SPM packages to each watch target
+            for (const pkg of watchSPMPackages) {
+                if ("path" in pkg) {
+                    pkg.path = path.resolve(basedir, pkg.path);
+                }
+                this.$logger.debug(`Adding SPM package ${JSON.stringify(pkg)} to targets ${targetNames}`);
+                for (const targetName of targetNames) {
+                    project.ios.addSPMPackage(targetName, pkg);
+                }
+            }
+            await project.commit();
+            this.$logger.debug(`Successfully applied SPM packages to targets ${targetNames}`);
+        }
+        catch (err) {
+            this.$logger.debug(`Error applying SPM packages to targets ${targetNames} "`, err);
+        }
+    }
+    /**
+     * Get SPM packages configured for watch app targets
+     */
+    getWatchSPMPackages(platformData) {
+        const $projectConfigService = yok_1.injector.resolve("projectConfigService");
+        // Check for watch-specific SPM packages in config
+        const watchPackages = $projectConfigService.getValue(`${platformData.platformNameLowerCase}.watchApp.SPMPackages`, []);
+        return watchPackages;
     }
 }
 exports.IOSWatchAppService = IOSWatchAppService;
-IOSWatchAppService.WATCH_APP_IDENTIFIER = "watchkitapp";
-IOSWatchAppService.WACTCH_EXTENSION_IDENTIFIER = "watchkitextension";
 yok_1.injector.register("iOSWatchAppService", IOSWatchAppService);
 //# sourceMappingURL=ios-watch-app-service.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nativescript",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "9.0.6-rc.2",
+  "version": "9.0.7-dev.0",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {

package/lib/definitions/devtools-host-service.d.ts

@@ -1,44 +0,0 @@
-import { IProjectData } from "./project";
-
-/**
- * Origin of a running loopback HTTP server for a single platform,
- * e.g. "http://127.0.0.1:41500".
- */
-export interface IDevtoolsHostOrigin {
-	platform: string;
-	origin: string;
-}
-
-/**
- * Loopback HTTP server (per platform) that serves the webpack output
- * directory with CORS so Chrome DevTools (served from
- * https://chrome-devtools-frontend.appspot.com) can fetch .map / .js
- * files while a debug session is active.
- *
- * Bound to 127.0.0.1 only; never exposed to the network.
- */
-export interface IDevtoolsHostService {
-	/**
-	 * Start (or return existing) HTTP server for a platform. Idempotent
-	 * per platform — subsequent calls return the same origin.
-	 */
-	start(
-		projectData: IProjectData,
-		platform: string,
-	): Promise<IDevtoolsHostOrigin | null>;
-
-	/**
-	 * Stop the server for a single platform. Quiet no-op if nothing running.
-	 */
-	stop(platform: string): Promise<void>;
-
-	/**
-	 * Stop all running servers.
-	 */
-	stopAll(): Promise<void>;
-
-	/**
-	 * Current origin for a platform, or null if not running.
-	 */
-	getOrigin(platform: string): string | null;
-}

package/lib/services/devtools-host-service.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DevtoolsHostService = void 0;
-const http = require("http");
-const path = require("path");
-const fs = require("fs");
-const constants_1 = require("../constants");
-const yok_1 = require("../common/yok");
-const LOOPBACK_HOST = "127.0.0.1";
-const PORT_RANGE_START = 41500;
-const PORT_RANGE_END = 41999;
-// Allowed Chrome DevTools origins. Bundled DevTools (devtools://devtools)
-// is the default flow opened by chrome://inspect; the appspot frontend is
-// used when the CLI prints a hosted URL. Any other origin (including
-// custom NS DevTools forks) gets a permissive ACAO since loopback bind
-// is the real security boundary anyway.
-const KNOWN_DEVTOOLS_ORIGINS = new Set([
-    "devtools://devtools",
-    "https://chrome-devtools-frontend.appspot.com",
-]);
-const CONTENT_TYPES = {
-    ".map": "application/json; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".js": "application/javascript; charset=utf-8",
-    ".mjs": "application/javascript; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-};
-class DevtoolsHostService {
-    constructor($net, $logger, $platformsDataService) {
-        this.$net = $net;
-        this.$logger = $logger;
-        this.$platformsDataService = $platformsDataService;
-        this.servers = new Map();
-    }
-    async start(projectData, platform) {
-        var _a, _b;
-        const key = platform.toLowerCase();
-        const existing = this.servers.get(key);
-        if (existing) {
-            return { platform: key, origin: this.formatOrigin(existing.port) };
-        }
-        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
-        // Webpack writes to <appDestinationDirectoryPath>/app on both iOS
-        // (platforms/ios/<appName>/app) and Android
-        // (platforms/android/app/src/main/assets/app). Match that exactly so
-        // requests for /bundle.mjs.map resolve to the actual emitted file.
-        const rootDir = (platformData === null || platformData === void 0 ? void 0 : platformData.appDestinationDirectoryPath)
-            ? path.join(platformData.appDestinationDirectoryPath, constants_1.APP_FOLDER_NAME)
-            : null;
-        if (!rootDir) {
-            this.$logger.warn(`DevTools host: unable to resolve output directory for ${platform}.`);
-            return null;
-        }
-        let port;
-        try {
-            port = await this.$net.getAvailablePortInRange(PORT_RANGE_START, PORT_RANGE_END);
-        }
-        catch (err) {
-            this.$logger.warn(`DevTools host: no free port in ${PORT_RANGE_START}-${PORT_RANGE_END}. Source maps will not load in Chrome DevTools. (${(err === null || err === void 0 ? void 0 : err.message) || err})`);
-            return null;
-        }
-        const server = http.createServer((req, res) => this.handleRequest(req, res, rootDir));
-        try {
-            await new Promise((resolve, reject) => {
-                const onError = (err) => reject(err);
-                server.once("error", onError);
-                server.listen(port, LOOPBACK_HOST, () => {
-                    server.off("error", onError);
-                    resolve();
-                });
-            });
-        }
-        catch (err) {
-            this.$logger.warn(`DevTools host: failed to bind ${LOOPBACK_HOST}:${port} (${(err === null || err === void 0 ? void 0 : err.message) || err}).`);
-            return null;
-        }
-        // `.unref()` so a lingering server doesn't keep the CLI process alive.
-        server.unref();
-        const actualPort = (_b = (_a = server.address()) === null || _a === void 0 ? void 0 : _a.port) !== null && _b !== void 0 ? _b : port;
-        const entry = { server, port: actualPort, rootDir };
-        this.servers.set(key, entry);
-        const origin = this.formatOrigin(actualPort);
-        this.$logger.info(`DevTools host (${platform}) serving ${rootDir} at ${origin}`);
-        return { platform: key, origin };
-    }
-    async stop(platform) {
-        const key = platform.toLowerCase();
-        const entry = this.servers.get(key);
-        if (!entry) {
-            return;
-        }
-        this.servers.delete(key);
-        await new Promise((resolve) => {
-            entry.server.close(() => resolve());
-        });
-    }
-    async stopAll() {
-        const platforms = Array.from(this.servers.keys());
-        await Promise.all(platforms.map((p) => this.stop(p)));
-    }
-    getOrigin(platform) {
-        const entry = this.servers.get(platform.toLowerCase());
-        return entry ? this.formatOrigin(entry.port) : null;
-    }
-    formatOrigin(port) {
-        return `http://${LOOPBACK_HOST}:${port}`;
-    }
-    handleRequest(req, res, rootDir) {
-        const requestOrigin = req.headers.origin;
-        const allowOrigin = requestOrigin && KNOWN_DEVTOOLS_ORIGINS.has(requestOrigin)
-            ? requestOrigin
-            : "*";
-        res.setHeader("Access-Control-Allow-Origin", allowOrigin);
-        res.setHeader("Vary", "Origin");
-        res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
-        res.setHeader("Access-Control-Allow-Headers", "*");
-        res.setHeader("Cache-Control", "no-cache");
-        if (req.method === "OPTIONS") {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (req.method !== "GET" && req.method !== "HEAD") {
-            res.writeHead(405);
-            res.end();
-            return;
-        }
-        let urlPath;
-        try {
-            urlPath = decodeURIComponent(new URL(req.url || "/", "http://x").pathname);
-        }
-        catch (_a) {
-            res.writeHead(400);
-            res.end();
-            return;
-        }
-        const ext = path.extname(urlPath).toLowerCase();
-        if (!CONTENT_TYPES[ext]) {
-            res.writeHead(403);
-            res.end();
-            return;
-        }
-        const resolvedRoot = path.resolve(rootDir);
-        const filePath = path.resolve(resolvedRoot, "." + urlPath);
-        if (filePath !== resolvedRoot &&
-            !filePath.startsWith(resolvedRoot + path.sep)) {
-            res.writeHead(403);
-            res.end();
-            return;
-        }
-        fs.stat(filePath, (statErr, stats) => {
-            if (statErr || !stats.isFile()) {
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            res.setHeader("Content-Type", CONTENT_TYPES[ext]);
-            res.setHeader("Content-Length", String(stats.size));
-            if (req.method === "HEAD") {
-                res.writeHead(200);
-                res.end();
-                return;
-            }
-            const stream = fs.createReadStream(filePath);
-            stream.on("error", () => {
-                if (!res.headersSent) {
-                    res.writeHead(500);
-                }
-                res.end();
-            });
-            res.writeHead(200);
-            stream.pipe(res);
-        });
-    }
-}
-exports.DevtoolsHostService = DevtoolsHostService;
-yok_1.injector.register("devtoolsHostService", DevtoolsHostService);
-//# sourceMappingURL=devtools-host-service.js.map