@akylas/nativescript-cli 8.8.7 → 8.10.0

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

@@ -4,34 +4,154 @@ 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',
+    '.ttf', '.otf', '.woff', '.woff2',
+    '.xcassets',
+    '.storyboard', '.xib',
+    '.strings', '.stringsdict',
+    '.json', '.xml', '.plist',
+    '.m4a', '.mp3', '.wav', '.caf',
+    '.mp4', '.mov',
+    '.bundle',
+];
+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;
+    }
+    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, }) {
+        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)) {
+        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);
         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);
+        const extensionPath = path.join(watchAppFolderPath, constants_1.IOS_WATCHAPP_EXTENSION_FOLDER);
+        if (this.$fs.exists(extensionPath)) {
+            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 }));
+        const watchSPMPackages = this.getWatchSPMPackages(platformData);
+        await this.applySPMPackagesToTargets(targetNames, platformData, projectData.projectDir, watchSPMPackages);
         this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, 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);
+        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);
+        project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
+        return 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);
+            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}`);
+        }
+    }
+    addResourcesFromDirectory(dirPath, targetUuid, project, platformData, groupName, excludePatterns) {
+        const items = this.$fs.readDirectory(dirPath);
+        for (const item of items) {
+            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);
+            if (excludePatterns && this.shouldExclude(relativePath, excludePatterns)) {
+                this.$logger.debug(`Excluding from resources: ${relativePath}`);
+                continue;
+            }
+            if (stats.isDirectory()) {
+                if (item.endsWith('.xcassets') || item.endsWith('.bundle')) {
+                    this.$logger.debug(`Adding resource bundle: ${relativePath}`);
+                    this.addResourceFile(project, relativePath, { target: targetUuid }, groupName);
+                }
+                else {
+                    this.addResourcesFromDirectory(itemPath, targetUuid, project, platformData, groupName, excludePatterns);
+                }
+            }
+            else {
+                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,23 +163,427 @@ 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) {
         const identifierParts = identifier.split(".");
         identifierParts.pop();
         const wkAppBundleIdentifier = identifierParts.join(".");
-        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+        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);
+        ];
+        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) || [];
+        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}`);
+            }
+        }
+        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) {
+            await this.processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude);
+        }
+    }
+    async processWatchAppConfiguration(config, basedir, targetName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude) {
+        this.$logger.debug(`processWatchAppConfiguration ${JSON.stringify(config)}`);
+        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)) {
+            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);
+            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()) {
+                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) {
+            this.addCompiledFramework(moduleDef, relativePath, targetName, target, project);
+        }
+        else if (isFolder) {
+            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,
+        });
+        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
+        });
+        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);
+        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)) {
+            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}`);
+    }
+    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}`);
+        }
+    }
+    getBuildProperty(propertyName, targetName, project) {
+        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;
+    }
+    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;
+    }
+    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;
+            }
+            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);
+        }
+    }
+    getWatchSPMPackages(platformData) {
+        const $projectConfigService = yok_1.injector.resolve("projectConfigService");
+        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);

package/lib/services/livesync/android-livesync-tool.js

@@ -253,7 +253,7 @@ class AndroidLivesyncTool {
                 if (!isConnected) {
                     isConnected = true;
                     if (this.pendingConnectionData &&
-                        this.pendingConnectionData.socketTimer) {
+                        typeof this.pendingConnectionData.socketTimer === "number") {
                         clearTimeout(this.pendingConnectionData.socketTimer);
                     }
                     const applicationPid = await this.$androidProcessService.getAppProcessId(configuration.deviceIdentifier, configuration.appIdentifier);
@@ -292,7 +292,9 @@ class AndroidLivesyncTool {
                     socket.removeAllListeners();
                     this.pendingConnectionData.socketTimer = setTimeout(tryConnect, 1000);
                 };
-                this.pendingConnectionData.socket = socket;
+                if (this.pendingConnectionData) {
+                    this.pendingConnectionData.socket = socket;
+                }
                 socket.once("data", (data) => {
                     socket.removeListener("close", tryConnectAfterTimeout);
                     socket.removeListener("error", tryConnectAfterTimeout);

package/lib/services/plugins-service.js

@@ -302,6 +302,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
             if (pluginData.isPlugin) {
                 pluginData.platformsData = data.platforms;
                 pluginData.pluginVariables = data.variables;
+                pluginData.nativescript = data;
             }
             return pluginData;
         }

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

@@ -39,7 +39,7 @@ class ProjectChangesService {
     get currentChanges() {
         return this._changesInfo;
     }
-    async checkForChanges(platformData, projectData, prepareData, filesChangedData) {
+    async checkForChanges(platformData, projectData, prepareData) {
         this._changesInfo = new ProjectChangesInfo();
         const isNewPrepareInfo = await this.ensurePrepareInfo(platformData, projectData, prepareData);
         if (!isNewPrepareInfo) {