@akylas/nativescript-cli 8.11.2 → 8.11.3

package/lib/common/dispatchers.js

@@ -84,18 +84,17 @@ class CommandDispatcher {
         let updateCommand = "";
         switch (packageManagerName) {
             case constants_1.PackageManagers.yarn:
-            case constants_1.PackageManagers.yarn2:
-                updateCommand = "yarn global add nativescript";
+                updateCommand = "yarn global add @akylas/nativescript-cli";
                 break;
             case constants_1.PackageManagers.pnpm:
-                updateCommand = "pnpm i -g nativescript";
+                updateCommand = "pnpm i -g @akylas/nativescript-cli";
                 break;
             case constants_1.PackageManagers.bun:
-                updateCommand = "bun add --global nativescript";
+                updateCommand = "bun add --global @akylas/nativescript-cli";
                 break;
             case constants_1.PackageManagers.npm:
             default:
-                updateCommand = "npm i -g nativescript";
+                updateCommand = "npm i -g @akylas/nativescript-cli";
                 break;
         }
         if (semver.gte(nativescriptCliVersion.currentVersion, nativescriptCliVersion.latestVersion, {

package/lib/constants.js

@@ -8,7 +8,7 @@ exports.APP_FOLDER_NAME = "app";
 exports.APP_RESOURCES_FOLDER_NAME = "App_Resources";
 exports.PROJECT_FRAMEWORK_FOLDER_NAME = "framework";
 exports.NS_BASE_PODFILE = "NSPodfileBase";
-exports.NATIVESCRIPT_KEY_NAME = "nativescript";
+exports.NATIVESCRIPT_KEY_NAME = "@akylas/nativescript-cli";
 exports.NODE_MODULES_FOLDER_NAME = "node_modules";
 exports.TNS_MODULES_FOLDER_NAME = "tns_modules";
 exports.TNS_CORE_MODULES_NAME = "tns-core-modules";

package/lib/controllers/prepare-controller.js

@@ -211,7 +211,7 @@ class PrepareController extends events_1.EventEmitter {
     }
     async getWatcherPatterns(platformData, projectData) {
         const dependencies = this.$nodeModulesDependenciesBuilder
-            .getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies)
+            .getProductionDependencies(projectData.projectDir, projectData.getIgnoredDependencies(platformData.platformNameLowerCase))
             .filter((dep) => dep.nativescript);
         const pluginsNativeDirectories = dependencies.map((dep) => path.join(dep.directory, constants_1.PLATFORMS_DIR_NAME, platformData.platformNameLowerCase));
         const pluginsPackageJsonFiles = dependencies.map((dep) => path.join(dep.directory, constants_1.PACKAGE_JSON_FILE_NAME));
@@ -233,7 +233,7 @@ class PrepareController extends events_1.EventEmitter {
             return;
         }
         this.$logger.info("Updating runtime package.json with configuration values...");
-        const { hooks, ignoredNativeDependencies, webpackPackageName, webpackConfigPath, appResourcesPath, buildPath, appPath, ...nsConfig } = this.$projectConfigService.readConfig(projectData.projectDir);
+        const { hooks, webpackPackageName, webpackConfigPath, appResourcesPath, buildPath, appPath, ...nsConfig } = this.$projectConfigService.readConfig(projectData.projectDir);
         const platform = platformData.platformNameLowerCase;
         let installedRuntimePackageJSON;
         let runtimePackageName;

package/lib/definitions/gradle.d.ts

@@ -30,4 +30,5 @@ interface IGradleBuildService {
 interface IGradleBuildArgsService {
 	getBuildTaskArgs(buildData: IAndroidBuildData): Promise<string[]>;
 	getCleanTaskArgs(buildData: IAndroidBuildData): string[];
+	getBuildLoggingArgs(): string[];
 }

package/lib/definitions/project.d.ts

@@ -126,6 +126,7 @@ export type BundlerType = "webpack" | "rspack" | "vite";
 interface INsConfigIOS extends INsConfigPlaform {
 	discardUncaughtJsExceptions?: boolean;
 	runtimePackageName?: string
+	ignoredNativeDependencies?: string[];
 	cocoapodUseBundleExec?: boolean
 	/**
 	 * Swift Package Manager
@@ -175,9 +176,11 @@ interface INsConfigAndroid extends INsConfigPlaform {
 
 	gradleArgs?: string[];
 
-	plugins?:{ [k:string]: { aarSuffix?: string } }
+	plugins?:{ [k:string]: { aarSuffix?: string } };
 
-	runtimePackageName?: string
+	runtimePackageName?: string;
+
+	ignoredNativeDependencies?: string[];
 }
 
 interface INsConfigHooks {
@@ -212,7 +215,6 @@ interface IProjectData extends ICreateProjectData {
 	projectId: string;
 	projectIdentifiers?: Mobile.IProjectIdentifier;
 	dependencies: any;
-	ignoredDependencies?: string[];
 	devDependencies: IStringDictionary;
 	appDirectoryPath: string;
 	appResourcesDirectoryPath: string;
@@ -270,6 +272,7 @@ interface IProjectData extends ICreateProjectData {
 	getAppResourcesDirectoryPath(projectDir?: string): string;
 	getAppResourcesRelativeDirectoryPath(): string;
 	getBuildRelativeDirectoryPath(): string;
+	getIgnoredDependencies(platform: string): string[];
 }
 
 interface IProjectDataService {
@@ -908,6 +911,7 @@ interface IWatchAppJSONConfig {
 	basedir?: string;
 	infoPlistPath?: string;
 	xcprivacyPath?: string;
+	entitlements?: string;
 	importSourcesFromMainFolder?: boolean;
 	importResourcesFromMainFolder?: boolean;
 	resources?: string[];

package/lib/project-data.js

@@ -83,7 +83,6 @@ class ProjectData {
             this.dependencies = packageJsonData.dependencies;
             this.devDependencies = packageJsonData.devDependencies;
             this.projectType = this.getProjectType();
-            this.ignoredDependencies = nsConfig === null || nsConfig === void 0 ? void 0 : nsConfig.ignoredNativeDependencies;
             this.appDirectoryPath = this.getAppDirectoryPath();
             this.appResourcesDirectoryPath = this.getAppResourcesDirectoryPath();
             this.androidManifestPath = this.getPathToAndroidManifest(this.appResourcesDirectoryPath);
@@ -191,6 +190,20 @@ class ProjectData {
         }
         return identifier;
     }
+    getIgnoredDependencies(platform) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        let ignoredNativeDependencies = (_b = (_a = this.nsConfig) === null || _a === void 0 ? void 0 : _a.ignoredNativeDependencies) !== null && _b !== void 0 ? _b : [];
+        if (platform === "visionos") {
+            ignoredNativeDependencies = ignoredNativeDependencies.concat((_e = (_d = (_c = this.nsConfig) === null || _c === void 0 ? void 0 : _c.visionos) === null || _d === void 0 ? void 0 : _d.ignoredNativeDependencies) !== null && _e !== void 0 ? _e : []);
+        }
+        else if (platform === "ios") {
+            ignoredNativeDependencies = ignoredNativeDependencies.concat((_h = (_g = (_f = this.nsConfig) === null || _f === void 0 ? void 0 : _f.ios) === null || _g === void 0 ? void 0 : _g.ignoredNativeDependencies) !== null && _h !== void 0 ? _h : []);
+        }
+        else if (platform === "android") {
+            ignoredNativeDependencies = ignoredNativeDependencies.concat((_l = (_k = (_j = this.nsConfig) === null || _j === void 0 ? void 0 : _j.android) === null || _k === void 0 ? void 0 : _k.ignoredNativeDependencies) !== null && _l !== void 0 ? _l : []);
+        }
+        return ignoredNativeDependencies;
+    }
     getProjectType() {
         let detectedProjectType = _.find(ProjectData.PROJECT_TYPES, (projectType) => projectType.isDefaultProjectType).type;
         const deps = _.keys(this.dependencies).concat(_.keys(this.devDependencies));

package/lib/services/android/gradle-build-args-service.js

@@ -36,7 +36,7 @@ class GradleBuildArgsService {
             projectDir: buildData.projectDir,
         });
         this.$projectData.initializeProjectData(buildData.projectDir);
-        args.push(`--stacktrace`, `-PcompileSdk=${toolsInfo.compileSdkVersion}`, `-PtargetSdk=${toolsInfo.targetSdkVersion}`, `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`, `-PgenerateTypings=${toolsInfo.generateTypings}`, `-PprojectRoot=${this.$projectData.projectDir}`, `-DprojectRoot=${this.$projectData.projectDir}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-DappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
+        args.push(`-PcompileSdk=${toolsInfo.compileSdkVersion}`, `-PtargetSdk=${toolsInfo.targetSdkVersion}`, `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`, `-PgenerateTypings=${toolsInfo.generateTypings}`, `-PprojectRoot=${this.$projectData.projectDir}`, `-DprojectRoot=${this.$projectData.projectDir}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-DappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
         const gradleArgs = (this.$projectData.nsConfig.android.gradleArgs || []).concat(buildData.gradleArgs || []);
         if (gradleArgs) {
             const additionalArgs = [];
@@ -51,17 +51,23 @@ class GradleBuildArgsService {
         if (buildData.release || buildData.keyStorePath) {
             args.push(`-PksPath=${path.resolve(buildData.keyStorePath)}`, `-Palias=${buildData.keyStoreAlias}`, `-Ppassword=${buildData.keyStoreAliasPassword}`, `-PksPassword=${buildData.keyStorePassword}`);
         }
+        console.log('getBuildTaskArgs', args);
         return args;
     }
     getBuildLoggingArgs() {
         const args = [];
         const logLevel = this.$logger.getLevel();
         if (logLevel === constants_2.LoggerLevel.TRACE) {
+            args.push("--stacktrace");
             args.push("--debug");
         }
         else if (logLevel === constants_2.LoggerLevel.DEBUG) {
+            args.push("--stacktrace");
             args.push("--info");
         }
+        else if (logLevel === constants_2.LoggerLevel.INFO) {
+            args.push("--quiet");
+        }
         return args;
     }
     getBuildTaskName(buildData) {

package/lib/services/android-plugin-build-service.js

@@ -19,7 +19,7 @@ class AndroidPluginBuildService {
     get $platformsDataService() {
         return this.$injector.resolve("platformsDataService");
     }
-    constructor($fs, $childProcess, $androidToolsInfo, $hostInfo, $options, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
+    constructor($fs, $childProcess, $androidToolsInfo, $hostInfo, $options, $logger, $packageManager, $projectData, $projectDataService, $devicePlatformsConstants, $gradleBuildArgsService, $errors, $filesHashService, $hooksService, $injector, $watchIgnoreListService) {
         this.$fs = $fs;
         this.$childProcess = $childProcess;
         this.$androidToolsInfo = $androidToolsInfo;
@@ -30,6 +30,7 @@ class AndroidPluginBuildService {
         this.$projectData = $projectData;
         this.$projectDataService = $projectDataService;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$gradleBuildArgsService = $gradleBuildArgsService;
         this.$errors = $errors;
         this.$filesHashService = $filesHashService;
         this.$hooksService = $hooksService;
@@ -453,9 +454,7 @@ class AndroidPluginBuildService {
             });
             localArgs.push(...additionalArgs);
         }
-        if (this.$logger.getLevel() === "INFO") {
-            localArgs.push("--info");
-        }
+        localArgs.push(...this.$gradleBuildArgsService.getBuildLoggingArgs());
         const opts = {
             cwd: pluginBuildSettings.pluginDir,
             stdio: "inherit",

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

@@ -4,15 +4,43 @@ exports.IOSExtensionsService = 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 CONFIG_FILE_EXTENSION = "extension.json";
+const RESOURCES_TO_IGNORE = [CONFIG_FILE_EXTENSION, 'node_modules'];
 class IOSExtensionsService {
-    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 = 'ExtensionResources') {
+        const file = project.addResourceFile(path, opt, group);
+        project.addToResourcesPbxGroup(file, group);
+    }
+    addSourceFile(project, path, opt, group = 'ExtensionSrc') {
+        const file = project.addSourceFile(path, opt, group);
+        project.addToResourcesPbxGroup(file, group);
     }
     async addExtensionsFromPath({ extensionsFolderPath, projectData, platformData, pbxProjPath, }) {
         const targetUuids = [];
+        const targetNames = [];
         let addedExtensions = false;
         if (!this.$fs.exists(extensionsFolderPath)) {
             return false;
@@ -23,23 +51,507 @@ class IOSExtensionsService {
             .getTargetDirectories(extensionsFolderPath)
             .forEach((extensionFolder) => {
             const target = this.$iOSNativeTargetService.addTargetToProject(extensionsFolderPath, extensionFolder, constants_1.IOSNativeTargetTypes.appExtension, project, platformData);
-            this.configureTarget(extensionFolder, path.join(extensionsFolderPath, extensionFolder), target, project, projectData);
+            const extensionPath = path.join(extensionsFolderPath, extensionFolder);
+            const configPath = path.join(extensionPath, CONFIG_FILE_EXTENSION);
+            const config = this.$fs.exists(configPath) ? this.$fs.readJson(configPath) : null;
+            this.configureTarget(extensionFolder, extensionPath, configPath, config, target, project, projectData, platformData, pbxProjPath);
             targetUuids.push(target.uuid);
+            targetNames.push(extensionFolder);
             addedExtensions = true;
         });
         this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+        const extensionSPMPackages = this.getExtensionSPMPackages(platformData);
+        await this.applySPMPackagesToTargets(targetNames, platformData, projectData.projectDir, extensionSPMPackages);
         this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, pbxProjPath);
         return addedExtensions;
     }
-    configureTarget(extensionName, extensionPath, target, project, projectData) {
-        const extJsonPath = path.join(extensionPath, "extension.json");
-        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+    async configureTarget(extensionName, extensionPath, configPath, config, target, project, projectData, platformData, pbxProjPath) {
+        const resourcesGroup = extensionName + "Resources";
+        project.addPbxGroup([], resourcesGroup, project.filepath, null, {
+            isMain: true,
+            target: target.uuid,
+            filesRelativeToProject: true,
+        });
+        const srcGroup = extensionName + "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) || [];
+        const buildConfigProperties = [
             {
                 name: "PRODUCT_BUNDLE_IDENTIFIER",
                 value: `${projectData.projectIdentifiers.ios}.${extensionName}`,
             },
-        ], extensionName, project);
-        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(extJsonPath, target.uuid, extensionName, project);
+        ];
+        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: `"${relativeInfoPlistPath}"`
+                });
+                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, relativeXcprivacyPath, { target: target.uuid }, resourcesGroup);
+                resourcesExclude.push(relativeXcprivacyPath);
+            }
+            else {
+                this.$logger.warn(`Custom xcprivacy file not found at: ${xcprivacyPath}`);
+            }
+        }
+        if (config === null || config === void 0 ? void 0 : config.entitlements) {
+            const entitlementsPath = path.resolve(basedir, config.entitlements);
+            console.log('entitlementsPath', entitlementsPath);
+            if (this.$fs.exists(entitlementsPath)) {
+                const relativeEntitlementsPath = path.relative(platformData.projectRoot, entitlementsPath);
+                buildConfigProperties.push({
+                    name: "CODE_SIGN_ENTITLEMENTS",
+                    value: `"${relativeEntitlementsPath}"`
+                });
+            }
+            else {
+                this.$logger.warn(`Custom xcprivacy file not found at: ${entitlementsPath}`);
+            }
+        }
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties(buildConfigProperties, extensionName, project);
+        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(configPath, target.uuid, extensionName, project);
+        project.addToHeaderSearchPaths(extensionPath, target.pbxNativeTarget.productName);
+        if ((config === null || config === void 0 ? void 0 : config.importSourcesFromMainFolder) === true) {
+            this.addSourceFilesFromDirectory(basedir, target.uuid, project, platformData, srcGroup, srcExclude);
+        }
+        if ((config === null || config === void 0 ? void 0 : config.importResourcesFromMainFolder) === true) {
+            this.addTargetResources(basedir, [target.uuid], project, platformData, resourcesGroup, resourcesExclude);
+        }
+        if (config) {
+            await this.processExtensionConfiguration(config, basedir, extensionName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude);
+        }
+    }
+    async processExtensionConfiguration(config, basedir, extensionName, target, project, projectData, platformData, pbxProjPath, srcExclude, resourcesExclude) {
+        this.$logger.debug(`processExtensionConfiguration ${JSON.stringify(config)}`);
+        if (config.resources && Array.isArray(config.resources)) {
+            this.$logger.debug(`Processing ${config.resources.length} custom resource(s) for extension target: ${extensionName}`);
+            for (const resourcePath of config.resources) {
+                this.addCustomResource(resourcePath, target.uuid, project, projectData, platformData, extensionName + "Resources", resourcesExclude, basedir);
+            }
+        }
+        if (config.src && Array.isArray(config.src)) {
+            this.$logger.debug(`Processing ${config.src.length} custom source file(s) for extension target: ${extensionName}`);
+            for (const srcPath of config.src) {
+                this.addCustomSourceFile(srcPath, target.uuid, project, projectData, platformData, srcExclude, extensionName + 'Src', basedir);
+            }
+        }
+        if (config.SPMPackages && Array.isArray(config.SPMPackages)) {
+            this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+            await this.applySPMPackagesToTargets([extensionName], platformData, basedir, config.SPMPackages);
+            project.parseSync();
+        }
+        if (config.modules && Array.isArray(config.modules)) {
+            this.$logger.debug(`Processing ${config.modules.length} module(s) for extension target: ${extensionName}`);
+            for (const moduleDef of config.modules) {
+                await this.addModuleDependency(moduleDef, config, extensionName, target, project, projectData, platformData, srcExclude, resourcesExclude, basedir);
+            }
+        }
+    }
+    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);
+            }
+        }
+    }
+    addTargetResources(folderPath, targetUuids, project, platformData, groupName, excludePatterns) {
+        try {
+            if (!this.$fs.exists(folderPath)) {
+                return;
+            }
+            for (const targetUuid of targetUuids) {
+                this.addResourcesFromDirectory(folderPath, targetUuid, project, platformData, groupName, excludePatterns);
+            }
+            this.$logger.debug("Extension resources added successfully");
+        }
+        catch (err) {
+            this.$logger.warn(`Error adding extension 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);
+                }
+            }
+        }
+    }
+    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()) {
+            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);
+        }
+    }
+    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;
+        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}`);
+    }
+    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);
+        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);
+        if (files.length > 0) {
+            project.addPbxGroup(files, moduleName, modulePath, null, {
+                isMain: true,
+                target: moduleTarget.uuid,
+                filesRelativeToProject: true,
+            });
+        }
+        const moduleSpmPackages = moduleDef.SPMPackages;
+        if (moduleDef.frameworks && Array.isArray(moduleDef.frameworks)) {
+            for (const framework of moduleDef.frameworks) {
+                const frameworkName = typeof framework === 'string' ? framework : framework.path;
+                const isSpmProduct = Array.isArray(moduleSpmPackages) && moduleSpmPackages.some((p) => {
+                    var _a;
+                    const pkg = typeof p === 'string' ? (_a = config.SPMPackages) === null || _a === void 0 ? void 0 : _a.find(s => s.name === p) : p;
+                    return pkg && Array.isArray(pkg.libs) && pkg.libs.includes(frameworkName);
+                });
+                if (isSpmProduct) {
+                    this.$logger.debug(`Skipping framework ${frameworkName} because it is provided by SPM package`);
+                    continue;
+                }
+                if (typeof framework === 'string') {
+                    project.addFramework(framework, { target: moduleTarget.uuid });
+                }
+                else {
+                    project.addFramework(framework.path, { target: moduleTarget.uuid, ...framework });
+                }
+            }
+        }
+        if (moduleDef.src && Array.isArray(moduleDef.src)) {
+            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)) {
+            for (const resourcePath of moduleDef.resources) {
+                this.addCustomResource(resourcePath, moduleTarget.uuid, project, projectData, platformData, moduleName + "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) {
+                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 => {
+                var _a;
+                if (typeof t === 'string') {
+                    return (_a = config.SPMPackages) === null || _a === void 0 ? void 0 : _a.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;
+    }
+    resolvePathWithBasedir(relativePath, basedir, fallbackDir) {
+        return basedir
+            ? path.resolve(basedir, relativePath)
+            : path.resolve(fallbackDir, 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;
+    }
+    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, spmPackages) {
+        try {
+            if (spmPackages.length === 0) {
+                return;
+            }
+            this.$logger.debug(`Applying ${spmPackages.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 spmPackages) {
+                if ("path" in pkg) {
+                    pkg.path = path.resolve(basedir, pkg.path);
+                }
+                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);
+        }
+    }
+    getExtensionSPMPackages(platformData) {
+        const $projectConfigService = yok_1.injector.resolve("projectConfigService");
+        const extensionPackages = $projectConfigService.getValue(`${platformData.platformNameLowerCase}.extensions.SPMPackages`, []);
+        return extensionPackages;
     }
     removeExtensions({ pbxProjPath }) {
         const project = new this.$xcode.project(pbxProjPath);

package/lib/services/plugins-service.js

@@ -159,7 +159,7 @@ class PluginsService {
     getAllProductionPlugins(projectData, platform, dependencies) {
         dependencies =
             dependencies ||
-                this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies);
+                this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir, projectData.getIgnoredDependencies(platform));
         if (_.isEmpty(dependencies)) {
             return [];
         }

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

@@ -51,7 +51,7 @@ class ProjectChangesService {
             }
             this._changesInfo.appResourcesChanged = this.containsNewerFiles(platformResourcesDir, projectData);
             this.$nodeModulesDependenciesBuilder
-                .getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies)
+                .getProductionDependencies(projectData.projectDir, projectData.getIgnoredDependencies(platformData.platformNameLowerCase))
                 .filter((dep) => dep.nativescript &&
                 this.$fs.exists(path.join(dep.directory, constants_1.PLATFORMS_DIR_NAME, platformData.platformNameLowerCase)))
                 .forEach((dep) => {

package/lib/tools/node-modules/node-modules-builder.js

@@ -10,7 +10,7 @@ class NodeModulesBuilder {
         this.$pluginsService = $pluginsService;
     }
     async prepareNodeModules({ platformData, projectData, }) {
-        let dependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir, projectData.ignoredDependencies);
+        let dependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir, projectData.getIgnoredDependencies(platformData.platformNameLowerCase));
         dependencies = await platformData.platformProjectService.beforePrepareAllPlugins(projectData, dependencies);
         const pluginsData = this.$pluginsService.getAllProductionPlugins(projectData, platformData.platformNameLowerCase, dependencies);
         if (_.isEmpty(pluginsData)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akylas/nativescript-cli",
   "main": "./lib/nativescript-cli-lib.js",
-  "version": "8.11.2",
+  "version": "8.11.3",
   "author": "NativeScript <oss@nativescript.org>",
   "description": "Command-line interface for building NativeScript projects",
   "bin": {

package/vendor/gradle-plugin/build.gradle

@@ -191,6 +191,10 @@ buildscript {
         def pluginData = appDependencies.find { it.name == project.ext.PLUGIN_NAME }
         project.ext.nativescriptDependencies = appDependencies.findAll{pluginData.dependencies.contains(it.name)}.plus([pluginData])
     }
+
+    initialize()
+    project.ext.applyBeforePluginGradleConfiguration()
+
     def applyBuildScriptConfigurations = { ->
         def absolutePathToAppResources = project.ext.getAppResourcesPath()
         def pathToBuildScriptGradle = "$absolutePathToAppResources/Android/buildscript.gradle"
@@ -223,8 +227,6 @@ buildscript {
         }
     }
 
-    initialize()
-    project.ext.applyBeforePluginGradleConfiguration()
     applyBuildScriptConfigurations()
 
     def computeKotlinVersion = { -> project.hasProperty("kotlinVersion") ? kotlinVersion : "${ns_default_kotlin_version}" }