nativescript 9.0.7-dev.0 → 9.0.7-next.2026-05-22-26267331378

package/config/test-deps-versions-generated.json

@@ -3,7 +3,7 @@
   "karma": "6.4.4",
   "karma-coverage": "2.2.1",
   "karma-nativescript-launcher": "1.0.0",
-  "mocha": "11.7.5",
+  "mocha": "11.7.6",
   "karma-mocha": "2.0.1",
   "karma-chai": "0.1.0",
   "karma-jasmine": "4.0.2",
@@ -11,6 +11,6 @@
   "@types/karma-chai": "0.1.8",
   "@types/mocha": "10.0.10",
   "@types/jasmine": "6.0.0",
-  "@types/qunit": "2.19.13",
+  "@types/qunit": "2.19.14",
   "nyc": "18.0.0"
 }

package/lib/constants.js

@@ -324,7 +324,6 @@ 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/definitions/nativescript-dev-xcode.d.ts

@@ -8,27 +8,16 @@ 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,
@@ -38,30 +27,17 @@ 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,
-			productTargetType?: string
+			parentTarget?: string
 		): target;
 		addBuildPhase(
 			filePathsArray: string[],

package/lib/definitions/project.d.ts

@@ -601,7 +601,9 @@ interface INativePrepare {
 }
 
 interface IBuildConfig
-	extends IAndroidBuildOptionsSettings, IiOSBuildConfig, IProjectDir {
+	extends IAndroidBuildOptionsSettings,
+		IiOSBuildConfig,
+		IProjectDir {
 	clean?: boolean;
 	architectures?: string[];
 	buildOutputStdio?: string;
@@ -613,8 +615,7 @@ interface IBuildConfig
  * Describes iOS-specific build configuration properties
  */
 interface IiOSBuildConfig
-	extends
-		IBuildForDevice,
+	extends IBuildForDevice,
 		IiCloudContainerEnvironment,
 		IDeviceIdentifier,
 		IProvision,
@@ -864,7 +865,6 @@ interface IAddExtensionsFromPathOptions extends IAddTargetFromPathOptions {
 
 interface IAddWatchAppFromPathOptions extends IAddTargetFromPathOptions {
 	watchAppFolderPath: string;
-	disableStubBinary?: boolean;
 }
 
 interface IRemoveExtensionsOptions {
@@ -873,37 +873,6 @@ 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/services/bundler/bundler-compiler-service.js

@@ -96,7 +96,6 @@ 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));

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

@@ -265,8 +265,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         return Promise.resolve();
     }
     async isDynamicFramework(frameworkPath) {
-        const isDynamicFrameworkBundle = async (bundlePath, frameworkName) => {
-            const frameworkBinaryPath = path.join(bundlePath, frameworkName);
+        const isDynamicFrameworkBundle = async (frameworkBinaryPath) => {
             const fileResult = (await this.$childProcess.spawnFromEvent("file", [frameworkBinaryPath], "close")).stdout;
             const isDynamicallyLinked = _.includes(fileResult, "dynamically linked");
             return isDynamicallyLinked;
@@ -278,7 +277,11 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 const singlePlatformFramework = path.join(frameworkPath, library.LibraryIdentifier, library.LibraryPath);
                 if (this.$fs.exists(singlePlatformFramework)) {
                     const frameworkName = path.basename(singlePlatformFramework, path.extname(singlePlatformFramework));
-                    isDynamic = await isDynamicFrameworkBundle(singlePlatformFramework, frameworkName);
+                    let frameworkBinaryPath = path.join(singlePlatformFramework, frameworkName);
+                    if (library.BinaryPath) {
+                        frameworkBinaryPath = path.join(frameworkPath, library.LibraryIdentifier, library.BinaryPath);
+                    }
+                    isDynamic = await isDynamicFrameworkBundle(frameworkBinaryPath);
                     break;
                 }
             }
@@ -286,7 +289,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         }
         else {
             const frameworkName = path.basename(frameworkPath, path.extname(frameworkPath));
-            return await isDynamicFrameworkBundle(frameworkPath, frameworkName);
+            return await isDynamicFrameworkBundle(path.join(frameworkPath, frameworkName));
         }
     }
     /**
@@ -468,6 +471,7 @@ 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,208 +4,34 @@ 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, $logger) {
+    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService) {
         this.$fs = $fs;
         this.$pbxprojDomXcode = $pbxprojDomXcode;
         this.$xcode = $xcode;
         this.$iOSNativeTargetService = $iOSNativeTargetService;
-        this.$logger = $logger;
     }
-    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;
+    async addWatchAppFromPath({ watchAppFolderPath, projectData, platformData, pbxProjPath, }) {
         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);
-        const hasWatchExtension = this.$fs.exists(extensionPath);
-        // Check if watchapp exists - it's required
-        if (!this.$fs.exists(appPath)) {
+        if (!this.$fs.exists(appPath) || !this.$fs.exists(extensionPath)) {
             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 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);
+        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);
         targetUuids.push(watchApptarget.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+)");
-        }
+        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);
         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();
@@ -217,497 +43,24 @@ class IOSWatchAppService {
         const watchAppPath = path.join(projectData.getAppResourcesDirectoryPath(), platformData.normalizedPlatformName, constants_1.IOS_WATCHAPP_FOLDER);
         return this.$fs.exists(watchAppPath);
     }
-    async configureTarget(targetName, targetPath, identifier, configPath, config, target, project, projectData, platformData, pbxProjPath, disableStubBinary = false) {
+    configureTarget(targetName, targetPath, identifier, configurationFileName, target, project) {
+        const targetConfigurationJsonPath = path.join(targetPath, configurationFileName);
         const identifierParts = identifier.split(".");
         identifierParts.pop();
         const wkAppBundleIdentifier = identifierParts.join(".");
-        // Build configuration properties
-        const buildConfigProperties = [
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
             { 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 },
-        ];
-        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;
+        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(targetConfigurationJsonPath, target.uuid, targetName, project);
+        project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
     }
 }
 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.7-dev.0",
+  "version": "9.0.7-next.2026-05-22-26267331378",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {